@qwen-code/web-shell 0.24.6 → 0.24.7-nightly.20260929.b906f937ec

package/dist/types/components/managed/java-managed-agent-client.d.ts

@@ -1,80 +1,27 @@
+import type { components } from './generated/managed-agent-api';
+type Schemas = components['schemas'];
 export type JavaAgentDate = number | string;
-export interface JavaAgentTurn {
-    turnId: string;
-    sessionId: string;
-    status: string;
-    submittedAt: JavaAgentDate;
-    completedAt?: JavaAgentDate;
-    errorCode?: string;
-    usage?: Record<string, unknown>;
-}
+export type JavaAgentTurn = Schemas['WebShellTurn'];
 export interface JavaAgentEnvironment {
     environmentId?: string;
     state?: string;
     errorCode?: string;
 }
-export interface JavaAgentSession {
-    sessionId: string;
-    title?: string;
-    agentId?: string;
-    status: string;
-    createdAt: JavaAgentDate;
-    updatedAt: JavaAgentDate;
-    activeTurn?: JavaAgentTurn;
-    environment?: JavaAgentEnvironment;
-    lastSequence: number;
-}
-export interface JavaAgentEvent {
-    sequence: number;
-    eventId: string;
-    sessionId: string;
-    turnId: string;
-    itemId?: string;
-    type: string;
-    createdAt: JavaAgentDate;
-    data?: Record<string, unknown>;
-    terminal: boolean;
-}
-export interface JavaAgentContentPart {
-    partId: string;
-    type: 'input_text' | 'output_text' | 'reasoning' | string;
-    text: string;
-    firstSequence: number;
-    lastSequence: number;
-}
-export interface JavaAgentItem {
-    itemId: string;
-    sessionId: string;
-    turnId: string;
-    type: 'message' | 'tool_call' | string;
-    role?: string;
-    status: string;
-    content: JavaAgentContentPart[];
-    attributes: Record<string, unknown>;
-    firstSequence: number;
-    lastSequence: number;
-    createdAt: JavaAgentDate;
-    updatedAt: JavaAgentDate;
-}
-export interface JavaAgentCommandAdmission {
-    sessionId: string;
-    turnId?: string;
-    status: string;
-    replayed: boolean;
-}
-export interface JavaAgentCursorPage<T> {
-    data: T[];
-    nextCursor?: string;
-    hasMore: boolean;
-}
-export interface JavaAgentTranscript {
-    items?: JavaAgentItem[];
-    events: JavaAgentEvent[];
-    coveredSequence?: number;
-    olderCursor?: string;
-    hasMore: boolean;
-    lastSequence: number;
-}
+export type JavaAgentSession = Omit<Schemas['WebShellSession'], 'environment'> & {
+    environment?: JavaAgentEnvironment | null;
+};
+export type JavaAgentWorkspace = Schemas['WebShellWorkspace'];
+export type JavaAgentWorkspacePage = Schemas['WebShellWorkspacePage'];
+export type JavaAgentSessionPage = Omit<Schemas['WebShellSessionPage'], 'data'> & {
+    data: JavaAgentSession[];
+};
+export type JavaAgentEvent = Schemas['WebShellEvent'];
+export type JavaAgentResyncRequired = Schemas['WebShellResyncRequired'];
+export declare function isJavaAgentResyncRequired(frame: JavaAgentEvent | JavaAgentResyncRequired): frame is JavaAgentResyncRequired;
+export type JavaAgentContentPart = Schemas['WebShellContentPart'];
+export type JavaAgentItem = Schemas['WebShellItem'];
+export type JavaAgentCommandAdmission = Schemas['WebShellAdmission'];
+export type JavaAgentTranscript = Schemas['WebShellTranscript'];
 export interface JavaManagedAgentClientOptions {
     baseUrl: string;
     getHeaders?: () => HeadersInit | Promise<HeadersInit>;
@@ -92,49 +39,21 @@ export declare class JavaManagedAgentClient {
     private readonly fetchImpl;
     private readonly credentials;
     constructor(options: JavaManagedAgentClientOptions);
-    listSessions(request: {
-        cursor?: string;
-        limit?: number;
-    }, signal?: AbortSignal): Promise<JavaAgentCursorPage<JavaAgentSession>>;
+    listSessions(request: Schemas['WebShellListRequest'], signal?: AbortSignal): Promise<JavaAgentSessionPage>;
     getSession(sessionId: string, signal?: AbortSignal): Promise<JavaAgentSession>;
-    getTranscript(request: {
-        sessionId: string;
-        cursor?: string;
-        limit?: number;
-    }, signal?: AbortSignal): Promise<JavaAgentTranscript>;
-    createSession(request: {
-        requestId: string;
-        idempotencyKey: string;
-        agentId: string;
-        environmentId?: string;
-        title?: string;
-        input: Array<{
-            type: 'text';
-            text: string;
-        }>;
-        metadata?: Record<string, unknown>;
-    }, signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
-    submitTurn(request: {
-        requestId: string;
-        idempotencyKey: string;
-        sessionId: string;
-        input: Array<{
-            type: 'text';
-            text: string;
-        }>;
-        metadata?: Record<string, unknown>;
-    }, signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
-    cancelTurn(request: {
-        requestId: string;
-        idempotencyKey: string;
-        sessionId: string;
-        turnId: string;
-    }, signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
-    streamEvents(request: {
-        sessionId: string;
-        afterSequence?: number;
-        limit?: number;
-    }, signal?: AbortSignal): AsyncGenerator<JavaAgentEvent>;
+    listWorkspaces(request: Schemas['WebShellWorkspaceQueryRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspacePage>;
+    getWorkspace(workspaceId: string, signal?: AbortSignal): Promise<{
+        workspaceId: string;
+        displayName: string;
+        canCreateSession: boolean;
+        state: "active" | "draining" | "removed";
+    }>;
+    getTranscript(request: Schemas['WebShellTranscriptRequest'], signal?: AbortSignal): Promise<JavaAgentTranscript>;
+    createSession(request: Schemas['WebShellCreateRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    submitTurn(request: Schemas['WebShellSubmitRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    cancelTurn(request: Schemas['WebShellCancelRequest'], signal?: AbortSignal): Promise<JavaAgentCommandAdmission>;
+    streamEvents(request: Schemas['WebShellStreamRequest'], signal?: AbortSignal): AsyncGenerator<JavaAgentEvent | JavaAgentResyncRequired>;
     private post;
     private request;
 }
+export {};

package/dist/types/components/managed/java-managed-agent-provider.d.ts

@@ -4,5 +4,6 @@ export interface JavaManagedAgentProviderOptions extends JavaManagedAgentClientO
     agentId?: string;
     environmentId?: string;
     productScope?: string;
+    enableWorkspaceBinding?: boolean;
 }
 export declare function createJavaManagedAgentProvider(options: JavaManagedAgentProviderOptions): ManagedAgentProvider;

package/dist/types/components/managed/managed-agent-provider.d.ts

@@ -1,10 +1,14 @@
-export type ManagedAgentSessionPhase = 'admitted' | 'runtime_starting' | 'agent_running' | 'waiting_runtime' | 'tool_running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
+export type ManagedAgentSessionPhase = 'created' | 'admitted' | 'runtime_starting' | 'agent_running' | 'waiting_runtime' | 'tool_running' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
 export type ManagedAgentRuntimeState = 'unknown' | 'starting' | 'ready' | 'failed';
 export interface ManagedAgentSessionSummary {
     sessionId: string;
     activeTurnId?: string;
     title: string;
     workspaceCwd?: string;
+    workspace?: {
+        workspaceId: string;
+        cwdRelative: string;
+    };
     createdAt: number;
     admittedAt: number;
     updatedAt: number;
@@ -50,6 +54,26 @@ export interface ManagedAgentProvider {
     readonly storageKey: string;
     readonly canCancel: boolean;
     readonly acceptsWorkspaceCwd: boolean;
+    readonly workspaceBinding?: {
+        readonly agentId: string;
+        list(options: ManagedAgentRequestOptions & {
+            cursor?: string;
+            limit?: number;
+        }): Promise<{
+            data: ManagedAgentWorkspace[];
+            defaultWorkspace?: ManagedAgentWorkspace | null;
+            nextCursor?: string;
+            supported: boolean;
+        }>;
+        get(workspaceId: string, options: ManagedAgentRequestOptions): Promise<ManagedAgentWorkspace>;
+        createEmpty(request: {
+            agentId: string;
+            workspaceId: string;
+            cwdRelative: string;
+        }, options: ManagedAgentCommandOptions): Promise<{
+            sessionId: string;
+        }>;
+    };
     listSessions(options: ManagedAgentRequestOptions & {
         workspaceCwd?: string;
         limit?: number;
@@ -75,3 +99,9 @@ export interface ManagedAgentProvider {
         lastEventId?: number;
     }): AsyncIterable<ManagedAgentSessionEvent>;
 }
+export interface ManagedAgentWorkspace {
+    workspaceId: string;
+    displayName: string;
+    state: string;
+    canCreateSession: boolean;
+}

package/dist/types/components/messages/AssistantMessage.d.ts

@@ -1,7 +1,9 @@
 import { type WebShellAssistantFeedbackRating, type WebShellAssistantTurnFooterRenderInfo, type WebShellSource } from '../../customization';
 import type { DaemonSessionGenerationEvent } from '@qwen-code/sdk/daemon';
+import type { DaemonMessageAuthor } from '../../adapters/messageTypes';
 interface AssistantMessageProps {
     content: string;
+    author?: DaemonMessageAuthor;
     isStreaming?: boolean;
     timestamp?: number;
     onBranchSession?: () => void | Promise<void>;
@@ -19,6 +21,7 @@ interface AssistantMessageProps {
 export declare const AssistantMessage: import("react").NamedExoticComponent<AssistantMessageProps>;
 interface ThinkingMessageProps {
     content: string;
+    author?: DaemonMessageAuthor;
     isStreaming?: boolean;
     timestamp?: number;
     isLocateFlashing?: boolean;

package/dist/types/components/messages/AuthorAvatar.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The initial of a named assistant voice, tinted with its color when it has
+ * one. The same mark stands for an agent in its replies, the Team panel and
+ * the Agents page, so a reader learns it once.
+ */
+export declare function AuthorAvatar({ name, color, size, className, }: {
+    name: string;
+    color?: string;
+    size?: 'sm' | 'md';
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/messages/McpApp.d.ts

@@ -13,7 +13,7 @@ export interface McpAppDisplay {
     permissions?: SandboxResource['permissions'];
 }
 export declare function getMcpAppDisplay(value: unknown): McpAppDisplay | undefined;
-export declare function resolveMcpAppSandboxUrl(daemonBaseUrl: string, hostUrl: string): string | undefined;
+export declare function resolveMcpAppSandboxUrl(daemonBaseUrl: string, hostUrl: string, dataMode?: boolean): string | undefined;
 export declare function applySandboxCspQuery(sandboxUrl: string, cspJson: string): string;
 export declare function McpApp({ display }: {
     display: McpAppDisplay;

package/dist/types/components/messages/toolFormatting.d.ts

@@ -36,6 +36,8 @@ export declare function getShellToolSemanticDescription(tool: ACPToolCall): stri
 export declare function extractText(tool: ACPToolCall): string | null;
 export declare function getAdvisorDisplayText(tool: ACPToolCall): string | null;
 export declare function getToolResultSummary(tool: ACPToolCall): string;
+export declare function getEmptyMcpToolTitleDescription(toolName: string | undefined, title: string | undefined, input: Record<string, unknown> | undefined): string | undefined;
+export declare function isEmptyMcpToolTitle(toolName: string | undefined, title: string | undefined, input: Record<string, unknown> | undefined): boolean;
 /**
  * Like every other is*ToolName helper, normalizes case so callers can pass
  * the raw wire name. One predicate on purpose: ToolGroup gates the detail

package/dist/types/components/panels/EnvironmentPanel.d.ts

@@ -13,6 +13,7 @@ interface EnvironmentPanelProps {
     workspaceCwd?: string;
     gitWorkspaceCwd?: string;
     gitCwd?: string;
+    gitSessionId?: string;
     branch?: string;
     gitStatus?: DaemonWorkspaceGitStatus;
     tasks: readonly DaemonSessionTaskWithWorkflowStatus[];
@@ -43,5 +44,5 @@ export type EnvironmentAgentTask = DaemonSessionAgentTaskStatus & {
     color?: string;
     lineageState?: 'complete' | 'orphaned' | 'cycle';
 };
-export declare function EnvironmentPanel({ sources, onOpenSource, retrySourceRegistration, floating, hidden, workspaceCwd, gitWorkspaceCwd, gitCwd, branch, gitStatus, tasks, agentTasks, attachments, attachmentsLoading, attachmentsError, onRetryAttachments, artifacts, artifactsLoading, items, onOpenGitDiff, onOpenGitCommit, onOpenGitWorktrees, onOpenGitLog, onOpenAgent, onOpenAgentWorkflow, onOpenTask, onReadImage, onImagePreview, onAttachmentPreview, onAttachmentPreviewError, onOpenArtifact, onDismiss, }: EnvironmentPanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function EnvironmentPanel({ sources, onOpenSource, retrySourceRegistration, floating, hidden, workspaceCwd, gitWorkspaceCwd, gitCwd, gitSessionId, branch, gitStatus, tasks, agentTasks, attachments, attachmentsLoading, attachmentsError, onRetryAttachments, artifacts, artifactsLoading, items, onOpenGitDiff, onOpenGitCommit, onOpenGitWorktrees, onOpenGitLog, onOpenAgent, onOpenAgentWorkflow, onOpenTask, onReadImage, onImagePreview, onAttachmentPreview, onAttachmentPreviewError, onOpenArtifact, onDismiss, }: EnvironmentPanelProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/sidebar/UpdateControl.d.ts

@@ -0,0 +1,10 @@
+import type { DaemonClient } from '@qwen-code/sdk/daemon';
+interface UpdateControlProps {
+    client: Pick<DaemonClient, 'daemonUpdateStatus' | 'prepareDaemonUpdate' | 'restartDaemonForUpdate'>;
+    collapsed: boolean;
+    currentVersion: string;
+    onError: (error: unknown, fallback: string) => void;
+    onRestarted?: (url: string) => void;
+}
+export declare function UpdateControl({ client, collapsed, currentVersion, onError, onRestarted, }: UpdateControlProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/types/components/sidebar/WebShellSidebar.d.ts

@@ -2,7 +2,7 @@ import { type ReactNode } from 'react';
 import { type DaemonWorkspaceCapability } from '@qwen-code/sdk/daemon';
 import { type WebShellTheme } from '../../themeContext';
 import { type WorkspaceManagementTarget, type WorkspaceOverviewItem } from './workspaceOverviewModel';
-export type WebShellSidebarFooterItem = 'settings' | 'version' | 'theme' | 'sessionsOverview' | 'workspacesOverview' | 'splitView' | 'daemonStatus' | 'localFiles' | 'collapse';
+export type WebShellSidebarFooterItem = 'settings' | 'update' | 'version' | 'theme' | 'sessionsOverview' | 'workspacesOverview' | 'splitView' | 'daemonStatus' | 'localFiles' | 'desktopRelay' | 'collapse';
 export interface WebShellSidebarBranding {
     /** Replace the complete top branding row. */
     render?: () => ReactNode;
@@ -15,7 +15,7 @@ export interface WebShellSidebarLockedWorkspace {
         expanded: boolean;
     }) => ReactNode;
 }
-export type WebShellSidebarPrimaryNavItem = 'newTask' | 'plugins' | 'channels' | 'scheduledTasks' | 'workflows' | 'goals' | 'managed';
+export type WebShellSidebarPrimaryNavItem = 'newTask' | 'agents' | 'plugins' | 'channels' | 'scheduledTasks' | 'workflows' | 'goals' | 'managed';
 export interface WebShellSidebarPrimaryNavOptions {
     /** Built-in primary nav entries to show. Defaults to all. */
     items?: readonly WebShellSidebarPrimaryNavItem[];
@@ -54,9 +54,12 @@ export interface WebShellSidebarWorkspaceOverviewOptions {
 }
 export type { WorkspaceManagementTarget, WorkspaceOverviewItem };
 interface WebShellSidebarProps {
+    selectedCollaborationId?: string;
+    onOpenCollaboration?: (id: string, cwd: string) => void;
     collapsed: boolean;
     onCollapsedChange: (collapsed: boolean) => void;
     onOpenSettings: () => void;
+    onOpenAgents?: (view?: 'agents' | 'tasks') => void;
     onOpenPlugins: () => void;
     onOpenChannels: () => void;
     onOpenManagedSessions?: () => void;
@@ -145,4 +148,4 @@ interface WebShellSidebarProps {
     onLoadStandaloneSession?: (sessionId: string) => Promise<void> | void;
     onStandaloneNotice?: (message: string) => void;
 }
-export declare function WebShellSidebar({ collapsed, onCollapsedChange, onOpenSettings, onOpenPlugins, onOpenChannels, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;
+export declare function WebShellSidebar({ selectedCollaborationId, onOpenCollaboration, collapsed, onCollapsedChange, onOpenSettings, onOpenAgents, onOpenPlugins, onOpenChannels, onOpenManagedSessions, onOpenDaemonStatus, onOpenScheduledTasks, onOpenWorkflows, onOpenGoals, onOpenSessions, canOpenSessionsOverview, onOpenWorkspacesOverview, onOpenSplitView, canOpenSplitView, onNewSession, onNewStandaloneSession, onLoadSession, onSelectCurrentSession, onSessionRenameConfirmed, onSessionsDeleted, onError, theme, onThemeChange, mobileOpen, onMobileClose, selectedWorkspaceCwd, onSelectWorkspace, onOpenGitDiff, onOpenCommit, onOpenAddWorkspace, workspaces: providedWorkspaces, lockedWorkspaceCwd, lockedWorkspace: lockedWorkspaceOptions, branding, primaryNav: primaryNavOptions, showSessionSourceSwitch, showLive, hideProjectHeader, sessionActions: sessionActionsOptions, footer, workspaceOverview, onOpenWorkspaceManagement, onNewWorktreeSession, projectFeaturesEnabled, onLoadStandaloneSession, onStandaloneNotice, }: WebShellSidebarProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/sidebar/WorkspaceSection.d.ts

@@ -9,6 +9,7 @@ export interface WorkspaceHeaderActionsContext {
     gitBranch: string | null | undefined;
 }
 interface WorkspaceSectionProps {
+    additionalSessions?: readonly DaemonSessionSummary[];
     workspace: DaemonWorkspaceCapability;
     remote?: boolean;
     renderHeader?: (expanded: boolean) => ReactNode;
@@ -116,5 +117,5 @@ interface WorkspaceSectionProps {
     /** Commit entry for the same picker; the row still opens without it. */
     onOpenCommit?: (workspaceCwd: string) => void;
 }
-export declare function WorkspaceSection({ workspace, remote, renderHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, forceAutoExpand, onExpandedChange, renderSessions, renderSession, pendingSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
+export declare function WorkspaceSection({ additionalSessions, workspace, remote, renderHeader, client, reloadToken, untrustedLabel, readOnlyLabel, trustToOpenLabel, noSessionsLabel, loadErrorLabel, organizationEnabled, sessionCatalogRequestsEnabled, sessionGroupCatalog, sessionLiveStateEnabled, sourceType, channelGroupingEnabled, ungroupedLabel, searchQuery, expanded: controlledExpanded, autoExpandKey, forceAutoExpand, onExpandedChange, renderSessions, renderSession, pendingSession, mapSession, showSessionDetails, headerActions, overviewEnabled, overviewMenuOpen, overviewItems, gitBranchWanted, sessionStats, onRenameGroup, onDeleteGroup, renameGroupLabel, deleteGroupLabel, groupActionsDisabled, excludePinned, limitSessions, isPinnedSectionMember, onOpenPathLocally, onOpenTerminalLocally, onOpenGitDiff, onOpenCommit, }: WorkspaceSectionProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/sidebar/sessionSearch.d.ts

@@ -8,7 +8,8 @@ export declare function sessionMatchesGitQuery(session: DaemonSessionSummary, qu
 /**
  * The sidebar's session-source scope: the "channel" tab lists only
  * channel-source sessions, the "default" tab lists unattributed (legacy)
- * and default/Qwen Live tasks, and no filter lists everything.
+ * and default/Qwen Live tasks, every other source lists exact matches, and
+ * no filter lists everything.
  */
 export declare function sessionMatchesSource(session: DaemonSessionSummary, source: string | undefined): boolean;
 /**

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

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

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

@@ -0,0 +1,30 @@
+import { type ThreadDetailView } from './ThreadView';
+import { type RoutingPreviewTarget } from './agents-view-logic';
+interface AgentEntry {
+    id: string;
+    name: string;
+    color?: string;
+    enabled: boolean;
+    retiredAt?: number;
+}
+export declare function ThreadChat({ thread, agents, preview, pending, onSend, onDraftChange, onOpenAgentSession, onCancelRun, onMarkDone, onOpenThread, onRespondPermission, onAssign, onBack, activityOnly, onOpenActivity, headerActionsContainer, }: {
+    headerActionsContainer?: HTMLElement | null;
+    activityOnly?: boolean;
+    onOpenActivity?: () => void;
+    preview?: readonly RoutingPreviewTarget[];
+    agents: readonly AgentEntry[];
+    thread: ThreadDetailView;
+    pending: boolean;
+    onSend: (text: string) => Promise<boolean>;
+    onDraftChange: (text: string) => void;
+    onOpenAgentSession?: (sessionId: string) => void;
+    onCancelRun: (runId: string) => void;
+    onMarkDone: () => void;
+    onOpenThread: (threadId: string) => void;
+    onRespondPermission?: (sessionId: string, requestId: string, optionId: string) => Promise<unknown>;
+    /** Hands the conversation to another agent. */
+    onAssign?: (assignee?: string) => void;
+    /** Shown when the conversation is not in the shell's own chat column. */
+    onBack?: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type RunRow, type RunView } from './agents-view-logic';
+export interface ThreadPostView {
+    sourceRunId?: string;
+    id: string;
+    sequence: number;
+    authorKind: 'human' | 'agent' | 'system';
+    authorName: string;
+    authorDeleted?: boolean;
+    text: string;
+    at: number;
+    outcomes?: readonly {
+        agentName?: string;
+        kind: 'dispatch' | 'coalesce' | 'skip';
+        reason?: string;
+        into?: 'queued' | 'running';
+    }[];
+}
+export interface ThreadDetailView {
+    id: string;
+    title: string;
+    body: string;
+    /** What "done" means here, in the author's words. */
+    acceptanceCriteria?: string;
+    priority?: 'urgent' | 'high' | 'normal' | 'low';
+    parent?: {
+        id: string;
+        title: string;
+    };
+    assigneeName?: string;
+    status: 'open' | 'in_progress' | 'blocked' | 'in_review' | 'done' | 'cancelled';
+    /** The resolver's sentence. Rendered verbatim. */
+    reason: string;
+    posts: readonly ThreadPostView[];
+    runs: readonly RunView[];
+    children?: readonly ThreadChildView[];
+    budget: {
+        turnsUsed: number;
+        turnLimit: number;
+        tokensUsed: number;
+        tokenLimit: number;
+    };
+}
+export interface ThreadChildView {
+    id: string;
+    title: string;
+    status: ThreadDetailView['status'];
+    reason: string;
+    assigneeName?: string;
+}
+/**
+ * One run: its state, how long it has gone, and what it is doing, with the
+ * thinking and output so far folded under it. Under a member in the Team
+ * panel the member row already names the agent, so `hideAgent` drops it.
+ */
+export declare function RunRowView({ row, hideAgent, onOpenAgentSession, onCancelRun, }: {
+    row: RunRow;
+    hideAgent?: boolean;
+    onOpenAgentSession?: (sessionId: string) => void;
+    onCancelRun?: (runId: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type RoutingPreviewTarget, type ThreadSummaryView } from './agents-view-logic';
+/**
+ * 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;
+}
+/** What every agent in this workspace may do. A property of the subsystem. */
+export interface AgentCapabilitiesView {
+    readOnly: boolean;
+    allowed: readonly string[];
+    threadTools: readonly string[];
+}
+export interface ThreadsPageProps {
+    createError?: string;
+    agents: readonly WorkspaceAgentSummaryView[];
+    threads: readonly ThreadSummaryView[];
+    view: AgentWorkspaceView;
+    onViewChange: (view: AgentWorkspaceView) => void;
+    onOpenThread: (threadId: string) => void;
+    onDeleteAgent: (agentId: string) => void;
+    onSetAgentEnabled: (agentId: string, enabled: boolean) => void;
+    onUpdateAgent?: (agentId: string, patch: AgentConfigPatch) => void;
+    onOpenAgentBuilder?: () => void;
+    onOpenDefinitions?: () => void;
+    capabilities?: AgentCapabilitiesView;
+    onCreateThread: (input: NewThread) => Promise<boolean> | void;
+    workspaceCwd?: string;
+    workspaces?: readonly {
+        cwd: string;
+    }[];
+    onWorkspaceChange?: (cwd: string) => void;
+    onPreviewThread?: (assignee?: string) => void;
+    createPreview?: readonly RoutingPreviewTarget[];
+    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;
+    enabled: boolean;
+    status: 'offline' | 'idle' | 'working' | 'blocked' | 'error';
+    /** Set once the identity is retired: it keeps its posts and takes no work. */
+    retiredAt?: number;
+    workingOn?: {
+        id: string;
+        title: string;
+        state: 'working' | 'finishing' | 'stopping';
+    };
+    waiting: number;
+}
+export type AgentWorkspaceView = 'agents' | 'tasks';
+export interface NewWorkspaceAgent {
+    name: string;
+    description?: string;
+    agentType?: string;
+    model?: string;
+    instructions?: string;
+    maxConcurrentRuns?: number;
+}
+export type ThreadPriorityChoice = 'urgent' | 'high' | 'normal' | 'low';
+export interface NewThread {
+    title: string;
+    body: string;
+    /** What "done" means. Sent only when written, so a blank stays absent. */
+    acceptanceCriteria?: string;
+    priority?: ThreadPriorityChoice;
+    assignee?: string;
+    /** The first post; the assignee starts from it. */
+    message?: string;
+}
+/**
+ * The thread list, grouped by what each thread needs.
+ *
+ * Recency sorting is the obvious default and it buries the two threads that
+ * need a person under twenty that do not. Grouping answers the question
+ * someone actually opens this page with.
+ */
+export declare function ThreadsPage({ agents, threads, view, onViewChange, onOpenThread, onDeleteAgent, onSetAgentEnabled, onUpdateAgent, onOpenAgentBuilder, onOpenDefinitions, capabilities, onCreateThread, workspaceCwd, workspaces, onWorkspaceChange, createError, onPreviewThread, createPreview, pending, }: ThreadsPageProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type AgentWorkspaceView } from './ThreadsPage';
+export interface ThreadsRouteProps {
+    /** `new-agent` opens straight into the New agent page. */
+    initialView?: AgentWorkspaceView | 'new-agent';
+    initialThreadId?: string;
+    workspaceCwd?: string;
+    chat?: boolean;
+    activityOnly?: boolean;
+    onOpenActivity?: (threadId: string, workspaceCwd: string) => void;
+    headerActionsContainer?: HTMLElement | null;
+    onTitleChange?: (threadId: string, title: string) => void;
+    onOpenThreadChat?: (threadId: string, workspaceCwd: string) => void;
+    /** Switches the shell to an agent's own session. Absent when embedded
+     * somewhere with no session view to switch to. */
+    onOpenAgentSession?: (sessionId: string) => void;
+    onOpenDefinitions?: () => void;
+}
+export declare function ThreadsRoute({ initialView, initialThreadId, workspaceCwd: boundWorkspaceCwd, chat, activityOnly, onOpenActivity, headerActionsContainer, onTitleChange, onOpenThreadChat, onOpenAgentSession, onOpenDefinitions, }: ThreadsRouteProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Client for `GET /workspaces/:ws/agent/events`, the collaboration stream.
+ *
+ * `fetch` rather than `EventSource`: the daemon wants a bearer header, which
+ * `EventSource` cannot send. Frames are plain `event:` + one `data:` line.
+ */
+export interface AgentPermissionPromptView {
+    requestId: string;
+    title: string;
+    options: Array<{
+        optionId: string;
+        name: string;
+        kind?: string;
+    }>;
+}
+export interface AgentRunStepView {
+    id: string;
+    title: string;
+    status: 'running' | 'done' | 'failed';
+}
+export interface AgentRunProgressEvent {
+    type: 'progress';
+    threadId: string;
+    runId: string;
+    attempt: number;
+    sessionId: string;
+    stage: string;
+    detail: string;
+    outputText: string;
+    thoughtText: string;
+    activityAt: number;
+    permission?: AgentPermissionPromptView;
+    steps?: AgentRunStepView[];
+}
+export type AgentLiveEvent = {
+    type: 'changed';
+    threadId?: string;
+} | AgentRunProgressEvent;
+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(url: string, token: string | undefined, onEvent: (event: AgentLiveEvent) => void, onState: (state: AgentStreamState) => void): () => void;