@qwen-code/web-shell 0.24.6 → 0.24.7-nightly.20260930.57e720bc97

package/dist/types/components/managed/generated/managed-agent-api.d.ts

@@ -0,0 +1,1346 @@
+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/transcript/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** @description Without a cursor, a Session that has a Snapshot returns all of its Items, the events up to the Snapshot other than turn.accepted, item.output_text.delta, item.reasoning.delta and item.tool_call.updated, which the Items already hold, and every event after it. Otherwise, and for an olderCursor, limit bounds the page of events. */
+        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 below the replay floor ends the stream with one agent.session.resync_required frame instead of a 409; 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 and fixed server-owned profile with public Session creation. Later Workspace submit, cancel and lifecycle operations remain gated. Freeze selection with the original idempotency key; admission does not prove physical directory readiness. */
+        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;
+        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;
+        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 D6 serves Hosted permission Actions. Question Actions and vote_recorded remain planned. Reads follow Session authorization; only the Session creator may respond. 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 D6 serves Hosted permission Actions. Question Actions and vote_recorded remain planned. Reads follow Session authorization; only the Session creator may respond. 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 D6 serves Hosted permission Actions. Question Actions and vote_recorded remain planned. Reads follow Session authorization; only the Session creator may respond. 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;
+        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;
+        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;
+        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;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        InputBlock: {
+            /** @enum {string} */
+            type: "input_text";
+            text: string;
+        };
+        WebShellListRequest: {
+            cursor?: string | null;
+            /** @default 20 */
+            limit?: number | 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 Planned; phase one rejects non-blank values. */
+            environmentId?: string | null;
+            title?: string | null;
+            input?: components["schemas"]["InputBlock"][];
+            metadata?: components["schemas"]["WebShellMetadata"];
+            workspace?: components["schemas"]["WebShellWorkspaceSelection"];
+        };
+        WebShellSubmitRequest: {
+            /** @description Trace correlation only. */
+            requestId?: string | null;
+            idempotencyKey: string;
+            /** Format: uuid */
+            sessionId: string;
+            input?: components["schemas"]["InputBlock"][];
+            metadata?: components["schemas"]["WebShellMetadata"];
+        };
+        WebShellCancelRequest: {
+            /** @description Trace correlation only. */
+            requestId?: string | null;
+            idempotencyKey: string;
+            /** Format: uuid */
+            sessionId: string;
+            turnId: string;
+        };
+        WebShellMetadata: {
+            clientId?: string;
+        } | null;
+        /** @description With durable_operations enabled, all three target fields are returned. accepted means Java durable delivery responsibility, not model execution. Missing fields retain the deployed legacy response semantics. */
+        WebShellAdmission: {
+            /** Format: uuid */
+            sessionId: string;
+            turnId?: string | null;
+            status: string;
+            replayed: boolean;
+        };
+        WebShellTurn: {
+            turnId: string;
+            /** Format: uuid */
+            sessionId: string;
+            status: string;
+            /** Format: int64 */
+            submittedAt: number;
+            /** Format: int64 */
+            completedAt?: number | null;
+            errorCode?: string | null;
+            usage?: {
+                [key: string]: unknown;
+            } | 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"];
+        };
+        WebShellSessionCapabilities: {
+            /** @default false */
+            actions: boolean;
+            tasks: boolean;
+        };
+        WebShellSessionPage: {
+            data: components["schemas"]["WebShellSession"][];
+            nextCursor?: string | null;
+            hasMore: boolean;
+        };
+        WebShellTranscript: {
+            items: components["schemas"]["WebShellItem"][];
+            events: components["schemas"]["WebShellEvent"][];
+            /** Format: int64 */
+            coveredSequence: number;
+            olderCursor?: string | null;
+            hasMore: boolean;
+            /** Format: int64 */
+            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 */
+            snapshotThroughSequence: number;
+            /** @constant */
+            action: "reload_snapshot";
+        };
+        ErrorEnvelope: {
+            error: {
+                code: string;
+                message: string;
+                request_id: string;
+                /** Format: int64 */
+                replay_floor_sequence?: number | null;
+                /** Format: int64 */
+                snapshot_through_sequence?: number | null;
+            };
+        };
+        /**
+         * @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;
+        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";
+        };
+        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 Read/Write/Edit Turn at creation; later submit, cancel and lifecycle operations remain gated. */
+                workspaceBinding: 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;
+        };
+        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/cancel completion is command acceptance, not Turn completion or physical stop. 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. */
+        WebShellCommandOperation: {
+            operationId: string;
+            /** Format: uuid */
+            sessionId: string;
+            /** @enum {unknown} */
+            type: "create_session" | "submit_input" | "cancel" | "action_response" | "close" | "archive" | "delete" | "task_cancel";
+            /** @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. */
+            failureCode?: string;
+            replayed: boolean;
+        } & (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;
+            questions: components["schemas"]["WebShellActionQuestion"][];
+        } & unknown;
+        /** @description At most one requested Hosted approval per Turn. allow and deny are stable option IDs. Tool arguments are read from Items by function_call_id (functionCallId in WebShell). 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;
+        } & 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"]["WebShellCommandOperation"];
+        WebShellActionQueryRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            cursor?: string;
+            /** @default 20 */
+            limit?: number;
+        };
+        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;
+        };
+        WebShellWorkspaceQueryRequest: {
+            cursor?: string | null;
+            /** @default 50 */
+            limit?: number | null;
+        };
+        WebShellWorkspaceGetRequest: {
+            workspaceId: string;
+        };
+        /** @enum {string} */
+        TaskKind: "child_agent" | "workflow" | "background_shell" | "monitor" | "automation_run";
+        /**
+         * @description Logical run state. completed, failed and cancelled are terminal and are set only after the physical execution has 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; 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;
+            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 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"][];
+        } & (unknown & unknown & unknown & unknown);
+        WebShellTaskPage: {
+            data: components["schemas"]["WebShellTask"][];
+            hasMore: boolean;
+            nextCursor?: string | null;
+        } & unknown;
+        WebShellTaskQueryRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            cursor?: string;
+            /** @default 20 */
+            limit?: number;
+        };
+        WebShellTaskGetRequest: {
+            /** Format: uuid */
+            sessionId: string;
+            taskId: 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. */
+        Forbidden: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+        /** @description A trusted actor is required for this request but none was supplied. */
+        Unauthorized: {
+            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. */
+        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 A dependency such as the Hosted Harness is unavailable; retry later. */
+        Unavailable: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components["schemas"]["ErrorEnvelope"];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: {
+        /** @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"];
+            403: components["responses"]["Forbidden"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    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"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    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"];
+            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"]["WebShellAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"]["WebShellAdmission"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"];
+            /** @description Responding requires the Session creator (action_forbidden). */
+            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"];
+        };
+    };
+    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"];
+            /** @description Responding requires the Session creator (action_forbidden). */
+            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"];
+        };
+    };
+    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"];
+            /** @description Responding requires the Session creator (action_forbidden). */
+            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 or an ended Action (action_expired, action_cancelled, action_already_resolved). */
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+    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"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+        };
+    };
+}