@mono-agent/web 0.20.11 → 0.21.0

package/dist/contracts.d.ts

@@ -1,4 +1,4 @@
-import { type AgentReplyMcpAppPart, type AgentReplyPartFailure, type CronOperatorHealth, type CronOperatorJob, type CronOperatorOverview, type CronOperatorRun, type CronOperatorRunBase, type CronOperatorRunDetail, type CronOperatorRunPage, type CronOperatorRunStatus, type CronOperatorRunSummary, type CronOperatorRunTrigger, type CronOperatorRunTruncatedField, type SessionToolHistoryEventMetadata, type ProcessJobProjection } from "@mono-agent/agent-contracts";
+import { type AgentReplyMcpAppPart, type AgentReplyPartFailure, type CronOperatorHealth, type CronOperatorJob, type CronOperatorOverview, type CronOperatorRun, type CronOperatorRunBase, type CronOperatorRunDetail, type CronOperatorRunPage, type CronOperatorRunStatus, type CronOperatorRunSummary, type CronOperatorRunTrigger, type CronOperatorRunTruncatedField, type SessionToolHistoryEventMetadata, type MonitorProjection, type ProcessJobProjection } from "@mono-agent/agent-contracts";
 /** Machine-readable discovery contract consumed by local ACP clients such as Worklab. */
 export declare const ACP_BRIDGE_DISCOVERY_SCHEMA: "mono-agent.acp-discovery.v1";
 export declare const ACP_BRIDGE_SOURCE_SCHEMA: "mono-agent.acp-source.v1";
@@ -47,6 +47,8 @@ export declare const WEB_API_VERSION: 1;
 export declare const WEB_THEMES: readonly ["evergreen", "ocean", "plum", "terracotta"];
 export type WebTheme = (typeof WEB_THEMES)[number];
 export declare const DEFAULT_WEB_THEME: WebTheme;
+/** Canonical upper bound on the operator-chosen console label. */
+export declare const WEB_CONSOLE_NAME_MAX_CHARACTERS = 80;
 export declare const WEB_MAX_FILES_PER_TURN = 10;
 export declare const WEB_MAX_TURN_ATTACHMENT_BYTES: number;
 export declare const WEB_STAGED_UPLOAD_TTL_MS: number;
@@ -59,7 +61,7 @@ export declare const WEB_MAX_TURN_TEXT_CHARACTERS = 200000;
 export declare const WEB_MAX_LIVE_INPUTS_PER_THREAD = 100;
 export type WebAgentStatus = "online" | "offline" | "degraded";
 export type WebThreadNotificationTriggerKind = "cron" | "webhook";
-export type WebNotificationTriggerKind = WebThreadNotificationTriggerKind | "job";
+export type WebNotificationTriggerKind = WebThreadNotificationTriggerKind | "job" | "monitor";
 export type WebThreadTrigger = {
     readonly kind: "webhook";
 } | {
@@ -74,28 +76,84 @@ export interface WebCronCapability {
 }
 export interface WebModelOption {
     readonly effortLevels?: readonly string[];
+    /** Configured fallback effort; null means provider default. */
+    readonly effort?: string | null;
     readonly reasoning?: boolean;
     readonly reasoningMode?: string;
     readonly label?: string;
     readonly contextWindow?: number;
 }
+export type WebRunSettingSource = "config" | "override";
+/** Config defaults, optional web-console overrides, and the effective values for new conversations. */
+export interface WebAgentRunSettings {
+    readonly config: {
+        readonly model?: string;
+        readonly effort?: string;
+    };
+    readonly override: {
+        readonly model?: string;
+        readonly effort?: string;
+    } | null;
+    readonly effective: {
+        readonly model?: string;
+        readonly modelSource: WebRunSettingSource;
+        readonly effort?: string;
+        readonly effortSource: WebRunSettingSource;
+    };
+}
 export interface WebAgentSummary {
     readonly sourceId: string;
+    /**
+     * Opaque token for the agent PROCESS this summary describes: stable while
+     * that process lives, different once it is replaced. Additive, and additive
+     * only -- no client is required to read it.
+     *
+     * A source id outlives the process behind it, so anything a client caches
+     * per agent (the `/v1/models` pages the model picker fetches, above all)
+     * outlives the catalog that filled it. The console's server already scopes
+     * its own catalog cache this way; before this field the browser had nothing
+     * generation-shaped to observe at all -- no pid, no start time, and an
+     * `updatedAt` that is a discovery heartbeat -- so a tab kept offering a
+     * restarted agent's retired models until it was reloaded.
+     *
+     * Absent on any summary not built from a live discovery pass.
+     */
+    readonly generation?: string;
     readonly label: string;
     readonly status: WebAgentStatus;
     readonly pinned?: boolean;
     readonly health?: string;
     readonly supportsAttachments: boolean;
+    /**
+     * Agent operator exposes Pi provider authentication v1. The operator client
+     * adds a bearer only when that discovered endpoint has an API key.
+     *
+     * Usability is projected from the live connection's `/v1/info`; a stored bit
+     * is presentation state, never authorization to call the agent.
+     */
+    readonly supportsProviderAuth?: true;
+    /** Additive explicit live-check action; passive status remains traffic-free. */
+    readonly supportsProviderAuthChecks?: true;
     readonly models?: readonly string[];
     readonly defaultModel?: string;
     readonly defaultEffort?: string;
     readonly efforts?: readonly string[];
     readonly modelOptions?: Readonly<Record<string, WebModelOption>>;
+    /** Web-console-owned defaults copied into conversations created after they are saved. */
+    readonly runSettings: WebAgentRunSettings;
+    /**
+     * Providers this agent supports. `models`/`modelOptions` stay the configured
+     * shortlist; this is what the selector groups and filters by, and what tells
+     * a client which providers are worth requesting a `/v1/models` page for.
+     * Absent when the agent predates the provider catalog.
+     */
+    readonly providers?: readonly WebAgentProvider[];
     /** Absent when the addressed agent predates first-class cron operator routes. */
     readonly cron?: WebCronCapability;
     readonly supportsAskById?: boolean;
     readonly updatedAt: string;
 }
+export type { ProviderAuthCheckResult, ProviderAuthCheckSessionSnapshot, ProviderAuthCheckStartInput, ProviderAuthMethod, ProviderAuthPrompt, ProviderAuthProviderStatus, ProviderAuthSessionInput, ProviderAuthSessionSnapshot, ProviderAuthSessionStartInput, ProviderAuthStatusSnapshot, ProviderAuthUsage, } from "@mono-agent/agent-contracts";
 export type WebSkillAvailability = "inlined" | "on-demand" | "unavailable";
 export type WebSkillUnavailableReason = "not-selected" | "read-skill-disabled" | "unsupported-name";
 export interface WebSkillInfo {
@@ -115,17 +173,62 @@ export type WebSkillRegistry = {
     readonly items: readonly [];
 };
 export type WebRunStatus = "idle" | "running" | "complete" | "failed" | "cancelled" | "interrupted";
+export interface WebRunSelection {
+    readonly model?: string;
+    readonly effort?: string;
+}
+export interface WebRunExecution extends WebRunSelection {
+    readonly effectiveEffort?: string;
+}
+export interface WebRunTransition {
+    readonly from: string;
+    readonly to: string;
+    readonly attemptIndex?: number;
+    readonly reason?: string;
+}
+export interface WebRunRetry {
+    readonly model?: string;
+    readonly retryIndex?: number;
+    readonly attempts?: number;
+    readonly reason?: string;
+}
+export interface WebRunAttribution {
+    readonly requested: WebRunSelection;
+    readonly attempted?: WebRunExecution;
+    readonly executed?: WebRunExecution;
+    readonly disposition: "requested" | "fallback" | "unknown";
+    readonly transitions: readonly WebRunTransition[];
+    readonly retries: readonly WebRunRetry[];
+    readonly truncated?: true;
+}
 export interface WebRunState {
     readonly id?: string;
     readonly status: WebRunStatus;
     readonly startedAt?: string;
     readonly finishedAt?: string;
+    /** Previous meaningful outcome when this completion was a silent host-only wake. */
+    readonly lastOutcome?: {
+        readonly status: WebRunStatus;
+        readonly finishedAt?: string;
+    } | null;
     readonly error?: {
         readonly code?: string;
         readonly message: string;
     };
     readonly model?: string;
     readonly effort?: string;
+    readonly attribution?: WebRunAttribution;
+}
+/** Bounded activity derived from every retained process-job card in a thread. */
+export interface WebJobActivity {
+    readonly queued: number;
+    readonly starting: number;
+    readonly running: number;
+    readonly latestTerminal?: {
+        readonly state: Exclude<ProcessJobProjection["state"], "queued" | "starting" | "running">;
+        readonly completedAt: string;
+        readonly replyPreview?: string;
+    };
 }
 export interface WebThread {
     readonly id: string;
@@ -139,11 +242,63 @@ export interface WebThread {
     readonly lastMessagePreview?: string;
     readonly messageCount: number;
     readonly runState: WebRunState;
+    readonly jobActivity?: WebJobActivity;
     readonly canSend: boolean;
     readonly canUpload: boolean;
+    /** Per-conversation model override, or null when the agent default applies. */
+    readonly runModel: string | null;
+    /** Per-conversation effort override, or null when the agent default applies. */
+    readonly runEffort: string | null;
 }
 export type WebMessageStatus = "running" | "complete" | "failed" | "cancelled" | "interrupted";
 export type WebToolCallStatus = "running" | "complete" | "failed";
+export interface WebCronReplyContextPart {
+    readonly type: "cron-reply-context";
+    readonly schema: "mono-agent.web.cron-reply-context.v1";
+    readonly untrusted: true;
+    readonly source: {
+        readonly sourceId: string;
+        readonly jobId: string;
+        readonly runId: string;
+    };
+    readonly run: {
+        readonly sequence: number;
+        readonly trigger: WebCronRunTrigger;
+        readonly status: WebCronRunStatus;
+        readonly scheduledAt: string;
+        readonly orderedAt: string;
+        readonly startedAt?: string;
+        readonly completedAt?: string;
+        readonly blockedByRunId?: string;
+        readonly blockedByTrigger?: WebCronRunTrigger;
+        readonly queueDepth?: number;
+    };
+    readonly snapshot: {
+        readonly capturedAt: string;
+        readonly kind: WebCronReplySnapshotKind;
+        readonly sourceTruncationKnown: boolean;
+        readonly sourceFieldsTruncated: readonly WebCronRunTruncatedField[];
+        readonly maxBytes: number;
+        readonly originalErrorBytes: number;
+        readonly retainedErrorBytes: number;
+        readonly originalResultBytes: number;
+        readonly retainedResultBytes: number;
+        readonly truncatedFields: readonly ("failure.message" | "result.text")[];
+    };
+    readonly result: {
+        readonly text: string;
+    };
+    readonly failure: {
+        readonly code?: string;
+        readonly message?: string;
+    };
+    /** Exact human-readable framing which precedes the JSON on the agent wire. */
+    readonly prefix: string;
+    /** Exact JSON substring from the imported wire text; never re-serialized. */
+    readonly rawJson: string;
+    /** Exact imported wire text retained for diagnostics and copy-safe display. */
+    readonly rawText: string;
+}
 /** One tool call, whether the agent made it or one of its subagents did. */
 export interface WebToolCall {
     readonly toolCallId: string;
@@ -151,9 +306,8 @@ export interface WebToolCall {
     readonly args?: unknown;
     readonly result?: unknown;
     /**
-     * An MCP tool's machine-readable result, when it returned one. `result` is the
-     * model-facing text and is lossy; renderers that must reason about the outcome
-     * (the AskUser card reads `interactionId`/`answered`) read this instead.
+     * A bounded machine-readable tool result, from MCP or a canonical host tool
+     * outcome. `result` is model-facing and lossy; consumers validate the schema here.
      */
     readonly structuredResult?: unknown;
     readonly status: WebToolCallStatus;
@@ -165,6 +319,33 @@ export interface WebToolCall {
     readonly executionMs?: number;
     /** Canonical durable-tool record metadata received on the live event. */
     readonly history?: SessionToolHistoryEventMetadata;
+    /**
+     * Set when the transcript carries only the head of `result`. A 20 KB `Exec`
+     * body is the single largest thing a conversation read transfers and almost
+     * none of it is ever looked at, so a browser read gets a preview and the
+     * whole body stays one request away at
+     * `/threads/:id/messages/:messageId/tool-calls/:toolCallId`. Never set on a
+     * `?full=1` read.
+     */
+    readonly resultTruncated?: boolean;
+    /** Character length of the untruncated `result` text, when it was truncated. */
+    readonly resultBytes?: number;
+    /**
+     * Lowercase sha-256 hex of the SERIALIZED untruncated `result` -- the string
+     * itself for a string payload, its JSON otherwise.
+     *
+     * Carried by a truncated preview AND by the whole body the tool-call route
+     * serves, so a console holding a repaired body can prove the preview that
+     * arrived after it describes the same content. It is an identity, not a
+     * signature: nothing here is secret and nothing is keyed.
+     */
+    readonly resultDigest?: string;
+    /** As {@link resultTruncated}, for the call's arguments. */
+    readonly argsTruncated?: boolean;
+    /** Character length of the untruncated `args` text, when it was truncated. */
+    readonly argsBytes?: number;
+    /** As {@link resultDigest}, for the call's arguments. */
+    readonly argsDigest?: string;
 }
 export type WebMessagePart = {
     readonly type: "text";
@@ -172,7 +353,7 @@ export type WebMessagePart = {
 } | {
     readonly type: "reasoning";
     readonly text: string;
-} | ({
+} | WebCronReplyContextPart | ({
     readonly type: "tool-call";
 } & WebToolCall)
 /**
@@ -194,8 +375,19 @@ export type WebMessagePart = {
     readonly executionMs?: number;
     /** What this delegation cost, when the runtime priced its model. */
     readonly costUsd?: number;
+    /** Provider route requested, attempted, and executed by this child. */
+    readonly attribution?: WebRunAttribution;
     /** Metadata for the persisted parent `Agent` call; child internals omit it. */
     readonly history?: SessionToolHistoryEventMetadata;
+    /** See {@link WebToolCall.resultTruncated}; the delegation's report is truncated the same way. */
+    readonly resultTruncated?: boolean;
+    readonly resultBytes?: number;
+    /** See {@link WebToolCall.resultDigest}. */
+    readonly resultDigest?: string;
+    readonly argsTruncated?: boolean;
+    readonly argsBytes?: number;
+    /** See {@link WebToolCall.resultDigest}. */
+    readonly argsDigest?: string;
     readonly status: WebToolCallStatus;
     readonly calls: readonly WebToolCall[];
 } | {
@@ -204,8 +396,31 @@ export type WebMessagePart = {
     /** Bounded normal-turn answer produced by the terminal wake, when ready. */
     readonly responseText?: string;
 } | {
+    /** Chronological marker for the point where a retained job wake was applied. */
+    readonly type: "process-job-wake";
+    readonly jobId: string;
+    readonly deliveryKey: string;
+    readonly disposition: "steered" | "follow_up";
+} | {
+    readonly type: "monitor-activity";
+    /** One compact run-level row, with one latest projection per Monitor. */
+    readonly monitors: readonly {
+        readonly projection: MonitorProjection;
+        /** Exact delivered wake identities, retained only for idempotent UI aggregation. */
+        readonly deliveryKeys: readonly string[];
+    }[];
+}
+/**
+ * One runtime/provider diagnostic. `data` is present only for the events the
+ * console actually renders or sums; everything else keeps its identity (and
+ * its position, which the transcript's index-based reads depend on) and drops
+ * the payload. `kind` names a stripped `runtime_telemetry`'s variant so the
+ * part still says what it was.
+ */
+ | {
     readonly type: "telemetry";
     readonly event: string;
+    readonly kind?: string;
     readonly data?: unknown;
 } | {
     readonly type: "error";
@@ -273,8 +488,24 @@ export interface WebMessage {
     readonly attachments: readonly WebAttachment[];
     readonly createdAt: string;
     readonly updatedAt: string;
+    /**
+     * When the turn that produced this assistant message reached a terminal state
+     * (complete, failed, cancelled or interrupted). `createdAt` is that turn's
+     * start, so the pair is the turn's wall-clock window. Absent while the turn
+     * runs, on user and system rows, and on assistant rows with no turn.
+     */
+    readonly finishedAt?: string;
     readonly status: WebMessageStatus;
-    readonly liveInputStatus?: "pending" | "applied" | "queued" | "cancelled";
+    readonly liveInputStatus?: "pending" | "applied" | "queued" | "cancelled" | "uncertain";
+    readonly attribution?: WebRunAttribution;
+    /**
+     * How many times this message's parts have been persisted, counted from the
+     * row's creation. It is what makes a {@link WebMessageDelta} safe to apply:
+     * a holder of `seq` can tell the very next write from one that skipped ahead
+     * of it, and re-read the message instead of guessing. Rows written before the
+     * console counted read 0.
+     */
+    readonly seq: number;
 }
 export interface WebQuote {
     readonly text: string;
@@ -337,6 +568,46 @@ export interface WebCronRunPage extends CronOperatorRunPage {
     /** Canonical messages reconciled by the web backend for this page. */
     readonly messages?: readonly WebMessage[];
 }
+export type WebCronReplySnapshotKind = "summary" | "detail";
+export interface CreateWebCronReplyInput {
+    readonly operationId: string;
+    readonly snapshotKind: WebCronReplySnapshotKind;
+}
+/** One durable, server-owned import receipt. `duplicate` means local replay. */
+export interface WebCronReplyReceipt {
+    readonly operationId: string;
+    readonly sourceId: string;
+    readonly jobId: string;
+    readonly runId: string;
+    readonly duplicate: boolean;
+    readonly thread: WebThread;
+    /** Presentation-shaped messages. The two canonical stored rows fold to one card. */
+    readonly messages: readonly WebMessage[];
+}
+/** One provider an agent advertises as supported. */
+export interface WebAgentProvider {
+    readonly id: string;
+    readonly label: string;
+    /** The agent declared this provider or routes through it. */
+    readonly configured?: true;
+}
+/** One model served by the lazy agent `/v1/models` catalog endpoint. */
+export interface WebCatalogModel {
+    readonly id: string;
+    readonly name: string;
+    readonly provider: string;
+    readonly providerLabel: string;
+    readonly contextWindow?: number;
+    readonly reasoning?: boolean;
+    readonly effortLevels?: readonly string[];
+    readonly reasoningMode?: string;
+}
+/** A bounded model-catalog page proxied from an agent's `/v1/models` endpoint. */
+export interface WebModelPage {
+    readonly models: readonly WebCatalogModel[];
+    readonly nextCursor?: string;
+    readonly truncated: boolean;
+}
 export interface WebCronConfirmation {
     readonly token: string;
     readonly expiresAt: string;
@@ -365,7 +636,10 @@ export interface WebChannelConfigView {
     readonly fields: readonly WebChannelConfigViewField[];
 }
 export interface WebConsoleIdentity {
+    /** Machine hostname; the default display name and the LAN identity operators recognise. */
     readonly hostName: string;
+    /** Operator-chosen console label (`mono-agent web --name`), falling back to `hostName`. */
+    readonly displayName: string;
     readonly theme: WebTheme;
 }
 export interface WebPushBootstrap {
@@ -385,12 +659,32 @@ export interface WebPushSubscriptionStatus {
     readonly lastErrorAt?: string;
     readonly lastErrorCode?: string;
 }
+/**
+ * What a bootstrap should carry, when the console knows.
+ *
+ * A bootstrap used to carry every discovered agent's conversations -- one
+ * 200-row bucket per agent per archive state -- and the console then re-read
+ * the single bucket its sidebar shows. `sourceId` names the bucket it wants;
+ * an absent or unknown one falls back rather than failing, because the first
+ * request a fresh console makes has no selection to name yet.
+ */
+export interface WebBootstrapScope {
+    readonly sourceId?: string;
+    readonly archived?: boolean;
+    readonly limit?: number;
+}
 export interface WebBootstrap {
     readonly version: typeof WEB_API_VERSION;
     readonly console: WebConsoleIdentity;
     readonly push: WebPushBootstrap;
+    /** Every discovered agent, in full: the rail shows all of them at once. */
     readonly agents: readonly WebAgentSummary[];
+    /** One page of ONE (agent, archived) bucket -- the one `threadsSourceId` names. */
     readonly threads: readonly WebThread[];
+    /** The bucket `threads` came from, or `null` when there is no agent to open on. */
+    readonly threadsSourceId: string | null;
+    /** Keyset cursor for the next older page of that bucket, or `null` at its end. */
+    readonly threadsNextCursor: string | null;
     readonly currentThreadId?: string;
     readonly limits: {
         readonly maxFileBytes: number;
@@ -399,17 +693,125 @@ export interface WebBootstrap {
         readonly accept: readonly string[];
     };
 }
-export type WebEventType = "ready" | "agents.changed" | "cron.changed" | "threads.changed" | "thread.changed" | "message.changed" | "turn.changed" | "attachment.changed" | "push.pending";
+export type WebEventType = "ready" | "agents.changed" | "cron.changed" | "threads.changed" | "thread.changed" | "message.changed" | "message.delta" | "turn.changed" | "attachment.changed" | "push.pending";
+/**
+ * The payload of every `thread.changed`/`threads.changed` that names a
+ * conversation.
+ *
+ * The fresh summary travels WITH the event: one that only named a conversation
+ * cost every connected console a page of its bucket to find out what had
+ * changed about a row it was already holding. A removal has no summary left to
+ * carry, so it says so.
+ */
+export type WebThreadChangedPayload = {
+    readonly thread: WebThread;
+} | {
+    readonly threadId: string;
+    readonly removed: true;
+};
+/**
+ * What an `agents.changed` says about itself.
+ *
+ * A pin is a one-field write the writing tab already applied from the PATCH
+ * response, so it names the agent and the new state rather than telling every
+ * console to re-read the bootstrap, its skills and its cron. Discovery-driven
+ * invalidations carry nothing: an agent that appeared, went away, or advertises
+ * something different can have changed anything at all.
+ */
+export type WebAgentsChangedPayload = {
+    readonly sourceId: string;
+    readonly pinned: boolean;
+} | undefined;
+/**
+ * One edit to a message's part array.
+ *
+ * Ops are ordered so that applying them front to back is always well defined: a
+ * `truncate` comes first when the array shrank, and the rest ascend by index,
+ * which is also why an index never names a slot the shortened array lost.
+ */
+export type WebMessageDeltaOp = 
+/** Text streamed onto the end of the `text`/`reasoning` part at `index`. */
+{
+    readonly op: "append";
+    readonly index: number;
+    readonly delta: string;
+}
+/** The whole part at `index`, replaced or appended one past the end. */
+ | {
+    readonly op: "set";
+    readonly index: number;
+    readonly part: WebMessagePart;
+}
+/** Drop every part from `length` onward. Emitted first when it is emitted. */
+ | {
+    readonly op: "truncate";
+    readonly length: number;
+};
+/**
+ * One persisted parts write, as content rather than an invalidation hint.
+ *
+ * A streaming answer is rewritten every ~50 ms, and a hint made every console
+ * answer each one by re-reading the whole conversation. This says what actually
+ * changed instead. `baseSeq` is the version the ops apply to and `seq` the one
+ * they produce: a client whose message is not at `baseSeq` has missed a write
+ * and must re-read that message rather than apply anything.
+ */
+export interface WebMessageDelta {
+    readonly messageId: string;
+    /** The message's {@link WebMessage.seq} BEFORE this write. */
+    readonly baseSeq: number;
+    /** The message's `seq` after it, always `baseSeq + 1`. */
+    readonly seq: number;
+    readonly status: WebMessageStatus;
+    readonly updatedAt: string;
+    /**
+     * {@link WebMessage.finishedAt}, carried by the write that SETS it.
+     *
+     * The turn's wall-clock window is `createdAt` to this, and a console holding
+     * only the first half had to re-read the whole conversation at every turn
+     * finish to draw it. Absent on every write that leaves the turn running.
+     */
+    readonly finishedAt?: string;
+    /** Full replacement snapshot when provider routing metadata changed. */
+    readonly attribution?: WebRunAttribution;
+    readonly ops: readonly WebMessageDeltaOp[];
+}
+/**
+ * The payload of a `message.changed`: the message moved, go and read it.
+ *
+ * `deltaDeclined` is NOT part of the wire contract -- the event stream strips
+ * it, and a browser reads the same two fields either way. It marks the hint the
+ * delta path emits when the delta it built would have cost more than the
+ * message it describes, so the stream layer can tell one write-rate frame from
+ * a reconciliation and rate-limit only the first.
+ */
+export interface WebMessageChangedPayload {
+    readonly messageId: string;
+    readonly updatedAt: string;
+    readonly deltaDeclined?: true;
+}
 export interface WebEvent {
     readonly id: string;
     readonly version: typeof WEB_API_VERSION;
     readonly type: WebEventType;
     readonly at: string;
     readonly threadId?: string;
+    /**
+     * Event-specific detail. A payload-less `agents.changed` invalidates the
+     * bootstrap snapshot; see {@link WebAgentsChangedPayload}.
+     */
     readonly payload?: unknown;
 }
 export interface CreateWebThreadInput {
     readonly sourceId: string;
+    /** Explicit draft choice; absent inherits the web default and null selects config. */
+    readonly model?: string | null;
+    /** Explicit draft choice; absent inherits the web default and null selects config. */
+    readonly effort?: string | null;
+}
+export interface PutWebAgentRunSettingsInput {
+    readonly model: string | null;
+    readonly effort: string | null;
 }
 export interface PatchWebAgentInput {
     readonly pinned: boolean;
@@ -417,6 +819,19 @@ export interface PatchWebAgentInput {
 export interface PatchWebThreadInput {
     readonly title?: string;
     readonly archived?: boolean;
+    readonly model?: string | null;
+    readonly effort?: string | null;
+    /**
+     * Compare-and-set: apply nothing unless this conversation still has NO run
+     * override. The console's one-time adoption of a browser-local preference
+     * reads the thread and then writes it, and between those two calls another
+     * tab (or another device) can set a real override -- an unconditional write
+     * then makes the adopting tab's stale local value the final server state.
+     * The precondition is checked and the write applied in one synchronous step,
+     * so nothing can interleave. When it does not hold the current thread comes
+     * back untouched, which is exactly what the caller must adopt.
+     */
+    readonly ifRunConfigUnset?: boolean;
 }
 export interface StartWebTurnInput {
     readonly text?: string;
@@ -428,6 +843,20 @@ export interface StartWebTurnInput {
 export interface StartWebLiveInputInput {
     readonly text: string;
 }
+export interface StartWebSubmissionInput extends StartWebTurnInput {
+    readonly submissionId: string;
+}
+export interface WebSubmissionReceipt {
+    readonly submissionId: string;
+    readonly threadId: string;
+    readonly outcome: "turn" | "live-input" | "rejected";
+    readonly reason?: "active_attachments_unsupported" | "unsupported_targeting" | "closed_before_dispatch" | "operator_inactive" | "operator_unsupported" | "operator_too_large" | "operator_full" | "operator_invalid" | "mailbox_unsupported" | "mailbox_closed" | "mailbox_failed";
+    readonly disposition?: "pending" | "queued";
+    readonly messageId?: string;
+    readonly turnId?: string;
+    readonly message?: WebMessage;
+    readonly turn?: WebRunState;
+}
 export interface WebLiveInputReceipt {
     readonly message: WebMessage;
     readonly disposition: "pending" | "queued";