palbase 0.7.0 → 0.8.1

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

@@ -21,12 +21,24 @@ export type AgentDefinition = {
      * The project's machine that defines the agent at each turn.
      */
     backend?: string;
+    /**
+     * 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).
+     */
+    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;
     /**
@@ -37,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').
      */
@@ -67,6 +83,7 @@ export type Chat = {
      * 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.
      */
@@ -89,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.
      */
@@ -136,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.
      */
@@ -148,6 +197,115 @@ 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.
@@ -209,6 +367,60 @@ export type ChatRequest = {
     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.
  */
@@ -221,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.
@@ -412,6 +641,207 @@ export type ErrorResponse = {
      */
     status: number;
 };
+/**
+ * Where to fork a chat.
+ */
+export type ForkRequest = {
+    /**
+     * The message the fork is cut before (a message's id): it, and all that came after it, are not the fork's.
+     */
+    before_message: string;
+    /**
+     * Who is in the fork (64 at most; left out or null: the chat's members, as they are).
+     */
+    members?: NewMember[] | null;
+    /**
+     * The fork's title (256 bytes at most; left out: the chat's).
+     */
+    title?: string;
+};
+/**
+ * A chat's goal.
+ */
+export type Goal = {
+    /**
+     * When it was met; null: not yet.
+     */
+    achieved_at: string | null;
+    budget: GoalBudget;
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * When it was set.
+     */
+    created_at: string;
+    /**
+     * The goal's id (a new goal, a new id).
+     */
+    id: string;
+    /**
+     * The most turns it opens; null: no limit.
+     */
+    max_turns: number | null;
+    /**
+     * What the chat works toward.
+     */
+    objective: string;
+    /**
+     * What its next turn is: work, or verify (the check of a completion its agent claimed).
+     */
+    phase: string;
+    /**
+     * What a claimed completion is checked against.
+     */
+    rubric: string;
+    /**
+     * The member it was set as; null: the server.
+     */
+    set_by: string | null;
+    /**
+     * active, paused, blocked (it cannot go on without a person), budget_limited, or achieved.
+     */
+    status: string;
+    /**
+     * 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.
+     */
+    stop_code: string;
+    /**
+     * Why, in a sentence.
+     */
+    stop_reason: string;
+    /**
+     * When it last changed.
+     */
+    updated_at: string;
+    usage: GoalUsage;
+};
+/**
+ * What a goal may cost at most, all its turns and their subagents together; null: no limit.
+ */
+export type GoalBudget = ({
+    /**
+     * In dollars.
+     */
+    max_cost_usd: number;
+}) | null;
+/**
+ * A chat's goal set, its status changed, or cleared.
+ */
+export type GoalEvent = {
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * The goal.
+     */
+    goal_id: string;
+    /**
+     * The chat's labels.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * What it was; null: no goal.
+     */
+    previous_status: string | null;
+    /**
+     * The member it was set as; null: the server.
+     */
+    set_by: string | null;
+    /**
+     * What it is now: active, paused, blocked, budget_limited, achieved — or cleared.
+     */
+    status: string;
+    /**
+     * Why it left active, as a stable code (empty while active).
+     */
+    stop_code: string;
+    /**
+     * Why, in a sentence.
+     */
+    stop_reason: string;
+};
+/**
+ * What changes of a chat's goal: a field left out is left as it is.
+ */
+export type GoalPatch = {
+    /**
+     * The member the server changes it as: the one it was set as (403 not_your_turn otherwise).
+     */
+    as?: string;
+    budget?: GoalBudget;
+    /**
+     * The most turns it opens; null: no limit.
+     */
+    max_turns?: number | null;
+    /**
+     * Its objective, edited.
+     */
+    objective?: string;
+    /**
+     * Why it is paused, with status paused (500 characters at most): said in its stop_reason and its event.
+     */
+    reason?: string;
+    /**
+     * Its rubric, edited.
+     */
+    rubric?: string;
+    /**
+     * paused (the goal waits) or active (it goes on).
+     */
+    status?: "paused" | "active";
+};
+/**
+ * A chat's goal to set.
+ */
+export type GoalRequest = {
+    /**
+     * 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.
+     */
+    as?: string;
+    budget?: TurnBudget;
+    /**
+     * The most turns it opens (1 to 10000; left out: no limit).
+     */
+    max_turns?: number;
+    /**
+     * What the chat works toward, in words (4000 characters at most).
+     */
+    objective: string;
+    /**
+     * What a claimed completion is checked against (8000 characters at most; left out: the objective itself).
+     */
+    rubric?: string;
+};
+/**
+ * What a goal has used so far.
+ */
+export type GoalUsage = {
+    /**
+     * How long it has been at work since it was set or last resumed.
+     */
+    active_seconds: number;
+    /**
+     * Some of its use has no price yet: it cost at least this.
+     */
+    cost_is_lower_bound: boolean;
+    /**
+     * What its turns cost so far, in dollars.
+     */
+    cost_usd: number;
+    /**
+     * Work turns it opened.
+     */
+    turns: number;
+    /**
+     * Checks of a claimed completion.
+     */
+    verifications: number;
+};
 /**
  * A picture job.
  */
@@ -575,7 +1005,7 @@ export type ImageUsage = ({
     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.
+ * 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 = {
     /**
@@ -583,7 +1013,15 @@ export type InputImage = {
      */
     bucket?: string;
     /**
-     * The picture's path in the bucket.
+     * The picture's bytes, base64: 5 MiB at most, 6 MiB with the question's other pictures given so.
+     */
+    data?: string;
+    /**
+     * The picture's type, with its bytes: image/png, image/jpeg, image/webp or image/gif.
+     */
+    media_type?: string;
+    /**
+     * The picture's path in the bucket.
      */
     path?: string;
     /**
@@ -591,6 +1029,23 @@ export type InputImage = {
      */
     url?: string;
 };
+/**
+ * A model's price past its prompt's step: the whole request pays it.
+ */
+export type LongContextPrice = {
+    /**
+     * The step: a prompt of more tokens.
+     */
+    above_prompt_tokens: number;
+    /**
+     * Input.
+     */
+    input_usd_per_mtok: number;
+    /**
+     * Output.
+     */
+    output_usd_per_mtok: number;
+};
 /**
  * A user in a chat.
  */
@@ -612,6 +1067,10 @@ export type Member = {
  * 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.
      */
@@ -634,6 +1093,77 @@ export type Message = {
      */
     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.
  */
@@ -660,19 +1190,54 @@ export type MessageRequest = {
      * 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 message (64 KiB at most).
      */
     text: string;
 };
+/**
+ * The voice a line of kind voice was said in, and by whom.
+ */
+export type MessageVoice = {
+    /**
+     * The voice.
+     */
+    id: string;
+    /**
+     * user (the person) or assistant (the voice).
+     */
+    role: string;
+};
 /**
  * What a project may name.
  */
 export type Models = {
+    /**
+     * 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.
+     */
+    chat: ChatModel[];
     /**
      * Embedding models, with their list prices.
      */
@@ -685,11 +1250,19 @@ export type Models = {
      * 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.
      */
@@ -734,6 +1307,27 @@ export type ProviderList = {
      */
     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.
  */
@@ -760,9 +1354,13 @@ export type Repo = {
     repository: string;
 };
 /**
- * The project's repositories.
+ * 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[];
 };
 /**
@@ -833,15 +1431,34 @@ export type ResponseError = ({
     message: string;
 }) | null;
 /**
- * A background response ended.
+ * 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;
     /**
-     * The caller's own labels (16 at most, snake_case keys): returned with the response and its event.
+     * 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;
@@ -855,9 +1472,30 @@ export type ResponseEvent = {
      */
     response_id: string;
     /**
-     * How it ended.
+     * 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.
@@ -880,7 +1518,7 @@ export type ResponseRequest = {
      */
     instructions?: string;
     /**
-     * How many tool calls the answer makes at most: past it the model is told it has no tools left and answers.
+     * 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;
     /**
@@ -920,6 +1558,14 @@ export type ResponseRequest = {
  * 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.
      */
@@ -928,6 +1574,10 @@ export type ResponseUsage = {
      * Tokens written.
      */
     output_tokens: number;
+    /**
+     * cost_nano_usd in dollars.
+     */
+    usd: number;
 };
 /**
  * A message a subagent was given.
@@ -959,6 +1609,24 @@ export type RunMessageRequest = {
      */
     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.
  */
@@ -972,9 +1640,9 @@ export type Settings = {
      */
     history_bytes: number;
     /**
-     * How much chat history the project keeps; a message past it is refused (history_full) until chats are deleted.
+     * 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;
+    history_limit_bytes: number | null;
     /**
      * How many messages one user sends a minute (default 20).
      */
@@ -989,9 +1657,9 @@ export type SettingsRequest = {
      */
     clients?: boolean;
     /**
-     * At most the plan's (500 MiB): a project may keep less, not more.
+     * 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;
+    history_limit_bytes?: number | null;
     /**
      * 1 to 600.
      */
@@ -1010,10 +1678,18 @@ export type StopResult = {
  * 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.
      */
@@ -1030,6 +1706,10 @@ export type Subagent = {
      * 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.
      */
@@ -1096,7 +1776,7 @@ export type ToolOutputAccepted = {
     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), or client (code of the app the chat is open in: the turn waits for its answer).
+ * 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 = {
     /**
@@ -1112,7 +1792,7 @@ export type ToolRef = {
      */
     machine?: string;
     /**
-     * The tool (backend, client), or the endpoint's name (https, mcp).
+     * 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;
     /**
@@ -1126,9 +1806,9 @@ export type ToolRef = {
         [key: string]: unknown;
     };
     /**
-     * backend, https, mcp or client.
+     * backend, https, mcp, client or platform.
      */
-    source: "backend" | "https" | "mcp" | "client";
+    source: "backend" | "https" | "mcp" | "client" | "platform";
 };
 /**
  * One artifact a turn's agent published.
@@ -1202,10 +1882,121 @@ export type TurnCost = {
      * 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;
+    /**
+     * cost_nano_usd in dollars.
+     */
+    usd: number;
+};
+/**
+ * What one run of a turn — its own, or a subagent's — cost so far.
+ */
+export type TurnRunCost = {
+    /**
+     * Tokens read from the provider's cache.
+     */
+    cache_read_tokens: number;
+    /**
+     * Tokens written to it.
+     */
+    cache_write_tokens: number;
+    /**
+     * Its cost, in billionths of a dollar.
+     */
+    cost_nano_usd: number;
+    /**
+     * Tokens read.
+     */
+    input_tokens: number;
+    /**
+     * The model it ran on, as provider:model.
+     */
+    model: string;
+    /**
+     * Tokens written.
+     */
+    output_tokens: number;
+    /**
+     * The run that started it; absent for the turn's own.
+     */
+    parent_run_id?: string;
+    /**
+     * Its response: the turn's, or the subagent's (an agent part's response_id).
+     */
+    response_id: string;
+    /**
+     * The run.
+     */
+    run_id: string;
+    /**
+     * Where it is: running, completed, failed…
+     */
+    state: string;
+    /**
+     * The subagent it is; empty for the turn's own run.
+     */
+    subagent: string;
+    /**
+     * Some of its use had no rate: the cost is a floor.
+     */
+    unpriced: boolean;
+    /**
+     * Its cost in dollars.
+     */
+    usd: number;
+};
+/**
+ * A tool call of a turn as the engine committed it.
+ */
+export type TurnToolCall = {
+    /**
+     * What the agent called it with, as JSON.
+     */
+    arguments: unknown;
+    /**
+     * The call.
+     */
+    call_id: string;
+    /**
+     * When it was made.
+     */
+    created_at: string;
+    /**
+     * The tool.
+     */
+    name: string;
+    /**
+     * 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.
+     */
+    result?: unknown;
+    /**
+     * Where it is, as the engine says it.
+     */
+    state: string;
+    /**
+     * When it last changed.
+     */
+    updated_at: string;
+};
+/**
+ * A page of a turn's tool calls, in the order the engine committed them.
+ */
+export type TurnToolCallPage = {
+    /**
+     * Pages on (cursor=); absent on the last page.
+     */
+    next_cursor?: string;
+    /**
+     * The calls.
+     */
+    tool_calls: TurnToolCall[];
 };
 /**
  * A page of uses.
@@ -1256,6 +2047,12 @@ export type Use = {
      * text, embedding or image.
      */
     kind: "text" | "embedding" | "image";
+    /**
+     * 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.
+     */
+    metadata: {
+        [key: string]: string;
+    };
     /**
      * The model.
      */
@@ -1273,67 +2070,330 @@ export type Use = {
  * Text for the voice.
  */
 export type VoiceCommand = {
+    /**
+     * The voice's member the server tells it as (the server's alone).
+     */
+    as?: string;
     /**
      * The delegated voice part this answers (speak).
      */
     delegation_id?: string;
+    /**
+     * speak only: cut what the voice is saying and say the text at once.
+     */
+    interrupt?: boolean;
     /**
      * What it is given (16 KiB at most).
      */
     text: string;
     /**
-     * speak (say this), know (keep it in mind) or instruct (behave so).
+     * 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" | "know" | "instruct";
+    type: "speak" | "tell" | "know" | "instruct";
 };
 /**
- * Starts the chat's live voice.
+ * 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 VoiceRequest = {
+export type VoiceDelegatedEvent = {
     /**
-     * The app's WebRTC offer (an SDP).
+     * The chat.
      */
-    sdp: string;
+    chat_id: string;
     /**
-     * The voice (the provider's default unless said).
+     * The request: a speak naming it answers it.
      */
-    voice?: string;
-};
-/**
- * A chat's live voice.
- */
-export type VoiceSession = {
+    delegation_id: string;
     /**
-     * The chat.
+     * What was said before it that the voice answered itself, in order.
      */
-    chat_id: string;
+    earlier: VoiceLine[];
     /**
-     * The voice session.
+     * The chat's labels.
      */
-    id: string;
+    metadata: {
+        [key: string]: string;
+    };
     /**
-     * The provider's WebRTC answer, for the app's peer connection (on start).
+     * What they asked, as the voice heard it.
      */
-    sdp?: string;
+    text: string;
     /**
-     * How long it lasted (on close).
+     * The voice's member (null: the server's own).
      */
-    seconds: number;
+    user_id: string | null;
+    /**
+     * The voice.
+     */
+    voice_id: string;
+};
+/**
+ * A chat's voice began, or ended.
+ */
+export type VoiceEvent = {
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * Why it ended (empty while live).
+     */
+    close_reason: string;
+    /**
+     * chat or events.
+     */
+    delegation: string;
+    /**
+     * The chat's labels.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * How long it lasted.
+     */
+    seconds: number;
     /**
      * active, or closed.
      */
-    status?: string;
+    status: string;
+    /**
+     * Its member (null: the server's own).
+     */
+    user_id: string | null;
+    /**
+     * The voice.
+     */
+    voice_id: string;
+};
+/**
+ * A line said in a voice conversation: the person's (user) or the voice's (assistant).
+ */
+export type VoiceLine = {
+    /**
+     * user or assistant.
+     */
+    role: string;
+    /**
+     * The line.
+     */
+    text: string;
+};
+/**
+ * Starts the chat's live voice.
+ */
+export type VoiceRequest = {
+    /**
+     * The member the server starts it for (the server's alone): the voice is theirs, and counts toward their starts.
+     */
+    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;
+};
+/**
+ * A chat's voice.
+ */
+export type VoiceSession = {
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * 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.
+     */
+    close_reason?: string;
+    /**
+     * When it ended (null: live).
+     */
+    closed_at: string | null;
+    /**
+     * chat or events: what becomes of what the person asks for.
+     */
+    delegation: string;
+    /**
+     * The voice session.
+     */
+    id: string;
+    /**
+     * The provider's WebRTC answer, for the app's peer connection (on start).
+     */
+    sdp?: string;
+    /**
+     * How long it has lasted.
+     */
+    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 file a published tree changed against the tree it replaced.
+ */
+export type WorkspaceChange = {
+    /**
+     * added, modified (its bytes or its mode) or removed.
+     */
+    change: string;
+    /**
+     * The file, as the tree names it (repo/output/app/App.zip).
+     */
+    path: string;
+    /**
+     * Its size in the tree; 0 for one removed.
+     */
+    size_bytes: number;
+};
+/**
+ * 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 WorkspacePublishedEvent = {
+    /**
+     * What changed against the tree it replaced, sorted by path: 1000 at most (changed_truncated).
+     */
+    changed: WorkspaceChange[];
+    /**
+     * How many files changed.
+     */
+    changed_count: number;
+    /**
+     * More changed than changed names.
+     */
+    changed_truncated: boolean;
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * The tree: a file of it is read by it (GET /ai/chats/{chat_id}/workspace/files?manifest=), whatever the workspace published after it.
+     */
+    manifest_id: string;
+    /**
+     * The chat's labels.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * The tree it replaced; absent for none.
+     */
+    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 = {
+    /**
+     * The branch it was pushed to.
+     */
+    branch: string;
+    /**
+     * The chat.
+     */
+    chat_id: string;
+    /**
+     * What the push brought to the branch, the oldest first: 100 at most (commits_truncated); none when the branch was there already.
+     */
+    commits: PushedCommit[];
+    /**
+     * It brought more than commits names.
+     */
+    commits_truncated: boolean;
+    /**
+     * The commit the branch is at now.
+     */
+    head_sha: string;
+    /**
+     * The chat's labels.
+     */
+    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;
+    /**
+     * The member the turn was for; null: the server's.
+     */
+    user_id: string | null;
+};
+/**
+ * A repository put in an open chat's workspace.
+ */
+export type WorkspaceRepoRequest = {
+    /**
+     * The branch it is checked out at and pushed to (the repository's default unless said).
+     */
+    branch?: string;
+    /**
+     * The project's name for the repository (PUT /ai/repos/{name}): one put at work's moment too.
+     */
+    repo: 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.response.completed: a response started with background: true completed; read its answer by its id.
+     * 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.
+     */
+    "ai.goal.updated": GoalEvent;
+    /**
+     * ai.response.completed: a response started with background: true completed — read its answer by its id — or a chat's turn completed.
      */
     "ai.response.completed": ResponseEvent;
     /**
-     * ai.response.failed: a response started with background: true ended without completing (failed, canceled, timed out, over its budget).
+     * 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).
      */
     "ai.response.failed": ResponseEvent;
+    /**
+     * 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.
+     */
+    "ai.response.started": ResponseEvent;
+    /**
+     * ai.voice.closed: a chat's voice ended — closed, replaced, its member taken out, its chat deleted, lost — with how long it lasted.
+     */
+    "ai.voice.closed": VoiceEvent;
+    /**
+     * 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.voice.delegated": VoiceDelegatedEvent;
+    /**
+     * ai.voice.started: a chat's voice began.
+     */
+    "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): {
@@ -1371,11 +2431,14 @@ 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>>;
@@ -1423,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: {
@@ -1439,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: {
@@ -1466,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 — 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).
+     * 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: {
@@ -1475,10 +2602,39 @@ 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, waiting: {reason: approval|tool_output|subagents|message, text_offset, approval_id, tool_call_id, tool_name, input}, error}), `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), `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), `voice` ({voice_session_id, kind: transcript|started|closed|delegated, role: user|assistant, text, delegation_id, task}: the chat's live voice — what was said either way), and `seen` (the journal moved past what was handed already). 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.
+     * 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: {
@@ -1511,21 +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>>;
+    /**
+     * A turn's tool calls
+     *
+     * 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).
+     */
+    listTurnToolCalls(input: {
+        path: {
+            chat_id: string;
+        };
+        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, 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. 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).
+     * 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: {
@@ -1575,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: {
@@ -1584,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: {
@@ -1609,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
      *
@@ -1629,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: {
@@ -1726,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>>;
     /**
@@ -1757,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: {
@@ -1828,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>>;