@teaflask/assistant 0.6.0 → 0.7.1

package/dist/core/tool-view.d.ts

@@ -1,62 +1,235 @@
 import type { ToolCallState } from "./tool-call-display.js";
+/** The palette a tool view renders in. */
 export type ToolViewThemeMode = "light" | "dark";
+/** A JSON Schema document, passed through as received and never validated. */
 export type JsonSchema = Record<string, unknown>;
+/**
+ * One tool or action call, as a tool view receives it. You get a fresh copy
+ * through `update` as the call progresses; never mutate it.
+ */
 export interface ToolViewCall<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** The tool's name. For an action, `action__<slug>`. */
     toolName: string;
+    /**
+     * Unique id of the call, stable for its whole life and equal to the
+     * `data-tf-tool-call-id` attribute on its row. Empty when the call has no
+     * id.
+     */
     toolCallId: string;
+    /** Where the call is in its life. See ToolCallState for each value. */
     status: ToolCallState;
+    /**
+     * True while an approval or a question tied to this call is waiting on the
+     * user. The view may say so, but the decision itself happens in the
+     * assistant's own card, never in the view.
+     */
     awaitingDecision: boolean;
+    /**
+     * The arguments the agent passed, parsed, without the short caption the
+     * agent writes for each step; `{}` while they are still streaming in or if
+     * they are not a JSON object. For an action, `{ path_params, query, body
+     * }`, with one key for each part your API operation declares.
+     */
     args: TArgs;
+    /**
+     * The parsed result once the call has finished; for an action, your API's
+     * response body alone (read the HTTP status with
+     * `actionEnvelopeOf(resultText)`). Undefined until the result arrives, when
+     * it is not JSON, or when `truncated` is true.
+     */
     result?: TResult;
+    /**
+     * The raw result text as recorded. Undefined until the call finishes, and
+     * withheld for calls that failed, were not approved, didn't run, were
+     * declined or had their result replaced by a preview.
+     */
     resultText?: string;
+    /**
+     * True when the result was cut to fit a size limit. `result` is then
+     * undefined and `resultText` holds only the cut text, so don't show it as
+     * complete.
+     */
     truncated?: boolean;
+    /**
+     * True when the result was too large for the agent and was replaced by a
+     * shortened preview. The tool's real output is not available to the view.
+     */
     offloaded?: boolean;
+    /**
+     * Why the call failed, set when it failed. Use humanFailureSentenceOf to
+     * get a sentence fit for the user, and actionFailureOf to read an action's
+     * HTTP status, error code and per-field problems.
+     */
     errorText?: string;
+    /**
+     * Teaflask's reason for declining the call, set when `status` is "refused".
+     */
     refusalText?: string;
+    /**
+     * The JSON Schema of the tool's arguments, when it declared one. For an
+     * action, built from your operation's path, query and body schemas;
+     * undefined (never `{}`) otherwise, so a view must still work without it.
+     */
     argsSchema?: JsonSchema;
+    /**
+     * The JSON Schema of the tool's successful result, when it declared one.
+     * For an action, your operation's success response body schema, which
+     * matches `result`; undefined otherwise.
+     */
     resultSchema?: JsonSchema;
 }
+/** What a tool view's `mount` and `update` receive. */
 export interface ToolViewProps<TArgs = Record<string, unknown>, TResult = unknown> {
+    /** The call to draw. */
     call: ToolViewCall<TArgs, TResult>;
+    /**
+     * `themeMode` is the palette the assistant is actually painted in, "light"
+     * or "dark", with an "auto" setting already resolved. A change arrives
+     * through `update`.
+     */
     context: {
         themeMode: ToolViewThemeMode;
     };
 }
+/** A mounted tool view, as returned from `mount`. */
 export interface ToolViewInstance<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Called with new props whenever the call changes (arguments arrive, status
+     * advances, the result lands, an approval opens or settles) or the theme
+     * changes. Apply them to the existing view so the user's state in it
+     * survives; a throw makes the assistant show the next matching view.
+     */
     update(props: ToolViewProps<TArgs, TResult>): void;
+    /**
+     * Called when the view is removed. Release any listeners, timers or roots
+     * you created.
+     */
     destroy(): void;
 }
+/**
+ * A tool view, which draws one tool or action call inside its row in the
+ * conversation in place of the default view of its arguments. Write one
+ * directly for plain DOM or any framework, or create one from a React component
+ * with reactToolView.
+ */
 export interface ToolViewAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Called once per call, even while its row is collapsed. Draw into
+     * `container` (the assistant owns it) and return the instance that receives
+     * updates; if `mount` throws, the error goes to the provider's `onError`
+     * and the next matching view is shown instead.
+     */
     mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
 }
+/**
+ * A custom icon for a tool call, drawn in place of the default glyph in the
+ * small mark beside the row's label. Same mount, update and destroy lifecycle
+ * as a view; reactToolView can create one from a React component.
+ */
 export interface IconAdapter<TArgs = Record<string, unknown>, TResult = unknown> {
+    /**
+     * Draws the icon into `container` and returns the instance that receives
+     * later updates and teardown. If it throws, the next matching icon or the
+     * default glyph is shown instead.
+     */
     mount(container: HTMLElement, props: ToolViewProps<TArgs, TResult>): ToolViewInstance<TArgs, TResult>;
 }
+/** One entry in your tool-view registry, carrying a view, an icon, or both. */
 export interface ToolViewRegistration {
-    version: number;
+    /**
+     * Leave it out for your own tools and actions; they match by tool name,
+     * which ignores it. It only matters for a view key the server names, which
+     * must match this version exactly.
+     */
+    version?: number;
+    /**
+     * Draws the call in its row's body, replacing the default view of its
+     * arguments.
+     */
     view?: ToolViewAdapter;
+    /**
+     * Replaces the glyph in the small mark beside the row's label. The mark's
+     * frame stays.
+     */
     icon?: IconAdapter;
 }
+/**
+ * Your tool views, keyed by tool name (for an action, `action__<slug>`; see
+ * actionToolViews) or by a view key the server names, and passed as `toolViews`
+ * on the provider or the script-tag element. Keys starting with `teaflask.` are
+ * reserved and ignored.
+ */
 export type ToolViewRegistry = Readonly<Record<string, ToolViewRegistration>>;
 export declare function isReservedToolViewKey(key: string): boolean;
 export declare const PACKAGE_TOOL_VIEWS: ToolViewRegistry;
+/**
+ * Returns the tool name an action runs under, `action__<slug>`, where the slug
+ * is the one shown for the action on its Actions page in Teaflask.
+ */
 export declare function actionToolName(slug: string): string;
+/**
+ * Builds a tool-view registry keyed by action slug instead of tool name, by
+ * turning each slug into `action__<slug>`. Spread the result beside a registry
+ * of ordinary tool names and pass both as `toolViews`.
+ */
 export declare function actionToolViews(bySlug: Readonly<Record<string, ToolViewRegistration>>): ToolViewRegistry;
+/** One tool view that matches a call, and how it matched. */
 export interface ResolvedToolView {
+    /**
+     * How the view matched, where lower wins. 1 is your registry by the view
+     * key and version the server named for this call, 2 is your registry by the
+     * call's exact tool name (for an action, `action__<slug>`), and 3 is a view
+     * built into the package; because 2 beats 3, registering under a built-in
+     * tool's name replaces its view, and with no match at all the package's
+     * default view of the arguments is shown.
+     */
     rung: 1 | 2 | 3;
+    /**
+     * The registry key that matched, either the server-named view key or the
+     * tool name.
+     */
     key: string;
+    /** The view to mount. */
     adapter: ToolViewAdapter;
 }
+/** One tool-call icon that matches a call, and how it matched. */
 export interface ResolvedToolViewIcon {
+    /**
+     * How the icon matched, with the same meaning as ResolvedToolView.rung. 1
+     * is your registry by the server-named view key and version, 2 is your
+     * registry by exact tool name, and 3 is a built-in.
+     */
     rung: 1 | 2 | 3;
+    /**
+     * The registry key that matched, either the server-named view key or the
+     * tool name.
+     */
     key: string;
+    /** The icon to mount. */
     adapter: IconAdapter;
 }
+/**
+ * The views and icons that match one call, best first, plus the call they will
+ * receive.
+ */
 export interface ToolViewResolution {
+    /**
+     * Matching views, best first. The first that mounts without throwing is
+     * shown; an empty list means the default view of the arguments.
+     */
     views: readonly ResolvedToolView[];
+    /** Matching icons, best first. An empty list means the default glyph. */
     icons: readonly ResolvedToolViewIcon[];
+    /** The call the matched view receives, built the first time it is read. */
     call: ToolViewCall;
 }
+/**
+ * Finds the registered views and icons that match one tool call, best first,
+ * from the view the server named for it (if any), its tool name and your
+ * registry. The assistant does this for you; call it only if you render tool
+ * calls yourself, and treat an empty `views` list as "use the default view of
+ * the arguments".
+ */
 export declare function resolvedToolViewsOf(ref: {
     key: string;
     version: number;

package/dist/core/transcript-rows.d.ts

@@ -1,7 +1,7 @@
 import type { Message } from "@ag-ui/core";
 import type { TurnAttachment } from "../contract/threads.js";
 import type { UserTurnMeta } from "./user-turn-ledger.js";
-import type { MarkerAnchorsSnapshot } from "./connection-epoch.js";
+import type { TranscriptMarkers } from "./connection-epoch.js";
 import { type MemoryUpdated } from "./memory-provenance-anchors.js";
 import type { BlockTiming } from "./segment-timing.js";
 import { type SubagentGroupRow } from "./subagent-rows.js";
@@ -10,61 +10,196 @@ import type { AnchoredTurnFailReceipts } from "./turn-failed-anchors.js";
 import type { ToolCallDisplay, ToolCallState } from "./tool-call-display.js";
 import type { ToolCallSchemas } from "./tool-schema-anchors.js";
 export type MarkerPosition = "before" | "after";
+/** A message the user sent. */
 export interface UserMessageRow {
+    /** Identifies a user message row. */
     kind: "user";
+    /** Stable unique key for this row, which is also the user message's id. */
     key: string;
+    /** What the user typed. Empty when the message carries only attachments. */
     text: string;
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
+    /**
+     * When the message was sent, as an ISO-8601 timestamp from the server.
+     * Absent on an optimistic row and when transcriptRowsOf was given no turn
+     * metadata.
+     */
     createdAt?: string;
+    /**
+     * True while the message has been sent but not yet confirmed by the
+     * conversation; it already sits in its final position.
+     */
     optimistic?: true;
 }
+/** A block of the assistant's reply text. */
 export interface AssistantTextRow {
+    /** Identifies an assistant reply row. */
     kind: "assistant-text";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /**
+     * The reply as Markdown. While `streaming` is true it may end mid-sentence
+     * or mid-syntax.
+     */
     text: string;
+    /**
+     * True only on the newest reply text while the assistant is still working,
+     * meaning the text is still growing.
+     */
     streaming: boolean;
+    /**
+     * Memories the assistant saved during the run that produced this message,
+     * in the order they were saved. Absent when it saved none.
+     */
     memoryUpdates?: MemoryUpdated[];
 }
+/**
+ * The model's visible thinking before or between its replies and tool calls.
+ */
 export interface ReasoningRow {
+    /** Identifies a reasoning row. */
     kind: "reasoning";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The reasoning text. */
     text: string;
+    /**
+     * True while this is the newest message and the assistant is still working;
+     * turns false as soon as reply text or a tool call starts, which is a good
+     * moment to collapse it.
+     */
     streaming: boolean;
+    /**
+     * When the reasoning started and ended by the server's clock. Absent when
+     * the history carries no timestamps, which means unknown rather than zero.
+     */
     timing?: BlockTiming;
 }
+/**
+ * One tool or action call the agent made, with its arguments, state and result.
+ */
 export interface ToolCallRow {
+    /** Identifies a tool call row. */
     kind: "tool-call";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The call's id, which also keys this call in the markerAnchors maps. */
     toolCallId: string;
+    /**
+     * The name of the tool the agent called; an action appears as
+     * `action__<slug>`.
+     */
     toolName: string;
+    /**
+     * Where the call stands. output-available means the result arrived,
+     * output-error it failed, denied the user declined its approval, cancelled
+     * it was stopped before it ran, refused the tool declined the request,
+     * superseded a retry abandoned it, input-available it awaits its result
+     * while the assistant works, and input-streaming it has no result while the
+     * assistant is not working (for example, paused for an approval).
+     */
     state: ToolCallState;
+    /**
+     * The arguments as raw JSON text, which may be incomplete while they are
+     * still streaming.
+     */
     argsText: string;
+    /**
+     * The result text exactly as the agent received it. Undefined until it
+     * arrives.
+     */
     result?: string;
+    /**
+     * True when the tool's output was too large and `result` holds a shortened
+     * stand-in rather than the actual output; show a "result shortened" note
+     * instead of the content.
+     */
     offloaded: boolean;
+    /** Why the call failed. Present only when state is output-error. */
     errorText?: string;
+    /**
+     * The tool's explanation for declining the request. Present only when state
+     * is refused.
+     */
     refusalText?: string;
+    /**
+     * Captions, status text, an icon and a tool view reference supplied by the
+     * server for this call. Absent when it supplied none.
+     */
     display?: ToolCallDisplay;
+    /**
+     * The JSON Schemas declared for this tool's arguments and result. Absent
+     * when the tool declared none.
+     */
     schemas?: ToolCallSchemas;
+    /**
+     * When the call started and finished by the server's clock. Absent when the
+     * history carries no timestamps, which means unknown rather than zero.
+     */
     timing?: BlockTiming;
+    /**
+     * True when the user was asked to approve this call or answer a question
+     * for it; it stays true after the decision and after a reload.
+     */
     decisionBearing?: boolean;
 }
+/**
+ * A notice shown after the last message of a turn that failed for a reason
+ * outside any single tool call, such as the model provider, usage limits or a
+ * lost connection.
+ */
 export interface TurnFailedReceiptsRow {
+    /** Identifies a failed-turn notice row. */
     kind: "turn-failed-receipts";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /**
+     * Sentences explaining the failure, written to be shown to the user as they
+     * are.
+     */
     receipts: AnchoredTurnFailReceipts[MarkerPosition];
 }
+/**
+ * A divider shown before the assistant's reply in a turn it started on its own
+ * to report finished sub-agent results; such turns have no user message.
+ */
 export interface SubagentDeliveryRow {
+    /** Identifies a sub-agent delivery divider row. */
     kind: "subagent-delivery";
+    /** Stable unique key for this row, suitable as a React list key. */
     key: string;
+    /** The finished sub-agents whose results this turn reports. */
     results: DeliveredResult[];
 }
+/** One row of the transcript. Switch on `kind` to pick how to render it. */
 export type TranscriptRow = UserMessageRow | AssistantTextRow | ReasoningRow | ToolCallRow | SubagentGroupRow | TurnFailedReceiptsRow | SubagentDeliveryRow;
+/**
+ * A message the user has just sent that the transcript does not contain yet,
+ * shown optimistically until it arrives.
+ */
 export interface PendingUserEcho {
+    /**
+     * Temporary id for the message; it switches to the message's real id once
+     * the send succeeds, so the echo is dropped when that row arrives.
+     */
     messageId: string;
+    /** What the user typed. */
     text: string;
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
 }
-export declare function transcriptRowsOf(messages: readonly Message[], anchors: MarkerAnchorsSnapshot, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>): TranscriptRow[];
+/**
+ * Builds the transcript rows from the raw message list and its extra facts,
+ * exactly as useTranscript does. Pure; call it only when you need to derive
+ * rows from your own inputs.
+ */
+export declare function transcriptRowsOf(messages: readonly Message[], anchors: TranscriptMarkers, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>): TranscriptRow[];
+/**
+ * Appends the just-sent user message to the rows as an optimistic user row,
+ * unless a user row with the same key is already present. Returns the rows
+ * unchanged when `echo` is null.
+ */
 export declare function withPendingUserEcho(rows: readonly TranscriptRow[], echo: PendingUserEcho | null): readonly TranscriptRow[];
 export declare function trailingRowIsStreaming(rows: readonly TranscriptRow[]): boolean;
 export declare function errorTextOf(recordedError: string | undefined, result: string | undefined): string | undefined;
@@ -77,7 +212,7 @@ export interface TranscriptBlock {
     messageId: string;
     rows: TranscriptRow[];
 }
-export declare function transcriptBlocksOf(messages: readonly Message[], anchors: MarkerAnchorsSnapshot, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>, options?: {
+export declare function transcriptBlocksOf(messages: readonly Message[], anchors: TranscriptMarkers, running: boolean, metaByMessageId?: ReadonlyMap<string, UserTurnMeta>, options?: {
     markerBoundaries?: MarkerBoundaries;
     attachmentsByMessageId?: ReadonlyMap<string, TurnAttachment[]>;
 }): TranscriptBlock[];

package/dist/core/turn-failed-anchors.d.ts

@@ -1,5 +1,9 @@
 import { receiptOf, wellFormedReceiptAnchorsOf, withReceiptAnchored, type AnchoredReceipts } from "./receipt-anchors.js";
 import type { AgentSubscriber } from "@ag-ui/client";
+/**
+ * The failure sentences for a failed turn, split by whether they are shown
+ * before or after the message they belong to.
+ */
 export type AnchoredTurnFailReceipts = AnchoredReceipts;
 export declare const EMPTY_TURN_FAILED_ANCHORS: ReadonlyMap<string, AnchoredTurnFailReceipts>;
 export declare const turnFailedReceiptOf: typeof receiptOf;

package/dist/core/user-turn-ledger.d.ts

@@ -8,8 +8,11 @@ export interface UserTurnRecord {
     attachments: TurnAttachment[];
     createdAt: string;
 }
+/** The send time and attachments of one user message. */
 export interface UserTurnMeta {
+    /** The files attached to the message, in upload order. */
     attachments: TurnAttachment[];
+    /** When the message was sent, as an ISO-8601 timestamp from the server. */
     createdAt: string;
 }
 export interface InjectableTurnLedger {

package/dist/generated/models/apiErrorCode.d.ts

@@ -21,6 +21,7 @@ export declare const ApiErrorCode: {
     readonly DOC_SLUG_RESERVED: "DOC_SLUG_RESERVED";
     readonly DOC_REVISION_NOT_PUBLISHABLE: "DOC_REVISION_NOT_PUBLISHABLE";
     readonly DOC_REVISION_NOT_DISCARDABLE: "DOC_REVISION_NOT_DISCARDABLE";
+    readonly DOC_PROPOSAL_STALE: "DOC_PROPOSAL_STALE";
     readonly DOC_LIMIT_REACHED: "DOC_LIMIT_REACHED";
     readonly HELP_SITE_CONFIG_INVALID: "HELP_SITE_CONFIG_INVALID";
     readonly HELP_SITE_NEVER_PUBLISHED: "HELP_SITE_NEVER_PUBLISHED";

package/dist/generated/models/apiErrorCode.js

@@ -20,6 +20,7 @@ export const ApiErrorCode = {
     DOC_SLUG_RESERVED: "DOC_SLUG_RESERVED",
     DOC_REVISION_NOT_PUBLISHABLE: "DOC_REVISION_NOT_PUBLISHABLE",
     DOC_REVISION_NOT_DISCARDABLE: "DOC_REVISION_NOT_DISCARDABLE",
+    DOC_PROPOSAL_STALE: "DOC_PROPOSAL_STALE",
     DOC_LIMIT_REACHED: "DOC_LIMIT_REACHED",
     HELP_SITE_CONFIG_INVALID: "HELP_SITE_CONFIG_INVALID",
     HELP_SITE_NEVER_PUBLISHED: "HELP_SITE_NEVER_PUBLISHED",

package/dist/generated/models/assistantTurnStatus.d.ts

@@ -1,4 +1,20 @@
+/**
+ * A turn's state. "queued" waits behind an earlier turn; "working" is running;
+ * "awaiting_input" is paused for an approval, an answer to a question or a
+ * browser tool result; "parked" waited too long and stopped, though a late
+ * answer still resumes it; "succeeded" and "failed" are finished; "superseded"
+ * means a new message replaced a parked turn's pending work; "stopped" means
+ * the user stopped it.
+ */
 export type AssistantTurnStatus = (typeof AssistantTurnStatus)[keyof typeof AssistantTurnStatus];
+/**
+ * A turn's state. "queued" waits behind an earlier turn; "working" is running;
+ * "awaiting_input" is paused for an approval, an answer to a question or a
+ * browser tool result; "parked" waited too long and stopped, though a late
+ * answer still resumes it; "succeeded" and "failed" are finished; "superseded"
+ * means a new message replaced a parked turn's pending work; "stopped" means
+ * the user stopped it.
+ */
 export declare const AssistantTurnStatus: {
     readonly queued: "queued";
     readonly working: "working";

package/dist/generated/models/servingAssistantThreadResponse.d.ts

@@ -1,10 +1,33 @@
 import type { ThreadModelPickResponse } from "./threadModelPickResponse.js";
+/** One conversation between a user and your assistant. */
 export interface ServingAssistantThreadResponse {
+    /** The conversation's id, stable for its whole life. */
     id: string;
+    /**
+     * A short label taken from the first line of the first message (cut to 50
+     * characters), or the first attachment's filename when that message had no
+     * text.
+     */
     title: string;
+    /**
+     * True while the assistant has work running or queued in this conversation;
+     * false once it settles, or once a pause has outlived its wait and parked.
+     */
     busy: boolean;
+    /**
+     * The id of the conversation's live event stream, which differs from id.
+     * The package connects to the stream for you.
+     */
     stream_thread_id: string;
+    /** When the conversation was created, as an ISO 8601 timestamp. */
     created_at: string;
+    /** When the conversation was last updated, as an ISO 8601 timestamp. */
     updated_at: string;
+    /**
+     * The user's stored model and effort choice, or null when there is none and
+     * the assistant's configured model answers. The server may clear it between
+     * turns, for example when the model is no longer offered, so trust this
+     * over any locally remembered choice.
+     */
     model_pick?: ThreadModelPickResponse | null;
 }

package/dist/generated/models/servingAttachmentResponse.d.ts

@@ -1,9 +1,38 @@
 import type { AttachmentKind } from "./attachmentKind.js";
+/**
+ * An uploaded file, as returned when you start an upload and when you finalize
+ * it.
+ */
 export interface ServingAttachmentResponse {
+    /**
+     * The attachment's id; pass it in sendMessage's attachment ids to send the
+     * file with a message.
+     */
     id: string;
+    /**
+     * What the file is, detected from its contents when the upload is
+     * finalized. Reads "file" until then, and for anything not recognized as an
+     * image, document, video or audio.
+     */
     kind: AttachmentKind;
+    /**
+     * The detected format, such as "png", "pdf", "txt" or "mp4". Null until the
+     * upload is finalized, and for kind "file".
+     */
     format: string | null;
+    /**
+     * The file's name without any folder path or control characters, shortened
+     * if very long.
+     */
     filename: string;
+    /**
+     * The file's size in bytes, as declared when the upload started and as
+     * measured once it is finalized.
+     */
     byte_size: number;
+    /**
+     * True once the upload is finalized; only ready attachments can be sent
+     * with a message.
+     */
     ready: boolean;
 }

package/dist/generated/models/servingErrorCode.d.ts

@@ -1,4 +1,22 @@
+/**
+ * The error codes the Teaflask API returns. PUBLISHABLE_KEY_INVALID,
+ * ORIGIN_NOT_ALLOWED and END_USER_TOKEN_INVALID mean a setup problem in your
+ * integration; RATE_LIMITED and ORCHESTRATION_UNAVAILABLE clear on retry;
+ * ASSISTANT_SIGN_IN_REQUIRED means the assistant only serves signed-in users;
+ * ASSISTANT_UNFUNDED means your Teaflask organization has no funds to pay for
+ * replies; the SUBSCRIPTION_ codes come from a user connecting their own
+ * ChatGPT plan.
+ */
 export type ServingErrorCode = (typeof ServingErrorCode)[keyof typeof ServingErrorCode];
+/**
+ * The error codes the Teaflask API returns. PUBLISHABLE_KEY_INVALID,
+ * ORIGIN_NOT_ALLOWED and END_USER_TOKEN_INVALID mean a setup problem in your
+ * integration; RATE_LIMITED and ORCHESTRATION_UNAVAILABLE clear on retry;
+ * ASSISTANT_SIGN_IN_REQUIRED means the assistant only serves signed-in users;
+ * ASSISTANT_UNFUNDED means your Teaflask organization has no funds to pay for
+ * replies; the SUBSCRIPTION_ codes come from a user connecting their own
+ * ChatGPT plan.
+ */
 export declare const ServingErrorCode: {
     readonly PUBLISHABLE_KEY_INVALID: "PUBLISHABLE_KEY_INVALID";
     readonly ORIGIN_NOT_ALLOWED: "ORIGIN_NOT_ALLOWED";

package/dist/generated/models/servingTurnAttachmentResponse.d.ts

@@ -1,8 +1,20 @@
 import type { AttachmentKind } from "./attachmentKind.js";
+/**
+ * A file sent with a turn's message, as listed with the message; the built-in
+ * conversation shows it as a chip.
+ */
 export interface ServingTurnAttachmentResponse {
+    /** The attachment's id. */
     id: string;
+    /** What the file is, detected from its contents. */
     kind: AttachmentKind;
+    /**
+     * The detected format, such as "png", "pdf", "txt" or "mp4"; null for kind
+     * "file".
+     */
     format: string | null;
+    /** The file's name. */
     filename: string;
+    /** The file's size in bytes. */
     byte_size: number;
 }

package/dist/generated/models/siteTheme.d.ts

@@ -1,6 +1,7 @@
 import type { SiteThemeDefaultAppearance } from "./siteThemeDefaultAppearance.js";
 export interface SiteTheme {
     name: string;
+    description?: string | null;
     logo_light_url?: string | null;
     logo_dark_url?: string | null;
     favicon_url?: string | null;

package/dist/generated/models/thinkingEffort.d.ts

@@ -1,4 +1,14 @@
+/**
+ * How much reasoning the model spends on each reply, from least to most: low,
+ * medium, high, xhigh, max. A level the answering model doesn't support is
+ * moved to the nearest one it does.
+ */
 export type ThinkingEffort = (typeof ThinkingEffort)[keyof typeof ThinkingEffort];
+/**
+ * How much reasoning the model spends on each reply, from least to most: low,
+ * medium, high, xhigh, max. A level the answering model doesn't support is
+ * moved to the nearest one it does.
+ */
 export declare const ThinkingEffort: {
     readonly low: "low";
     readonly medium: "medium";