// skippable values in lowercase
const tags = ["stream"];
const patterns = ["stream", "wss"];
const patches = {
    documents: {
        headPattern: "generate",
        contextData: {
            0: "Facts[]",
            1: "Transcript",
            2: "string",
        }
    }
};

const watchContentContainer = () => {
    const observer = new MutationObserver((mutations, observer) => {
        for (const mut of mutations) {
            if (mut.type !== "childList") {
                continue;
            }
            disablePlaygrounds();
            patchBugDocuments();
            watchDocumentsContextTypeContainer();
        }
    });
    if (!observer) {
        console.error("Failed to create content observer");
        return;
    }

    const target = document.getElementById("content-container");
    if (!target) {
        console.error("Missing #content-container");
        return;
    }

    observer.observe(target, { childList: true });
};

const watchDocumentsContextTypeContainer = () => {
    const docPatch = patches["documents"];
    if (!docPatch) {
        console.error("Missing patch for Documents");
        return;
    }

    const pattern = docPatch["headPattern"];
    if (!docPatch) {
        console.error("Missing header pattern check for Documents");
        return;
    }

    if (shouldSkipDocumentsPatch(pattern)) {
        return;
    }

    const observer = new MutationObserver((mutations, observer) => {
        for (const mut of mutations) {
            if (mut.type !== "childList") {
                continue;
            }
            patchBugDocuments();
        }
    });
    if (!observer) {
        console.error("Failed to create Documents context observer");
        return;
    }

    const target = document.getElementById("body-context-data");
    if (!target) {
        console.error("Missing #body-context-data");
        return;
    }

    observer.observe(target.parentNode.parentNode, { childList: true });
};

const findContentArea = () => {
    const area = document.getElementById("content-area");
    if (!area) {
        throw new Error("Missing #content-area");
    }
    return area;
};

const disablePlayground = () => {
    try {
        const area = findContentArea();
    } catch (exc) {
        console.error(exc);
    }

    const flexContainer = area.closest("div.flex");
    if (!flexContainer) {
        console.error("Missing playground container");
        return;
    }

    for (const button of flexContainer.getElementsByTagName("button")) {
        if (!button.textContent.toLowerCase().includes("try it")) {
            continue;
        }

        button.style.display = "none";
        return true;
    }
};

const disablePlaygrounds = () => {
    for (const tag of tags) {
        for (const head of document.getElementsByClassName("eyebrow")) {
            if (!head.textContent.toLowerCase().includes(tag)) {
                continue;
            }

            if (disablePlayground()) {
                return;
            }
        }
    }

    for (const pattern of patterns) {
        for (const head of document.getElementsByTagName("h1")) {
            if (!head.textContent.toLowerCase().includes(pattern)) {
                continue;
            }

            if (disablePlayground()) {
                return;
            }
        }
    }
};

const patchPlayground = () => {
    try {
        const area = findContentArea();
    } catch (exc) {
        console.error(exc);
    }

    const flexContainer = area.closest("div.flex");
    if (!flexContainer) {
        console.error("Missing playground container");
        return;
    }

    for (const button of flexContainer.getElementsByTagName("button")) {
        if (!button.textContent.toLowerCase().includes("try it")) {
            continue;
        }

        button.style.display = "none";
        return true;
    }
};

const shouldSkipDocumentsPatch = (pattern) => {
    for (const head of document.getElementsByTagName("h1")) {
        if (!head.textContent.toLowerCase().includes(pattern)) {
            return true;
        }
    }
};

const patchBugDocuments = () => {
    const docPatch = patches["documents"];
    if (!docPatch) {
        console.error("Missing patch for Documents");
        return;
    }

    const pattern = docPatch["headPattern"];
    if (!docPatch) {
        console.error("Missing header pattern check for Documents");
        return;
    }

    if (shouldSkipDocumentsPatch(pattern)) {
        return;
    }

    const data = document.getElementById("body-context-data");
    if (!data) {
        console.error("Missing #body-context-data");
        return;
    }

    for (const select of data.getElementsByTagName("select")) {
        const options = Array.from(
            select.getElementsByTagName("option")
        ).entries();

        for (const [idx, option] of options) {
            const contextPatch = docPatch["contextData"];
            if (!contextPatch) {
                console.error("Missing patch for Documents context");
                return;
            }

            const optionPatch = contextPatch[idx];
            if (!optionPatch) {
                console.error(`Missing patch for context option ${idx}`);
                return;
            }

            option.textContent = optionPatch;
        }
    }
};

window.addEventListener("load", () => {
    disablePlaygrounds();
    patchBugDocuments();
    watchContentContainer();
    watchDocumentsContextTypeContainer();
})


 This endpoint is used for binary classification tasks where a boolean output is expected.

Create Classification

Corti API Documentation

API Reference

Updates

Get Started

Support

Overview of Corti application programming interfaces (API)

Introduction

AI Platform

How it works

Learn about how languages are supported in Corti APIs

Languages

Get access

Learn how to authenticate to the Corti API

Authentication

Example Workflows

Learn how to generate documents with Templates

Working with Templates

Find the latest updates across Corti's products

Overview

Updates and improvements to Corti foundation models. More information is available [here](https://www.corti.ai/foundation-models).

Foundation Model Updates

Updates and improvements to Corti application programming interfaces (API). Detailed API documentation is available [here](/api-reference/).

API Updates

Updates and improvements to language models supported by Corti automated speech recognition (ASR). Detailed language documentation is availabile [here](/about/languages/).

Language Updates

Connect to stream

 Lists all existing interactions. Results can be filtered by encounter status and patient ID.

List All Interactions

Create Interaction

 Retrieves a previously recorded interaction by its unique identifier (interaction ID).

Get Existing Interaction

Delete Interaction

 Modifies an existing interaction by updating specific fields without overwriting the entire record.

Update Interaction

 Retrieves a list of facts for a given interaction.

List Facts

Add Facts

 Updates multiple facts associated with an interaction. If the interaction `status = "in progress"`, the updated facts will be sent to the client over WebSocket.

Update Facts

 Updates an existing fact within a specific interaction. If the interaction `status = "in progress"`, the updated fact will be sent to the client via WebSocket. To discard a fact, simply set `discarded = true`.

Update Fact

List Documents

Generate Document

Get Document

Delete Document

Update Document

 Get all codes associated with an interaction.

List codes

Select codes

Generate Codes

 Retrieve a list of recordings for a given interaction.

List Recordings

 Upload a recording for a given interaction. There is a maximum limit of 60 minutes in length and 150MB in size for recordings.

Upload Recording

 Retrieve a specific recording for a given interaction.

Get Recording

 Delete a specific recording for a given interaction.

Delete Recording

 Retrieves a list of transcripts for a given interaction.

List Transcripts

 Creates a new transcript for an interaction.

Create Transcript

 Retrieves the transcript for a specific interaction.

Get Transcript

 Deletes a specific transcript associated with an interaction.

Delete Transcript

 JSON representation of the API documentation.

Swagger JSON

 Compares a 'source' document with a 'target' document and returns a percentage alignment, optionally including aligned segments.

Align Sections

 Allows users to ask questions or make queries, which are processed in the context of a specific interaction. Multiple tools provide responses via SSE. A thread ID is returned with the initial query, which can be used to continue posting to the same thread in subsequent queries.

Contextual Query Assistant

 Processes a query and returns a summary along with relevant sources.

Guidelines Tool API

 Finds mentions of a query within a set of reference texts.

Mentions Tool API

 Provides a list of suggested questions based on a query and/or context.

stream

interactions

facts

documents

codes

recordings

transcripts

swagger

experimental

Create Classification

Headers

Path Parameters

Body

Response