palbase 0.6.2 → 0.8.0

package/types/internal/src/modules/ai.d.ts

@@ -22,15 +22,23 @@ export type AgentDefinition = {
      */
     backend?: string;
     /**
-     * The app's users start chats with this named agent themselves (when the project lets them talk to its agents): an agent the server alone uses is not one they reach.
+     * The window, in tokens, the turn works in (the model's standard one unless said; more is billed as its provider bills it — GET /ai/models, context_window and max_input_tokens).
      */
-    clients?: boolean;
+    context_window?: number;
+    /**
+     * How hard the model thinks: none, minimal, low, medium, high, xhigh, max — which rungs a model takes is its catalogue entry's (GET /ai/models, efforts). Left out: the platform's.
+     */
+    effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
     /**
      * Its instructions.
      */
     instructions?: string;
     /**
-     * How many tool calls a turn makes at most: past it the agent is told it has no tools left and answers.
+     * The language of the person the turn works for, as a BCP 47 tag (tr, en-GB): the model writes to them in it on every step, and so do its subagents.
+     */
+    language?: string;
+    /**
+     * How many tool calls a turn makes at most (10000: the engine's own bound): past it the agent is told it has no tools left and answers. What a turn spends is its budget's to bound.
      */
     max_tool_calls?: number;
     /**
@@ -41,6 +49,10 @@ export type AgentDefinition = {
      * Its subagents (16 at most).
      */
     subagents?: Subagent[];
+    /**
+     * Whether the model's reasoning is shown in the chat's stream (visible: thinking parts) or not asked for at all (hidden). Left out: the platform's.
+     */
+    thinking?: "visible" | "hidden";
     /**
      * Its tools (64 at most, with its MCP servers').
      */
@@ -68,9 +80,10 @@ export type Chat = {
      */
     created_at: string;
     /**
-     * The user who started it; null: the project's server.
+     * Null: the project's server started it, as it starts every chat (a user's id: a chat a user started before chats were the server's alone).
      */
     created_by: string | null;
+    forked_from?: ChatFork;
     /**
      * What it keeps of the project's history.
      */
@@ -93,21 +106,43 @@ export type Chat = {
      * Its title.
      */
     title: string;
+    voice?: VoiceSession;
     workspace?: ChatWorkspace;
 };
 /**
- * Chats, the newest first (100 at most).
+ * Where a forked chat came from.
+ */
+export type ChatFork = {
+    /**
+     * The message it was cut before.
+     */
+    before_message: string;
+    /**
+     * The chat it was forked from (it may be deleted since).
+     */
+    chat_id: string;
+};
+/**
+ * Chats, the newest first, a page at a time.
  */
 export type ChatList = {
     /**
      * The chats.
      */
     chats: Chat[];
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
 };
 /**
  * A member's (or the server's) message.
  */
 export type ChatMessage = {
+    /**
+     * The pictures and the files it carries, its images first ([] for none).
+     */
+    attachments: MessageAttachment[];
     /**
      * The member who wrote it; null: the server.
      */
@@ -140,6 +175,16 @@ export type ChatMessage = {
      * Its id.
      */
     id: string;
+    /**
+     * text — a message written to the chat — or voice: a line said out loud in its voice, the person's (author, the member) or the voice's own (author null); voice says which.
+     */
+    kind: "text" | "voice";
+    /**
+     * Its writer's labels for it ({} for none).
+     */
+    metadata: {
+        [key: string]: string;
+    };
     /**
      * The turn it started or reached.
      */
@@ -152,6 +197,137 @@ export type ChatMessage = {
      * What they wrote.
      */
     text: string;
+    voice?: MessageVoice;
+};
+/**
+ * A text model a turn may name.
+ */
+export type ChatModel = {
+    /**
+     * The window a turn works in unless its definition asks for more — the largest billed at the standard rate where the price steps with the prompt (0: nobody says).
+     */
+    context_window: number;
+    /**
+     * Whether it is the model a turn that names none runs on.
+     */
+    default: boolean;
+    /**
+     * What it is for.
+     */
+    description: string;
+    /**
+     * Whether anyone says which rungs it takes: false offers none but the provider's own.
+     */
+    effort_known: boolean;
+    /**
+     * The rungs it takes (a definition's effort); empty when nobody says.
+     */
+    efforts: string[];
+    /**
+     * What a definition names it by (provider:model).
+     */
+    id: string;
+    /**
+     * The most it reads (0: nobody says).
+     */
+    max_input_tokens: number;
+    /**
+     * The most it writes (0: nobody says).
+     */
+    max_output_tokens: number;
+    /**
+     * Its name as people read it.
+     */
+    name: string;
+    price: ChatModelPrice;
+    /**
+     * The provider connection that serves it.
+     */
+    provider: string;
+    /**
+     * The roles it carries: fast, default, strong.
+     */
+    roles: string[];
+};
+/**
+ * A text model's list price per million tokens.
+ */
+export type ChatModelPrice = {
+    /**
+     * A cache read.
+     */
+    cache_read_usd_per_mtok: number;
+    /**
+     * A cache write (five minutes).
+     */
+    cache_write_usd_per_mtok: number;
+    /**
+     * Input.
+     */
+    input_usd_per_mtok: number;
+    long_context?: LongContextPrice;
+    /**
+     * Output.
+     */
+    output_usd_per_mtok: number;
+};
+/**
+ * One part of a chat's stream, as its channel carries it.
+ */
+export type ChatPart = {
+    /**
+     * What the part says, as the stream says it.
+     */
+    data: {
+        [key: string]: unknown;
+    };
+    /**
+     * The journal's sequence it was told at; absent for an answer's text, placed by its offset.
+     */
+    id?: number;
+    /**
+     * The id the channel told it under: the journal's sequence, or an answer's response and offset.
+     */
+    part_id: string;
+    /**
+     * message, turn, text, reset, thinking, tool, agent, goal, voice, transcript — as the stream says them.
+     */
+    type: string;
+};
+/**
+ * A page of a chat's past, in the order its stream told it.
+ */
+export type ChatPartPage = {
+    /**
+     * Reads the page before this one; absent once the chat's start is in this one.
+     */
+    next_cursor?: string;
+    /**
+     * The parts.
+     */
+    parts: ChatPart[];
+};
+/**
+ * Where a chat's stream is written.
+ */
+export type ChatPipe = {
+    /**
+     * A channel of the project's realtime (not one of the platform's: roles:, flags:, purchases:, messaging:, debug:, nor phoenix, realtime's heartbeat).
+     */
+    topic: string;
+};
+/**
+ * A chat's pipe.
+ */
+export type ChatPipeResult = {
+    /**
+     * The chat's id.
+     */
+    chat_id: string;
+    /**
+     * The channel its stream is written into.
+     */
+    topic: string;
 };
 /**
  * One repository of a chat's workspace.
@@ -167,11 +343,11 @@ export type ChatRepo = {
     repo: string;
 };
 /**
- * A chat to start.
+ * A chat to start: the project's server's alone.
  */
 export type ChatRequest = {
     /**
-     * The agent it talks to: a named agent of the project's — or, from the server with a definition of the chat's own, its name for it.
+     * The agent it talks to: a named agent of the project's — or, with a definition of the chat's own, the server's name for it.
      */
     agent: string;
     definition?: AgentDefinition;
@@ -185,16 +361,66 @@ export type ChatRequest = {
     metadata?: {
         [key: string]: string;
     };
-    /**
-     * A user who starts a chat is in it as its owner, under this name.
-     */
-    name?: string;
     /**
      * Its title (256 bytes at most).
      */
     title?: string;
     workspace?: ChatWorkspace;
 };
+/**
+ * Stops the chat's turn.
+ */
+export type ChatStop = {
+    /**
+     * The member the server stops it as (the server's alone): a member of the chat (403 not_a_member).
+     */
+    as?: string;
+};
+/**
+ * One tool call of a chat, its whole answer: what the chat's stream showed by its end (output, omitted_bytes), read whole — its secret shapes masked, as the stream masks them.
+ */
+export type ChatToolCall = {
+    /**
+     * The call.
+     */
+    call_id: string;
+    /**
+     * How many pictures it returned.
+     */
+    image_count: number;
+    /**
+     * What the agent called it with; null when its arguments, masked, are no JSON.
+     */
+    input: unknown;
+    /**
+     * The tool failed.
+     */
+    is_error: boolean;
+    /**
+     * The tool.
+     */
+    name: string;
+    /**
+     * Its answer's text, whole; null: none yet.
+     */
+    output: string | null;
+    /**
+     * How long the answer is.
+     */
+    output_bytes: number;
+    /**
+     * The turn — or the subagent's work in it — that made it.
+     */
+    response_id: string;
+    /**
+     * The run that made it: the turn's, or a subagent's.
+     */
+    run_id: string;
+    /**
+     * Where it is, as the engine says it: pending, executing, completed, failed…
+     */
+    status: string;
+};
 /**
  * The project's repositories a chat works in, each at a branch: its turns run on a machine of the platform's with them checked out, and what its agent commits is pushed to that branch.
  */
@@ -207,6 +433,23 @@ export type ChatWorkspace = {
      * 1 to 8 of the project's repositories, each once.
      */
     repos: ChatRepo[];
+    /**
+     * What each of its commits carries at its message's end (16 at most): a task, a link back to the conversation, a co-author. The engine writes each commit as the member its turn is for — their name and address — with these trailers; a turn of no member's commits as the platform.
+     */
+    trailers?: CommitTrailer[];
+};
+/**
+ * A git trailer each of the chat's commits carries at its message's end.
+ */
+export type CommitTrailer = {
+    /**
+     * Its token, as git takes one: letters, digits and -, at most 64 (Co-authored-by, PalCore-Task).
+     */
+    key: string;
+    /**
+     * One line of at most 512 bytes.
+     */
+    value: string;
 };
 /**
  * A decision made.
@@ -229,6 +472,10 @@ export type DecisionRequest = {
      * Yes, or no.
      */
     approve: boolean;
+    /**
+     * The member the project's server acts as: held to that member's rules — their turn (403 not_your_turn) — and the decision is theirs (the server's alone: a user sending it is answered 400; one who is not a member of the chat, 403 not_a_member). Left out, the server acts as itself.
+     */
+    as?: string;
     /**
      * Why (told to the agent; 1024 bytes at most).
      */
@@ -395,919 +642,1758 @@ export type ErrorResponse = {
     status: number;
 };
 /**
- * A picture job.
+ * Where to fork a chat.
  */
-export type Image = {
-    /**
-     * When it started.
-     */
-    created_at: string;
-    error: ImageError;
+export type ForkRequest = {
     /**
-     * When it and its pictures are forgotten.
-     */
-    expires_at: string;
-    /**
-     * Its pictures, once completed.
-     */
-    files: ImageFile[];
-    /**
-     * The job's id.
+     * The message the fork is cut before (a message's id): it, and all that came after it, are not the fork's.
      */
-    id: string;
+    before_message: string;
     /**
-     * The model.
+     * Who is in the fork (64 at most; left out or null: the chat's members, as they are).
      */
-    model: string;
+    members?: NewMember[] | null;
     /**
-     * running, completed or failed.
+     * The fork's title (256 bytes at most; left out: the chat's).
      */
-    status: "running" | "completed" | "failed";
-    usage: ImageUsage;
+    title?: string;
 };
 /**
- * Why a job failed; null when it did not.
+ * A chat's goal.
  */
-export type ImageError = ({
+export type Goal = {
     /**
-     * Why, as a stable code.
+     * When it was met; null: not yet.
      */
-    code: string;
+    achieved_at: string | null;
+    budget: GoalBudget;
     /**
-     * Why, in a sentence.
+     * The chat.
      */
-    message: string;
-}) | null;
-/**
- * A picture of a finished job.
- */
-export type ImageFile = {
+    chat_id: string;
     /**
-     * Its size.
+     * When it was set.
      */
-    bytes: number;
+    created_at: string;
     /**
-     * Its media type.
+     * The goal's id (a new goal, a new id).
      */
-    media_type: string;
+    id: string;
     /**
-     * Where to read it (GET).
+     * The most turns it opens; null: no limit.
      */
-    path: string;
+    max_turns: number | null;
     /**
-     * Its place in the job, from 0.
+     * What the chat works toward.
      */
-    position: number;
-};
-/**
- * A picture the caller sends.
- */
-export type ImageInput = {
+    objective: string;
     /**
-     * The picture's bytes, base64-encoded (20 MB at most).
+     * What its next turn is: work, or verify (the check of a completion its agent claimed).
      */
-    data: string;
+    phase: string;
     /**
-     * image/png, image/jpeg or image/webp (a mask is image/png with an alpha channel).
+     * What a claimed completion is checked against.
      */
-    media_type: "image/png" | "image/jpeg" | "image/webp";
-};
-/**
- * An image model.
- */
-export type ImageModel = {
+    rubric: string;
     /**
-     * List price of a million reference picture tokens, in US dollars.
+     * The member it was set as; null: the server.
      */
-    image_input_usd_per_mtok: number;
+    set_by: string | null;
     /**
-     * List price of a million picture tokens, in US dollars.
+     * active, paused, blocked (it cannot go on without a person), budget_limited, or achieved.
      */
-    image_output_usd_per_mtok: number;
+    status: string;
     /**
-     * The model, as provider:model.
+     * Why it last left active, as a stable code (empty while active): paused_by_person, paused_by_client, turn_stopped, turns_failed, no_progress, judge_unreadable, check_unreadable, needs_person, credit_hold, not_admitted, budget_spent, turns_used, time_used, achieved.
      */
-    model: string;
+    stop_code: string;
     /**
-     * The role that names it: default, strong, or empty.
+     * Why, in a sentence.
      */
-    role: string;
+    stop_reason: string;
     /**
-     * List price of a million prompt tokens, in US dollars.
+     * When it last changed.
      */
-    text_input_usd_per_mtok: number;
+    updated_at: string;
+    usage: GoalUsage;
 };
 /**
- * A request for pictures.
+ * What a goal may cost at most, all its turns and their subagents together; null: no limit.
  */
-export type ImageRequest = {
+export type GoalBudget = ({
     /**
-     * auto, transparent or opaque; transparent needs png or webp.
+     * In dollars.
      */
-    background?: string;
+    max_cost_usd: number;
+}) | null;
+/**
+ * A chat's goal set, its status changed, or cleared.
+ */
+export type GoalEvent = {
     /**
-     * How many pictures (1–4, default 1).
+     * The chat.
      */
-    count?: number;
+    chat_id: string;
     /**
-     * png (default), jpeg or webp.
+     * The goal.
      */
-    format?: string;
-    mask?: ImageInput;
+    goal_id: string;
     /**
-     * default (fast), strong (precise edits), or a catalogue image model as provider:model.
+     * The chat's labels.
      */
-    model?: string;
+    metadata: {
+        [key: string]: string;
+    };
     /**
-     * What to make.
+     * What it was; null: no goal.
      */
-    prompt: string;
+    previous_status: string | null;
     /**
-     * auto, low, medium, high, xhigh or max.
+     * The member it was set as; null: the server.
      */
-    quality?: string;
+    set_by: string | null;
     /**
-     * Pictures to work from (4 at most, each 8 MiB at most and — with the mask — 24 MiB together, as PNG, JPEG or WebP): with them the job is an edit.
+     * What it is now: active, paused, blocked, budget_limited, achieved — or cleared.
      */
-    references?: ImageInput[];
+    status: string;
     /**
-     * auto, 1024x1024, 1536x1024, 1024x1536, or WIDTHxHEIGHT: sides multiples of 16, an aspect between 1:3 and 3:1, 655,360 to 8,294,400 pixels.
+     * Why it left active, as a stable code (empty while active).
      */
-    size?: string;
-};
-/**
- * What a finished job cost; null until then.
- */
-export type ImageUsage = ({
+    stop_code: string;
     /**
-     * What it cost at the list price, in billionths of a dollar.
+     * Why, in a sentence.
      */
-    cost_nano_usd: number;
+    stop_reason: string;
+};
+/**
+ * What changes of a chat's goal: a field left out is left as it is.
+ */
+export type GoalPatch = {
     /**
-     * Reference picture tokens.
+     * The member the server changes it as: the one it was set as (403 not_your_turn otherwise).
      */
-    image_input_tokens: number;
+    as?: string;
+    budget?: GoalBudget;
     /**
-     * Prompt tokens.
+     * The most turns it opens; null: no limit.
      */
-    input_tokens: number;
+    max_turns?: number | null;
     /**
-     * Picture tokens.
+     * Its objective, edited.
      */
-    output_tokens: number;
-}) | null;
-/**
- * A picture a question is about: a file of the project's storage (bucket and path), read by the model through a URL signed for the while it is answered, or an https address the model reads it from. Nothing of it is kept by the module.
- */
-export type InputImage = {
+    objective?: string;
     /**
-     * The project's storage bucket the picture is in (with path).
+     * Why it is paused, with status paused (500 characters at most): said in its stop_reason and its event.
      */
-    bucket?: string;
+    reason?: string;
     /**
-     * The picture's path in the bucket.
+     * Its rubric, edited.
      */
-    path?: string;
+    rubric?: string;
     /**
-     * An https address the model reads the picture from (2048 characters at most), instead of bucket and path.
+     * paused (the goal waits) or active (it goes on).
      */
-    url?: string;
+    status?: "paused" | "active";
 };
 /**
- * A user in a chat.
+ * A chat's goal to set.
  */
-export type Member = {
+export type GoalRequest = {
     /**
-     * How the agent and the others are told who wrote.
+     * The member the server sets it as: the goal and its turns are theirs (the server's alone: a user sending it is answered 403 server_only; one who is not a member of the chat, 403 not_a_member). Left out, the server's.
      */
-    name: string;
+    as?: string;
+    budget?: TurnBudget;
     /**
-     * The owner deletes the chat.
+     * The most turns it opens (1 to 10000; left out: no limit).
      */
-    owner: boolean;
+    max_turns?: number;
     /**
-     * The user's id.
+     * What the chat works toward, in words (4000 characters at most).
      */
-    user_id: string;
+    objective: string;
+    /**
+     * What a claimed completion is checked against (8000 characters at most; left out: the objective itself).
+     */
+    rubric?: string;
 };
 /**
- * A user to put in a chat.
+ * What a goal has used so far.
  */
-export type MemberRequest = {
+export type GoalUsage = {
     /**
-     * Their name in it.
+     * How long it has been at work since it was set or last resumed.
      */
-    name?: string;
+    active_seconds: number;
     /**
-     * Whether they own it.
+     * Some of its use has no price yet: it cost at least this.
      */
-    owner?: boolean;
-};
-/**
- * One turn of the conversation so far.
- */
-export type Message = {
+    cost_is_lower_bound: boolean;
     /**
-     * What was said.
+     * What its turns cost so far, in dollars.
      */
-    content: string;
+    cost_usd: number;
     /**
-     * Who said it.
+     * Work turns it opened.
      */
-    role: "user" | "assistant";
+    turns: number;
+    /**
+     * Checks of a claimed completion.
+     */
+    verifications: number;
 };
 /**
- * A page of a chat's messages, the newest first.
+ * A picture job.
  */
-export type MessagePage = {
+export type Image = {
     /**
-     * The messages.
+     * When it started.
      */
-    messages: ChatMessage[];
+    created_at: string;
+    error: ImageError;
     /**
-     * Pages on (cursor=); absent on the last page.
+     * When it and its pictures are forgotten.
      */
-    next_cursor?: string;
-};
-/**
- * A message for a chat.
- */
-export type MessageRequest = {
+    expires_at: string;
     /**
-     * The member the server writes as (the server's alone).
+     * Its pictures, once completed.
      */
-    as?: string;
-    budget?: TurnBudget;
+    files: ImageFile[];
     /**
-     * The writer's own id for it: sent again — a retry, a second tab — it is the same message, delivered once.
+     * The job's id.
      */
-    client_id: string;
+    id: string;
     /**
-     * While the agent works on a turn: next gives it the message at its next step (the default), now cuts the step it is in. When no turn runs, a message starts one.
+     * The model.
      */
-    delivery?: "next" | "now";
+    model: string;
     /**
-     * The message (64 KiB at most).
+     * running, completed or failed.
      */
-    text: string;
+    status: "running" | "completed" | "failed";
+    usage: ImageUsage;
 };
 /**
- * What a project may name.
+ * Why a job failed; null when it did not.
  */
-export type Models = {
-    /**
-     * Embedding models, with their list prices.
-     */
-    embeddings: EmbeddingModel[];
+export type ImageError = ({
     /**
-     * Image models, with their list prices.
+     * Why, as a stable code.
      */
-    images: ImageModel[];
+    code: string;
     /**
-     * The roles a text model is chosen by.
+     * Why, in a sentence.
      */
-    text: TextModel[];
-};
+    message: string;
+}) | null;
 /**
- * A user to put in a chat as it starts.
+ * A picture of a finished job.
  */
-export type NewMember = {
+export type ImageFile = {
     /**
-     * How the agent and the others are told who wrote.
+     * Its size.
      */
-    name?: string;
+    bytes: number;
     /**
-     * Whether they own it.
+     * Its media type.
      */
-    owner?: boolean;
+    media_type: string;
     /**
-     * The user's id.
+     * Where to read it (GET).
      */
-    user_id: string;
+    path: string;
+    /**
+     * Its place in the job, from 0.
+     */
+    position: number;
 };
 /**
- * A provider the project connected with its own key.
+ * A picture the caller sends.
  */
-export type Provider = {
+export type ImageInput = {
     /**
-     * The provider.
+     * The picture's bytes, base64-encoded (20 MB at most).
      */
-    name: string;
+    data: string;
     /**
-     * The provider accepted the key when it was connected.
+     * image/png, image/jpeg or image/webp (a mask is image/png with an alpha channel).
      */
-    verified: boolean;
+    media_type: "image/png" | "image/jpeg" | "image/webp";
 };
 /**
- * A provider key.
+ * An image model.
  */
-export type ProviderKey = {
+export type ImageModel = {
     /**
-     * The provider's API key. It is never read back.
+     * List price of a million reference picture tokens, in US dollars.
      */
-    key: string;
-};
-/**
- * The project's own provider keys.
- */
-export type ProviderList = {
+    image_input_usd_per_mtok: number;
     /**
-     * The project's providers.
+     * List price of a million picture tokens, in US dollars.
      */
-    providers: Provider[];
+    image_output_usd_per_mtok: number;
+    /**
+     * The model, as provider:model.
+     */
+    model: string;
+    /**
+     * The role that names it: default, strong, or empty.
+     */
+    role: string;
+    /**
+     * List price of a million prompt tokens, in US dollars.
+     */
+    text_input_usd_per_mtok: number;
 };
 /**
- * A GitHub repository the project's chats work in, by the project's name for it; the project's backend gives its tokens (the framework's ai.repo), asked at each clone and each push.
+ * A request for pictures.
  */
-export type Repo = {
+export type ImageRequest = {
     /**
-     * The project's machine that gives its tokens.
+     * auto, transparent or opaque; transparent needs png or webp.
      */
-    backend: string;
+    background?: string;
     /**
-     * When it was put first.
+     * How many pictures (1–4, default 1).
      */
-    created_at: string;
+    count?: number;
     /**
-     * The branch a workspace takes when it names none.
+     * png (default), jpeg or webp.
      */
-    default_branch: string;
+    format?: string;
+    mask?: ImageInput;
     /**
-     * The project's name for it.
+     * default (fast), strong (precise edits), or a catalogue image model as provider:model.
      */
-    name: string;
+    model?: string;
     /**
-     * The GitHub repository, owner/name.
+     * What to make.
      */
-    repository: string;
-};
-/**
- * The project's repositories.
- */
-export type RepoPage = {
-    repos: Repo[];
-};
-/**
- * A repository the project's chats work in.
- */
-export type RepoRequest = {
+    prompt: string;
     /**
-     * The project's machine whose framework gives the repository's tokens (backend unless said).
+     * auto, low, medium, high, xhigh or max.
      */
-    backend?: string;
+    quality?: string;
     /**
-     * The branch a workspace takes when it names none (main unless said).
+     * Pictures to work from (4 at most, each 8 MiB at most and — with the mask — 24 MiB together, as PNG, JPEG or WebP): with them the job is an edit.
      */
-    default_branch?: string;
+    references?: ImageInput[];
     /**
-     * The GitHub repository, owner/name.
+     * auto, 1024x1024, 1536x1024, 1024x1536, or WIDTHxHEIGHT: sides multiples of 16, an aspect between 1:3 and 3:1, 655,360 to 8,294,400 pixels.
      */
-    repository: string;
+    size?: string;
 };
 /**
- * A response.
+ * What a finished job cost; null until then.
  */
-export type Response = {
+export type ImageUsage = ({
     /**
-     * When it was admitted.
+     * What it cost at the list price, in billionths of a dollar.
      */
-    created_at: string;
-    error: ResponseError;
+    cost_nano_usd: number;
     /**
-     * The response's id.
+     * Reference picture tokens.
      */
-    id: string;
+    image_input_tokens: number;
     /**
-     * The caller's own labels (16 at most, snake_case keys): returned with the response and its event.
+     * Prompt tokens.
      */
-    metadata: {
-        [key: string]: string;
-    };
+    input_tokens: number;
     /**
-     * The model that answered.
+     * Picture tokens.
      */
-    model: string;
+    output_tokens: number;
+}) | null;
+/**
+ * A picture the question is about: a file of the project's storage (bucket and path), an https address the model reads it from (url), or its bytes (data, base64, of media_type) — a screenshot the caller holds, kept in the project's storage for the while the question is answered. One of the three.
+ */
+export type InputImage = {
     /**
-     * The parsed document of an answer to a schema; null otherwise.
+     * The project's storage bucket the picture is in (with path).
      */
-    output: unknown;
+    bucket?: string;
     /**
-     * Where it is: queued, in_progress, then completed, failed, canceled, timed_out or budget_exceeded.
+     * The picture's bytes, base64: 5 MiB at most, 6 MiB with the question's other pictures given so.
      */
-    status: string;
+    data?: string;
     /**
-     * The answer as the model wrote it; for a schema's answer, the JSON document.
+     * The picture's type, with its bytes: image/png, image/jpeg, image/webp or image/gif.
      */
-    text: string | null;
-    usage: ResponseUsage;
-};
+    media_type?: string;
+    /**
+     * The picture's path in the bucket.
+     */
+    path?: string;
+    /**
+     * An https address the model reads the picture from (2048 characters at most), instead of bucket and path.
+     */
+    url?: string;
+};
 /**
- * Why a response did not complete; null when it did.
+ * A model's price past its prompt's step: the whole request pays it.
  */
-export type ResponseError = ({
+export type LongContextPrice = {
     /**
-     * Why, as a stable code.
+     * The step: a prompt of more tokens.
      */
-    code: string;
+    above_prompt_tokens: number;
     /**
-     * Why, in a sentence.
+     * Input.
      */
-    message: string;
-}) | null;
+    input_usd_per_mtok: number;
+    /**
+     * Output.
+     */
+    output_usd_per_mtok: number;
+};
 /**
- * A background response ended.
+ * A user in a chat.
  */
-export type ResponseEvent = {
+export type Member = {
     /**
-     * What it cost, in billionths of a dollar.
+     * How the agent and the others are told who wrote.
      */
-    cost_nano_usd: number;
+    name: string;
     /**
-     * The caller's own labels (16 at most, snake_case keys): returned with the response and its event.
+     * The owner deletes the chat.
      */
-    metadata: {
+    owner: boolean;
+    /**
+     * The user's id.
+     */
+    user_id: string;
+};
+/**
+ * A user to put in a chat.
+ */
+export type MemberRequest = {
+    /**
+     * Their address (none: the one kept, if any): what their turns' commits are written as. Never served.
+     */
+    email?: string;
+    /**
+     * Their name in it.
+     */
+    name?: string;
+    /**
+     * Whether they own it.
+     */
+    owner?: boolean;
+};
+/**
+ * One turn of the conversation so far.
+ */
+export type Message = {
+    /**
+     * What was said.
+     */
+    content: string;
+    /**
+     * Who said it.
+     */
+    role: "user" | "assistant";
+};
+/**
+ * A picture or a file a message carries, its images first. Its bytes are read at GET /ai/chats/{chat_id}/messages/{message_id}/attachments/{position}, by the chat's members and its server.
+ */
+export type MessageAttachment = {
+    /**
+     * The bucket of the project's storage it was copied from.
+     */
+    bucket: string;
+    /**
+     * What it is: a picture's type by its bytes (whatever it was labelled), a file's as its message or the project's storage said.
+     */
+    content_type: string;
+    /**
+     * image: a picture the model is shown with the message; file: a file put in the chat's workspace.
+     */
+    kind: "image" | "file";
+    /**
+     * What the message calls it: a file's name in the workspace.
+     */
+    name: string;
+    /**
+     * Its path in that bucket.
+     */
+    path: string;
+    /**
+     * Its bytes' sha256, hex.
+     */
+    sha256: string;
+    /**
+     * Its size in bytes.
+     */
+    size: number;
+    /**
+     * Where a file is in the chat's workspace: .palbase/attachments/<message id>/<name>.
+     */
+    workspace_path?: string;
+};
+/**
+ * A file of the project's storage a message puts in its chat's workspace.
+ */
+export type MessageFileRequest = {
+    /**
+     * The bucket it is in: one of the project's own.
+     */
+    bucket: string;
+    /**
+     * What it is, as the agent is told (a media type: application/pdf; its parameters dropped). None: what the project's storage says.
+     */
+    content_type?: string;
+    /**
+     * Its name in the workspace, and what the message calls it (its path's last segment when none; a second of a name in one message is numbered, rapor-2.pdf).
+     */
+    filename?: string;
+    /**
+     * Its path in the bucket.
+     */
+    path: string;
+};
+/**
+ * A picture of the project's storage a message shows the model.
+ */
+export type MessageImageRequest = {
+    /**
+     * The bucket it is in: one of the project's own.
+     */
+    bucket: string;
+    /**
+     * Its path in the bucket.
+     */
+    path: string;
+};
+/**
+ * A page of a chat's messages, the newest first.
+ */
+export type MessagePage = {
+    /**
+     * The messages.
+     */
+    messages: ChatMessage[];
+    /**
+     * Pages on (cursor=); absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * A message for a chat.
+ */
+export type MessageRequest = {
+    /**
+     * The member the server writes as (the server's alone: a user sending it is answered 400; one who is not a member of the chat, 403 not_a_member): the message is theirs, and counts toward their messages a minute (429 too_many_messages, as theirs would).
+     */
+    as?: string;
+    budget?: TurnBudget;
+    /**
+     * The writer's own id for it: sent again — a retry, a second tab — it is the same message, delivered once.
+     */
+    client_id: string;
+    /**
+     * What the model reads with the message and no member does (the server's alone: a user sending it is answered 400; 64 KiB at most): a document the agent needs, how to open a file the message names. The agent is told it as the project's own words, apart from the writer's; the chat's stream and its list never show it.
+     */
+    context?: string;
+    /**
+     * While the agent works on a turn: next gives it the message at its next step (the default), now cuts the step it is in. When no turn runs, a message starts one.
+     */
+    delivery?: "next" | "now";
+    /**
+     * Files of the project's storage put in the chat's workspace before the agent reads the message, at .palbase/attachments/<message id>/<filename>, and the agent is told where (8 at most, 15 MiB each at most). A chat that works in no workspace takes none (409 no_workspace). Copied for the chat, and who may attach which, as images; an object the message names twice — a picture of it and a file of it too — is read once.
+     */
+    files?: MessageFileRequest[];
+    /**
+     * Pictures of the project's storage the model is shown with the message (4 at most, as many as the model is shown at once; png, jpeg, webp or gif by their bytes, whatever they are labelled — another is 415 unsupported_image; 5 MiB each at most). Each is copied for the chat as the message is written: what it carried is what the agent reads, whatever becomes of the file, and the copy goes with the chat. The server attaches any file of its storage, writing as a member or not: its decision. A member with their own session attaches a public bucket's files alone — a private bucket's file, their own (owner_id) too, is the server's to attach. Any other is not found (404 attachment_not_found), as one that is not there is. Past the bounds: 413 attachment_too_large; changed while it was attached: 409 attachment_changed.
+     */
+    images?: MessageImageRequest[];
+    /**
+     * Its writer's own labels for the message (16 at most, snake_case keys, values of 512 bytes at most) — what an app draws it by: the files it names, the kind of row it is, the model its writer chose. Kept with it, shown with it in the chat's stream and its list, and given to the backend that defines the agent of the turn it opens (the agent context's message). Sent again with the same client_id, the first message's stand.
+     */
+    metadata?: {
         [key: string]: string;
     };
     /**
-     * The model that answered.
+     * The message (64 KiB at most).
      */
-    model: string;
+    text: string;
+};
+/**
+ * The voice a line of kind voice was said in, and by whom.
+ */
+export type MessageVoice = {
     /**
-     * The response.
+     * The voice.
      */
-    response_id: string;
+    id: string;
     /**
-     * How it ended.
+     * user (the person) or assistant (the voice).
      */
-    status: string;
+    role: string;
 };
 /**
- * A question for a model: input, or messages.
+ * What a project may name.
  */
-export type ResponseRequest = {
+export type Models = {
     /**
-     * Answer at once; the response's end is the event ai.response.completed or ai.response.failed.
+     * Every text model a turn may name — a chat's agent, a response — on the project's own provider connections or the platform's, as the engine's catalogue says it: what a model picker offers a person.
      */
-    background?: boolean;
+    chat: ChatModel[];
     /**
-     * Pictures the question is about, shown to the model with it (4 at most).
+     * Embedding models, with their list prices.
      */
-    images?: InputImage[];
+    embeddings: EmbeddingModel[];
+    /**
+     * Image models, with their list prices.
+     */
+    images: ImageModel[];
+    /**
+     * The roles a text model is chosen by.
+     */
+    text: TextModel[];
+    /**
+     * The providers whose models could not be listed just now: their models are missing from chat until they answer.
+     */
+    unavailable: string[];
+};
+/**
+ * A user to put in a chat as it starts.
+ */
+export type NewMember = {
+    /**
+     * Their address: what the commits their turns' agent makes in the chat's workspace are written as (with their name). Kept, never served; a member's own session says it again, verified, as they write. None: an address of the platform's that names them and reaches no one.
+     */
+    email?: string;
+    /**
+     * How the agent and the others are told who wrote.
+     */
+    name?: string;
+    /**
+     * Whether they own it.
+     */
+    owner?: boolean;
+    /**
+     * The user's id.
+     */
+    user_id: string;
+};
+/**
+ * A provider the project connected with its own key.
+ */
+export type Provider = {
+    /**
+     * The provider.
+     */
+    name: string;
+    /**
+     * The provider accepted the key when it was connected.
+     */
+    verified: boolean;
+};
+/**
+ * A provider key.
+ */
+export type ProviderKey = {
+    /**
+     * The provider's API key. It is never read back.
+     */
+    key: string;
+};
+/**
+ * The project's own provider keys.
+ */
+export type ProviderList = {
+    /**
+     * The project's providers.
+     */
+    providers: Provider[];
+};
+/**
+ * A commit a push brought to its branch.
+ */
+export type PushedCommit = {
+    /**
+     * Its author's address.
+     */
+    author_email: string;
+    /**
+     * Its author: the member the turn was for, when the server said who they are.
+     */
+    author_name: string;
+    /**
+     * The commit.
+     */
+    sha: string;
+    /**
+     * Its message's first line.
+     */
+    subject: string;
+};
+/**
+ * A GitHub repository the project's chats work in, by the project's name for it; the project's backend gives its tokens (the framework's ai.repo), asked at each clone and each push.
+ */
+export type Repo = {
+    /**
+     * The project's machine that gives its tokens.
+     */
+    backend: string;
+    /**
+     * When it was put first.
+     */
+    created_at: string;
+    /**
+     * The branch a workspace takes when it names none.
+     */
+    default_branch: string;
+    /**
+     * The project's name for it.
+     */
+    name: string;
+    /**
+     * The GitHub repository, owner/name.
+     */
+    repository: string;
+};
+/**
+ * The project's repositories, by name, a page at a time.
+ */
+export type RepoPage = {
+    /**
+     * The next page's cursor; absent on the last page.
+     */
+    next_cursor?: string;
+    repos: Repo[];
+};
+/**
+ * A repository the project's chats work in.
+ */
+export type RepoRequest = {
+    /**
+     * The project's machine whose framework gives the repository's tokens (backend unless said).
+     */
+    backend?: string;
+    /**
+     * The branch a workspace takes when it names none (main unless said).
+     */
+    default_branch?: string;
+    /**
+     * The GitHub repository, owner/name.
+     */
+    repository: string;
+};
+/**
+ * A response.
+ */
+export type Response = {
+    /**
+     * When it was admitted.
+     */
+    created_at: string;
+    error: ResponseError;
+    /**
+     * The response's id.
+     */
+    id: string;
+    /**
+     * The caller's own labels (16 at most, snake_case keys): returned with the response and its event.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * The model that answered.
+     */
+    model: string;
+    /**
+     * The parsed document of an answer to a schema; null otherwise.
+     */
+    output: unknown;
+    /**
+     * Where it is: queued, in_progress, then completed, failed, canceled, timed_out or budget_exceeded.
+     */
+    status: string;
+    /**
+     * The answer as the model wrote it; for a schema's answer, the JSON document.
+     */
+    text: string | null;
+    usage: ResponseUsage;
+};
+/**
+ * Why a response did not complete; null when it did.
+ */
+export type ResponseError = ({
+    /**
+     * Why, as a stable code.
+     */
+    code: string;
+    /**
+     * Why, in a sentence.
+     */
+    message: string;
+}) | null;
+/**
+ * A response started in the background ended, or a chat's turn began or ended: a chat's turn carries the chat's fields besides (chat_id, user_id, message_metadata, goal_id, goal_turn).
+ */
+export type ResponseEvent = {
+    /**
+     * A chat's turn: the chat.
+     */
+    chat_id?: string;
+    /**
+     * What it cost, in billionths of a dollar.
+     */
+    cost_nano_usd: number;
+    error?: ResponseEventError;
+    /**
+     * A chat's turn: the goal it is a turn of; null: none.
+     */
+    goal_id?: string | null;
+    /**
+     * A chat's turn: whether it is a turn of the chat's goal.
+     */
+    goal_turn?: boolean;
+    /**
+     * A chat's turn: the labels of the message that opened it ({}: none, or a turn no message opened).
+     */
+    message_metadata?: {
+        [key: string]: string;
+    };
+    /**
+     * A background response's: the caller's own labels (16 at most, snake_case keys). A chat's turn's: the chat's labels.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * The model that answered.
+     */
+    model: string;
+    /**
+     * The response.
+     */
+    response_id: string;
+    /**
+     * How it ended — a background response's as the engine says it (completed, failed, canceled, timed_out, budget_exceeded); a chat's turn's in the chat's words: running (ai.response.started), completed, failed, stopped (a member or the server stopped it, or the chat went), budget_exceeded.
+     */
+    status: string;
+    /**
+     * A chat's turn: the member it ran for — whose message opened it, or whose goal it is; null: the server's.
+     */
+    user_id?: string | null;
+};
+/**
+ * How a response ended when it did not complete, and was not stopped.
+ */
+export type ResponseEventError = {
+    /**
+     * A stable code: internal_error, timed_out, budget_exceeded, or the engine's own.
+     */
+    code: string;
+    /**
+     * Why, in a sentence.
+     */
+    message: string;
+    /**
+     * Whether asking again may go otherwise.
+     */
+    retryable: boolean;
+};
+/**
+ * A question for a model: input, or messages.
+ */
+export type ResponseRequest = {
+    /**
+     * Answer at once; the response's end is the event ai.response.completed or ai.response.failed.
+     */
+    background?: boolean;
+    /**
+     * Pictures the question is about, shown to the model with it (4 at most).
+     */
+    images?: InputImage[];
+    /**
+     * The question (2 MB at most). Give this, or messages.
+     */
+    input?: string;
+    /**
+     * How the model should answer (256 KB at most).
+     */
+    instructions?: string;
+    /**
+     * How many tool calls the answer makes at most (10000: the engine's own bound): past it the model is told it has no tools left and answers.
+     */
+    max_tool_calls?: number;
+    /**
+     * The conversation so far instead of one question (500 turns at most); its last turn is the user's.
+     */
+    messages?: Message[];
+    /**
+     * The caller's own labels (16 at most, snake_case keys): returned with the response and its event.
+     */
+    metadata?: {
+        [key: string]: string;
+    };
+    /**
+     * A role — fast, default (the default), strong — or a catalogue model as provider:model. Name a role: when a provider retires a model, the role is bound to another and your code does not change.
+     */
+    model?: string;
+    /**
+     * A JSON Schema the answer must be a document of. Its keywords are the provider's strict subset: type, properties, required, additionalProperties, items, enum, description, title, minimum, maximum, minLength, maxLength, minItems, maxItems — no $ref, at most 12 levels and 512 properties; every property required (a nullable one may be null). One outside the subset is refused, naming where it is.
+     */
+    schema?: {
+        [key: string]: unknown;
+    };
+    /**
+     * The schema's name, as the model is told it (letters, digits, _ and -; default answer).
+     */
+    schema_name?: string;
+    /**
+     * Answer with the response's live view (text/event-stream).
+     */
+    stream?: boolean;
+    /**
+     * What the model may call to answer: the project's backend's functions, its HTTPS tools and MCP servers (an app's own tools are a chat's).
+     */
+    tools?: ToolRef[];
+};
+/**
+ * What a response used.
+ */
+export type ResponseUsage = {
+    /**
+     * Nothing more of its cost can be settled: what it cost is the whole.
+     */
+    cost_final: boolean;
+    /**
+     * What it cost, in billionths of a dollar, once it ended (0 before).
+     */
+    cost_nano_usd: number;
+    /**
+     * Tokens read.
+     */
+    input_tokens: number;
+    /**
+     * Tokens written.
+     */
+    output_tokens: number;
+    /**
+     * cost_nano_usd in dollars.
+     */
+    usd: number;
+};
+/**
+ * A message a subagent was given.
+ */
+export type RunMessageAccepted = {
+    /**
+     * The writer's id for it.
+     */
+    client_id: string;
+    /**
+     * The subagent's run.
+     */
+    run_id: string;
+};
+/**
+ * A message for a subagent at work.
+ */
+export type RunMessageRequest = {
+    /**
+     * The member the project's server acts as: held to that member's rules — their messages a minute (429 too_many_messages) — and the message is theirs (the server's alone: a user sending it is answered 400; one who is not a member of the chat, 403 not_a_member). Left out, the server acts as itself.
+     */
+    as?: string;
+    /**
+     * The writer's id for it.
+     */
+    client_id: string;
+    /**
+     * The message.
+     */
+    text: string;
+};
+/**
+ * Who stops a subagent.
+ */
+export type RunStopRequest = {
+    /**
+     * The member the project's server stops it as: a member of the chat (the server's alone: a user sending it is answered 400; one who is not a member, 403 not_a_member). Left out, the server stops it as itself.
+     */
+    as?: string;
+};
+/**
+ * A subagent a stop ended.
+ */
+export type RunStopped = {
+    /**
+     * Its run.
+     */
+    run_id: string;
+};
+/**
+ * What the project allows its chats.
+ */
+export type Settings = {
+    /**
+     * Whether the app's users talk to the project's agents with their own session: read and write to the chats they are in (the project's server starts them).
+     */
+    clients: boolean;
+    /**
+     * How much it keeps now.
+     */
+    history_bytes: number;
+    /**
+     * How much chat history the project keeps; a message past it is refused (history_full) until chats are deleted. A free project keeps 500 MiB at most; null: no fixed limit — a project with paid rights keeps all of it, paid by use, unless it says a limit of its own.
+     */
+    history_limit_bytes: number | null;
+    /**
+     * How many messages one user sends a minute (default 20).
+     */
+    user_messages_per_minute: number;
+};
+/**
+ * A change of what the project allows its chats; a field left out is left as it is.
+ */
+export type SettingsRequest = {
+    /**
+     * Let the app's users talk to the project's agents themselves.
+     */
+    clients?: boolean;
+    /**
+     * A limit of the project's own: a free project at most the plan's 500 MiB (it may keep less, not more), a project with paid rights at most 1 TiB. null clears it: the plan's is kept (free: 500 MiB; with paid rights: none).
+     */
+    history_limit_bytes?: number | null;
+    /**
+     * 1 to 600.
+     */
+    user_messages_per_minute?: number;
+};
+/**
+ * The turn a stop stopped.
+ */
+export type StopResult = {
+    /**
+     * Its response; null: none was running.
+     */
+    stopped: string | null;
+};
+/**
+ * An agent the agent may hand part of a turn to.
+ */
+export type Subagent = {
+    /**
+     * The window, in tokens, it works in. Left out: the agent's, when it runs on the agent's model.
+     */
+    context_window?: number;
+    /**
+     * What it is for: the agent reads it to choose.
+     */
+    description: string;
+    /**
+     * How hard its model thinks. Left out: the agent's, when it runs on the agent's model.
+     */
+    effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    /**
+     * Its instructions.
+     */
+    instructions?: string;
+    /**
+     * Its model: a role (fast, default, strong) or a catalogue model.
+     */
+    model?: string;
+    /**
+     * Its name, unique among the subagents.
+     */
+    name: string;
+    /**
+     * The turn fails if this subagent's part fails.
+     */
+    required?: boolean;
+    /**
+     * Whether its model's reasoning is asked for to show (visible) or not at all (hidden). Left out: the agent's.
+     */
+    thinking?: "visible" | "hidden";
+    /**
+     * Its tools.
+     */
+    tools?: ToolRef[];
+};
+/**
+ * A role a text model is chosen by.
+ */
+export type TextModel = {
+    /**
+     * What it is for.
+     */
+    description: string;
+    /**
+     * The role.
+     */
+    role: string;
+};
+/**
+ * A part of what a tool returned.
+ */
+export type ToolContent = {
+    /**
+     * An image as base64 (5 MiB at most).
+     */
+    data?: string;
+    /**
+     * An image's type: image/png, image/jpeg, image/webp or image/gif.
+     */
+    media_type?: string;
+    /**
+     * The text.
+     */
+    text?: string;
+    /**
+     * text or image.
+     */
+    type: "text" | "image";
+};
+/**
+ * What an app's tool returned (1 MiB of text and 4 images at most).
+ */
+export type ToolOutput = {
+    /**
+     * The member the project's server acts as: held to that member's rules — their turn (403 not_your_turn) (the server's alone: a user sending it is answered 400; one who is not a member of the chat, 403 not_a_member). Left out, the server acts as itself.
+     */
+    as?: string;
+    /**
+     * The tool failed; the output says why.
+     */
+    is_error?: boolean;
+    /**
+     * Text and images: the agent is shown both.
+     */
+    output: ToolContent[];
+};
+/**
+ * An app's answer the turn was given.
+ */
+export type ToolOutputAccepted = {
+    /**
+     * The tool call.
+     */
+    call_id: string;
+};
+/**
+ * A tool an agent is given, by where it runs: backend (a function of the project's backend, the framework's ai.tool, on its machine), https (an endpoint the project put), mcp (an MCP server the project put: its tools, or the ones named in only), client (code of the app the chat is open in: the turn waits for its answer), or platform (one of the platform's own, by name: web.search, web.fetch, workspace.fetch_archive — the agent's alone; its subagents work with the agent's).
+ */
+export type ToolRef = {
+    /**
+     * A call waits for a person's yes (a member of the chat, or the server); one denied is told to the agent with the reason.
+     */
+    approval?: boolean;
+    /**
+     * What it does: the agent reads it to choose (backend and client tools; an endpoint says its own).
+     */
+    description?: string;
+    /**
+     * The machine a backend tool runs on (default backend).
+     */
+    machine?: string;
+    /**
+     * The tool (backend, client), the endpoint's name (https, mcp), or the platform's tool: web.search (the web searched), web.fetch (a page of it read), workspace.fetch_archive (an archive at a URL unpacked into the chat's workspace).
+     */
+    name: string;
+    /**
+     * The MCP server's tools to offer (none: all).
+     */
+    only?: string[];
+    /**
+     * A JSON Schema of type object: what the tool takes.
+     */
+    parameters?: {
+        [key: string]: unknown;
+    };
+    /**
+     * backend, https, mcp, client or platform.
+     */
+    source: "backend" | "https" | "mcp" | "client" | "platform";
+};
+/**
+ * One artifact a turn's agent published.
+ */
+export type TurnArtifact = {
+    /**
+     * Its digest (sha256:<hex>).
+     */
+    checksum: string;
+    /**
+     * When it was published.
+     */
+    created_at: string;
+    /**
+     * The artifact.
+     */
+    id: string;
+    /**
+     * What it is to the engine, when it says.
+     */
+    logical_type?: string;
+    /**
+     * Its media type, as published.
+     */
+    media_type: string;
+    /**
+     * Its size.
+     */
+    size_bytes: number;
+};
+/**
+ * A turn's artifacts.
+ */
+export type TurnArtifacts = {
+    artifacts: TurnArtifact[];
+};
+/**
+ * What the turn a message starts may cost at most, its subagents' spend counted (the server's alone): past it the engine stops the turn. A message delivered into a turn already running takes that turn's.
+ */
+export type TurnBudget = {
+    /**
+     * US dollars, more than 0 and at most 100000; rounded up to the cent.
+     */
+    max_cost_usd: number;
+};
+/**
+ * What one turn of a chat cost so far: its model calls and its subagents', at the engine's frozen rates.
+ */
+export type TurnCost = {
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * What they cost, in billionths of a US dollar.
+     */
+    cost_nano_usd: number;
+    /**
+     * Nothing more of the turn's use can be settled: false while it or a subagent of it runs.
+     */
+    final: boolean;
+    /**
+     * Input tokens of the turn and its subagents.
+     */
+    input_tokens: number;
+    /**
+     * Output tokens of the turn and its subagents.
+     */
+    output_tokens: number;
+    /**
+     * The turn.
+     */
+    response_id: string;
+    /**
+     * The cost run by run — the turn's own and each subagent's, by its name and model — so far: a turn at work is read as it spends.
+     */
+    runs: TurnRunCost[];
+    /**
+     * A model of the turn has no price: the cost is a lower bound.
+     */
+    unpriced: boolean;
     /**
-     * The question (2 MB at most). Give this, or messages.
+     * cost_nano_usd in dollars.
      */
-    input?: string;
+    usd: number;
+};
+/**
+ * What one run of a turn — its own, or a subagent's — cost so far.
+ */
+export type TurnRunCost = {
     /**
-     * How the model should answer (256 KB at most).
+     * Tokens read from the provider's cache.
      */
-    instructions?: string;
+    cache_read_tokens: number;
     /**
-     * How many tool calls the answer makes at most: past it the model is told it has no tools left and answers.
+     * Tokens written to it.
      */
-    max_tool_calls?: number;
+    cache_write_tokens: number;
     /**
-     * The conversation so far instead of one question (500 turns at most); its last turn is the user's.
+     * Its cost, in billionths of a dollar.
      */
-    messages?: Message[];
+    cost_nano_usd: number;
     /**
-     * The caller's own labels (16 at most, snake_case keys): returned with the response and its event.
+     * Tokens read.
      */
-    metadata?: {
-        [key: string]: string;
-    };
+    input_tokens: number;
     /**
-     * A role — fast, default (the default), strong — or a catalogue model as provider:model. Name a role: when a provider retires a model, the role is bound to another and your code does not change.
+     * The model it ran on, as provider:model.
      */
-    model?: string;
+    model: string;
     /**
-     * A JSON Schema the answer must be a document of. Its keywords are the provider's strict subset: type, properties, required, additionalProperties, items, enum, description, title, minimum, maximum, minLength, maxLength, minItems, maxItems — no $ref, at most 12 levels and 512 properties; every property required (a nullable one may be null). One outside the subset is refused, naming where it is.
+     * Tokens written.
      */
-    schema?: {
-        [key: string]: unknown;
-    };
+    output_tokens: number;
     /**
-     * The schema's name, as the model is told it (letters, digits, _ and -; default answer).
+     * The run that started it; absent for the turn's own.
      */
-    schema_name?: string;
+    parent_run_id?: string;
     /**
-     * Answer with the response's live view (text/event-stream).
+     * Its response: the turn's, or the subagent's (an agent part's response_id).
      */
-    stream?: boolean;
+    response_id: string;
     /**
-     * What the model may call to answer: the project's backend's functions, its HTTPS tools and MCP servers (an app's own tools are a chat's).
+     * The run.
      */
-    tools?: ToolRef[];
-};
-/**
- * What a response used.
- */
-export type ResponseUsage = {
+    run_id: string;
     /**
-     * Tokens read.
+     * Where it is: running, completed, failed…
      */
-    input_tokens: number;
+    state: string;
     /**
-     * Tokens written.
+     * The subagent it is; empty for the turn's own run.
      */
-    output_tokens: number;
-};
-/**
- * A message a subagent was given.
- */
-export type RunMessageAccepted = {
+    subagent: string;
     /**
-     * The writer's id for it.
+     * Some of its use had no rate: the cost is a floor.
      */
-    client_id: string;
+    unpriced: boolean;
     /**
-     * The subagent's run.
+     * Its cost in dollars.
      */
-    run_id: string;
+    usd: number;
 };
 /**
- * A message for a subagent at work.
+ * A tool call of a turn as the engine committed it.
  */
-export type RunMessageRequest = {
+export type TurnToolCall = {
     /**
-     * The writer's id for it.
+     * What the agent called it with, as JSON.
      */
-    client_id: string;
+    arguments: unknown;
     /**
-     * The message.
+     * The call.
      */
-    text: string;
-};
-/**
- * What the project allows its chats.
- */
-export type Settings = {
+    call_id: string;
     /**
-     * Whether the app's users talk to the project's agents with their own session: start a chat with a named agent, write to the chats they are in.
+     * When it was made.
      */
-    clients: boolean;
+    created_at: string;
     /**
-     * How much it keeps now.
+     * The tool.
      */
-    history_bytes: number;
+    name: string;
     /**
-     * How much chat history the project keeps; a message past it is refused (history_full) until chats are deleted.
+     * What it returned, as the engine committed it: an app's, a backend's or an endpoint's answer as {output: [...], is_error}; a platform tool's own JSON. Absent: nothing yet.
      */
-    history_limit_bytes: number;
+    result?: unknown;
     /**
-     * How many messages one user sends a minute (default 20).
+     * Where it is, as the engine says it.
      */
-    user_messages_per_minute: number;
+    state: string;
+    /**
+     * When it last changed.
+     */
+    updated_at: string;
 };
 /**
- * A change of what the project allows its chats; a field left out is left as it is.
+ * A page of a turn's tool calls, in the order the engine committed them.
  */
-export type SettingsRequest = {
-    /**
-     * Let the app's users talk to the project's agents themselves.
-     */
-    clients?: boolean;
+export type TurnToolCallPage = {
     /**
-     * At most the plan's (500 MiB): a project may keep less, not more.
+     * Pages on (cursor=); absent on the last page.
      */
-    history_limit_bytes?: number;
+    next_cursor?: string;
     /**
-     * 1 to 600.
+     * The calls.
      */
-    user_messages_per_minute?: number;
+    tool_calls: TurnToolCall[];
 };
 /**
- * The turn a stop stopped.
+ * A page of uses.
  */
-export type StopResult = {
+export type UsagePage = {
     /**
-     * Its response; null: none was running.
+     * The cursor of the next page; absent on the last.
      */
-    stopped: string | null;
+    next_cursor?: string;
+    /**
+     * Uses, newest first.
+     */
+    usage: Use[];
 };
 /**
- * An agent the agent may hand part of a turn to.
+ * One use of a model.
  */
-export type Subagent = {
+export type Use = {
     /**
-     * What it is for: the agent reads it to choose.
+     * Whose connection paid: platform, or project (the project's own key).
      */
-    description: string;
+    connection_owner: "platform" | "project" | "";
     /**
-     * Its instructions.
+     * What it cost at the provider's list price, in billionths of a dollar.
      */
-    instructions?: string;
+    cost_nano_usd: number;
     /**
-     * Its model: a role (fast, default, strong) or a catalogue model.
+     * When.
      */
-    model?: string;
+    created_at: string;
     /**
-     * Its name, unique among the subagents.
+     * The use's id.
      */
-    name: string;
+    id: string;
     /**
-     * The turn fails if this subagent's part fails.
+     * Reference picture tokens.
      */
-    required?: boolean;
+    image_input_tokens: number;
     /**
-     * Its tools.
+     * Tokens read.
      */
-    tools?: ToolRef[];
-};
-/**
- * A role a text model is chosen by.
- */
-export type TextModel = {
+    input_tokens: number;
     /**
-     * What it is for.
+     * Texts embedded, or pictures made.
      */
-    description: string;
+    items: number;
     /**
-     * The role.
+     * text, embedding or image.
      */
-    role: string;
-};
-/**
- * A part of what a tool returned.
- */
-export type ToolContent = {
+    kind: "text" | "embedding" | "image";
     /**
-     * An image as base64 (5 MiB at most).
+     * What the use is labelled by: its response's caller's labels — a chat's turn's, its chat's, and the chat (chat). {} for none.
      */
-    data?: string;
+    metadata: {
+        [key: string]: string;
+    };
     /**
-     * An image's type: image/png, image/jpeg, image/webp or image/gif.
+     * The model.
      */
-    media_type?: string;
+    model: string;
     /**
-     * The text.
+     * Tokens written.
      */
-    text?: string;
+    output_tokens: number;
     /**
-     * text or image.
+     * The response, for a text use.
      */
-    type: "text" | "image";
+    response_id: string | null;
 };
 /**
- * What an app's tool returned (1 MiB of text and 4 images at most).
+ * Text for the voice.
  */
-export type ToolOutput = {
+export type VoiceCommand = {
     /**
-     * The tool failed; the output says why.
+     * The voice's member the server tells it as (the server's alone).
      */
-    is_error?: boolean;
+    as?: string;
     /**
-     * Text and images: the agent is shown both.
+     * The delegated voice part this answers (speak).
      */
-    output: ToolContent[];
-};
-/**
- * An app's answer the turn was given.
- */
-export type ToolOutputAccepted = {
+    delegation_id?: string;
     /**
-     * The tool call.
+     * speak only: cut what the voice is saying and say the text at once.
      */
-    call_id: string;
+    interrupt?: boolean;
+    /**
+     * What it is given (16 KiB at most).
+     */
+    text: string;
+    /**
+     * speak (say this exactly and nothing else, once what the voice is saying ends; speaks in the order they came), tell (say it in your own words), know (keep it in mind) or instruct (behave so).
+     */
+    type: "speak" | "tell" | "know" | "instruct";
 };
 /**
- * A tool an agent is given, by where it runs: backend (a function of the project's backend, the framework's ai.tool, on its machine), https (an endpoint the project put), mcp (an MCP server the project put: its tools, or the ones named in only), or client (code of the app the chat is open in: the turn waits for its answer).
+ * What a person asked for out loud of a voice of delegation events: for the project's backend to have done, and answer with the voice's speak, naming the delegation.
  */
-export type ToolRef = {
+export type VoiceDelegatedEvent = {
     /**
-     * A call waits for a person's yes (a member of the chat, or the server); one denied is told to the agent with the reason.
+     * The chat.
      */
-    approval?: boolean;
+    chat_id: string;
     /**
-     * What it does: the agent reads it to choose (backend and client tools; an endpoint says its own).
+     * The request: a speak naming it answers it.
      */
-    description?: string;
+    delegation_id: string;
     /**
-     * The machine a backend tool runs on (default backend).
+     * What was said before it that the voice answered itself, in order.
      */
-    machine?: string;
+    earlier: VoiceLine[];
     /**
-     * The tool (backend, client), or the endpoint's name (https, mcp).
+     * The chat's labels.
      */
-    name: string;
+    metadata: {
+        [key: string]: string;
+    };
     /**
-     * The MCP server's tools to offer (none: all).
+     * What they asked, as the voice heard it.
      */
-    only?: string[];
+    text: string;
     /**
-     * A JSON Schema of type object: what the tool takes.
+     * The voice's member (null: the server's own).
      */
-    parameters?: {
-        [key: string]: unknown;
-    };
+    user_id: string | null;
     /**
-     * backend, https, mcp or client.
+     * The voice.
      */
-    source: "backend" | "https" | "mcp" | "client";
+    voice_id: string;
 };
 /**
- * One artifact a turn's agent published.
+ * A chat's voice began, or ended.
  */
-export type TurnArtifact = {
+export type VoiceEvent = {
     /**
-     * Its digest (sha256:<hex>).
+     * The chat.
      */
-    checksum: string;
+    chat_id: string;
     /**
-     * When it was published.
+     * Why it ended (empty while live).
      */
-    created_at: string;
+    close_reason: string;
     /**
-     * The artifact.
+     * chat or events.
      */
-    id: string;
+    delegation: string;
     /**
-     * What it is to the engine, when it says.
+     * The chat's labels.
      */
-    logical_type?: string;
+    metadata: {
+        [key: string]: string;
+    };
     /**
-     * Its media type, as published.
+     * How long it lasted.
      */
-    media_type: string;
+    seconds: number;
     /**
-     * Its size.
+     * active, or closed.
      */
-    size_bytes: number;
+    status: string;
+    /**
+     * Its member (null: the server's own).
+     */
+    user_id: string | null;
+    /**
+     * The voice.
+     */
+    voice_id: string;
 };
 /**
- * A turn's artifacts.
+ * A line said in a voice conversation: the person's (user) or the voice's (assistant).
  */
-export type TurnArtifacts = {
-    artifacts: TurnArtifact[];
+export type VoiceLine = {
+    /**
+     * user or assistant.
+     */
+    role: string;
+    /**
+     * The line.
+     */
+    text: string;
 };
 /**
- * What the turn a message starts may cost at most, its subagents' spend counted (the server's alone): past it the engine stops the turn. A message delivered into a turn already running takes that turn's.
+ * Starts the chat's live voice.
  */
-export type TurnBudget = {
+export type VoiceRequest = {
     /**
-     * US dollars, more than 0 and at most 100000; rounded up to the cent.
+     * The member the server starts it for (the server's alone): the voice is theirs, and counts toward their starts.
      */
-    max_cost_usd: number;
+    as?: string;
+    /**
+     * What becomes of what the person asks for out loud: chat (the default) — a message of the voice's member to the chat's agent, a turn of the chat, whose answer the voice says back; events — the event ai.voice.delegated, for the project's backend to have done and answer with speak (its delegation_id).
+     */
+    delegation?: "chat" | "events";
+    /**
+     * The app's WebRTC offer (an SDP).
+     */
+    sdp: string;
+    /**
+     * The voice (the provider's default unless said).
+     */
+    voice?: string;
 };
 /**
- * What one turn of a chat cost so far: its model calls and its subagents', at the engine's frozen rates.
+ * A chat's voice.
  */
-export type TurnCost = {
+export type VoiceSession = {
     /**
      * The chat.
      */
     chat_id: string;
     /**
-     * What they cost, in billionths of a US dollar.
+     * Why it ended: close_requested, member_removed, chat_deleted, replaced (its member started another), lost (the engine no longer holds it), or the provider's word.
      */
-    cost_nano_usd: number;
+    close_reason?: string;
     /**
-     * Nothing more of the turn's use can be settled: false while it or a subagent of it runs.
+     * When it ended (null: live).
      */
-    final: boolean;
+    closed_at: string | null;
     /**
-     * Input tokens of the turn and its subagents.
+     * chat or events: what becomes of what the person asks for.
      */
-    input_tokens: number;
+    delegation: string;
     /**
-     * Output tokens of the turn and its subagents.
+     * The voice session.
      */
-    output_tokens: number;
+    id: string;
     /**
-     * The turn.
+     * The provider's WebRTC answer, for the app's peer connection (on start).
      */
-    response_id: string;
+    sdp?: string;
     /**
-     * A model of the turn has no price: the cost is a lower bound.
+     * How long it has lasted.
      */
-    unpriced: boolean;
+    seconds: number;
+    /**
+     * When it began.
+     */
+    started_at: string;
+    /**
+     * active, or closed.
+     */
+    status: string;
+    /**
+     * The member it is (null: the server's own).
+     */
+    user_id: string | null;
 };
 /**
- * A page of uses.
+ * A file a published tree changed against the tree it replaced.
  */
-export type UsagePage = {
+export type WorkspaceChange = {
     /**
-     * The cursor of the next page; absent on the last.
+     * added, modified (its bytes or its mode) or removed.
      */
-    next_cursor?: string;
+    change: string;
     /**
-     * Uses, newest first.
+     * The file, as the tree names it (repo/output/app/App.zip).
      */
-    usage: Use[];
+    path: string;
+    /**
+     * Its size in the tree; 0 for one removed.
+     */
+    size_bytes: number;
 };
 /**
- * One use of a model.
+ * A tree the chat's workspace published: its machine publishes whenever the files are quiet for a moment — mid-turn, as a build writes its product — and once more as it lets the workspace go.
  */
-export type Use = {
+export type WorkspacePublishedEvent = {
     /**
-     * Whose connection paid: platform, or project (the project's own key).
+     * What changed against the tree it replaced, sorted by path: 1000 at most (changed_truncated).
      */
-    connection_owner: "platform" | "project" | "";
+    changed: WorkspaceChange[];
     /**
-     * What it cost at the provider's list price, in billionths of a dollar.
+     * How many files changed.
      */
-    cost_nano_usd: number;
+    changed_count: number;
     /**
-     * When.
+     * More changed than changed names.
      */
-    created_at: string;
+    changed_truncated: boolean;
     /**
-     * The use's id.
+     * The chat.
      */
-    id: string;
+    chat_id: string;
     /**
-     * Reference picture tokens.
+     * The tree: a file of it is read by it (GET /ai/chats/{chat_id}/workspace/files?manifest=), whatever the workspace published after it.
      */
-    image_input_tokens: number;
+    manifest_id: string;
     /**
-     * Tokens read.
+     * The chat's labels.
      */
-    input_tokens: number;
+    metadata: {
+        [key: string]: string;
+    };
     /**
-     * Texts embedded, or pictures made.
+     * The tree it replaced; absent for none.
      */
-    items: number;
+    previous_manifest_id?: string;
+};
+/**
+ * A push the chat's agent made: to the chat's branch, the only one a turn's work is pushed to.
+ */
+export type WorkspacePushedEvent = {
     /**
-     * text, embedding or image.
+     * The branch it was pushed to.
      */
-    kind: "text" | "embedding" | "image";
+    branch: string;
     /**
-     * The model.
+     * The chat.
      */
-    model: string;
+    chat_id: string;
     /**
-     * Tokens written.
+     * What the push brought to the branch, the oldest first: 100 at most (commits_truncated); none when the branch was there already.
      */
-    output_tokens: number;
+    commits: PushedCommit[];
     /**
-     * The response, for a text use.
+     * It brought more than commits names.
      */
-    response_id: string | null;
-};
-/**
- * Text for the voice.
- */
-export type VoiceCommand = {
+    commits_truncated: boolean;
     /**
-     * The delegated voice part this answers (speak).
+     * The commit the branch is at now.
      */
-    delegation_id?: string;
+    head_sha: string;
     /**
-     * What it is given (16 KiB at most).
+     * The chat's labels.
      */
-    text: string;
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * The project's name of the repository (PUT /ai/repos/{name}).
+     */
+    repo: string;
+    /**
+     * The GitHub repository, owner/name.
+     */
+    repository: string;
+    /**
+     * The turn — or a subagent's work in it — that pushed.
+     */
+    response_id: string;
     /**
-     * speak (say this), know (keep it in mind) or instruct (behave so).
+     * The member the turn was for; null: the server's.
      */
-    type: "speak" | "know" | "instruct";
+    user_id: string | null;
 };
 /**
- * Starts the chat's live voice.
+ * A repository put in an open chat's workspace.
  */
-export type VoiceRequest = {
+export type WorkspaceRepoRequest = {
     /**
-     * The app's WebRTC offer (an SDP).
+     * The branch it is checked out at and pushed to (the repository's default unless said).
      */
-    sdp: string;
+    branch?: string;
     /**
-     * The voice (the provider's default unless said).
+     * The project's name for the repository (PUT /ai/repos/{name}): one put at work's moment too.
      */
-    voice?: string;
+    repo: string;
 };
-/**
- * A chat's live voice.
- */
-export type VoiceSession = {
+/** The events this module sends the project's webhooks (x-palbase-events), by type: each one's payload, the event's data. */
+export interface Events {
     /**
-     * The chat.
+     * ai.goal.updated: a chat's goal was set, its status changed (paused, resumed, blocked, out of budget or turns, achieved), or it was cleared.
      */
-    chat_id: string;
+    "ai.goal.updated": GoalEvent;
     /**
-     * The voice session.
+     * ai.response.completed: a response started with background: true completed — read its answer by its id — or a chat's turn completed.
      */
-    id: string;
+    "ai.response.completed": ResponseEvent;
     /**
-     * The provider's WebRTC answer, for the app's peer connection (on start).
+     * ai.response.failed: a response started with background: true ended without completing (failed, canceled, timed out, over its budget), or a chat's turn did (failed, stopped, budget_exceeded).
      */
-    sdp?: string;
+    "ai.response.failed": ResponseEvent;
     /**
-     * How long it lasted (on close).
+     * ai.response.started: a chat's turn began — a member's message, the server's, the chat's goal, or the late messages of the turn before opened it.
      */
-    seconds: number;
+    "ai.response.started": ResponseEvent;
     /**
-     * active, or closed.
+     * ai.voice.closed: a chat's voice ended — closed, replaced, its member taken out, its chat deleted, lost — with how long it lasted.
      */
-    status?: string;
-};
-/** The events this module sends the project's webhooks (x-palbase-events), by type: each one's payload, the event's data. */
-export interface Events {
+    "ai.voice.closed": VoiceEvent;
     /**
-     * ai.response.completed: a response started with background: true completed; read its answer by its id.
+     * ai.voice.delegated: a person asked a voice of delegation events for something out loud; the backend answers with the voice's speak, naming the delegation.
      */
-    "ai.response.completed": ResponseEvent;
+    "ai.voice.delegated": VoiceDelegatedEvent;
     /**
-     * ai.response.failed: a response started with background: true ended without completing (failed, canceled, timed out, over its budget).
+     * ai.voice.started: a chat's voice began.
      */
-    "ai.response.failed": ResponseEvent;
+    "ai.voice.started": VoiceEvent;
+    /**
+     * ai.workspace.published: a chat's workspace published a tree — what its files are now, with the files it changed; read one of them by the tree (GET /ai/chats/{chat_id}/workspace/files?manifest=).
+     */
+    "ai.workspace.published": WorkspacePublishedEvent;
+    /**
+     * ai.workspace.pushed: a chat's agent pushed its work to the chat's branch, with the commits it brought.
+     */
+    "ai.workspace.pushed": WorkspacePushedEvent;
 }
 /** Palbase ai */
 export declare function client(t: Transport): {
@@ -1322,7 +2408,7 @@ export declare function client(t: Transport): {
     /**
      * Name an agent
      *
-     * An agent a chat started from the app — or by name from the server — talks to: its definition, or the backend machine that defines it at each turn.
+     * An agent a chat the server starts by its name talks to: its definition, or the backend machine that defines it at each turn.
      */
     putAgent(input: {
         path: {
@@ -1345,18 +2431,21 @@ export declare function client(t: Transport): {
     /**
      * The chats
      *
-     * The server's: every chat, or a member's (member=); a user's: the chats they are in. The newest first, 100 at most.
+     * The server's: every chat, or a member's (member=); a user's: the chats they are in. The newest first, a page at a time (limit, cursor), and only those labelled so when metadata= names labels.
      */
     listChats(input?: {
         query?: {
-            member?: string;
+            member?: string; /** How many (1 to 100, default 100). */
+            limit?: number; /** next_cursor of the page before. */
+            cursor?: string; /** A label the chats have, key:value (its metadata); given again, every label named: metadata=project_id:p_123. */
+            metadata?: string[];
         }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, ChatList>>;
     /**
      * Start a chat
      *
-     * The server starts a chat with a named agent or a definition of its own, and names its members; a signed-in user (when the project lets them) starts one with a named agent, as its owner.
+     * The project's server's alone: its backend, with the secret key, starts a chat with a named agent or a definition of its own, and names its members. A signed-in user is answered 403 server_only, whatever the project lets them (settings.clients is what they do in the chats they are in).
      */
     createChat(input: {
         body: ChatRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
@@ -1387,7 +2476,7 @@ export declare function client(t: Transport): {
     /**
      * Decide a tool call
      *
-     * A tool call that waits for a person's yes: approved it is made; denied, the agent is told, with the reason, and goes on.
+     * A tool call that waits for a person's yes: approved it is made; denied, the agent is told, with the reason, and goes on. Decided by the member whose message began the turn (403 not_your_turn for any other) — or by the project's server, for any turn, or as that member (as).
      */
     decideChatApproval(input: {
         path: {
@@ -1397,10 +2486,74 @@ export declare function client(t: Transport): {
         body: DecisionRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, Decision>>;
+    /**
+     * Fork a chat before a message
+     *
+     * Forks the chat before one of its messages — what a person's "edit this message" makes: a new chat that begins where this one was, without that message and what came after it, for the edited message to be sent into. The project's server's alone, as starting a chat is. The fork talks to the same agent, carries the chat's labels and — unless members says otherwise — its members. What it begins with is the chat's messages and its agent's answers before that message, in the journal's order — its subagents' work left out, a member's message with the context the model read with it: the engine is given them with the fork's first turn, and its pipe writes them first (history parts). A fork of a chat that works in a workspace works in the same one, the files as they are now, on a session of its own; the workspace goes once no chat that works in it is left. A chat whose agent is at work is not forked (409 turn_running); a message that is not one of the chat's, or that its agent was not given, is 400; what came before past 512 KiB is 409 fork_too_large; past the history the project keeps, 409 history_full.
+     */
+    forkChat(input: {
+        path: {
+            chat_id: string;
+        };
+        body: ForkRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Chat>>;
+    /**
+     * Read the chat's goal
+     *
+     * The chat's goal: its status, why it stopped, what its next turn is (phase), its limits and what it has used so far. The project's server's.
+     */
+    getChatGoal(input: {
+        path: {
+            chat_id: string;
+        };
+        query?: {
+            as?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Goal>>;
+    /**
+     * Set the chat's goal
+     *
+     * Sets the chat's goal — replacing any it had: the engine works the chat toward the objective by itself, a turn at a time — each turn the chat's agent as it is defined now (a backend's agent is asked, told of the goal), judged when it ends, a claimed completion checked against the rubric — until it is met, or max_turns, the budget or a brake (turns that fail, that do nothing) stops it; its first turn opens at once when no turn of the chat is at work. The project's server's alone — as itself, or as a member (as: the goal is then theirs, as their message's turn is: they decide and answer its turns' approvals and app tools, and change and clear it — while they stand where they stood when it was set: in the chat, and, its agent defined for them alone, the chat theirs alone; taken out, or the chat given another member, the goal is paused with a reason saying why and its turn at work stopped). Each of its turns is the chat's: in its stream (a turn part that says the goal's, its role and number), billed, its tools served, stopped by a stop; a member's message goes before its next turn. Its status, each time it changes, is the event ai.goal.updated, and its words are goal parts of the chat's stream.
+     */
+    setChatGoal(input: {
+        path: {
+            chat_id: string;
+        };
+        body: GoalRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Goal>>;
+    /**
+     * Clear the chat's goal
+     *
+     * Clears the chat's goal: no turn of it opens again, and one at work finishes as an ordinary turn. As the server, or as the member it was set as (as); the event ai.goal.updated says it cleared.
+     */
+    clearChatGoal(input: {
+        path: {
+            chat_id: string;
+        };
+        query?: {
+            as?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Change the chat's goal
+     *
+     * Pauses the goal (with a reason, said in its event) or resumes it — a resumed goal opens its next turn at once when no turn of the chat is at work — edits its objective or rubric, or changes a limit (null: none). As the server, or as the member it was set as (as); another member changes nothing of it (403 not_your_turn). An achieved goal is changed by setting a new one (409 goal_achieved); one set as a member who no longer stands where they stood when it was set — out of the chat, or the chat no longer theirs alone — is not resumed (409 goal_lapsed): it is cleared, or another set for the chat as it is now.
+     */
+    updateChatGoal(input: {
+        path: {
+            chat_id: string;
+        };
+        body: GoalPatch; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Goal>>;
     /**
      * Put a user in a chat
      *
-     * Who is in a chat is the server's to say.
+     * Who is in a chat is the server's to say. A goal set as the chat's one member, its agent defined for them alone, is paused when another is put in it.
      */
     putChatMember(input: {
         path: {
@@ -1413,7 +2566,7 @@ export declare function client(t: Transport): {
     /**
      * Take a user out of a chat
      *
-     * The server takes anyone out; a user takes themselves out.
+     * The server takes anyone out; a user takes themselves out. A goal set as the member taken out is paused, and its turn at work stopped.
      */
     deleteChatMember(input: {
         path: {
@@ -1440,7 +2593,7 @@ export declare function client(t: Transport): {
     /**
      * Write to a chat
      *
-     * A message for the agent: a turn of its own when none runs; while one does, at its next step (next) or cutting the step it is in (now). The same client_id again is the same message. A user sends user_messages_per_minute a minute (429 too_many_messages); past the history the project keeps a message is refused (409 history_full).
+     * A message for the agent: a turn of its own when none runs; while one does, at its next step (next) or cutting the step it is in (now). The same client_id again is the same message. A user sends user_messages_per_minute a minute — and so does the server writing as them (429 too_many_messages); past the history the project keeps a message is refused (409 history_full). It carries pictures of the project's storage the model is shown (images) and, in a chat that works in a workspace, files put in it before the agent reads the message (files), each copied for the chat.
      */
     sendChatMessage(input: {
         path: {
@@ -1449,10 +2602,62 @@ export declare function client(t: Transport): {
         body: MessageRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, ChatMessage> | Reply<202, ChatMessage>>;
+    /**
+     * A picture or a file a message carries
+     *
+     * The bytes of a picture or a file a message of the chat carries, as it was sent (a download by its name, never a page): to the chat's members and its server. A position the message has nothing at is not found (404 attachment_not_found).
+     */
+    getChatMessageAttachment(input: {
+        path: {
+            chat_id: string; /** The message. */
+            message_id: string; /** Its place among the message's attachments (its images, then its files), from 0. */
+            position: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Response>>;
+    /**
+     * The chat's past
+     *
+     * The chat's past as its stream told it, a page at a time from its newest end back: the members' messages, the turns, the answers as text at their offsets, the tools and the subagents, the goal's and the voice's words — each page in the order it was told, each part under the id its channel told it (part_id), so an app holding the channel's parts and a page of these keeps each once. A page reads limit of the chat's events before the cursor, or before the oldest part the app holds of the chat's channel (before: that part's id), so the first page does not read again the day the channel told; with neither, from its newest end. Given both, the call is refused (400). The page that reaches the chat's start begins with where a fork began. A voice's end is under the id its channel told it (vclosed:<voice>); a voice the engine lost, its end said by no journal, has it right after its last part. Reading a page records nothing. A call's answer is by its end, as the stream shows it. Read by the chat's members and the project's server.
+     */
+    listChatParts(input: {
+        path: {
+            chat_id: string;
+        };
+        query?: {
+            limit?: number; /** A next_cursor: the page before it. Not with before. */
+            cursor?: string; /** The id of the oldest part the app holds of the chat's channel (a part's id: its journal sequence): the first page is the parts told before it. Not with cursor. */
+            before?: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ChatPartPage>>;
+    /**
+     * Pipe the chat into a channel
+     *
+     * Writes the chat's stream into a channel of the project's realtime from now on — a gateway's, durable — as the platform: the members' messages, the turns, the answer as it is written (gathered into a few writes a second), the tools and subagents, each the channel's event `chat` {type, id?, data}, under an id of its own so a retry is kept once. The types: `message` (a ChatMessage, as the agent got it), `turn` ({response_id, status: running|waiting|completed|failed|canceled|timed_out|budget_exceeded, user_id, solo, goal: {goal_id, role: work|verify, seq} — a turn of the chat's goal, waiting: {reason: approval|tool_output|subagents|message, text_offset, approval_id, tool_call_id, tool_name, input, publication}, end: completed|failed|stopped|budget_exceeded — as the turn's event says it, error: {code, message, retryable}}), `text` ({response_id, offset, text}: the agent's answer as it is written, at its byte offset), `reset` ({response_id, offset}: discard the answer past offset), `thinking` ({response_id, run_id, step_id, text}: the model's reasoning as it thinks, when the agent shows it — thinking: visible), `tool` ({response_id, run_id, call_id, name, status: running|awaiting_output|awaiting_approval|approved|denied|expired|completed|failed|canceled, text_offset, input, output, image_count, is_error, approval_id, agent_response_id, …}), `agent` ({run_id, response_id, parent_response_id, name, required, status, text_offset}: a subagent at work), `goal` ({goal_id, kind: set|updated|turn_started|judged|verified|status_changed|cleared, goal: {objective, rubric, status, stop_code, stop_reason, phase, max_turns, max_cost_usd}, role, seq, response_id, run_id, verdict, reason, missing, from, to, code}: the chat's goal's words), `voice` ({voice_id, user_id, delegation, status: started|closed, seconds, close_reason}: the chat's live voice began or ended), `transcript` ({id, voice_id, role: user|assistant, user_id, author_name, text, final, created_at}: a line it said either way — the chat's history's message of kind voice, by its id), `seen` (the journal moved past what was handed already), and — first, in a fork's channel — `history` ({forked_from: {chat_id, before_message}, part, parts, items: [{role: user|assistant, message_id, client_id, author, author_name, text, metadata, created_at, response_id, text_truncated, attachments}]}: what the fork began with, a few items a part, a long text cut in its part, its id h and the part's place). Every type but text and reset has the journal's sequence as its id; text_offset says where in the answer a tool or subagent part happened. The project's backend is not in the stream: the gateway's members hear the chat from realtime, and one that was away is given what it missed there. Put again with the same channel it goes on where it is — one realtime refused is tried again; with another, from the chat's start, and nothing more is written into the one before. The project's server's alone.
+     */
+    putChatPipe(input: {
+        path: {
+            chat_id: string;
+        };
+        body: ChatPipe; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ChatPipeResult>>;
+    /**
+     * Take the chat's pipe away
+     *
+     * The chat's stream is written nowhere from now on. The project's server's alone.
+     */
+    deleteChatPipe(input: {
+        path: {
+            chat_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
     /**
      * Write to a subagent at work
      *
-     * A message for one of the agent's subagents, at its next step.
+     * A message for one of the agent's subagents, at its next step: a message of the chat like any other — its writer's (or the member's the server writes as) messages a minute (429 too_many_messages), the history the project keeps (409 history_full).
      */
     sendSubagentMessage(input: {
         path: {
@@ -1462,37 +2667,63 @@ export declare function client(t: Transport): {
         body: RunMessageRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<202, RunMessageAccepted>>;
+    /**
+     * Stop a subagent at work
+     *
+     * Stops one subagent at work — with the subagents it started and its background work: the agent that started it is told a person stopped it, and not to start that work again unless asked, and the rest of the turn goes on. Any member stops it, as any member stops the turn, and the server — as itself, or as a member (as: the server's alone; a user sending it is answered 400; one who is not a member of the chat, 403 not_a_member). Asked again, the same stop answers as it did. A run that is not a subagent at work in this chat — ended, the agent itself, another chat's — is 404.
+     */
+    stopSubagent(input: {
+        path: {
+            chat_id: string; /** The subagent's run (an agent event's run_id). */
+            run_id: string;
+        };
+        body?: RunStopRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, RunStopped>>;
     /**
      * Stop the agent
      *
-     * Stops the turn it is working on: what it wrote stays; a message after starts the next turn.
+     * Stops the turn it is working on: what it wrote stays; a message after starts the next turn. Any member's; the server's as itself, or as a member (as).
      */
     stopChat(input: {
         path: {
             chat_id: string;
-        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        };
+        body?: ChatStop; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, StopResult>>;
     /**
-     * Follow a chat
+     * A turn's tool calls
      *
-     * What happens in the chat as typed parts, as it happens.
+     * A turn's tool calls as the engine committed them — their arguments and results as they were (what a diff of the files the turn wrote is made of), in their order, a page at a time. The project's server's alone; a subagent's work is read by its response (an agent part's response_id).
      */
-    followChat(input: {
+    listTurnToolCalls(input: {
         path: {
             chat_id: string;
         };
-        query?: {
-            after?: number; /** The response whose answer the reader was reading. */
-            response?: string; /** The bytes of that answer the reader holds. */
-            offset?: number;
+        query: {
+            turn: string; /** How many calls a page holds (1 to 500; 100). */
+            limit?: number; /** A next_cursor: the page after it. */
+            cursor?: string;
         }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
-    }): Promise<Reply<200, Response>>;
+    }): Promise<Reply<200, TurnToolCallPage>>;
+    /**
+     * A tool call of the chat, whole
+     *
+     * One tool call of the chat, its whole answer: the chat's stream shows a call's answer by its end (its last 16 KiB, omitted_bytes what it left out) — read here whole, its secret shapes masked as the stream masks them. Read by the chat's members and the project's server; another chat's call is not found.
+     */
+    getChatToolCall(input: {
+        path: {
+            chat_id: string; /** The call: a tool part's call_id. */
+            call_id: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, ChatToolCall>>;
     /**
      * Answer an app's tool call
      *
-     * The answer of a client tool's call, made by the app's code: the turn waiting for it goes on. The first answer is the one.
+     * The answer of a client tool's call, made by the app's code: the turn waiting for it goes on. The first answer is the one. Given by the app of the member whose message began the turn (403 not_your_turn for any other) — or by the project's server, for any turn, or as that member (as). A call of the project's backend (or an HTTPS tool of its) that answered {"deferred": true} — its work outlasts a call — is answered here too, by the project's server as itself, within the while it named (a minute to a day; an hour), and by no member.
      */
     answerChatToolCall(input: {
         path: {
@@ -1542,7 +2773,7 @@ export declare function client(t: Transport): {
     /**
      * Start a chat's voice
      *
-     * Starts the chat's live voice: the app's WebRTC offer in, the answer out — the audio then goes between the app and the platform's voice provider. What is said either way is in the chat's stream as voice parts (transcripts); a task the voice hands over is a voice part of kind delegated. One voice a chat at a time (409 voice_active). A user starts at most 5 voices an hour in the project's chats (429 too_many_voices, with Retry-After) — each is the project's spend while it lasts; the server's starts are not counted.
+     * Starts the chat's live voice: the app's WebRTC offer in, the answer out — the audio then goes between the app and the platform's voice provider. The voice is its member's — the user who starts it, or the member the server starts it for (as): they or the server read, tell and close it, no other member. What the person asks for out loud becomes, by delegation, a turn of the chat as that member whose answer the voice says back (chat, the default), or the event ai.voice.delegated (events). What is said either way is the chat's: transcript parts of its stream and lines of its history (messages of kind voice). One voice talks in a chat at a time: a member's new voice ends the one they left open (closed replaced); another member's live voice is refused (409 voice_active). A user starts at most 5 voices an hour in the project's chats, the server's for them counted as theirs (429 too_many_voices, with Retry-After) — each is the project's spend while it lasts. Its start is the event ai.voice.started.
      */
     startChatVoice(input: {
         path: {
@@ -1551,22 +2782,40 @@ export declare function client(t: Transport): {
         body: VoiceRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<201, VoiceSession>>;
+    /**
+     * Read a chat's voice
+     *
+     * The chat's voice: whose it is, whether it is live, how long it has lasted and why it ended — read from the engine while it is live. Its member's, or the server's (403 not_your_voice).
+     */
+    getChatVoice(input: {
+        path: {
+            chat_id: string; /** The voice session. */
+            voice_id: string;
+        };
+        query?: {
+            as?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, VoiceSession>>;
     /**
      * Close a chat's voice
      *
-     * Ends the chat's voice; the answer says how long it lasted.
+     * Ends the chat's voice; the answer says how long it lasted and why it ended. Its member's, or the server's (403 not_your_voice). Its end is the event ai.voice.closed — once.
      */
     closeChatVoice(input: {
         path: {
             chat_id: string; /** The voice session. */
             voice_id: string;
+        };
+        query?: {
+            as?: string;
         }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, VoiceSession>>;
     /**
      * Tell a chat's voice
      *
-     * The server's alone (a member is answered 403 server_only): a member's words would be the agent's own to every other member of the chat. Gives the chat's voice text: speak says it, know keeps it in mind, instruct changes how it behaves — speak with a delegation_id answers a task it handed over.
+     * The server's alone (a member is answered 403 server_only), as itself or as the voice's member (as; another member 403 not_your_voice): a member's words would be the agent's own to every other member of the chat. Gives the chat's voice text: speak says it, know keeps it in mind, instruct changes how it behaves — speak with a delegation_id answers a request it handed over (ai.voice.delegated). A voice that has ended is 409 voice_closed.
      */
     commandChatVoice(input: {
         path: {
@@ -1576,6 +2825,33 @@ export declare function client(t: Transport): {
         body: VoiceCommand; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<202, VoiceSession>>;
+    /**
+     * A file of the chat's workspace
+     *
+     * A file of the chat's workspace, its bytes (an attachment, never a page): from the tree the workspace is at now, or from the one an ai.workspace.published event named (manifest) — a build's product as that publish left it. Read by the chat's members and the project's server, as they read the chat. Served up to 64 MiB (413 file_too_large past it: publish a larger one as the turn's artifact); its digest is Content-Digest. A project reads 4 files at once (429 too_many_reads, Retry-After), and a file is written for no longer than its bytes take at 256 KiB/s and a minute more. A chat that works in no workspace yet, a tree of another workspace, a path its tree does not name: 404 file_not_found.
+     */
+    getChatWorkspaceFile(input: {
+        path: {
+            chat_id: string;
+        };
+        query: {
+            path: string; /** The tree to read it from: an ai.workspace.published event's manifest_id (none: the tree the workspace is at now). */
+            manifest?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Response>>;
+    /**
+     * Put a repository in the chat's workspace
+     *
+     * Puts one more of the project's repositories in the chat's workspace, at a branch, under its name beside the others: the engine clones it and merges it into the workspace's tree before the chat's next turn takes a machine; a chat whose first turn has not opened its workspace has it from that turn. Every chat working in the workspace (a fork works in its chat's) has it. Put again, the same. The project's server's alone; a chat that works in no workspace is refused (409 no_workspace).
+     */
+    addChatWorkspaceRepo(input: {
+        path: {
+            chat_id: string;
+        };
+        body: WorkspaceRepoRequest; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Chat>>;
     /**
      * Turn texts into vectors
      *
@@ -1596,7 +2872,7 @@ export declare function client(t: Transport): {
     /**
      * Put a tool endpoint
      *
-     * A tool at an HTTPS address of the project's — called with a signed POST {tool, call_id, input, context} and answered {output, is_error} or plain text — or an MCP server, whose tools an agent may use. The answer says an https tool's signing secret, once.
+     * A tool at an HTTPS address of the project's — called with a signed POST {tool, call_id, input, context: {chat_id, agent, user, metadata, turn_id, run_id, subagent} — the turn, and the run that called: the agent's own, or a subagent's at work (subagent names which, null for the agent)} and answered {output, is_error} or plain text — or an MCP server, whose tools an agent may use. The answer says an https tool's signing secret, once.
      */
     putEndpoint(input: {
         path: {
@@ -1693,9 +2969,13 @@ export declare function client(t: Transport): {
     /**
      * The project's repositories
      *
-     * The repositories the project's chats work in.
+     * The repositories the project's chats work in, by name, a page at a time (a project puts 10000 at most).
      */
     listRepos(input?: {
+        query?: {
+            limit?: number; /** next_cursor of the page before. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, RepoPage>>;
     /**
@@ -1724,7 +3004,7 @@ export declare function client(t: Transport): {
     /**
      * Ask a model
      *
-     * Admits a response: an answer to the input, as text or — with a schema — as a JSON document of that shape, validated before it is returned. With stream: true the answer is the response's live view (text/event-stream). With background: true it answers at once and the response's end is the event ai.response.completed (or ai.response.failed). Otherwise it answers at once with the response queued; read it by its id.
+     * Admits a response: an answer to the input, as text or — with a schema — as a JSON document of that shape, validated before it is returned. With stream: true the answer is the response's live view (text/event-stream). With background: true it answers at once and the response's end is the event ai.response.completed (or ai.response.failed). Otherwise it answers at once with the response queued; read it by its id. What the agent is given — its instructions, the conversation, the schema and the tools together — is at most 1 MiB as JSON, what the model service reads (413 request_too_large).
      */
     createResponse(input: {
         headers: {
@@ -1795,7 +3075,8 @@ export declare function client(t: Transport): {
         query?: {
             limit?: number; /** The next_cursor of the previous page. */
             cursor?: string; /** Only uses of this kind: text, embedding or image. */
-            kind?: "text" | "embedding" | "image";
+            kind?: "text" | "embedding" | "image"; /** Labels each use listed carries, as a JSON object ({"product":"p1"}): a product's spend, a task's. */
+            metadata?: string;
         }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<200, UsagePage>>;