QwenLM/qwen-code
1
0 Fork 0
mirror of https://github.com/QwenLM/qwen-code.git synced 2026-11-07 06:19:43 -10:00
Code Issues Packages Projects Releases 1 Wiki Activity
Files
32d22f950cf6f987eb8f06ac2722a02ca79fed2a
qwen-code/packages/web-shell/client/components/managed/generated/managed-agent-api.ts
T
jinyeandQwen-Coder 32d22f950c feat(managed-agent): support durable structured user questions (#16433) 
Connect Hosted question actions, structured answers, durable continuation, and the WebShell question form. Cover canonical response replay and pending-question recovery across Harness and Java context restarts.

Co-authored-by: Qwen-Coder <[email protected]>
2026-11-06 09:23:44 +00:00

5086 lines
227 KiB
TypeScript
Raw Blame History

// Generated by packages/web-shell/scripts/generate-managed-agent-api.mjs.
// Do not edit; run `npm run generate:managed-agent-api` in packages/web-shell.
export interface paths {
"/api/agent/web-shell/v1/sessions/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["webShellListSessions"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["webShellGetSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/rename": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Synchronously rename a Session through the same durable, fenced title service as public PATCH. HTTP 200 confirms persistence; an unavailable or unknown Harness outcome remains an error and is never a pending success. Workspace-bound fresh renames require current OPERATOR access and the original binding's execution facts; unbound Sessions use the existing tenant-scoped rename authorization. An active Turn does not itself block rename. Reuse the same idempotency key only for the same Session and title; completed replay returns the Session's current persisted title without another Harness rename, including the existing last-visible result after deletion. Fresh-rename capability changes do not preclude authorized replay. The result title is authoritative and can differ from the requested title when a later rename already completed. */
post: operations["webShellRenameSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/transcript/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires current Session read authorization. Read the most recent limit current message Items and selected bounded Turn control events; olderCursor pages toward older Items. Bodies and statuses remain live. The response coveredSequence and lastSequence both identify actual message projection coverage for SSE continuation, never an unmaterialized event tail. No persisted conversation snapshot or whole-history replay is read. Projection rebuild invalidates cursors. If projection coverage is below the replay floor, return retryable message_projection_pending. */
post: operations["webShellTranscript"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/events/stream": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description POST SSE consumed through fetch response.body. An afterSequence strictly below the durable replay floor ends the stream with one agent.session.resync_required frame. Projection rebuilds preserve that floor and invalidate message-page cursors. On the resync frame, reload the transcript and resume after its lastSequence. */
post: operations["webShellStreamEvents"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/create": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Maps workspaceId/cwdRelative to public Workspace selection without using environmentId or absolute cwd. Shares G0's opt-in initial file-tool Turn admission with public Session creation: the server-selected profile for the built-in qwen-code agent, and the profile selected by a stored definition's single allowlisted hosted_profile tools entry for a definition-pinned Session. Newly bound qwen-code Sessions, including empty creation, persist hosted-workspace-shell/1 with mandatory default/auto-edit approval when the Shell deployment opt-in is enabled; otherwise they persist hosted-workspace-files/1 with the configured file approval mode. The switch does not override a stored AgentDefinition's compiled profile or approval mode. Public callers cannot select the built-in profile. Any caller holding the OPERATOR role may submit later Turns and rename the Session under the same opt-in, while the Workspace registry row stays ACTIVE and still backs the binding, the actor recorded by the Workspace create command keeps OPERATOR or above, and the Session is active and undeleted and is either a qwen-code Session on the frozen execution profile or pinned to a stored definition; Workspace close follows its separate close capability and lifecycle admission; the same caller may cancel a running Turn (its delivery re-checks no grant it needs survives the cancellation), and the Session's own liveness keeps OPERATOR access even when its Workspace's background-exit observation closes some other bound Session; cancel is always allowed for its own running Turn even outside the Workspace files opt-in. A definition-pinned Session keeps its pinned revision's tool profile, model and instructions for its whole life, and a replay of the create command reuses the original pin; a WebShell Session inherits its Workspace's default Workspace selection when the request omits one. Shell Sessions additionally require the Shell opt-in and valid persisted approval for fresh Turns; disabling only Shell admission preserves original-key replay and accepted approvals and cancellation while Workspace files remain enabled and persisted approval remains valid. Qualified new public Shell Sessions expose agent by default under the public-child deployment switch and runtime/Harness admission; existing Sessions retain their original tool scope. Invalid approval or files-off can refuse attachment. Public Shell close and active delete require lifecycle v2 and reliable original-Worker stop support; archive and unarchive require completed close proof. Fresh Shell sending also requires foregroundShell=true; workspaceTurns alone is not sufficient Shell Turn admission. Manual rename uses the independent rename capability. */
post: operations["webShellCreateSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/turns/submit": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Admits the command durably and returns its operation identity, admission stage and delivery state. Replaying the same idempotency key returns the original command operation. Existing Session and actor authorization checks apply. */
post: operations["webShellSubmitTurn"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/turns/cancel": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Admits the command durably and returns its operation identity, admission stage and delivery state. Replaying the same idempotency key returns the original command operation. Existing Session and actor authorization checks apply. */
post: operations["webShellCancelTurn"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Same authorization, paging, explicit default and pre-Session capability discovery as listWorkspaces, with camelCase fields. Listing errors must not cause silent fallback to a default directory. */
post: operations["webShellQueryWorkspaces"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/operations/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["webShellQueryCwdOperation"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/actions/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Serves Hosted permission and structured question Actions. Question answers preserve the original question and option IDs, allow one to four answers, and are bounded to 32 KiB of canonical UTF-8 JSON. vote_recorded remains planned. Reads follow Session authorization; the Session's recorded owner or any caller holding OPERATOR on the bound Workspace may respond; a Shell Session's Actions may be answered only by its recorded owner (an unbound Session with no recorded creator and no recorded create command answers to any caller in its tenant, matching its read ACL; a bound Session without an owner record answers through the create-command actor recorded for it, or through the Workspace role arm). Responses are durable operations, reconciled against the original journal decision. */
post: operations["queryWebShellActions"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/actions/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Serves Hosted permission and structured question Actions. Question answers preserve the original question and option IDs, allow one to four answers, and are bounded to 32 KiB of canonical UTF-8 JSON. vote_recorded remains planned. Reads follow Session authorization; the Session's recorded owner or any caller holding OPERATOR on the bound Workspace may respond; a Shell Session's Actions may be answered only by its recorded owner (an unbound Session with no recorded creator and no recorded create command answers to any caller in its tenant, matching its read ACL; a bound Session without an owner record answers through the create-command actor recorded for it, or through the Workspace role arm). Responses are durable operations, reconciled against the original journal decision. */
post: operations["getWebShellAction"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/actions/respond": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Serves Hosted permission and structured question Actions. Question answers preserve the original question and option IDs, allow one to four answers, and are bounded to 32 KiB of canonical UTF-8 JSON. vote_recorded remains planned. Reads follow Session authorization; the Session's recorded owner or any caller holding OPERATOR on the bound Workspace may respond; a Shell Session's Actions may be answered only by its recorded owner (an unbound Session with no recorded creator and no recorded create command answers to any caller in its tenant, matching its read ACL; a bound Session without an owner record answers through the create-command actor recorded for it, or through the Workspace role arm). Responses are durable operations, reconciled against the original journal decision. */
post: operations["respondWebShellAction"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/close": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Uses the same close admission, owner authorization and durable cleanup semantics as the public close route. sessionClose describes deployment support; it does not grant actor authorization. New L3 Workspace close operations run SessionEnd only, retain data, and finish after durable effects verification and original Runtime stop. SessionDelete is reserved for ACTIVE delete. Missing protocol support rejects new admission; previously admitted operations retain their saved protocol. Unknown outcomes remain recovery_blocked. */
post: operations["closeWebShellSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/archive": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Workspace-bound archive requires a closed Session with completed reliable-close evidence and the Session's recorded owner with current read access. It completes atomically during admission, preserves data and the permanent close fence, and calls neither Harness nor Runtime. A readable non-owner returns 403; missing close evidence returns 409 workspace_unavailable. */
post: operations["archiveWebShellSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/delete": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Workspace-bound ACTIVE deletion supports idle hosted-workspace-files/1 Sessions when L3 lifecycle protocol and reliable Runtime stop are available. Only the Session's recorded owner (owner_actor_key, with the pre-V40 creator fallback) with current read access may admit it; accepted, running, cancelling or approval-waiting Turns return 409 turn_active. Admission persists a lifecycle-only execution fence and a versioned actor-scoped operation. SessionEnd settles before SessionDelete; committed Hook results are verified in Session Store and saved before permanent draining, attachment cleanup and original worker stop. Unknown outcomes or missing original stop evidence remain recovery_blocked and are never replayed on a replacement worker. CLOSED/ARCHIVED deletion retains L2: completed reliable-close evidence is required and no Harness or Hook is invoked. Completion atomically commits retirement, tombstone, receipt and terminal event, retaining shared Workspace files and neighboring holders. Authorized same-actor/key replays return the original operation, including after deletion; a readable non-owner returns 403. Missing lifecycle capability or close evidence returns 409 workspace_unavailable. */
post: operations["deleteWebShellSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read one authorized Workspace by its logical ID; absent or unreadable Workspaces return 404. No Runtime is started. */
post: operations["webShellGetWorkspace"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/tasks/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["queryWebShellTasks"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/tasks/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["getWebShellTask"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/tasks/events/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["queryWebShellTaskEvents"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/tasks/cancel": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["cancelWebShellTask"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/tool-results/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["getWebShellToolResult"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/artifacts/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["getWebShellArtifact"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/artifacts/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["queryWebShellArtifacts"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/unarchive": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Synchronously restores an archived Session to closed. Workspace-bound Sessions require completed reliable-close evidence and the Session's recorded owner with current read access (404 unreadable, 403 readable non-owner). Bound keys are tenant/Session/actor scoped. Replay returns the recorded outcome without repeating the mutation; a replay after delete answers with the Session as last visible — its pre-delete status — rather than 404. The permanent close fence is preserved and no Harness or Runtime call is made. */
post: operations["unarchiveWebShellSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/create": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Create an empty Workspace under the operator-controlled root, or supply sourceWorkspaceId and cwdRelative together to select an existing directory under an ACTIVE ROOT Workspace owned by the actor. Existing-directory creation shares its verified storage, config and policy and persists a default working directory. The actor-scoped idempotency key pins the normalized request and source generation. Completed replay checks current access and never restores grants. */
post: operations["webShellCreateWorkspace"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-options/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read effective approval policy options for an Agent in the authenticated tenant. Requires an actor. Does not create a Session or change an existing policy. */
post: operations["queryWebShellSessionOptions"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-models/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read the allowed model catalog and current model selection of a readable Session. No credentials or provider routes are returned. */
post: operations["queryWebShellSessionModels"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-models/change": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Change the model of an idle Workspace Session for later Turns. The actor-scoped idempotency key replays an earlier completed change before current admission checks; expectedRevision prevents overwriting a concurrent selection. */
post: operations["changeWebShellSessionModel"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-approval/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read the current policy and owner-authorized change support of a readable Workspace Session. */
post: operations["queryWebShellSessionApproval"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-approval/change": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Change the execution approval policy of an eligible Workspace Session: built-in qwen-code or a stored AgentDefinition on exactly hosted-workspace-files/1, hosted-workspace-files/3 or hosted-workspace-shell/1. With liveSupported, execution policy changes affect subsequent current-Turn permission checks and permit eligible pending ordinary tool approvals. Otherwise the Session must be idle. Plan changes remain idle-only. Requires its recorded owner, current OPERATOR or OWNER access and Session-specific Harness feature support. Changes are revision-checked and actor/session-scoped idempotent. Definition creation policy and pins remain immutable. Classifier auto requires auto-approval/1. Optional permissionRules requires permission-rules/1 and an idle Session. Omitted rules preserve the current selection; three empty arrays clear it. Mode, Plan and rules share one approval revision and receipt. Persisted rules are also snapshotted at Turn admission; replay preserves the original policy. Empty rules are omitted from responses and Harness payloads. */
post: operations["changeWebShellSessionApproval"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/runtime-nodes/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Lists only administrator-configured SSH nodes authorized for the current tenant and actor. Requires a trusted actor. Registration is disabled by default and answers 200 with supported=false and an empty data array; an enabled deployment may answer supported=true with no authorized nodes. Node credentials, SSH aliases and server paths are not exposed. This read starts no worker. */
post: operations["webShellQueryRuntimeNodes"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/check-directory": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Checks the configured Node.js and pinned qwen-code versions, allowed directory range, existing canonical directory and access permissions over SSH. Requires an enabled deployment and an exact tenant/actor node grant; disabled registration answers 404 ssh_runtime_disabled and an unknown or unauthorized node answers 403 runtime_node_forbidden. This is a preview: registration revalidates the directory and never creates a directory, clones a repository or starts a worker. */
post: operations["webShellCheckWorkspaceDirectory"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/operations/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Reads only a Workspace registration owned by the current tenant and actor; an unknown operation or another actor's operation answers 404 operation_not_found. Queries and accepted registration settlement remain available when new registration is disabled. Pending or running operations may resume their original registration attempt. A registration refused before it reserved its directory fails. One that may have reached its node is recovery_blocked and keeps the directory reserved while Java reads the node again, never registering anything: the registration's marker completes it, and a root without the marker, or holding another directory, fails it and releases the directory. Querying never unlocks it or starts a Runtime worker. */
post: operations["webShellGetWorkspaceOperation"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/register": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Admits actor-scoped, idempotent registration of an existing remote directory. The request body carries idempotencyKey; a retry with the same nodeId, path and displayName returns the original operation and its latest durable state, even after new registration is disabled or node admission is revoked. Reusing the key for different content answers 409 idempotency_conflict. Fresh admission requires an enabled deployment and an authorized node (404 ssh_runtime_disabled or 403 runtime_node_forbidden). A completed operation atomically creates the Workspace and creator OWNER grant. 202 does not mean registration is complete; query the operation, then read the Workspace and its canCreateSession hint. This operation creates no Session and starts no Runtime worker. requestId is trace-only and excluded from the request digest. */
post: operations["webShellRegisterWorkspace"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/directories/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description List bounded immediate real directories on the selected Workspace storage host. Requires an authenticated OWNER of the ACTIVE ROOT Workspace and verified LOCAL storage. Refuses traversal, symlinks and reserved maintenance directories; never uses the ordinary daemon filesystem. Root paths are disclosed only within this authorized scope. */
post: operations["queryWebShellWorkspaceDirectories"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-mcp/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read the selected Session's sanitized, committed MCP catalog. Requires a trusted actor and Workspace read access. Discovery states describe the published snapshot, not live Runtime health. Does not configure servers, discover capabilities or execute tools, resources or prompts. */
post: operations["queryWebShellSessionMcp"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-skills/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read only names and descriptions from the Session's pinned static Skill catalog. Requires a trusted actor and Workspace read access. Never resolves the latest AgentDefinition or discovers host Skills. */
post: operations["queryWebShellSessionSkills"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/files/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Read-only Workspace file query
* @description Browse directories or search file names within the persisted Workspace working directory. Requires a trusted actor with current OPERATOR or OWNER access to an ACTIVE Workspace, the deployment Workspace-files opt-in, and verified LOCAL or SSH_LOCAL storage. Authorization and binding are rechecked after I/O. Paths are relative to the working directory; host paths and Runtime credentials are never returned. Unsupported storage never falls back to the local daemon, and no Session, worker or model request is created.
*/
post: operations["webShellWorkspaceFilesQuery"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/files/read": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Read-only Workspace file read
* @description Read one selection-time snapshot of a nonempty, NUL-free UTF-8 file, at most 24 KiB, using the scope revision returned by query. Requires a trusted actor with current OPERATOR or OWNER access to an ACTIVE Workspace, the deployment Workspace-files opt-in, and verified LOCAL or SSH_LOCAL storage. Authorization and binding are rechecked after I/O. Paths are relative to the working directory; host paths and Runtime credentials are never returned. Unsupported storage never falls back to the local daemon, and no Session, worker or model request is created.
*/
post: operations["webShellWorkspaceFilesRead"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/tool-details/get": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post: operations["getWebShellToolDetails"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/compress": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Admits idle-only context compression without creating a Turn. A trusted Workspace OPERATOR or OWNER is required. Read authorization precedes actor-scoped idempotency replay; replay precedes mutable role, capability, revision and busy checks. Expected compaction revision begins at zero. Returns 409 session_context_busy for active or queued Turns, approvals, unsettled Hooks, recovery or conflicting context operations; 409 compaction_revision_conflict for a stale revision; 409 idempotency_conflict for key reuse with different content. A 202 is durable admission; query the original operation for completion. Unknown acceptance is reconciled from native evidence without blind redelivery. A compressed outcome invalidates the prior context usage until a new main-model observation; noop and failure preserve history and revision. */
post: operations["webShellCompressContext"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-mcp/management/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a trusted Workspace operator and the Session creator execution grants. Manage only the selected active public Session; commands retain immutable definition pins, serialize while idle, and select only deployed Runtime definitions. Status reads persisted receipts without restarting or replaying the original effect. Management reattachment never drives recovery, cleanup, or wake dispatch. After a Harness restart, continue or recover the Session through its normal execution flow first; otherwise management returns 409 hosted_mcp_session_load_required. A fresh empty Session can initialize without a Turn; command status never creates one. Unsupported management queries return supported=false. Responses never include private executable recipes or credentials. */
post: operations["queryWebShellSessionMcpManagement"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-mcp/management/submit": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a trusted Workspace operator and the Session creator execution grants. Manage only the selected active public Session; commands retain immutable definition pins, serialize while idle, and select only deployed Runtime definitions. Status reads persisted receipts without restarting or replaying the original effect. Management reattachment never drives recovery, cleanup, or wake dispatch. After a Harness restart, continue or recover the Session through its normal execution flow first; otherwise management returns 409 hosted_mcp_session_load_required. A fresh empty Session can initialize without a Turn; command status never creates one. Unsupported management queries return supported=false. Responses never include private executable recipes or credentials. */
post: operations["submitWebShellSessionMcpManagement"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-mcp/management/operations/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a trusted Workspace operator and the Session creator execution grants. Manage only the selected active public Session; commands retain immutable definition pins, serialize while idle, and select only deployed Runtime definitions. Status reads persisted receipts without restarting or replaying the original effect. Management reattachment never drives recovery, cleanup, or wake dispatch. After a Harness restart, continue or recover the Session through its normal execution flow first; otherwise management returns 409 hosted_mcp_session_load_required. A fresh empty Session can initialize without a Turn; command status never creates one. Unsupported management queries return supported=false. Responses never include private executable recipes or credentials. */
post: operations["queryWebShellSessionMcpManagementOperation"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-recovery/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Read authorized durable recovery facts and only already attached Harness evidence without loading a Session, acquiring a Runtime, invoking tools or models, stopping work or clearing a block. Missing or unreadable native readiness evidence never proves ready. This is Session-scoped; ordinary Workspace admission and concurrent unrelated Sessions remain independent. */
post: operations["queryWebShellSessionRecovery"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-recovery/recheck": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Recheck only the latest original Turn under the existing cancellation/cleanup authorization. Repeated requests coalesce and may only advance existing cancellation/reconciliation or retry settled cleanup; they never resubmit input, replay effects, reset retry budgets or change claim generations. A stale Turn returns recovery_target_changed and ineligible work returns recovery_recheck_unavailable. 202 means requested, not cancelled or ready. For a terminal Java Turn whose Harness attachment is cold or whose status cannot be read, this POST may attempt a narrow cleanup-only load. It must verify the original prompt has a durable native terminal, covered continuation checkpoint or lawful initial state, and no pending input before retrying only its existing cleanup. It never resumes models, tools, MCP or Hooks, clears a permanent journal block, or treats a historical SQL failure as native settlement. */
post: operations["recheckWebShellSessionRecovery"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/sessions/export/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Read one current Session message page for exports
* @description Requires current Session read authorization on every page. Read current message bodies forward within the first request sequence membership bound. snapshotThroughSequence retains its wire name for that fixed bound and does not change between pages. Content and status may change; no frozen snapshot version or cursor retention is provided. An initial projection behind committed events returns retryable message_projection_pending instead of silently exporting incomplete history. No private journal, Runtime or storage credentials are returned. A projection-generation change returns 409 message_projection_changed; discard the cursor and restart this read.
*/
post: operations["webShellExportSession"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/user-messages/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** Query or mutate the durable Session user message queue */
post: operations["webShellQueryUserMessages"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/user-messages/command": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** Query or mutate the durable Session user message queue */
post: operations["webShellCommandUserMessages"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspace-extensions/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. */
post: operations["queryWorkspaceExtensionPackages"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspace-extensions/packages/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. */
post: operations["queryWorkspaceExtensionPackage"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspace-extensions/settings/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. */
post: operations["queryWorkspaceExtensionPackageSettings"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspace-extensions/settings/submit": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires the same Workspace operator and deployment permission as publication. Writes a complete encrypted settings revision with optimistic concurrency; old pinned revisions remain available. No values are returned. */
post: operations["submitWorkspaceExtensionPackageSettings"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspace-extensions/operations/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires an authenticated actor with a read grant on the persisted Workspace. Reads durable metadata only; never creates a Runtime, loads a Harness Session, or retries an original operation. The querying actor must own the original publication or settings operation. */
post: operations["queryWorkspaceExtensionPackageOperation"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspace-extensions/publish": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires an ACTIVE Workspace, an authenticated operator and the deployment extension allowlist. The Idempotency-Key binds an actor-scoped durable operation. Publication retains immutable tar.gz bytes under a server-assigned stable extension identity; it does not activate a Session. The manifest query is base64url JSON and is covered by the existing request signature. Archive contents and Runtime compatibility are validated by the target compiler before activation. */
post: operations["publishWebShellWorkspaceExtensionPackage"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-extensions/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
post: operations["webShellSessionExtensionsQuery"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-extensions/submit": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
post: operations["webShellSessionExtensionsSubmit"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-extensions/continue": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
post: operations["webShellSessionExtensionsContinue"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/session-extensions/recover-previous": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** @description Requires a Workspace reader for status and OPERATOR for changes. Status reads durable configuration and never loads a Harness or retries an operation. Apply requires an idle Session and the original Runtime with the package execution contract; a committed unknown outcome fences new execution until the original operation is reconciled. Explicit recovery compiles previous content into a new revision. */
post: operations["webShellSessionExtensionsRecoverPrevious"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/files/upload": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Upload one binary file to a persisted Workspace
* @description Requires a trusted actor with OPERATOR or OWNER access, enabled Workspace files, verified LOCAL or SSH_LOCAL storage and an updated CLI. Uploads are limited to 8 MiB, require an existing parent directory and never overwrite an occupied path. A durable physical storage hold excludes tool execution and retirement until the original upload has a definite terminal result. Repeating the same upload ID reconciles its original command without replaying mutation; changed requests conflict. CSI is unsupported and never falls back to a primary Workspace. An uncertain result returns 503 workspace_upload_pending and must be queried by the original upload ID.
*/
post: operations["webShellWorkspaceFilesUpload"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/files/uploads/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Reconcile the original Workspace upload
* @description Only the admitting actor with a current Workspace operator grant can query the upload. Status checks use the frozen original storage target and never execute an upload or select a replacement Runtime. Reconciliation remains available through storage fencing; pending commands retain their durable hold. The server also reconciles pending uploads after client cancellation or restart.
*/
post: operations["webShellWorkspaceFilesUploadQuery"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/worktrees/options": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** Options a main Session worktree */
post: operations["webShellSessionWorktreeOptions"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/worktrees/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** Query a main Session worktree */
post: operations["webShellSessionWorktreeQuery"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/worktrees/inspect": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** Inspect a main Session worktree */
post: operations["webShellSessionWorktreeInspect"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/workspaces/worktrees/cleanup": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/** Cleanup a main Session worktree */
post: operations["webShellSessionWorktreeCleanup"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/agent/web-shell/v1/transcript/items/query": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Read recent current Session Items and page toward older Items
* @description Requires current Session read authorization on every page. Read at most limit recent current message Items in chronological order; nextCursor continues toward older Items in the initial sequence membership range. snapshotThroughSequence names that fixed membership upper bound, while bodies and statuses remain live. Cursors bind scope, backward direction and projection generation. Rebuild invalidates the cursor. No snapshot copies are generated and no live tail is scanned; transcript reads provide actual projection coverage for SSE handoff. Projection coverage below the replay floor returns retryable message_projection_pending.
*/
post: operations["webShellRecentTranscriptItems"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
}
export type webhooks = Record<string, never>;
export interface components {
schemas: {
PublicMcpCatalog: {
/** @constant */
object: "agent.mcp_catalog";
/** Format: uuid */
session_id: string;
servers: components["schemas"]["PublicMcpServerCatalog"][];
};
PublicMcpServerCatalog: {
server_id: string;
server_revision: number;
/** @description The pinned catalog revision; null while no catalog has been published. */
catalog_revision: number | null;
tools: components["schemas"]["PublicMcpTool"][];
resources: components["schemas"]["PublicMcpResource"][];
prompts: components["schemas"]["PublicMcpPrompt"][];
discovery: components["schemas"]["PublicMcpDiscovery"];
};
PublicMcpTool: {
name: string;
description?: string;
input_schema: {
[key: string]: unknown;
};
};
PublicMcpResource: {
name: string;
uri: string;
description?: string;
mime_type?: string;
};
PublicMcpPrompt: {
name: string;
description?: string;
arguments?: components["schemas"]["PublicMcpPromptArgument"][];
};
PublicMcpPromptArgument: {
name: string;
description?: string;
required?: boolean;
};
PublicMcpDiscovery: {
/** @enum {string} */
tools: "complete" | "partial" | "failed" | "stale";
/** @enum {string} */
resources: "complete" | "partial" | "failed" | "stale";
/** @enum {string} */
prompts: "complete" | "partial" | "failed" | "stale";
};
InputBlock: components["schemas"]["InputTextBlock"] | components["schemas"]["InputFileBlock"] | components["schemas"]["InputImageBlock"];
/** @description Immutable Session connection. Requires session-model-config/1, encrypted storage and an endpoint in the control-plane allowlist. UTF-8 limits: model 512 bytes, base_url 2048 bytes, api_key 4096 bytes, complete canonical JSON 8192 bytes. Secrets are never returned in public Session responses. Child Sessions inherit the configuration. Cannot be combined with modelId. */
SessionModelConfig: {
/** @enum {string} */
protocol: "openai" | "openai-responses" | "anthropic" | "gemini";
model: string;
/** @description Exact allowlisted HTTP(S) base URL without userinfo, query or fragment. */
base_url: string;
api_key: string;
generation_config?: {
temperature?: number;
top_p?: number;
top_k?: number;
max_tokens?: number;
presence_penalty?: number;
frequency_penalty?: number;
seed?: number;
};
};
PublicArtifact: {
/** @constant */
object: "agent.artifact";
id: string;
session_id: string;
result_id: string;
revision: string;
/** @enum {string} */
stream_role: "stdout" | "stderr";
/** Format: int64 */
byte_length: number;
sha256: string;
media_type: string;
/** @enum {string} */
availability: "available" | "unavailable";
/**
* Format: int64
* @description Unix epoch milliseconds, unlike the seconds that the public Session, Turn, Event and Item resources report.
*/
created_at: number;
};
WebShellListRequest: {
cursor?: string | null;
/** @default 20 */
limit?: number | null;
/**
* @description Filter before pagination. Omission preserves all readable, undeleted Sessions. Cursors are bound to the normalized archive state and title query.
* @default all
* @enum {string}
*/
archiveState?: "unarchived" | "archived" | "all";
/** @description Case-insensitive literal title substring, with surrounding whitespace stripped. Empty means no title filter; %, _ and backslash are literal. Applied before pagination. Cursors are bound to the stripped query and archiveState; listing is not a snapshot across title or archive changes. */
titleQuery?: string | null;
};
WebShellSessionRequest: {
/** Format: uuid */
sessionId: string;
};
WebShellTranscriptRequest: {
/** Format: uuid */
sessionId: string;
cursor?: string | null;
/** @default 100 */
limit?: number | null;
};
WebShellStreamRequest: {
/** Format: uuid */
sessionId: string;
/**
* Format: int64
* @default 0
*/
afterSequence?: number | null;
};
WebShellCreateRequest: {
/** @description Trace correlation only. */
requestId?: string | null;
idempotencyKey: string;
agentId: string;
/** @description Optional host-catalog model for a bound built-in qwen-code Session. Requires modelSelectionSupported. Persisted atomically before the first Turn and included in creation idempotency; omission preserves the default model and old digest. */
modelId?: string;
modelConfig?: components["schemas"]["SessionModelConfig"];
/** @description The server enforces the bound in UTF-16 code units (Java String.length()), so an astral character counts as two: a title this schema's code-point maxLength accepts can still exceed the server's 256-unit bound and answer 400 invalid_title. */
title?: string | null;
/** @description Text has a 4,000,000-character aggregate budget and per-block 1,000,000-character cap, counted in code points. Hosted also enforces its 64 KiB durable-record limit for text-only inputs and a 32 MiB prepared-snapshot ceiling. A complete canonical input containing file/image attachments must fit within 8 MiB and requires input-attachments/1. */
input?: components["schemas"]["InputBlock"][];
metadata?: components["schemas"]["WebShellMetadata"];
workspace?: components["schemas"]["WebShellWorkspaceSelection"];
/**
* @description Optional initial execution policy for Workspace creation, validated against the resolved Agent and profile. Omission preserves its default and idempotency digest. Independent of planMode.
* @enum {string}
*/
approvalMode?: "default" | "auto-edit" | "yolo";
/** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
planMode?: boolean;
/** @description Optional static Skills imported from the enabled management catalog or added explicitly to the pinned AgentDefinition catalog. The merged catalog has unique names, at most 256 entries, 512 KiB per body and 2 MiB compact JSON. Requires session-skills/2; persisted immutably and included in creation idempotency. */
skills?: components["schemas"]["SessionCreationSkill"][];
/** @description Optional immutable initial extension selection. Omission keeps the legacy configuration path; an explicit empty array starts the unified configuration format. Included in creation idempotency and applied before the first model request. Requires session-extension-packages/1 and an extension-capable original Runtime. */
extensionPins?: components["schemas"]["ManagedExtensionPackagePin"][];
/** @description Opt into a main Session worktree on supported LOCAL storage. Omission uses the current directory; an empty object freezes HEAD at first admission. Requires an explicit Workspace. Preparation is durable and gates Runtime execution; replay preserves the original commit, directory and branch. */
worktree?: {
baseRef?: string;
};
};
WebShellSubmitRequest: {
/** @description Trace correlation only. */
requestId?: string | null;
idempotencyKey: string;
/** Format: uuid */
sessionId: string;
/** @description Text has a 4,000,000-character aggregate budget and per-block 1,000,000-character cap, counted in code points. Hosted also enforces its 64 KiB durable-record limit for text-only inputs and a 32 MiB prepared-snapshot ceiling. A complete canonical input containing file/image attachments must fit within 8 MiB and requires input-attachments/1. */
input?: components["schemas"]["InputBlock"][];
metadata?: components["schemas"]["WebShellMetadata"];
};
WebShellCancelRequest: {
/** @description Trace correlation only. */
requestId?: string | null;
idempotencyKey: string;
/** Format: uuid */
sessionId: string;
turnId: string;
};
/** @description Arbitrary caller metadata, as a JSON object (or null). Accepted and ignored in Phase 1: nothing from it is persisted. On WebShellCreateRequest the Session title travels in that request's own `title` field; WebShellSubmitRequest has no title surface. Any keys are valid. */
WebShellMetadata: {
[key: string]: unknown;
} | null;
/** @description Command admission. Session creation and internal commands may omit operation fields. */
WebShellAdmission: {
/** Format: uuid */
sessionId: string;
turnId?: string | null;
status: string;
replayed: boolean;
/** @description Durable operation identifier for turn submission or cancellation. */
operationId?: string;
/**
* @description Persisted admission stage of the operation.
* @enum {string}
*/
admissionStage?: "java_durable" | "harness_confirmed";
/**
* @description Current delivery state of the operation.
* @enum {string}
*/
deliveryState?: "pending" | "leased" | "confirmed" | "blocked";
};
WebShellTurn: {
turnId: string;
/** Format: uuid */
sessionId: string;
/** @description recovery_blocked with hosted_harness_recovery_blocked means the Harness stopped without a safely settled Turn. The input remains active internally. Execution redispatch is parked, while bounded read-only observation of the original Harness journal may settle a later terminal result. Policy changes and lifecycle close wait for settlement; explicit cancellation remains available. */
status: string;
/** Format: int64 */
submittedAt: number;
/** Format: int64 */
completedAt?: number | null;
errorCode?: string | null;
};
WebShellSession: {
/** Format: uuid */
sessionId: string;
title?: string | null;
agentId: string;
status: string;
/** Format: int64 */
createdAt: number;
/** Format: int64 */
updatedAt: number;
activeTurn?: components["schemas"]["WebShellTurn"] | null;
environment?: {
[key: string]: unknown;
} | null;
/** Format: int64 */
lastSequence: number;
workspace?: components["schemas"]["WebShellWorkspaceContext"];
capabilities: components["schemas"]["WebShellSessionCapabilities"];
/**
* @description Current effective approval policy; initialApprovalMode retains the immutable creation policy.
* @enum {string}
*/
approvalMode?: "default" | "auto" | "auto-edit" | "yolo";
modelContext?: components["schemas"]["WebShellModelContext"];
modelSelection?: components["schemas"]["WebShellModelSelection"];
/** Format: int64 */
approvalRevision?: number;
/**
* @description Immutable creation-time policy, used to confirm creation replay.
* @enum {string}
*/
initialApprovalMode?: "default" | "auto-edit" | "yolo";
/** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
planMode?: boolean;
/** @description Optional deployment capability; missing means false. */
planModeSupported?: boolean;
/**
* Format: int64
* @description Sequence of the most recent native context.compacted event; independent of Workspace context revision. Omitted when retained pre-upgrade evidence cannot establish the revision, and context compression is unavailable.
* @default 0
*/
compactionRevision?: number | null;
/** @description Current durable context compression operation, including recovery_blocked; absent when none is active. */
contextCompressionOperationId?: string | null;
/** @description Current unsettled lifecycle operation, queried in batch under Session read authorization. A failed close/delete may leave the Session closing/deleting; only explicit retry starts a new operation. Settled Sessions omit this projection. */
lifecycleOperation?: components["schemas"]["WebShellLifecycleOperation"];
recovery?: components["schemas"]["SessionRecovery"];
worktree?: components["schemas"]["WebShellSessionWorktree"] | null;
};
WebShellSessionCapabilities: {
/**
* @deprecated
* @description Retired: Session directory-change submission has been removed; always false.
* @default false
*/
cwdChange?: boolean;
/** @default false */
actions: boolean;
/**
* @description True when the caller may submit later Turns of this Workspace-bound Session: the deployment enables Workspace files, the caller holds the OPERATOR role on a Workspace registry row whose state is ACTIVE and still backs the Session's binding, the actor recorded by the Workspace create command keeps OPERATOR or above, and the Session is active and undeleted and is either a qwen-code Session or a Session pinned to a stored definition (both on the Workspace's frozen execution profile). Cancelling only aborts work already running, so an OPERATOR caller may cancel a running Turn even when this is false; the capability does not gate cancellation. False for every other caller and for unbound Sessions, which do not use it. Shell Sessions also require foregroundShell=true for fresh sending; workspaceTurns may remain true with Shell admission disabled and is not sufficient Shell Turn admission. Manual rename uses the independent rename capability.
* @default false
*/
workspaceTurns: boolean;
tasks: boolean;
artifacts: boolean;
/**
* @description Close support including current actor authority. Workspace-bound Sessions require the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server.
* @default false
*/
sessionClose?: boolean;
/**
* @description Archive support including current actor authority. Workspace-bound Sessions require completed reliable-close evidence, the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server.
* @default false
*/
sessionArchive?: boolean;
/**
* @description Unarchive support including current actor authority. Workspace-bound Sessions require completed reliable-close evidence, the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server.
* @default false
*/
sessionUnarchive?: boolean;
/**
* @description Delete support including current actor authority. ACTIVE Workspace Sessions require a supported reliable-close protocol; CLOSED/ARCHIVED Sessions use completed close evidence. Workspace-bound Sessions require the recorded Session owner and current read access. Source-state and idle admission remain authoritative on the server. The aggregate session lifecycle capability is unchanged.
* @default false
*/
sessionDelete?: boolean;
/** @description Present only for persisted Shell Sessions, with no schema default; files and unbound Sessions omit it. True when Workspace files, Shell deployment admission and a valid persisted approval mode are valid. False prevents fresh sending. Disabling only the Shell flag preserves accepted cancellation and approval while Workspace files remain enabled and persisted approval remains valid; files-off or invalid approval can refuse attachment. This capability does not override authorization or recovery refusals. */
foregroundShell?: boolean;
/** @description The caller may request an idle Session model change using the server model catalog. Missing means unsupported; authorization and revision admission still apply. */
modelChange?: boolean;
/** @description The caller owns this eligible Workspace Session with current OPERATOR or OWNER access. Built-in qwen-code requires approval-selection/1; stored AgentDefinitions on exactly hosted-workspace-files/1, hosted-workspace-files/3 or hosted-workspace-shell/1 also require agent-definition-approval-selection/1. Idle-state admission is checked separately. Missing means false. */
approvalModeChange?: boolean;
/** @description Optional deployment capability; missing means false. */
inputAttachments?: boolean;
/**
* @description True for a visible ACTIVE Session when the Harness supports fenced title persistence and is available. Workspace-bound Sessions additionally require Workspace files admission, current OPERATOR access and the original binding's frozen execution facts, independently of approval or fresh Turn sending support. Unbound Sessions use the existing tenant-scoped rename permission. An active Turn does not itself make this false. Missing means false. This advertises fresh rename only; authorized completed original-key replay remains available under the rename service's replay rules.
* @default false
*/
rename?: boolean;
/**
* @description Requires a compatible Hosted Harness and an active Workspace Session. WebShell also reflects the current caller OPERATOR or OWNER grant; admission separately checks idle state.
* @default false
*/
contextCompression?: boolean;
/**
* @description Public child orchestration support for this persisted Session; launch and caller authorization are checked separately.
* @default false
*/
childAgents?: boolean;
};
WebShellSessionPage: {
data: components["schemas"]["WebShellSession"][];
nextCursor?: string | null;
hasMore: boolean;
};
WebShellTranscript: {
items: components["schemas"]["WebShellItem"][];
events: components["schemas"]["WebShellEvent"][];
/**
* Format: int64
* @description Actual message projection coverage of this read; resume SSE after this sequence.
*/
coveredSequence: number;
olderCursor?: string | null;
hasMore: boolean;
/**
* Format: int64
* @description Actual message projection coverage for SSE handoff, equal to coveredSequence; unmaterialized tail events are delivered by SSE.
*/
lastSequence: number;
};
WebShellContentPart: {
partId: string;
type: string;
text: string;
/** Format: int64 */
firstSequence: number;
/** Format: int64 */
lastSequence: number;
};
WebShellItem: {
itemId: string;
/** Format: uuid */
sessionId: string;
turnId: string;
type: string;
role?: string | null;
status: string;
content: components["schemas"]["WebShellContentPart"][];
attributes: {
[key: string]: unknown;
};
/** Format: int64 */
firstSequence: number;
/** Format: int64 */
lastSequence: number;
/** Format: int64 */
createdAt: number;
/** Format: int64 */
updatedAt: number;
};
/** @description A committed event, replayed with the versions and identity it was accepted with. A stream.reconciled event is the exception: it means that Harness recovery retracted earlier deltas of its Turn, which now have empty text and no itemId or contentPartId, and that later deltas may name other Parts. Reload the transcript and resume after its lastSequence. */
WebShellEvent: {
/** @default 1 */
schemaVersion?: number;
/** @default 1 */
projectionVersion?: number;
/** Format: int64 */
sequence: number;
eventId: string;
/** Format: uuid */
sessionId: string;
turnId?: string | null;
itemId?: string | null;
contentPartId?: string | null;
type: string;
/** Format: int64 */
createdAt: number;
data: {
[key: string]: unknown;
};
terminal: boolean;
};
/** @description Data of the agent.session.resync_required SSE frame. Reload the transcript, then resume after its lastSequence. */
WebShellResyncRequired: {
/** @constant */
type: "agent.session.resync_required";
/** Format: uuid */
sessionId: string;
/** Format: int64 */
replayFloorSequence: number;
/**
* Format: int64
* @description Retained wire name for current message projection coverage; no persisted conversation snapshot is implied.
*/
snapshotThroughSequence: number;
/** @constant */
action: "reload_snapshot";
};
ErrorEnvelope: {
error: {
code: string;
message: string;
request_id: string;
/** @description Present on Runtime Broker refusals; true permits retry, false is a definite refusal. Other errors may omit this field. */
retryable?: boolean;
/** Format: int64 */
replay_floor_sequence?: number | null;
/** Format: int64 */
snapshot_through_sequence?: number | null;
/** @description Names the definition field that cannot take effect on 409 agent_definition_unsupported; other errors may omit this field. */
field?: string;
};
};
/**
* @description Logical directory relative to the authorized workspace root; dot denotes root. Use slash separators. Reject absolute paths, drive prefixes, backslashes, NUL and parent segments. Runtime must verify directory existence, realpath containment and symlink safety before activation; schema validation alone is insufficient. Preserve spaces and case, normalize repeated separators and dot segments, and never percent-decode JSON values.
* @example .
* @example services/api
*/
WorkspaceRelativePath: string;
/** @enum {string} */
CwdOperationStatus: "pending" | "installing" | "completed" | "failed";
WebShellWorkspaceSelection: {
workspaceId: string;
/** @default . */
cwdRelative?: components["schemas"]["WorkspaceRelativePath"];
};
WebShellWorkspaceContext: {
workspaceId: string;
cwdRelative: components["schemas"]["WorkspaceRelativePath"];
/** Format: int64 */
contextRevision: number;
/** @enum {string} */
state: "ready" | "changing" | "recovery_blocked";
};
WebShellWorkspace: {
workspaceId: string;
displayName: string;
/** @description Current actor permission hint only; creation rechecks ACL, state and Agent/config compatibility. */
canCreateSession: boolean;
/** @enum {string} */
state: "active" | "draining" | "removed";
/** @description Persisted default working directory for new WebShell Sessions; absent means dot. */
defaultCwdRelative?: string;
/** @description Current actor owns this active root Workspace; directory discovery rechecks authorization and native storage. */
canSelectDirectory?: boolean;
};
WebShellWorkspacePage: {
data: components["schemas"]["WebShellWorkspace"][];
hasMore: boolean;
nextCursor?: string | null;
capabilities: {
/**
* @description Same end-to-end W0 readiness as public workspace_context; missing means unsupported.
* @default false
*/
workspaceContext: boolean;
/** @description Supports authorized Workspace discovery, Session creation, and saved binding read-back. This capability does not advertise execution readiness. Deployments may separately opt in to an initial Workspace Turn at creation: Read/Write/Edit under hosted-workspace-files/1, or file tools plus mandatory-approval foreground Shell under hosted-workspace-shell/1 when the Shell opt-in is enabled. Qualified new public Shell Sessions expose agent by default under the public-child deployment switch and runtime/Harness admission; existing Sessions retain their original tool scope. Callers holding the OPERATOR role may submit later Turns or rename under the same opt-in while the registry row stays ACTIVE and still backs the Session's binding and the actor recorded by the Workspace create command keeps OPERATOR or above, and may cancel a running Turn (its delivery re-checks no grants). Shell fresh sending also requires foregroundShell=true. Public Shell close and active delete require lifecycle v2 and reliable original-Worker stop support; archive and unarchive require completed close proof, while close of other profiles follows its separate capability and lifecycle admission; archive, delete and unarchive follow their separate retention capabilities after reliable Workspace close. */
workspaceBinding: boolean;
/** @description Supports creating empty Workspaces under the operator-controlled root. Missing or false means unsupported; current actor and server admission checks still apply. */
workspaceCreation?: boolean;
/** @description Supports effective Session policy options and explicit Workspace-bound creation policy. Missing or false means unsupported. */
approvalModeSelection?: boolean;
/** @description Supports browsing and selecting existing directories on authorized Linux or macOS storage; absent means unsupported. */
workspaceDirectorySelection?: boolean;
/** @description Trusted single-user local deployment can browse and import existing host directories without a pre-registered Workspace. Missing or false means unsupported. */
localDirectoryImport?: boolean;
};
/** @description Same authorized explicit default as default_workspace, including when outside this page; null if absent or not creatable. A non-null default is active and has canCreateSession=true. */
defaultWorkspace: (components["schemas"]["WebShellWorkspace"] & {
/** @constant */
state?: "active";
/** @constant */
canCreateSession?: true;
}) | null;
};
WebShellOperationRequest: {
/** Format: uuid */
sessionId: string;
operationId: string;
};
/** @description A completed operation returns the committed target revision. A replay returns the same operation identity and latest durable status, with replayed=true; polling itself is not replay. */
WebShellCwdOperation: {
operationId: string;
/** Format: uuid */
sessionId: string;
/** @constant */
type: "cwd_change";
status: components["schemas"]["CwdOperationStatus"];
/** Format: int64 */
expectedContextRevision: number;
targetCwdRelative: components["schemas"]["WorkspaceRelativePath"];
/** Format: int64 */
resultContextRevision?: number | null;
failureCode?: string | null;
replayed: boolean;
} & (unknown & unknown);
WebShellAction: components["schemas"]["WebShellPermissionAction"] | components["schemas"]["WebShellQuestionAction"];
WebShellActionResolution: {
actionId: string;
/**
* @description D6 supports decided only; vote_recorded is planned.
* @enum {unknown}
*/
outcome: "vote_recorded" | "decided";
receiptId: string;
decisionReceiptId?: string;
} & unknown;
WebShellQuestionAnswer: {
questionId: string;
optionIds?: string[];
text?: string;
} & (unknown | unknown);
WebShellActionQuestion: {
id: string;
prompt: string;
required: boolean;
multiple: boolean;
allowText: boolean;
options: components["schemas"]["WebShellActionOption"][];
};
/** @description Receipt IDs are opaque authorized product handles, not private journal or storage refs. Input completion means a Harness admitted its Turn, not that the Turn completed; an input whose Turn failed after a submission no Harness answered is recovery_blocked until the Session journal proves whether a Harness admitted it. For submit_input and task cancel, recovery_blocked means acceptance is unknown: the operation is never delivered again and settles only from its own durable evidence. For close and delete it is a published wait that delivery re-drives. Cancel completion means its Turn reached cancelled; a cancel fails with turn_already_settled when its Turn ended otherwise, except one that already existed when its Turn failed with managed_runtime_recovery_blocked after a Harness admitted it or a submission was attempted, which parks recovery_blocked with cancel_unconfirmed. A cancel submitted after the Turn ended still fails turn_already_settled. Action completion may only record one vote. Lifecycle completion requires its cleanup facts; archive may remain java_durable because Java is its authority. Task cancel 202 is Java durable admission; completion means the authority durably recorded cancellation and returned a receipt, not that the task stopped. Task cancel failed proves non-acceptance and no further delivery, with a failure code; recovery_blocked means acceptance is unknown and needs reconciliation before re-execution. Its status is never cancelled. Physical settlement and an unknown physical outcome belong to the task, independently of operation acceptance. A completed task cancel carries admission stage harness_confirmed and delivery state confirmed with the authority's receipt; failed and recovery_blocked carry java_durable and blocked, so they are never delivered again without reconciliation. A cancel parked as recovery_blocked/cancel_unconfirmed by unobserved-Turn recovery reconciles only from the original prompt's retained durable terminal event: cancelled completes it, completed or error fails it with turn_already_settled, and missing or unreadable evidence stays parked. A recorded stop request alone does not prove cancellation completed. */
WebShellCommandOperation: {
operationId: string;
/** Format: uuid */
sessionId: string;
/** @enum {unknown} */
type: "create_session" | "submit_input" | "cancel" | "action_response" | "close" | "archive" | "delete" | "task_cancel";
/** @description Task that a task_cancel operation targets. */
taskId?: string;
/** @enum {unknown} */
status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
/** @enum {unknown} */
admissionStage: "java_durable" | "harness_confirmed";
/** @enum {unknown} */
deliveryState: "pending" | "leased" | "confirmed" | "blocked";
receiptId?: string;
actionResolution?: components["schemas"]["WebShellActionResolution"];
/** @description Reason a durable response or task cancellation failed. Action response failures come from the original committed Action, or a definitive invalid response. Task cancel failures are task_already_settled (the run ended before the stop request was recorded), task_action_unavailable and task_not_found; a recovery_blocked task cancel reports task_cancel_unconfirmed. A lifecycle operation that exhausted its retry budget fails with the settle's failure: session_lifecycle_delivery_failed, managed_capability_mismatch or hosted_harness_protocol_error when the Hosted Harness refused to negotiate, a workspace close or lifecycle refusal (a workspace_close_* or workspace_lifecycle_* code, or runtime_admission_closed; a Runtime Broker runtime_broker_recovery_blocked refusal is reported as workspace_close_identity_unverified), or another Runtime Broker refusal code; one whose settle reached the Harness but stayed unsettled past the larger settled budget fails with session_close_completion_unsettled. A lifecycle recovery_blocked operation reports the refusal it waits on, original resource identity or unsettled execution for a Workspace close, session_close_writer_live while a Harness holds the journal writer or while that check itself fails, or hosted_harness_generation_mismatch while this replica's view of the Harness boot is stale, or hosted_lifecycle_recovery_required while the daemon settles a previous prompt, or hosted_turn_active while a turn, MCP call or hook is still draining; the Session remains closing. A submit_input failure carries its Turn's error code, and a recovery_blocked submit_input reports submit_input_unconfirmed; a cancel fails with turn_already_settled when its Turn completed or failed without being cancelled, except one that already existed when its Turn failed with managed_runtime_recovery_blocked after a Harness admitted it or a submission was attempted: it parks recovery_blocked with cancel_unconfirmed. A cancel submitted after the Turn ended still fails turn_already_settled. A cancel parked as recovery_blocked/cancel_unconfirmed by unobserved-Turn recovery reconciles only from the original prompt's retained durable terminal event: cancelled completes it, completed or error fails it with turn_already_settled, and missing or unreadable evidence stays parked. A recorded stop request alone does not prove cancellation completed. */
failureCode?: string;
replayed: boolean;
} & (unknown & unknown & unknown & unknown & unknown);
WebShellQuestionAction: {
actionId: string;
/** Format: uuid */
sessionId: string;
/** @constant */
kind: "question";
source: components["schemas"]["WebShellActionSource"];
/** @enum {unknown} */
state: "requested" | "decided" | "cancelled" | "expired";
/** Format: int64 */
inputRevision: number;
policyRevision: string;
/** Format: int64 */
createdAt: number;
/** Format: int64 */
expiresAt: number;
decisionReceiptId?: string;
turnId?: string;
functionCallId: string;
toolName: string;
questions: components["schemas"]["WebShellActionQuestion"][];
} & unknown;
/** @description At most one requested Hosted approval per Turn. allow and deny are stable option IDs. A requested native-tool Action may carry a bounded input preview when the producer supplies an input reference. Version 1 Actions and unavailable inputs omit it. Public timestamps are milliseconds, as recorded by the Harness. Decision receipts are opaque product IDs. */
WebShellPermissionAction: {
actionId: string;
/** Format: uuid */
sessionId: string;
/** @constant */
kind: "permission";
source: components["schemas"]["WebShellActionSource"];
/** @enum {unknown} */
state: "requested" | "decided" | "cancelled" | "expired";
/** Format: int64 */
inputRevision: number;
policyRevision: string;
/** Format: int64 */
createdAt: number;
/** Format: int64 */
expiresAt: number;
decisionReceiptId?: string;
options: components["schemas"]["WebShellActionOption"][];
turnId?: string;
functionCallId: string;
toolName: string;
inputPreview?: components["schemas"]["WebShellActionInputPreview"];
} & unknown;
WebShellPermissionResponse: {
/** @constant */
kind: "permission";
/** Format: int64 */
inputRevision: number;
policyRevision: string;
optionId: string;
};
WebShellActionPage: {
data: components["schemas"]["WebShellAction"][];
hasMore: boolean;
nextCursor?: string | null;
};
WebShellActionSource: {
/** @enum {unknown} */
kind: "tool_call" | "automation_run" | "team_plan" | "user_operation";
id: string;
};
/** @description Validate IDs, required answers, selection cardinality, text eligibility and current responder permission against the original Action. Unknown/expired/cancelled/conflicting revisions cannot grant execution. */
WebShellActionResponseRequest: components["schemas"]["WebShellPermissionResponse"] | components["schemas"]["WebShellQuestionResponse"];
WebShellActionOption: {
id: string;
label: string;
description?: string;
};
WebShellQuestionResponse: {
/** @constant */
kind: "question";
/** Format: int64 */
inputRevision: number;
policyRevision: string;
answers: components["schemas"]["WebShellQuestionAnswer"][];
};
WebShellOperation: components["schemas"]["WebShellCwdOperation"] | components["schemas"]["WebShellCommandOperation"] | components["schemas"]["WebShellContextCompressionOperation"];
WebShellActionQueryRequest: {
/** Format: uuid */
sessionId: string;
cursor?: string;
/** @default 20 */
limit?: number;
/**
* @description Include pending Actions of this public root Session and its direct children; each Action retains its actual owning sessionId.
* @default false
*/
includeChildren?: boolean;
};
WebShellActionGetRequest: {
/** Format: uuid */
sessionId: string;
actionId: string;
};
WebShellActionRespondRequest: {
/** Format: uuid */
sessionId: string;
actionId: string;
idempotencyKey: string;
response: components["schemas"]["WebShellActionResponseRequest"];
requestId?: string;
};
WebShellLifecycleRequest: {
/** Format: uuid */
sessionId: string;
idempotencyKey: string;
/** @description Trace-only client request identity, excluded from idempotency digests. */
requestId?: string | null;
};
WebShellWorkspaceQueryRequest: {
cursor?: string | null;
/** @default 50 */
limit?: number | null;
};
WebShellWorkspaceGetRequest: {
workspaceId: string;
};
/** @enum {string} */
TaskKind: "child_agent" | "workflow" | "background_shell" | "monitor" | "automation_run" | "channel_delivery";
/**
* @description Logical run state. completed is terminal and is set when the run's own line ends settled, with or without a physical execution; failed and cancelled are terminal too, and they also cover a run that ended before its execution started (cancelled before dispatch, or failed with no provable start), when no physical execution ever settled. degraded means that the task still runs with reduced guarantees, such as a Monitor that lost its observation source. recovery_blocked means that recovery cannot prove the physical outcome: it is not settled, is never reported as success and is never re-run automatically.
* @enum {string}
*/
TaskState: "pending" | "running" | "waiting" | "completed" | "failed" | "cancelled" | "degraded" | "recovery_blocked";
/**
* @description Redacted state of the Runtime that hosts the task, without binding identity or generation.
* @enum {string}
*/
TaskRuntimeState: "unbound" | "provisioning" | "ready" | "draining" | "lost";
/**
* @description Actions the task supports now, the same for every caller. cancel: the cancel route accepts a new command for this task (since 1.40 for child_agent, 1.46 for workflow and 1.54 for background_shell and monitor, tasks of those kinds in pending, running, waiting or degraded, and since 1.57 for channel_delivery, a delivery still pending because no adapter has claimed it, each in an active Session, and since 1.65 for automation_run in pending, running, waiting or degraded in an active Session; only that occurrence is cancelled and its schedule is preserved); whether a caller may use it is an authorization check (403 on the cancel route). send_input: reserved for a later capability route. read_output: the task events route returns output events for this task to any caller that can read it. read_output does not change during the task's life, and a task without it produces no output events: its output goes only to Artifacts, so the events route never filters out events that exist.
* @enum {string}
*/
TaskActionCapability: "cancel" | "send_input" | "read_output";
/** @description Read-only projection of one asynchronous task of a Session (SessionTaskView). It is rebuilt from the Session's durable domain records and is never their source of truth. It never carries a Runtime binding ID, generation, Runtime endpoint, Pod, absolute path, raw PID, SecretHandle or local sidecar; diagnostics are authorized Artifact references. */
WebShellTask: {
taskId: string;
/** Format: uuid */
sessionId: string;
/**
* Format: uuid
* @description The child Session that runs this task: present for a child_agent or workflow task once the run's committed record names it (the child's attach, or a terminal verdict that names a minted child), and absent for every other kind and before then. The child is a Session in the same Workspace, readable by exactly the callers that can read this task, so its Turns, items and events are the task's own output; reading them needs no other grant.
*/
childSessionId?: string;
kind: components["schemas"]["TaskKind"];
state: components["schemas"]["TaskState"];
/**
* Format: int64
* @description Immutable definition revision this run is pinned to, when the kind has a definition.
*/
definitionRevision?: number;
runtimeState?: components["schemas"]["TaskRuntimeState"];
/**
* Format: int64
* @description Unix epoch milliseconds.
*/
createdAt: number;
/**
* Format: int64
* @description Unix epoch milliseconds.
*/
startedAt?: number;
/**
* Format: int64
* @description Unix epoch milliseconds.
*/
settledAt?: number;
/** @description Stable task event cursor after the committed tail at view read time. No event can later appear at or before it. Pass it as after to follow only new events; recovery must instead keep its saved event page cursor so it does not skip intervening output. Normal retention may expire it. */
outputCursor?: string;
/** @description The newest Artifacts that hold durable task output, at most 100, oldest first. Entries must not rotate out until older Artifacts can be enumerated and attributed to the task: an evicted Artifact stays readable by id through the Session artifact routes but is no longer discoverable from the task. */
artifactRefs: string[];
actionCapabilities: components["schemas"]["TaskActionCapability"][];
/** @description A durable stop request has been recorded. This does not prove that the task has terminated. */
stopRequested?: boolean;
/**
* @description The actual immutable approval mode of this public child Session.
* @enum {string}
*/
approvalMode?: "default" | "auto-edit" | "yolo";
} & (unknown & unknown & unknown & unknown & unknown);
WebShellTaskPage: {
data: components["schemas"]["WebShellTask"][];
hasMore: boolean;
nextCursor?: string | null;
/** @description The total number of nonterminal child Agent tasks in this Session, independent of pagination. */
activeChildCount?: number;
} & unknown;
/** @description One task event: a logical state change, a bounded output chunk, or an Artifact reference. High-volume output goes to Artifacts or bounded chunks in this paged stream, never one Session event per raw line. The closed schema validates the server's own version; clients ignore unknown optional fields and unknown types and checkpoint their cursors. Strict response validation against an older minor version is not supported. Event identity, position, payload and accepted schema/projection versions are immutable across restart, projection rebuild and archival. */
WebShellTaskEvent: {
schemaVersion: number;
projectionVersion: number;
taskId: string;
/** Format: uuid */
sessionId: string;
type: components["schemas"]["TaskEventType"];
/** @description Stable opaque position after this event and its identity. Atomically apply the event and save this cursor to avoid duplicate application after a crash. It is never reassigned; normal retention can expire it. */
cursor: string;
/** Format: int64 */
createdAt: number;
state?: components["schemas"]["TaskState"];
runtimeState?: components["schemas"]["TaskRuntimeState"];
text?: string;
/** @description True when the chunk was cut to the event limit; its full output is already durably readable and discoverable in the task Artifacts when the event is published. */
truncated?: boolean;
artifactId?: string;
} & (unknown & unknown & unknown);
WebShellTaskEventPage: {
data: components["schemas"]["WebShellTaskEvent"][];
hasMore: boolean;
/** @description The last returned event cursor, never passing an event held back by limit. On an empty page, the requested position, or the durable retention floor if after was omitted. Required and never null, including when no events remain. No event may later become visible at or before this position. */
nextCursor: string;
};
WebShellTaskQueryRequest: {
/** Format: uuid */
sessionId: string;
cursor?: string;
/** @default 20 */
limit?: number;
};
WebShellTaskGetRequest: {
/** Format: uuid */
sessionId: string;
taskId: string;
};
WebShellTaskEventQueryRequest: {
/** Format: uuid */
sessionId: string;
taskId: string;
/** @description Opaque task event cursor: an event cursor, a page nextCursor or a task outputCursor. Omit it to read from the durable retention floor. Strictly below the floor is 409 cursor_expired; equality is valid, including with no retained events. */
after?: string;
/** @default 20 */
limit?: number;
};
WebShellTaskCancelRequest: {
/** @description Trace correlation only; excluded from the request digest, so a retry with another requestId still replays. A header-safe value (1 to 128 visible ASCII characters) is echoed as X-Request-Id; any other value is replaced by a server-chosen id. */
requestId?: string | null;
/** Format: uuid */
sessionId: string;
taskId: string;
idempotencyKey: string;
};
/** @description state_changed, output or artifact. The set is open: a later minor version may add types and optional fields. Clients ignore unknown optional fields and unknown types, while still checkpointing event cursors; strict validation against an older minor response schema is not supported. Existing fields forbidden for a known type cannot be repurposed on that type. */
TaskEventType: string;
ToolResultPreview: {
text: string;
truncated: boolean;
/** @enum {string} */
stream_id: "stdout" | "stderr";
/** Format: int64 */
source_start: number;
/** Format: int64 */
source_end: number;
};
PublicToolResult: {
id: string;
session_id: string;
turn_id: string;
item_id: string;
/** @description This implementation projects each result once at revision 1. Monotonic consumers reject duplicate or stale replay events; reprojection requires a separately reviewed migration and producer. */
projection_revision: number;
/** @enum {string} */
execution_status: "success" | "error" | "cancelled" | "not_started";
/** @enum {string|null} */
capture_status: "complete" | "partial" | "unavailable" | null;
/**
* @description O3 emits committed or blocked from the durable receipt. Pending is reserved for future producers and is not emitted by this implementation.
* @enum {string}
*/
delivery_status: "pending" | "committed" | "blocked";
/** @enum {string|null} */
capture_scope: "process_pty" | "process_pipes" | "tool_native" | null;
upstream_truncated: boolean | null;
/** @enum {string|null} */
reason_code?: "quota_exhausted" | "size_limit" | "producer_lost" | "storage_failed" | "cancelled" | null;
preview?: components["schemas"]["ToolResultPreview"] | null;
artifacts: components["schemas"]["PublicArtifact"][];
};
ArtifactAccess: {
can_read_content: boolean;
};
ToolResultResponse: {
result: components["schemas"]["PublicToolResult"];
access: components["schemas"]["ArtifactAccess"];
};
ArtifactResponse: {
artifact: components["schemas"]["PublicArtifact"];
access: components["schemas"]["ArtifactAccess"];
};
WebShellArtifactPage: {
data: components["schemas"]["ArtifactResponse"][];
nextCursor: string | null;
hasMore: boolean;
};
WebShellToolResultRequest: {
sessionId: string;
itemId: string;
};
WebShellArtifactRequest: {
sessionId: string;
artifactId: string;
};
WebShellArtifactQueryRequest: {
sessionId: string;
cursor?: string | null;
/** @default 20 */
limit?: number;
};
/** @description Optional preview for requested native read_file, write_file, edit or run_shell_command approvals. Missing or invalid input, and internal MCP inputs, omit the preview. No general secret redaction is performed; visibility follows Session read permissions. Deploy the version 2 Java reader before a Harness producer starts writing version 2 options. */
WebShellActionInputPreview: {
/** @description Exact UTF-8 prefix of payloadJson ({toolName,input}). Ordinary tools retain the 8192-byte preview. exit_plan_mode includes its complete input within the 64 KiB resource ceiling so a plan can be reviewed after refresh. Truncated ordinary previews may not be valid JSON. */
text: string;
/** @description True when text is shorter than the complete UTF-8 input. */
truncated: boolean;
/**
* Format: int64
* @description Byte length of the complete payloadJson in UTF-8, before truncation.
*/
byteLength: number;
};
WebShellWorkspaceCreateRequest: {
/** @description Trimmed display name, without control characters. The server validates the normalized name. */
displayName: string;
idempotencyKey: string;
sourceWorkspaceId?: string;
cwdRelative?: string;
/** @description Absolute execution-host directory. Requires localDirectoryImport; exclusive with Workspace-relative fields. An empty path is allowed only for directory browsing and starts at the host home directory. */
localPath?: string;
};
WebShellSessionOptionsRequest: {
agentId: string;
};
WebShellSessionOptions: {
/** @enum {string} */
approvalMode: "default" | "auto-edit" | "yolo";
/** @description Execution policies available at creation. Stored definitions retain their initial policy; existing eligible Sessions may select a policy separately. Plan is an independent overlay. */
availableApprovalModes: ("default" | "auto-edit" | "yolo")[];
/** @description Optional deployment capability; missing means false. */
planModeSupported?: boolean;
/** @description Optional deployment capability; missing means false. */
inputAttachments?: boolean;
/** @description Optional capability for modelId on Workspace creation. Missing means false. */
modelSelectionSupported?: boolean;
/** @description Optional deployment capability; missing means false. Requires a compatible Harness and durable Session Store. */
skillsSupported?: boolean;
};
/** @description Safe allowlisted observation for a Workspace-bound Session. Unknown counts are omitted, never estimated. */
WebShellModelContext: {
/** @description Actual model identity from the committed main-model usage resource. */
modelId: string;
/** @description Provider prompt token count for the latest successfully committed main-model request; not cumulative billing usage. */
inputTokens?: number;
/** @description Context capacity from the same resolved model configuration. Missing means unknown. */
contextWindowSize?: number;
/** @description Timestamp of the committed source observation, in Unix epoch milliseconds. */
observedAt: number;
};
WebShellModelSelection: {
modelId?: string;
/** Format: int64 */
revision: number;
};
WebShellModelOption: {
modelId: string;
label: string;
};
WebShellSessionModelsRequest: {
sessionId: string;
};
WebShellSessionModels: {
models: components["schemas"]["WebShellModelOption"][];
modelSelection: components["schemas"]["WebShellModelSelection"];
supported: boolean;
};
WebShellChangeModelRequest: {
sessionId: string;
modelId: string;
/** Format: int64 */
expectedRevision: number;
idempotencyKey: string;
requestId?: string;
};
WebShellModelChangeResult: {
sessionId: string;
modelSelection: components["schemas"]["WebShellModelSelection"];
replayed: boolean;
};
WebShellSessionApprovalRequest: {
sessionId: string;
};
WebShellSessionApproval: {
/** @description Execution approval can change during a Turn when true. Missing means idle-only; Plan changes remain idle-only. */
liveSupported?: boolean;
/** @enum {string} */
approvalMode: "default" | "auto" | "auto-edit" | "yolo";
/** Format: int64 */
approvalRevision: number;
availableApprovalModes: ("default" | "auto" | "auto-edit" | "yolo")[];
supported: boolean;
/** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
planMode?: boolean;
/** @description Optional deployment capability; missing means false. */
planModeSupported?: boolean;
/** @description Persisted rules, including when execution capability is unavailable. Omitted when empty. */
permissionRules?: components["schemas"]["ManagedPermissionRules"];
/** @description Owner-authorized Session rule editing is available only with Harness permission-rules/1 support. Missing means false. Rule changes require an idle Session. */
permissionRulesSupported?: boolean;
};
WebShellChangeApprovalRequest: {
sessionId: string;
/** Format: int64 */
expectedRevision: number;
idempotencyKey: string;
requestId?: string;
/** @enum {string} */
approvalMode: "default" | "auto" | "auto-edit" | "yolo";
/** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
planMode?: boolean;
/** @description Omission preserves the persisted rules. Supplying three empty arrays clears them. Rule edits require an idle Session, and share the approval revision and idempotency receipt with mode changes. */
permissionRules?: components["schemas"]["ManagedPermissionRules"];
};
WebShellApprovalChangeResult: {
sessionId: string;
/** @enum {string} */
approvalMode: "default" | "auto" | "auto-edit" | "yolo";
/** Format: int64 */
approvalRevision: number;
replayed: boolean;
/** @description Persisted public Plan overlay, independent of execution permission. Omission on a change preserves the selected state. */
planMode?: boolean;
/** @description Committed rules; omitted when empty. Replayed requests return their original policy receipt. */
permissionRules?: components["schemas"]["ManagedPermissionRules"];
};
WebShellRuntimeNode: {
nodeId: string;
displayName: string;
};
/** @description Disabled registration returns supported=false and no nodes. This capability controls fresh registration only; existing operation queries remain available. */
WebShellRuntimeNodePage: {
/** @default false */
supported: boolean;
data: components["schemas"]["WebShellRuntimeNode"][];
} & unknown;
WebShellWorkspaceDirectoryRequest: {
nodeId: string;
/** @description Existing absolute directory on the selected node; no directory or repository is created. */
path: string;
};
WebShellWorkspaceDirectory: {
nodeId: string;
/** @description Canonical absolute path after remote directory validation. */
canonicalPath: string;
/** @enum {string} */
platform: "linux" | "darwin";
};
WebShellWorkspaceOperationRequest: {
operationId: string;
};
/** @description workspaceId is returned only after completed registration. recovery_blocked means the registration may have reached its node: it keeps the original ownership until Java reads the node and completes it, or fails it and releases the directory. A node that cannot be read, no longer admits the actor or holds another registration's marker leaves it for administrator review, and a new browser draft does not release it. failed releases the directory if the registration reserved it. replayed=true identifies an existing operation returned by a repeated key or a query. */
WebShellWorkspaceCreateOperation: {
operationId: string;
/** @constant */
type: "workspace_create";
/** @enum {string} */
status: "pending" | "running" | "completed" | "failed" | "cancelled" | "recovery_blocked";
workspaceId?: string | null;
failureCode?: string | null;
replayed: boolean;
};
WebShellWorkspaceRegisterRequest: {
nodeId: string;
path: string;
displayName: string;
/** @description Actor-scoped registration key. Reuse this key and the same semantic fields until the operation identity is known. */
idempotencyKey: string;
/** @description Trace correlation only; excluded from the request digest, so a retry with another requestId still replays. A header-safe value (1 to 128 visible ASCII characters) is echoed as X-Request-Id; any other value is replaced by a server-chosen id. */
requestId?: string | null;
};
WebShellWorkspaceDirectoryPage: {
root: string;
cwdRelative: string;
truncated: boolean;
directories: {
name: string;
cwdRelative: string;
}[];
};
WebShellWorkspaceDirectoryQueryRequest: {
workspaceId: string;
cwdRelative: string;
} | {
/** @description Absolute execution-host directory. Requires localDirectoryImport; exclusive with Workspace-relative fields. An empty path is allowed only for directory browsing and starts at the host home directory. */
localPath: string;
};
InputTextBlock: {
/** @enum {string} */
type: "input_text" | "text";
text: string;
};
/** @description Inline UTF-8 text file. No host paths, URLs, binary or NUL. Conservative text MIME/extension validation; the complete canonical input containing attachments is limited to 8 MiB. */
InputFileBlock: {
/** @enum {string} */
type: "input_file";
name: string;
mime_type: string;
text: string;
};
/** @description Canonical base64 PNG, JPEG, GIF or WebP image with a matching signature. The image/jpg alias is normalized to image/jpeg. The complete canonical input containing attachments is limited to 8 MiB. */
InputImageBlock: {
/** @enum {string} */
type: "input_image";
/** @enum {string} */
mime_type: "image/png" | "image/jpeg" | "image/jpg" | "image/gif" | "image/webp";
data: string;
};
WebShellSkill: {
name: string;
description: string;
};
WebShellSessionSkills: {
skills: components["schemas"]["WebShellSkill"][];
};
WebShellWorkspaceFileQueryRequest: {
workspaceId?: string;
cwdRelative?: string;
directory: string;
query?: string;
expectedScopeRevision?: string;
/** Format: uuid */
sessionId?: string;
} & (unknown | unknown);
WebShellWorkspaceFileReadRequest: {
workspaceId?: string;
cwdRelative?: string;
path: string;
expectedScopeRevision: string;
/** Format: uuid */
sessionId?: string;
} & (unknown | unknown);
WebShellWorkspaceFileEntry: {
path: string;
name: string;
/** @enum {string} */
kind: "file" | "directory";
};
WebShellWorkspaceFilePage: {
scopeRevision: string;
directory: string;
entries: components["schemas"]["WebShellWorkspaceFileEntry"][];
truncated: boolean;
/** @description Present only when the selected CLI supports durable Workspace uploads. */
maxUploadBytes?: number;
};
WebShellWorkspaceFileSnapshot: {
scopeRevision: string;
path: string;
name: string;
/** @enum {string} */
mimeType: "text/plain";
text: string;
byteLength: number;
sha256: string;
};
WebShellToolDetails: {
/** @description Allowlisted display arguments, or null when unavailable or larger than 4 KiB. */
input: {
[key: string]: unknown;
} | null;
/** @description Recorded text or error, bounded to 8 KiB and 200 lines; null means unavailable, an empty string means recorded empty output. */
output: string | null;
truncated: boolean;
/** @description Validated saved Shell display, when available. Text fields share an 8 KiB/200-line budget; directory and output-file paths share an 8 KiB UTF-8 budget. Legacy text remains in output. */
shellResult?: components["schemas"]["WebShellShellResult"];
};
WebShellShellResult: {
/** @constant */
type: "shell_result";
/** @constant */
version: 1;
text: string;
output: string;
directory: string;
exitCode: number | null;
signal: number | null;
pid: number | null;
error: string | null;
/** @enum {string} */
outcome: "completed" | "failed" | "cancelled" | "timed_out";
notices: string[];
truncated: boolean;
outputFiles: string[];
};
WebShellRenameRequest: {
requestId?: string;
sessionId: string;
idempotencyKey: string;
/** @description The server enforces the bound in UTF-16 code units (Java String.length()), so an astral character counts as two: a title this schema's code-point maxLength accepts can still exceed the server's 256-unit bound and answer 400 invalid_title. */
title: string;
};
WebShellRenameResult: {
sessionId: string;
/** @description Current persisted title from the confirmed mutation or completed replay. */
title: string;
replayed: boolean;
};
SessionCreationSkill: {
/** @description Unique Skill name, at most 128 UTF-8 bytes. */
name: string;
/** @description At most 4096 UTF-8 bytes. */
description: string;
/** @description Static instructions, at most 524288 UTF-8 bytes. */
body: string;
/** @description Canonical POSIX path relative to the Session working directory; defaults to dot. */
base_directory?: string;
/** @description Whether the model may invoke this Skill; defaults to true. */
model_invocable?: boolean;
/** @description Whether the user may invoke this Skill; defaults to true. */
user_invocable?: boolean;
};
WebShellContextCompressionRequest: {
requestId?: string;
sessionId: string;
idempotencyKey: string;
/** Format: int64 */
expectedCompactionRevision: number;
};
WebShellContextCompressionOperation: {
operationId: string;
/** Format: uuid */
sessionId: string;
/** @constant */
type: "context_compression";
/** @enum {string} */
status: "pending" | "running" | "recovery_blocked" | "completed" | "failed";
/** Format: int64 */
expectedCompactionRevision: number;
/** Format: int64 */
compactionRevision?: number | null;
/** @enum {string|null} */
outcome?: "compressed" | "noop" | null;
failureCode?: string | null;
replayed: boolean;
};
ManagedMcpServerPin: {
serverId: string;
serverRevision: number;
definitionDigest: string;
};
ManagedMcpPublishedServer: {
serverId: string;
serverRevision: number;
definitionDigest: string;
/** @enum {string} */
transport: "stdio" | "streamable-http" | "sse";
};
ManagedMcpManagementServer: {
serverId: string;
serverRevision: number;
definitionDigest: string;
/** @enum {string} */
state: "enabled" | "disabled" | "removed";
};
ManagedMcpManagementOperation: {
/** Format: uuid */
operationId: string;
/** @enum {string} */
action: "add" | "edit" | "remove" | "enable" | "disable" | "reload" | "restart";
serverId: string;
revision: number;
/** @enum {string} */
state: "pending" | "settled" | "failed" | "recovery_required";
error?: {
code: string;
};
};
ManagedMcpManagementSnapshot: {
sessionId: string;
revision: number;
supported: boolean;
availableServers: components["schemas"]["ManagedMcpPublishedServer"][];
servers: components["schemas"]["ManagedMcpManagementServer"][];
operation?: components["schemas"]["ManagedMcpManagementOperation"];
};
WebShellMcpManagementQuery: {
sessionId: string;
requestId?: string;
};
WebShellMcpManagementSubmit: {
sessionId: string;
requestId?: string;
idempotencyKey: string;
/** @enum {string} */
action: "add" | "edit" | "remove" | "enable" | "disable" | "reload" | "restart";
serverId: string;
expectedRevision: number;
server?: components["schemas"]["ManagedMcpServerPin"];
};
WebShellMcpManagementOperationQuery: {
sessionId: string;
/** Format: uuid */
operationId: string;
requestId?: string;
};
SessionRecoveryActions: {
recheck: boolean;
cancel: boolean;
continueInNewSession: boolean;
};
/** @description Separate from Session lifecycle and Turn outcome. ready requires affirmative native input settlement and an admissible continuation boundary with no active Java Turn or blocking debt. Actions are authorization-scoped hints, checked again by their mutations. A new-Session action opens an editable text handoff and grants no additional Workspace permission. A cold or unreadable terminal Turn may advertise a proof-checked cleanup recheck while remaining operator_required with nextTurnAllowed=false; only affirmative native evidence after that mutation can establish readiness. */
SessionRecovery: {
/** @enum {string} */
state: "recovering" | "awaiting_evidence" | "cleanup_pending" | "ready" | "operator_required";
reasonCode: string;
/** @description Public Turn identity; never an internal prompt, checkpoint or execution reference. */
turnId?: string;
nextTurnAllowed: boolean;
actions: components["schemas"]["SessionRecoveryActions"];
/**
* Format: int64
* @description Known next reconciliation time in Unix epoch milliseconds.
*/
nextRecheckAt?: number;
};
WebShellRecoveryRecheckRequest: {
sessionId: string;
turnId: string;
};
WebShellLifecycleOperation: {
operationId: string;
/** @enum {string} */
type: "close" | "archive" | "delete";
/** @enum {string} */
status: "pending" | "running" | "completed" | "failed" | "recovery_blocked";
failureCode?: string | null;
};
WebShellExportPage: {
items: components["schemas"]["WebShellItem"][];
nextCursor?: string | null;
hasMore: boolean;
/**
* Format: int64
* @description Fixed first-request sequence membership upper bound. Bodies and statuses are read live on every page; this does not identify a retained content version.
*/
snapshotThroughSequence: number;
};
WebShellExportRequest: {
/** Format: uuid */
sessionId: string;
cursor?: string | null;
/** @default 100 */
limit?: number | null;
};
/** @description Durable Turn input or cancellation admission. The operation identifies the saved command and remains stable across idempotent retries. */
WebShellTurnAdmission: {
/** Format: uuid */
sessionId: string;
turnId: string;
status: string;
replayed: boolean;
/** @description Durable operation identifier for turn submission or cancellation. */
operationId: string;
/**
* @description Persisted admission stage of the operation.
* @enum {string}
*/
admissionStage: "java_durable" | "harness_confirmed";
/**
* @description Current delivery state of the operation.
* @enum {string}
*/
deliveryState: "pending" | "leased" | "confirmed" | "blocked";
};
/** @description Session-scoped portable permission-rules/1. Each rule must be trimmed, nonempty, free of control characters, and at most 512 UTF-8 bytes. At most 32 unique strings per list, 64 across all lists and 8192 UTF-8 bytes of compact JSON. Tool names and aliases match whole tools; MCP names may end with a wildcard. Bash/Shell/run_shell_command/monitor command globs and WebFetch/web_fetch(domain:host) are supported; file-path specifiers and arbitrary tool predicates are rejected. Deny takes precedence over ask, then allow, in every mode. Rules do not provide filesystem or process isolation. */
ManagedPermissionRules: {
allow: string[];
ask: string[];
deny: string[];
};
UserMessage: {
id: string;
sequence: number;
revision: number;
/** @enum {string} */
state: "queued" | "claimed" | "recovery_blocked";
input: {
type: string;
text?: string;
resource?: {
uri: string;
text: string;
mimeType: string;
};
}[];
turnId?: string | null;
};
UserMessageSnapshot: {
paused: boolean;
messages: components["schemas"]["UserMessage"][];
};
/** @description submit queues input; edit only changes queued input. withdraw removes queued input or explicitly discards recovery_blocked input without replaying it. Unknown delivery may already have reached the original Turn: discarding does not undo it, preserves late durable receipts and keeps the queue paused until resume. In-flight claimed input remains immutable. Commands replay the actor-scoped recorded result before checking new-work availability. */
UserMessageCommand: {
/** @enum {string} */
action: "submit" | "edit" | "withdraw" | "resume";
messageId?: string;
expectedRevision?: number;
input?: components["schemas"]["InputBlock"][];
};
WebShellUserMessageQuery: {
sessionId: string;
};
WebShellUserMessageCommand: {
sessionId: string;
idempotencyKey: string;
command: components["schemas"]["UserMessageCommand"];
};
ManagedExtensionPackagePin: {
extensionId: string;
/** Format: int64 */
packageRevision: number;
packageDigest: string;
/** Format: int64 */
settingsRevision?: number;
};
ManagedExtensionPackageManifest: {
/** @enum {integer} */
schemaVersion: 1;
/** @enum {integer} */
compilerVersion: 1;
name: string;
version: string;
target: {
/** @enum {string} */
platform: "linux" | "darwin";
/** @enum {string} */
arch: "x64" | "arm64" | "any";
};
components: ("skills" | "commands" | "agents" | "context" | "mcp" | "hooks" | "settings")[];
/** @enum {string} */
sourceType?: "git" | "github-release" | "npm" | "directory" | "archive" | "archive-url" | "link" | "snapshot";
/** @description Exact source commit, resolved npm version, or imported content revision. Supplied together with sourceType. */
sourceRevision?: string;
};
ManagedExtensionPackage: {
pin: components["schemas"]["ManagedExtensionPackagePin"];
manifest: components["schemas"]["ManagedExtensionPackageManifest"];
/** Format: int64 */
byteLength: number;
};
ManagedExtensionPackageCatalog: {
supported: boolean;
extensions: components["schemas"]["ManagedExtensionPackage"][];
};
ManagedExtensionPackageSettings: {
/** Format: int64 */
settingsRevision: number;
configuredKeys: string[];
};
ManagedExtensionPackageOperation: {
operationId: string;
extensionId: string;
/** @enum {string} */
kind: "publish" | "settings";
/** @enum {string} */
state: "pending" | "settled";
/** Format: int64 */
revision: number;
packageDigest: string | null;
};
WebShellExtensionWorkspaceQuery: {
workspaceId: string;
};
WebShellExtensionQuery: {
workspaceId: string;
extensionId: string;
};
WebShellExtensionOperationQuery: {
workspaceId: string;
operationId: string;
};
WebShellExtensionPackageQuery: {
workspaceId: string;
pin: components["schemas"]["ManagedExtensionPackagePin"];
};
WebShellExtensionSettingsSubmit: {
workspaceId: string;
extensionId: string;
idempotencyKey: string;
/** Format: int64 */
expectedRevision: number;
/** @description Complete settings revision, bounded to 8 KiB UTF-8 JSON. Values are encrypted at rest and never returned by metadata or operation queries. */
values: {
[key: string]: string;
};
};
ManagedExtensionApplySelection: {
expectedConfigRevision: number;
extensions: components["schemas"]["ManagedExtensionPackagePin"][];
};
ManagedExtensionApplyOperation: {
/** Format: uuid */
operationId: string;
/** @enum {string} */
state: "preparing" | "prepared" | "committed" | "active" | "recovery_required" | "failed";
/** @enum {string} */
mode: "apply" | "recoverPrevious";
revision: number;
error?: {
code: string;
};
};
ManagedExtensionManagementSnapshot: {
sessionId: string;
supported: boolean;
revision: number;
extensions: components["schemas"]["ManagedExtensionPackagePin"][];
requestedExtensions: components["schemas"]["ManagedExtensionPackagePin"][];
operation?: components["schemas"]["ManagedExtensionApplyOperation"];
};
WebShellExtensionSessionQuery: {
sessionId: string;
/** Format: uuid */
operationId?: string;
};
WebShellExtensionSessionOperation: {
sessionId: string;
/** Format: uuid */
operationId: string;
};
WebShellExtensionSessionSubmit: {
sessionId: string;
idempotencyKey: string;
command: components["schemas"]["ManagedExtensionApplySelection"];
};
WebShellWorkspaceFileUploadResult: {
scopeRevision: string;
/** Format: uuid */
uploadId: string;
path: string;
sizeBytes: number;
sha256: string;
};
WebShellWorkspaceFileUploadStatus: {
scopeRevision: string;
/** Format: uuid */
uploadId: string;
path: string;
sizeBytes: number;
sha256: string;
/** @enum {string} */
state: "completed" | "failed" | "pending";
code?: string;
};
WebShellWorkspaceFileUploadQueryRequest: {
/** Format: uuid */
uploadId: string;
};
WebShellSessionWorktree: {
id: string;
sessionId: string;
workspaceId: string;
branch: string;
baseCommit: string;
cwdRelative: string;
operationId: string;
/** @enum {string} */
state: "preparing" | "ready" | "failed" | "blocked" | "removing" | "removed";
revision: number;
errorCode?: string | null;
};
WebShellSessionWorktreeOptions: {
supported: boolean;
reason?: string | null;
baseCommit?: string | null;
/** @description Source checkout branch independent of base ref; HEAD when detached, null when unavailable. */
currentBranch?: string | null;
branches: string[];
};
WebShellSessionWorktreePage: {
data: components["schemas"]["WebShellSessionWorktree"][];
};
WebShellSessionWorktreeInspection: {
worktree: components["schemas"]["WebShellSessionWorktree"];
canCleanup: boolean;
cleanupBlocker?: string | null;
};
WebShellSessionWorktreeOptionsRequest: {
workspaceId: string;
cwdRelative: string;
baseRef?: string;
};
WebShellSessionWorktreeQueryRequest: {
workspaceId: string;
};
WebShellSessionWorktreeInspectRequest: {
workspaceId: string;
worktreeId: string;
};
WebShellSessionWorktreeCleanupRequest: {
workspaceId: string;
worktreeId: string;
idempotencyKey: string;
};
};
responses: {
/** @description The authenticated actor belongs to another tenant than X-Qwen-Tenant-Id or has an invalid ID (actor_scope_mismatch, which the tenant filter answers on every /v1/agents/ and WebShell route), or the resource is readable but the actor lacks this operation or the original Action responder permission. Artifact content reads may also return artifact_content_forbidden when the actor cannot read the original bytes. */
Forbidden: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description A trusted actor is required for this request but none was supplied (actor_required). In signed authentication mode (qwenSignature) every covered public and WebShell route additionally answers 401 authentication_required when the signature, timestamp or actor headers are missing, and 401 invalid_signature when the signature is wrong or stale. */
Unauthorized: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description In signed authentication mode (qwenSignature) a request body beyond the configured signed-body limit (qwen.managed-agent.auth.max-signed-body-bytes, default 10 MiB) answers 413 payload_too_large before the signature is compared. */
PayloadTooLarge: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Invalid request. */
BadRequest: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description State, idempotency, or recovery conflict. New Workspace-scoped admissions return workspace_unavailable with retryable=false while an offline Workspace migration holds the storage fence; authorized durable replays retain their existing behavior. */
Conflict: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Resource absent or outside the caller tenant scope. */
NotFound: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Task event cursor is strictly below the task's durable retention floor, which survives an empty retained set; equality is valid. The envelope's replay_floor_sequence and snapshot_through_sequence stay absent because task cursors are opaque. */
TaskCursorExpired: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description A dependency such as the Hosted Harness is unavailable; retry later. */
Unavailable: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description 409 message_projection_changed: the message projection generation changed. Discard the message cursor and restart this read; this is not replay-floor cursor expiration. */
MessageProjectionChanged: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description 413 message_page_too_large: selected message bodies or Turn control events exceed the response byte budget. Reducing limit can help a multi-Item page, but a single oversized Item cannot be returned even with limit=1. Signed POST requests may also return payload_too_large when their request body exceeds the configured signed-body limit. */
MessagePageTooLarge: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description 400 invalid_message_cursor for malformed, wrong-scope, wrong-direction or out-of-range message cursors; invalid_limit outside 1..100; invalid_event_cursor for a negative numeric after. */
InvalidMessagePage: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description 503 message_projection_pending: projection coverage is below the replay floor, or the initial forward read is behind committed events. Retry after message projection catches up. */
MessageProjectionPending: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
parameters: {
IdempotencyKey: string;
};
requestBodies: never;
headers: {
/** @description True when an accepted command or operation was replayed for the same idempotency key and digest without repeating its mutation. Session mutation responses represent the recorded outcome on the Session as last visible — a rename or unarchive replay after delete answers with the Session's pre-delete status rather than 404, while a create replay after delete answers 404 on the public create route, which re-reads the Session before responding, and answers the recorded 202 admission carrying the tombstoned sessionId on the WebShell create route, which does not re-read it; operation responses represent the original operation at its current state. */
IdempotentReplay: boolean;
/** @description Trace-only correlation identifier; never an idempotency key. */
RequestId: string;
};
pathItems: never;
}
export type $defs = Record<string, never>;
export interface operations {
webShellListSessions: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellListRequest"];
};
};
responses: {
/** @description WebShell session page. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionPage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellGetSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionRequest"];
};
};
responses: {
/** @description WebShell session. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSession"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellRenameSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellRenameRequest"];
};
};
responses: {
/** @description Confirmed persisted Session title, or an authorized completed replay. */
200: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
"X-Qwen-Idempotent-Replay": components["headers"]["IdempotentReplay"];
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellRenameResult"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
503: components["responses"]["Unavailable"];
};
};
webShellTranscript: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellTranscriptRequest"];
};
};
responses: {
/** @description Event transcript page. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellTranscript"];
};
};
400: components["responses"]["InvalidMessagePage"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["MessageProjectionChanged"];
413: components["responses"]["MessagePageTooLarge"];
503: components["responses"]["MessageProjectionPending"];
};
};
webShellStreamEvents: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellStreamRequest"];
};
};
responses: {
/** @description SSE stream. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"text/event-stream": string;
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellCreateSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellCreateRequest"];
};
};
responses: {
/** @description Session admitted. */
202: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellAdmission"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
503: components["responses"]["Unavailable"];
};
};
webShellSubmitTurn: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSubmitRequest"];
};
};
responses: {
/** @description Turn admitted. */
202: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellTurnAdmission"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellCancelTurn: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellCancelRequest"];
};
};
responses: {
/** @description Cancellation durably admitted. */
202: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellTurnAdmission"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellQueryWorkspaces: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceQueryRequest"];
};
};
responses: {
/** @description Authorized durable resource view; no Runtime startup required. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspacePage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellQueryCwdOperation: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellOperationRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellActions: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellActionQueryRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellActionPage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
getWebShellAction: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellActionGetRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellAction"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
respondWebShellAction: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellActionRespondRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellCommandOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
/** @description Responding requires the Session's recorded owner or a Workspace OPERATOR (action_forbidden); a Shell Session's Actions may be answered only by its recorded owner. An unbound Session with no recorded creator and no recorded create command (anonymous open-mode creation, or an unbound Session created before the V40 migration that also has no Workspace creation record) answers to any caller in its tenant, matching its read ACL; a bound Session with no recorded owner answers through the create-command actor recorded for it, or through the Workspace role arm. The tenant filter's 403 actor_scope_mismatch also applies on this route. */
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable Session (session_not_found), or unknown Action (action_not_found). */
404: components["responses"]["NotFound"];
/** @description Idempotency conflict, a non-active Session (session_inactive), or an ended Action (action_expired, action_cancelled, action_already_resolved). An existing matching response replays before the Session-state check. */
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
closeWebShellSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellLifecycleRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellCommandOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
archiveWebShellSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellLifecycleRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellCommandOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
deleteWebShellSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellLifecycleRequest"];
};
};
responses: {
/** @description Same authorized operation semantics as the public API. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellCommandOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellGetWorkspace: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceGetRequest"];
};
};
responses: {
/** @description Authorized durable resource view; no Runtime startup required. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspace"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellTasks: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellTaskQueryRequest"];
};
};
responses: {
/** @description Same authorized task semantics as the public API. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellTaskPage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
getWebShellTask: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellTaskGetRequest"];
};
};
responses: {
/** @description Same authorized task semantics as the public API. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellTask"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellTaskEvents: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellTaskEventQueryRequest"];
};
};
responses: {
/** @description Same authorized task semantics as the public task events route, including the durable retention floor, committed-prefix publication, Artifact recovery order and client tolerance of unknown optional fields and event types. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellTaskEventPage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["TaskCursorExpired"];
413: components["responses"]["PayloadTooLarge"];
};
};
cancelWebShellTask: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellTaskCancelRequest"];
};
};
responses: {
/** @description Same authorized task cancellation semantics as the public API: key validation, current access, idempotent replay, then new-request capability, Session, task and storage-migration checks (409 workspace_unavailable under a migration fence). Replay returns the same operation and latest durable state. 202 is durable admission, completed is authority acceptance, and neither proves physical stop. Admission requires no other open operation on the Session (409 session_operation_active), as on the lifecycle routes. A requestId in the body becomes the response's X-Request-Id and stays out of the request digest. */
202: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellCommandOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
getWebShellToolResult: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellToolResultRequest"];
};
};
responses: {
/** @description Authorized persisted tool result resource. */
200: {
headers: {
"Cache-Control"?: "private, no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ToolResultResponse"];
};
};
/** @description Invalid request. */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Trusted actor required. */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable resource. */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
413: components["responses"]["PayloadTooLarge"];
/** @description Resource temporarily unavailable. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
getWebShellArtifact: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellArtifactRequest"];
};
};
responses: {
/** @description Authorized persisted artifact metadata. */
200: {
headers: {
"Cache-Control"?: "private, no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ArtifactResponse"];
};
};
/** @description Invalid request. */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Trusted actor required. */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable resource. */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
413: components["responses"]["PayloadTooLarge"];
/** @description Resource temporarily unavailable. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
queryWebShellArtifacts: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellArtifactQueryRequest"];
};
};
responses: {
/** @description Authorized artifact metadata page. */
200: {
headers: {
"Cache-Control"?: "private, no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellArtifactPage"];
};
};
/** @description Invalid request. */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Trusted actor required. */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable resource. */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
413: components["responses"]["PayloadTooLarge"];
/** @description Resource temporarily unavailable. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
unarchiveWebShellSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellLifecycleRequest"];
};
};
responses: {
/** @description Current WebShell Session; replay does not repeat the mutation. */
200: {
headers: {
"X-Qwen-Idempotent-Replay": components["headers"]["IdempotentReplay"];
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSession"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellCreateWorkspace: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceCreateRequest"];
};
};
responses: {
/** @description Created Workspace or authorized same-key replay. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspace"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellSessionOptions: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionOptionsRequest"];
};
};
responses: {
/** @description Effective default and supported policies. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionOptions"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellSessionModels: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionModelsRequest"];
};
};
responses: {
/** @description Session model options. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionModels"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
changeWebShellSessionModel: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellChangeModelRequest"];
};
};
responses: {
/** @description The admitted model selection, or the same original result on replay. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellModelChangeResult"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellSessionApproval: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionApprovalRequest"];
};
};
responses: {
/** @description The current policy options. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionApproval"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
changeWebShellSessionApproval: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellChangeApprovalRequest"];
};
};
responses: {
/** @description The committed approval selection, or its original receipt on replay. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellApprovalChangeResult"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellQueryRuntimeNodes: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
/** @description SSH registration capability and authorized machine display names. */
200: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
"Cache-Control"?: "no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellRuntimeNodePage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellCheckWorkspaceDirectory: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceDirectoryRequest"];
};
};
responses: {
/** @description Validated canonical directory on the selected Linux or macOS node. */
200: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
"Cache-Control"?: "no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceDirectory"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The SSH bootstrap response is invalid. */
502: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
503: components["responses"]["Unavailable"];
};
};
webShellGetWorkspaceOperation: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceOperationRequest"];
};
};
responses: {
/** @description Latest durable state of the original actor-owned registration. */
200: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
"Cache-Control"?: "no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceCreateOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellRegisterWorkspace: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceRegisterRequest"];
};
};
responses: {
/** @description Durable registration operation; repeated requests retain the original identity. */
202: {
headers: {
"X-Request-Id": components["headers"]["RequestId"];
"Cache-Control"?: "no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceCreateOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellWorkspaceDirectories: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceDirectoryQueryRequest"];
};
};
responses: {
/** @description Authorized existing directories. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceDirectoryPage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
};
};
queryWebShellSessionMcp: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionRequest"];
};
};
responses: {
/** @description Session MCP catalog snapshot. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["PublicMcpCatalog"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellSessionSkills: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionRequest"];
};
};
responses: {
/** @description Session static Skill metadata. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionSkills"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellWorkspaceFilesQuery: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceFileQueryRequest"];
};
};
responses: {
/** @description Authorized Workspace file result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceFilePage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
503: components["responses"]["Unavailable"];
};
};
webShellWorkspaceFilesRead: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceFileReadRequest"];
};
};
responses: {
/** @description Authorized Workspace file result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceFileSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
503: components["responses"]["Unavailable"];
};
};
getWebShellToolDetails: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellToolResultRequest"];
};
};
responses: {
/** @description Bounded saved ReadFile/Shell input and text output, read on demand; requires a trusted actor and current Session/Workspace read access. Available to authorized readers without a feature switch. */
200: {
headers: {
"Cache-Control"?: "private, no-store";
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellToolDetails"];
};
};
/** @description Invalid request. */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Trusted actor required. */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
403: components["responses"]["Forbidden"];
/** @description Unknown or unreadable resource. */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description Resource temporarily unavailable. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
webShellCompressContext: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellContextCompressionRequest"];
};
};
responses: {
/** @description Durable context compression operation. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellContextCompressionOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWebShellSessionMcpManagement: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellMcpManagementQuery"];
};
};
responses: {
/** @description Session-local MCP settings and operation snapshot. Inventory describes published pins rather than live connection health; operation status omits inventory. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedMcpManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
submitWebShellSessionMcpManagement: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellMcpManagementSubmit"];
};
};
responses: {
/** @description Session-local MCP settings and operation snapshot. Inventory describes published pins rather than live connection health; operation status omits inventory. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedMcpManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
queryWebShellSessionMcpManagementOperation: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellMcpManagementOperationQuery"];
};
};
responses: {
/** @description Session-local MCP settings and operation snapshot. Inventory describes published pins rather than live connection health; operation status omits inventory. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedMcpManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
queryWebShellSessionRecovery: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionRequest"];
};
};
responses: {
/** @description Current recovery evidence. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["SessionRecovery"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
503: components["responses"]["Unavailable"];
};
};
recheckWebShellSessionRecovery: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellRecoveryRecheckRequest"];
};
};
responses: {
/** @description Current recovery evidence; recheck admission is not settlement. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["SessionRecovery"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
503: components["responses"]["Unavailable"];
};
};
webShellExportSession: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExportRequest"];
};
};
responses: {
/** @description Chronological page of current message Items within the initial sequence membership range; content remains live. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellExportPage"];
};
};
400: components["responses"]["InvalidMessagePage"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["MessageProjectionChanged"];
413: components["responses"]["MessagePageTooLarge"];
503: components["responses"]["MessageProjectionPending"];
};
};
webShellQueryUserMessages: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellUserMessageQuery"];
};
};
responses: {
/** @description Authoritative queue snapshot */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["UserMessageSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
503: components["responses"]["Unavailable"];
};
};
webShellCommandUserMessages: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellUserMessageCommand"];
};
};
responses: {
/** @description Authoritative queue snapshot */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["UserMessageSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
503: components["responses"]["Unavailable"];
};
};
queryWorkspaceExtensionPackages: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionWorkspaceQuery"];
};
};
responses: {
/** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionPackageCatalog"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWorkspaceExtensionPackage: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionPackageQuery"];
};
};
responses: {
/** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionPackage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWorkspaceExtensionPackageSettings: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionQuery"];
};
};
responses: {
/** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionPackageSettings"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
submitWorkspaceExtensionPackageSettings: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionSettingsSubmit"];
};
};
responses: {
/** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionPackageOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
queryWorkspaceExtensionPackageOperation: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionOperationQuery"];
};
};
responses: {
/** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionPackageOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
publishWebShellWorkspaceExtensionPackage: {
parameters: {
query: {
workspaceId: string;
extensionId?: string;
packageDigest: string;
manifest: string;
};
header: {
"Idempotency-Key": components["parameters"]["IdempotencyKey"];
};
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/octet-stream": string;
};
};
responses: {
/** @description Persisted Workspace extension resource. Contains no settings values or executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionPackageOperation"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
};
};
webShellSessionExtensionsQuery: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionSessionQuery"];
};
};
responses: {
/** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
webShellSessionExtensionsSubmit: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionSessionSubmit"];
};
};
responses: {
/** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
webShellSessionExtensionsContinue: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionSessionOperation"];
};
};
responses: {
/** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
webShellSessionExtensionsRecoverPrevious: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExtensionSessionOperation"];
};
};
responses: {
/** @description Persisted or reconciled Session configuration; contains no settings values or private executable recipes. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ManagedExtensionManagementSnapshot"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
413: components["responses"]["PayloadTooLarge"];
/** @description The original MCP Runtime or management operation cannot be confirmed. Retry the same operation identity. */
503: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
};
};
webShellWorkspaceFilesUpload: {
parameters: {
query: {
workspaceId?: string;
cwdRelative?: string;
path: string;
expectedScopeRevision: string;
uploadId: string;
/** @description Exactly one locator: Session ID, or Workspace ID plus cwdRelative. */
sessionId?: string;
};
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/octet-stream": string;
};
};
responses: {
/** @description Workspace upload result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceFileUploadResult"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
/** @description The upload exceeds the 8 MiB binary limit. */
413: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
/** @description Uploads require unencoded application/octet-stream bytes. */
415: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["ErrorEnvelope"];
};
};
503: components["responses"]["Unavailable"];
};
};
webShellWorkspaceFilesUploadQuery: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellWorkspaceFileUploadQueryRequest"];
};
};
responses: {
/** @description Workspace upload result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellWorkspaceFileUploadStatus"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
503: components["responses"]["Unavailable"];
};
};
webShellSessionWorktreeOptions: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionWorktreeOptionsRequest"];
};
};
responses: {
/** @description Session worktree result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionWorktreeOptions"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
};
};
webShellSessionWorktreeQuery: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionWorktreeQueryRequest"];
};
};
responses: {
/** @description Session worktree result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionWorktreePage"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
};
};
webShellSessionWorktreeInspect: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionWorktreeInspectRequest"];
};
};
responses: {
/** @description Session worktree result. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionWorktreeInspection"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
};
};
webShellSessionWorktreeCleanup: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellSessionWorktreeCleanupRequest"];
};
};
responses: {
/** @description Session worktree result. */
202: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellSessionWorktree"];
};
};
400: components["responses"]["BadRequest"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["Conflict"];
};
};
webShellRecentTranscriptItems: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["WebShellExportRequest"];
};
};
responses: {
/** @description Bounded recent current message Item page. Items are chronological within each page. */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["WebShellExportPage"];
};
};
400: components["responses"]["InvalidMessagePage"];
401: components["responses"]["Unauthorized"];
403: components["responses"]["Forbidden"];
404: components["responses"]["NotFound"];
409: components["responses"]["MessageProjectionChanged"];
413: components["responses"]["MessagePageTooLarge"];
503: components["responses"]["MessageProjectionPending"];
};
};
}
Reference in new issue View Git Blame Copy Permalink