@qwen-code/web-shell 0.24.7 → 0.25.0-nightly.20261009.085a44f336

package/dist/types/components/workspace-agents/ThreadsPage.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ConnectExistingInput, type JoinCoordinatorInput, type JoinToken } from './add-runtime-dialog';
+import { type AgentShare, type AgentShareSummary } from './share-agent-dialog';
+import { type AgentProgramView } from './agents-view-logic';
+import { type SquadsSectionProps } from './squads-section';
+/**
+ * A change to one agent's configuration. Absent leaves a field alone; `null`
+ * clears the override and returns the agent to what its definition says.
+ */
+export interface AgentConfigPatch {
+    description?: string | null;
+    color?: string | null;
+    model?: string | null;
+    instructions?: string | null;
+    agentType?: string | null;
+    maxConcurrentRuns?: number | null;
+    execution?: {
+        mode: 'local';
+        /** Program on this computer; Qwen Code when absent. */
+        provider?: AgentProgramView;
+    } | {
+        mode: 'managed-host';
+        hostIds: string[];
+        provider?: AgentProgramView;
+    };
+}
+export interface ThreadsPageProps {
+    onConnectRemoteHost?: (input: ConnectExistingInput) => Promise<boolean>;
+    /** Joins this daemon to another coordinator as one of its runtimes. */
+    onJoinCoordinator?: (input: JoinCoordinatorInput) => Promise<boolean>;
+    agents: readonly WorkspaceAgentSummaryView[];
+    runtimes?: readonly WorkspaceAgentRuntimeView[];
+    view: AgentWorkspaceView;
+    onViewChange: (view: AgentWorkspaceView) => void;
+    /**
+     * Puts `@name ` into the chat composer. Absent hides the agent card's
+     * mention button.
+     */
+    onMentionAgent?: (name: string) => void;
+    onDeleteAgent: (agentId: string) => void;
+    onSetAgentEnabled: (agentId: string, enabled: boolean) => void;
+    onUpdateAgent?: (agentId: string, patch: AgentConfigPatch) => void;
+    onOpenAgentBuilder?: (hostId?: string) => void;
+    onOpenDefinitions?: () => void;
+    /** Issues a single-use join token for the Add runtime dialog. */
+    onCreateJoinToken?: (supersedesHostId?: string) => Promise<JoinToken>;
+    onRemoveRuntime?: (hostId: string) => void;
+    hostServerUrl?: string;
+    /** A2A shares of one agent; absent hides Share. */
+    shares?: {
+        create: (agentId: string) => Promise<AgentShare>;
+        list: (agentId: string) => Promise<AgentShareSummary[]>;
+        revoke: (agentId: string, callerId: string) => Promise<unknown>;
+    };
+    /**
+     * The workspace's squads and their actions. Absent (a daemon without squad
+     * routes, or not loaded yet) shows the Squads view empty, with no New squad.
+     */
+    squads?: Pick<SquadsSectionProps, 'squads' | 'onCreate' | 'onUpdate' | 'onRetire'>;
+    pending?: boolean;
+}
+export interface WorkspaceAgentSummaryView {
+    id: string;
+    name: string;
+    description?: string;
+    color?: string;
+    /** Definition supplying the persona. Absent uses the workspace default. */
+    agentType?: string;
+    model?: string;
+    /** What this identity is told on top of its definition's prompt. */
+    instructions?: string;
+    maxConcurrentRuns?: number;
+    execution?: AgentConfigPatch['execution'];
+    enabled: boolean;
+    status: 'offline' | 'idle' | 'working' | 'error';
+    /** Absent from a daemon older than runtimes; that agent runs here. */
+    runtime?: WorkspaceAgentRuntimeView;
+    /** Set once the identity is retired: it keeps its posts and takes no work. */
+    retiredAt?: number;
+    /** Queued session-agent runs waiting for this agent. */
+    waiting: number;
+}
+export interface WorkspaceAgentRuntimeView {
+    id: string;
+    kind: 'local' | 'external';
+    label: string;
+    provider: string;
+    /**
+     * Program ids (`qwen` | `claude` | `codex`) the runtime reported it can run,
+     * the local daemon included (from its program probe). None means Qwen Code.
+     */
+    programs?: readonly string[];
+    status: 'online' | 'offline';
+    workspaceId?: string;
+    workspaceCwd?: string;
+    lastSeenAt?: number;
+    agentCount?: number;
+    sessionCount?: number;
+    runningTaskCount?: number;
+    queuedTaskCount?: number;
+}
+export type AgentWorkspaceView = 'agents' | 'squads' | 'runtime';
+export interface NewWorkspaceAgent {
+    name: string;
+    description?: string;
+    agentType?: string;
+    model?: string;
+    instructions?: string;
+    maxConcurrentRuns?: number;
+    execution?: AgentConfigPatch['execution'];
+}
+/**
+ * The Agents page: the workspace's agent roster, its squads, and the runtimes
+ * agents run on.
+ * Agents are addressed by @-mention in a chat session; this page only manages
+ * who they are and where they run.
+ */
+export declare function ThreadsPage({ agents, runtimes, view, onViewChange, onMentionAgent, onDeleteAgent, onSetAgentEnabled, onUpdateAgent, onOpenAgentBuilder, onOpenDefinitions, onCreateJoinToken, onRemoveRuntime, onConnectRemoteHost, onJoinCoordinator, hostServerUrl, shares, squads, pending, }: ThreadsPageProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/add-runtime-dialog.d.ts

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface RuntimeSummary {
+    id: string;
+    kind: 'local' | 'external';
+    label: string;
+    provider: string;
+    /** Program ids the runtime reported it can run. */
+    programs?: readonly string[];
+    status: 'online' | 'offline';
+}
+export interface JoinToken {
+    token: string;
+    workspaceId: string;
+    expiresAt: number;
+    replacementHostId?: string;
+}
+export interface ConnectExistingInput {
+    remoteUrl: string;
+    remoteToken: string;
+    remoteCwd: string;
+    serverUrl: string;
+    allowHttp: boolean;
+}
+/** `POST /hosts/connect`: this daemon joins another coordinator as a runtime. */
+export interface JoinCoordinatorInput {
+    serverUrl: string;
+    workspaceId: string;
+    enrollmentToken: string;
+    allowHttp: boolean;
+}
+/**
+ * Reads the link a coordinator shows under Runtime › Add runtime,
+ * `<coordinator URL>/join/<workspace id>`. Same rules as `parseJoinLink` in
+ * `packages/cli/src/serve/agent-host-join.ts` (keep the two in step); returns
+ * undefined instead of throwing so a form can validate as the user types.
+ */
+export declare function parseJoinLink(link: string): {
+    serverUrl: string;
+    workspaceId: string;
+} | undefined;
+/**
+ * The terminal equivalent of "Join a coordinator": `qwen agents join <link>`
+ * asks the running local `qwen serve` to join with the same link (it calls
+ * that daemon's `/hosts/connect`, exactly as this dialog does). The token
+ * rides in the environment, never in argv.
+ */
+export declare function joinCoordinatorCommand(link: string, token: string, allowHttp: boolean): string;
+export declare function findReplacementRuntime(runtimes: readonly RuntimeSummary[], knownIds: ReadonlySet<string>, supersededHostId: string, replacementHostId?: string): RuntimeSummary | undefined;
+export declare function joinCommands(address: string, join: JoinToken): {
+    qwen: string;
+    npx: string;
+    insecure: boolean;
+};
+/**
+ * "Add runtime": hand another machine a one-line command, then wait for it to
+ * show up. The dialog notices the new runtime through the same roster poll
+ * that updates the Runtime tab, so it flips from waiting to connected by
+ * itself (the Tailscale/Vercel "add device" pattern).
+ */
+export declare function AddRuntimeDialog({ open, onOpenChange, serverUrl, runtimes, onCreateJoinToken, onConnectExisting, onJoinCoordinator, onCreateAgentOn, replacementTarget, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The coordinator address this page talks to; the link's default. */
+    serverUrl: string;
+    runtimes: readonly RuntimeSummary[];
+    onCreateJoinToken: (supersedesHostId?: string) => Promise<JoinToken>;
+    onConnectExisting?: (input: ConnectExistingInput) => Promise<boolean>;
+    /** Joins THIS daemon to another coordinator; absent hides that entry. */
+    onJoinCoordinator?: (input: JoinCoordinatorInput) => Promise<boolean>;
+    onCreateAgentOn?: (runtimeId: string) => void;
+    replacementTarget?: RuntimeSummary;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/agent-events.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Client for the session-agents stream under `/workspaces/:ws/agent/`
+ * (`session-events?sessionId=`: a chat session's live agent runs). The roster
+ * has no stream; the Agents page polls it.
+ *
+ * `fetch` rather than `EventSource`: the daemon wants a bearer header, which
+ * `EventSource` cannot send. Frames are plain `event:` + one `data:` line.
+ */
+export type AgentStreamState = 'open' | 'closed';
+/**
+ * Subscribes to a workspace's stream. Subscribers of the same URL share one
+ * connection: browsers allow only a handful per origin, and the sidebar plus
+ * an open conversation would otherwise hold several for the same workspace.
+ */
+export declare function subscribeAgentStream<T = unknown>(url: string, token: string | undefined, onEvent: (event: T) => void, onState: (state: AgentStreamState) => void): () => void;

package/dist/types/components/workspace-agents/agents-route.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type AgentWorkspaceView } from './ThreadsPage';
+export interface AgentsRouteProps {
+    /** `new-agent` opens straight into the New agent page. */
+    initialView?: AgentWorkspaceView | 'new-agent';
+    workspaceCwd?: string;
+    onOpenDefinitions?: () => void;
+    /** Puts `@name ` into the chat composer; absent hides the card button. */
+    onMentionAgent?: (name: string) => void;
+}
+/**
+ * The Agents page with its data: the workspace's roster and runtimes, kept
+ * fresh by polling.
+ */
+export declare function AgentsRoute({ initialView, workspaceCwd: boundWorkspaceCwd, onOpenDefinitions, onMentionAgent, }: AgentsRouteProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/agents-view-logic.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @fileoverview Presentation logic for the Agents page (roster and runtimes).
+ *
+ * Everything here is pure and testable without a browser, following the same
+ * split as `agents-manager-logic.ts`.
+ */
+/**
+ * The programs an agent can run as. Mirrors `SessionAgentProgram` in
+ * `@qwen-code/sdk/daemon`; a runtime reports which of them it can run.
+ */
+export declare const AGENT_PROGRAMS: readonly ["qwen", "claude", "codex"];
+export type AgentProgramView = (typeof AGENT_PROGRAMS)[number];
+export declare function programLabel(program: string | undefined): string;
+/** Narrows a server-sent program id; anything unknown is dropped. */
+export declare function isAgentProgram(value: unknown): value is AgentProgramView;
+/**
+ * The programs a runtime offers, in display order. An omitted field keeps the
+ * older daemon's Qwen default; an explicit empty list offers no programs.
+ */
+export declare function runtimePrograms(runtime: {
+    programs?: readonly string[];
+}): AgentProgramView[];
+type Translate = (key: string, vars?: Record<string, string | number>) => string;
+/** "45 秒" or "6 分 45 秒": the one duration format the collaboration UI uses. */
+export declare function formatElapsed(ms: number, t: Translate): string;
+export {};

package/dist/types/components/workspace-agents/lazy-agents-route.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AgentsRouteProps } from './agents-route';
+export declare function LazyAgentsRoute(props: AgentsRouteProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/messages.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Agent collaboration strings (the Agents page, agents' live runs in a chat
+ * session, the @ picker's agent entries). Kept out of the main dictionary like Live
+ * Voice's: an exported transcript never renders these surfaces, so
+ * `vite.lib.config.ts` resolves this module to `messages.transcript-stub.ts`
+ * in `--mode transcript` and the transcript bundle stays within its budget.
+ */
+type CollabMessage = string | ((vars?: Record<string, string | number>) => string);
+export declare const COLLAB_MESSAGES_EN: Record<string, CollabMessage>;
+export declare const COLLAB_MESSAGES_ZH: Record<string, CollabMessage>;
+export {};

package/dist/types/components/workspace-agents/messages.transcript-stub.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Stands in for `./messages` in the transcript build (`--mode transcript`).
+ * The transcript renderer has no collaboration surface, so its dictionary
+ * carries none of those strings.
+ */
+export declare const COLLAB_MESSAGES_EN: {};
+export declare const COLLAB_MESSAGES_ZH: {};

package/dist/types/components/workspace-agents/session-agent-live-runs.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionAgentPermissionPrompt, SessionAgentRunFrame } from '@qwen-code/sdk/daemon';
+import type { PermissionRequest } from '../../adapters/types';
+import { useI18n } from '../../i18n';
+type Translate = ReturnType<typeof useI18n>['t'];
+/** No agent activity for this long: say it may be stuck. */
+export declare const STALL_NOTICE_MS: number;
+/**
+ * One line saying where a live run is. Returns `attention` for the states the
+ * user should notice (stuck, failed, offline).
+ */
+export declare function describeRun(run: SessionAgentRunFrame, now: number, t: Translate): {
+    text?: string;
+    attention: boolean;
+};
+/** Client-side cap on a tool input preview (the daemon bounds it too). */
+export declare const INPUT_PREVIEW_MAX_CHARS = 4000;
+/**
+ * The run's permission prompt as the main chat's approval card reads it. A
+ * shell tool shows its command as the main chat's shell approval does; any
+ * other tool shows its input preview in the card's monospace content block.
+ */
+export declare function toApprovalRequest(permission: SessionAgentPermissionPrompt, agent: string, t: Translate): PermissionRequest;
+/**
+ * A finished run the daemon offers to run again (`retryable`): failed by a
+ * restart, offline, or one whose record a restart lost. Never a stopped one.
+ */
+export declare function canRetryRun(run: SessionAgentRunFrame): boolean;
+/** A delegated member in a squad engagement. */
+export interface SquadMemberView {
+    name: string;
+    /** The agent's color, tinting its avatar as on its replies. */
+    color?: string;
+    /** `replied`: its run completed and its reply is on the way to the leader. */
+    state: 'working' | 'replied';
+}
+/** One squad engagement as the live runs show it. */
+export interface SquadEngagementView {
+    squadId: string;
+    squadName: string;
+    /** The leader, while its squad-mode run is queued or running. */
+    leader?: string;
+    leaderColor?: string;
+    /** Delegated members, in arrival order. */
+    members: SquadMemberView[];
+}
+/**
+ * Squad engagements under way in this session, derived from live run frames
+ * carrying `squadId`: a leader run names its squad on its author; a member
+ * run the leader waits on carries the squad id (and name) on the frame. A
+ * member's completed frame keeps them while its record is pending, which is
+ * the only time a finished run is still in the list: that member `replied`.
+ */
+export declare function squadEngagements(runs: readonly SessionAgentRunFrame[]): SquadEngagementView[];
+/**
+ * A small bar per active squad engagement: the squad's tag, then one entry per
+ * participant (avatar, name, state): the leader "deciding", a member working
+ * (spinner) or replied (check).
+ */
+export declare function SquadEngagementBar({ runs, }: {
+    runs: readonly SessionAgentRunFrame[];
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The session's live agent runs, rendered at the bottom of the message list as
+ * the agents' messages-in-progress. Each is replaced by the agent's recorded
+ * reply once that lands in the transcript.
+ *
+ * Mounted only by App (through MessageList's `tailContent`), never by the
+ * exported transcript, so it may use the collaboration dictionary.
+ */
+export declare function SessionAgentLiveRuns({ runs, onCancel, onRespond, onRetry, }: {
+    runs: readonly SessionAgentRunFrame[];
+    onCancel: (runId: string) => Promise<void>;
+    onRespond: (runId: string, requestId: string, optionId: string) => Promise<void>;
+    /** Offered on a failed run the daemon marked retryable. */
+    onRetry?: (runId: string) => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * The user's @-mentions the daemon holds until the running main-model turn
+ * settles, shown as their messages until the recorded ones replace them.
+ */
+export declare function PendingAgentMentions({ mentions, }: {
+    mentions: ReadonlyArray<{
+        id: string;
+        text: string;
+    }>;
+}): import("react/jsx-runtime").JSX.Element | null;
+/** Shown near the composer while any agent in this session is working. */
+export declare function StopAllAgentsButton({ onStopAll, }: {
+    onStopAll: () => Promise<void>;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/workspace-agents/session-agents-api.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionAgentEventFrame, SessionAgentRunFrame, SessionAgentRunStatus } from '@qwen-code/sdk/daemon';
+import { type AgentStreamState } from './agent-events';
+/** 202 body of `POST sessions/:sessionId/mentions`. */
+export interface SessionMentionResult {
+    recordId: string;
+    deferred?: boolean;
+    runs: Array<{
+        runId: string;
+        agentId: string;
+        status: SessionAgentRunStatus;
+    }>;
+    /** Why some mentioned squads were not started (the others were). */
+    squadError?: string;
+}
+/**
+ * The session-scoped collaboration routes: agents answering @-mentions inside
+ * an ordinary chat session.
+ */
+export interface SessionAgentsApi {
+    listRuns(sessionId: string): Promise<{
+        frames: SessionAgentRunFrame[];
+    }>;
+    mention(sessionId: string, input: {
+        text: string;
+        clientMessageId: string;
+    }): Promise<SessionMentionResult>;
+    cancelRun(sessionId: string, runId: string): Promise<unknown>;
+    /** Runs a failed run marked `retryable` again. */
+    retryRun(sessionId: string, runId: string): Promise<unknown>;
+    stopAll(sessionId: string): Promise<unknown>;
+    respondToPermission(sessionId: string, runId: string, requestId: string, optionId: string): Promise<unknown>;
+    subscribe(sessionId: string, onEvent: (event: SessionAgentEventFrame) => void, onState: (state: AgentStreamState) => void): () => void;
+}
+export declare function createSessionAgentsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): SessionAgentsApi;

package/dist/types/components/workspace-agents/share-agent-dialog.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** What the daemon returns for a new share; the secret is shown once. */
+export interface AgentShare {
+    endpoint: string;
+    workspaceId: string;
+    callerId: string;
+    agentId: string;
+    secret: string;
+    expiresAt?: number;
+}
+export interface AgentShareSummary {
+    callerId: string;
+    createdAt: number;
+    expiresAt?: number;
+}
+/**
+ * Share one agent with a caller outside this workspace over A2A. The agent
+ * runs under its live workspace configuration; the caller gets an endpoint,
+ * a token shown once and a one-line test. Each share is its own grant, so
+ * revoking one leaves the others working.
+ */
+export declare function ShareAgentDialog({ agentName, open, onOpenChange, onCreate, onList, onRevoke, }: {
+    agentName: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreate: () => Promise<AgentShare>;
+    onList: () => Promise<AgentShareSummary[]>;
+    onRevoke: (callerId: string) => Promise<unknown>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/squads-section.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SessionSquadView } from '@qwen-code/sdk/daemon';
+import type { WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { SquadInput } from './threads-api';
+export interface SquadsSectionProps {
+    squads: readonly SessionSquadView[];
+    agents: readonly WorkspaceAgentSummaryView[];
+    pending?: boolean;
+    /** The New squad form is open (its button is in the page header). */
+    creating: boolean;
+    onCreatingChange: (creating: boolean) => void;
+    onCreate: (input: SquadInput) => Promise<boolean>;
+    onUpdate: (squadId: string, input: SquadInput) => Promise<boolean>;
+    onRetire: (squadId: string) => void;
+    /** Puts `@name ` into the chat composer; absent hides the button. */
+    onMention?: (name: string) => void;
+}
+/** No squads (or a daemon without squad routes). */
+export declare function SquadsEmpty(): import("react/jsx-runtime").JSX.Element;
+/**
+ * The Agents page's Squads view: list, create, edit, retire. A squad is
+ * addressed by `@name` in a chat, which wakes its leader (session-multi-agent design §11.5).
+ */
+export declare function SquadsSection({ squads, agents, pending, creating, onCreatingChange, onCreate, onUpdate, onRetire, onMention, }: SquadsSectionProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/workspace-agents/threads-api.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AgentConfigPatch, NewWorkspaceAgent, WorkspaceAgentRuntimeView, WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { ConnectExistingInput, JoinCoordinatorInput, JoinToken } from './add-runtime-dialog';
+import type { AgentShare, AgentShareSummary } from './share-agent-dialog';
+import type { SessionSquadView } from '@qwen-code/sdk/daemon';
+/** Body of a squad create; on update, `null` clears a text field. */
+export interface SquadInput {
+    name: string;
+    description: string | null;
+    instructions: string | null;
+    leaderAgentId: string;
+    members: Array<{
+        agentId: string;
+        role?: string;
+    }>;
+}
+/** Agent roster, runtimes, enrollment and sharing for one workspace. */
+export interface ThreadsApi {
+    connectRemoteHost?(input: ConnectExistingInput): Promise<unknown>;
+    /** Makes this daemon a runtime of another coordinator. */
+    joinCoordinator?(input: JoinCoordinatorInput): Promise<unknown>;
+    listAgents(): Promise<{
+        agents: WorkspaceAgentSummaryView[];
+        runtime?: WorkspaceAgentRuntimeView;
+        runtimes?: WorkspaceAgentRuntimeView[];
+    }>;
+    /** A single-use token for `qwen serve --join` on another machine. */
+    createJoinToken?(supersedesHostId?: string): Promise<JoinToken>;
+    removeHost?(hostId: string): Promise<unknown>;
+    createShare?(agentId: string): Promise<AgentShare>;
+    listShares?(agentId: string): Promise<{
+        shares: AgentShareSummary[];
+    }>;
+    revokeShare?(agentId: string, callerId: string): Promise<unknown>;
+    createAgent(input: NewWorkspaceAgent): Promise<unknown>;
+    deleteAgent(id: string): Promise<unknown>;
+    setAgentEnabled(id: string, enabled: boolean): Promise<unknown>;
+    updateAgent(id: string, patch: AgentConfigPatch): Promise<unknown>;
+    /** Squads; absent on a daemon without them. */
+    listSquads?(): Promise<{
+        squads: SessionSquadView[];
+    }>;
+    createSquad?(input: SquadInput): Promise<unknown>;
+    updateSquad?(id: string, input: Partial<SquadInput>): Promise<unknown>;
+    /** Retires the squad (it keeps its name and history). */
+    retireSquad?(id: string): Promise<unknown>;
+}
+export declare function createThreadsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): ThreadsApi;

package/dist/types/components/workspace-agents/use-session-agent-runs.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonTranscriptBlock, type SessionAgentRunFrame, type SessionAgentRunStatus } from '@qwen-code/sdk/daemon';
+import type { SessionAgentsApi } from './session-agents-api';
+export declare function isTerminalRunStatus(status: SessionAgentRunStatus): boolean;
+/**
+ * The runs whose `agent_message` is already in the transcript, as one string
+ * (run ids joined by newlines) so a caller can memoize a Set on it: the blocks
+ * change on every streamed delta, the answer almost never.
+ */
+export declare function settledAgentRunKey(blocks: readonly DaemonTranscriptBlock[]): string;
+interface TrackedFrame {
+    frame: SessionAgentRunFrame;
+    /** Arrival order, so the list does not reshuffle as frames update. */
+    order: number;
+    /**
+     * The run is off the screen for good: its record is in the transcript, or
+     * none will be written. Kept, slimmed, so that a stale snapshot cannot put
+     * the card back.
+     */
+    settled?: true;
+}
+export type RunFrameMap = ReadonlyMap<string, TrackedFrame>;
+/**
+ * Whether a frame ends the run's card (contract `recorded`): a terminal frame
+ * keeps it only while `recorded` is `false` (record pending, or the run is
+ * retryable). `true` means the record now renders; absent means none will be
+ * written (cancelled while queued, dismissed, retried).
+ */
+export declare function isSettledRunFrame(frame: SessionAgentRunFrame): boolean;
+/**
+ * Folds one frame into the map. A frame seen twice (the stream opens with a
+ * snapshot that a GET may already have delivered) is harmless; an older frame
+ * never overwrites a newer one, a terminal run never comes back to life, and
+ * a settled run stays settled (a snapshot polled before the record landed can
+ * arrive after the frame that settled it).
+ */
+export declare function applyRunFrame(current: RunFrameMap, frame: SessionAgentRunFrame, order: number): RunFrameMap;
+/**
+ * Settles runs whose `agent_message` the transcript already shows (it can
+ * land before the frame that says so). Returns `current` when nothing
+ * changed.
+ */
+export declare function pruneRunFrames(current: RunFrameMap, settledRunIds: ReadonlySet<string>): RunFrameMap;
+/**
+ * Live agent runs of one chat session: the `runs` snapshot, then the
+ * `session-events` stream. A run keeps its card, finished or not, until a
+ * frame settles it (see {@link isSettledRunFrame}) or its `agent_message`
+ * shows up in the transcript (`settledRunIds`), which is what replaces it on
+ * screen. A finished run whose record waits behind a main-model turn, or a
+ * run a daemon restart cut short, stays until then.
+ */
+export declare function useSessionAgentRuns({ api, sessionId, settledRunIds, }: {
+    api: SessionAgentsApi | undefined;
+    sessionId: string | undefined;
+    settledRunIds: ReadonlySet<string>;
+}): {
+    runs: SessionAgentRunFrame[];
+    anyLive: boolean;
+    /** Runs a `retryable` run again; rejects when the daemon refuses. */
+    retry: (runId: string) => Promise<void>;
+};
+export {};