@qwen-code/web-shell 0.24.7 → 0.25.1-preview.0

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

@@ -0,0 +1,146 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type JoinToken } from './add-runtime-dialog';
+import { type AgentShare, type AgentShareSummary } from './share-agent-dialog';
+import { type AgentProgramView, 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;
+    execution?: {
+        mode: 'local';
+    } | {
+        mode: 'managed-host';
+        hostIds: string[];
+        provider?: AgentProgramView;
+    };
+}
+/** 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 {
+    onConnectRemoteHost?: (input: {
+        remoteUrl: string;
+        remoteToken: string;
+        remoteCwd: string;
+        serverUrl: string;
+        provider: 'qwen';
+        allowHttp: boolean;
+    }) => Promise<boolean>;
+    createError?: string;
+    agents: readonly WorkspaceAgentSummaryView[];
+    threads: readonly ThreadSummaryView[];
+    runtimes?: readonly WorkspaceAgentRuntimeView[];
+    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?: (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>;
+    };
+    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;
+    execution?: AgentConfigPatch['execution'];
+    enabled: boolean;
+    status: 'offline' | 'idle' | 'working' | 'blocked' | '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;
+    workingOn?: {
+        id: string;
+        title: string;
+        state: 'working' | 'finishing' | 'stopping';
+    };
+    waiting: number;
+}
+export interface WorkspaceAgentRuntimeView {
+    id: string;
+    kind: 'local' | 'external';
+    label: string;
+    provider: string;
+    /** Program ids the runtime reported it can run. */
+    programs?: readonly string[];
+    status: 'online' | 'offline';
+    workspaceId?: string;
+    workspaceCwd?: string;
+    hostSessionId?: string;
+    lastSeenAt?: number;
+    agentCount?: number;
+    sessionCount?: number;
+    runningTaskCount?: number;
+    queuedTaskCount?: number;
+}
+export type AgentWorkspaceView = 'agents' | 'tasks' | 'runtime';
+export interface NewWorkspaceAgent {
+    name: string;
+    description?: string;
+    agentType?: string;
+    model?: string;
+    instructions?: string;
+    maxConcurrentRuns?: number;
+    execution?: AgentConfigPatch['execution'];
+}
+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, runtimes, view, onViewChange, onOpenThread, onDeleteAgent, onSetAgentEnabled, onUpdateAgent, onOpenAgentBuilder, onOpenDefinitions, onCreateJoinToken, onRemoveRuntime, onConnectRemoteHost, hostServerUrl, shares, 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/add-runtime-dialog.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface RuntimeSummary {
+    id: string;
+    kind: 'local' | 'external';
+    label: string;
+    provider: string;
+    providers?: 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;
+    provider: 'qwen';
+    allowHttp: boolean;
+}
+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 live stream
+ * 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, 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>;
+    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,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;

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

@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @fileoverview Presentation logic for the agents-and-threads surface.
+ *
+ * Everything here is pure and testable without a browser, following the same
+ * split as `agents-manager-logic.ts`. Two rules it exists to enforce:
+ *
+ * 1. **The server decides a thread's state; this file only renders it.** The
+ *    thread resolver already returns a status *and* the sentence explaining it.
+ *    Deriving a second, shorter vocabulary here would give the product two
+ *    answers to "why is this blocked", and the shorter one would win because it
+ *    is the one on screen.
+ * 2. **A label never asserts a cause its reason code does not carry.** Copy
+ *    that conflates two causes sends people to fix the wrong thing — Multica
+ *    learned this when "runtime offline" wording sent users to reconnect a
+ *    machine that was already connected. Each refusal below names its own fix.
+ */
+import type { AgentPermissionPromptView, AgentRunStepView } from './agent-events';
+/** The programs an agent can be bound to on a joined runtime. */
+export declare const AGENT_PROGRAMS: readonly ["qwen"];
+export type AgentProgramView = (typeof AGENT_PROGRAMS)[number];
+export declare function programLabel(program: string | undefined): string;
+/**
+ * Opens a thread body that carries the conversation it was started from. The
+ * agents read it as-is; the chat view shows it folded instead of as a message.
+ */
+export declare const CONVERSATION_CONTEXT_PREFIX = "Context from the conversation this was sent from:\n\n";
+/** Wire shape of a thread row, as the REST layer returns it. */
+export interface ThreadSummaryView {
+    id: string;
+    title: string;
+    status: 'open' | 'in_progress' | 'blocked' | 'in_review' | 'done' | 'cancelled';
+    /** The resolver's own sentence. Rendered verbatim; never re-derived. */
+    reason: string;
+    updatedAt: number;
+    liveRunCount: number;
+    assigneeName?: string;
+    parentThreadId?: string;
+}
+export interface ThreadGroup {
+    key: 'needs_you' | 'running' | 'idle' | 'done';
+    threads: ThreadSummaryView[];
+    /** Finished work is evidence, not a task, so it starts collapsed. */
+    collapsedByDefault: boolean;
+}
+/**
+ * Groups threads by what they need, not by recency.
+ *
+ * Recency is the default sort and it buries the two threads that need a person
+ * under twenty that do not. `blocked` and `in_review` share one group because
+ * they are the same query for the reader — this is waiting on me — even though
+ * one is a question and the other is finished work. What tells them apart is
+ * each thread's own sentence, which is already on the row.
+ */
+export declare function groupThreads(threads: readonly ThreadSummaryView[]): ThreadGroup[];
+/** Which threads carry the single attention treatment. */
+export declare function needsAttention(thread: ThreadSummaryView): boolean;
+/** Wire shape of one run, as the REST layer returns it. */
+export interface RunView {
+    progress?: {
+        attempt?: number;
+        receivedAt: number;
+        activityAt: number;
+        /** A code: starting, thinking, responding, tool, awaiting_approval, stream_lost. */
+        stage: string;
+        /** Raw text such as a tool title; never UI copy. */
+        detail: string;
+        outputText?: string;
+        thoughtText?: string;
+        permission?: AgentPermissionPromptView;
+        /** The turn's latest tool calls, oldest first. */
+        steps?: AgentRunStepView[];
+    };
+    id: string;
+    agentId: string;
+    agentName: string;
+    agentColor?: string;
+    status: 'queued' | 'running' | 'finishing' | 'cancelling' | 'completed' | 'failed' | 'cancelled';
+    closeKind?: 'waiting' | 'blocked' | 'review' | 'unclosed' | 'stranded';
+    closeAcknowledged: boolean;
+    failureStage?: string;
+    error?: string;
+    /** Why this run exists, e.g. "assigned by you", "mentioned by alice". */
+    trigger: string;
+    /** Queued runs of the same agent that start before this one. */
+    queueAhead?: number;
+    startedAt?: number;
+    endedAt?: number;
+    /** The agent session this run took its turn in, once one is bound. */
+    sessionId?: string;
+}
+export interface RunRow {
+    run: RunView;
+    /** What this run is doing or left behind, in the reader's words. */
+    state: string;
+    /** Live runs pin to the top; terminal runs collapse behind a count. */
+    live: boolean;
+    /** True when a person still owes this run an answer. */
+    outstanding: boolean;
+}
+/**
+ * Describes a run the way the reader asks about it.
+ *
+ * A failed run reports its failure whatever close it managed to record first,
+ * because the failure is the thing a person has to act on. A stranded run is
+ * the exception: nothing the agent did ended it.
+ */
+export declare function describeRun(run: RunView, t: Translate): string;
+/**
+ * Orders runs for the side panel: live first in start order, then terminal
+ * runs newest-first behind their count.
+ *
+ * The row carries no agent-availability indicator. Whether an agent is
+ * reachable is not this row's story — the run's own state is, and a second
+ * signal beside it competes for the same glance.
+ */
+export declare function buildRunRows(runs: readonly RunView[], t: Translate): {
+    live: RunRow[];
+    past: RunRow[];
+};
+/**
+ * One line, not a bar. A budget is a limit you want to notice before it trips,
+ * not a goal you are filling, and a bar invites the second reading.
+ */
+export declare function formatBudget(budget: {
+    turnsUsed: number;
+    turnLimit: number;
+    tokensUsed: number;
+    tokenLimit: number;
+}, t: Translate): {
+    turns: string;
+    tokens: string;
+    scope: string;
+};
+/** One target's fate for a draft reply, as the server previews it. */
+export interface RoutingPreviewTarget {
+    agentName: string;
+    willWake: boolean;
+    kind?: 'dispatch' | 'coalesce' | 'skip';
+    into?: 'queued' | 'running';
+    /** Present when `willWake` is false. A skip reason from the rules layer. */
+    reason?: string;
+    /** True when the name matched no agent, so it renders as a warning. */
+    unknown?: boolean;
+}
+/**
+ * What a refusal means, and what to do about it.
+ *
+ * Each entry names its own fix. Two reasons that look alike but need different
+ * fixes stay apart: a missing definition is repaired by pointing the agent at
+ * one that exists, while a disabled agent is repaired by enabling it, and copy
+ * that merged them would send the reader to the wrong screen.
+ */
+export declare function explainSkip(reason: string, target: string, t: Translate): string;
+/**
+ * A one-line summary of a preview, for the composer's collapsed state.
+ *
+ * Says who *will* run, because that is the consequence of pressing send. When
+ * nobody will, that is the headline, since it is the case the system used to
+ * swallow silently.
+ */
+export declare function summarizePreview(targets: readonly RoutingPreviewTarget[], t: Translate): string;
+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;
+/**
+ * Why a run exists, in the reader's language. The server words this in
+ * English from a fixed set; anything outside it is shown as sent.
+ */
+export declare function triggerLabel(trigger: string, t: Translate): string;
+/**
+ * A thread's status reason in the reader's language. The server words it in
+ * English from a fixed set; anything outside it is shown as sent.
+ */
+export declare function statusReasonLabel(reason: string, t: Translate): string;
+export {};

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 Agent page, collaboration conversations,
+ * 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/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/threads-api.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AgentCapabilitiesView, AgentConfigPatch, NewThread, NewWorkspaceAgent, WorkspaceAgentRuntimeView, WorkspaceAgentSummaryView } from './ThreadsPage';
+import type { ThreadDetailView } from './ThreadView';
+import type { RoutingPreviewTarget, ThreadSummaryView } from './agents-view-logic';
+import { type AgentLiveEvent, type AgentStreamState } from './agent-events';
+import type { JoinToken } from './add-runtime-dialog';
+import type { AgentShare, AgentShareSummary } from './share-agent-dialog';
+interface CreateThreadResult {
+    id: string;
+}
+export interface ThreadsApi {
+    connectRemoteHost?(input: {
+        remoteUrl: string;
+        remoteToken: string;
+        remoteCwd: string;
+        serverUrl: string;
+        provider: 'qwen';
+        allowHttp: boolean;
+    }): Promise<unknown>;
+    listAgents(): Promise<{
+        agents: WorkspaceAgentSummaryView[];
+        runtime?: WorkspaceAgentRuntimeView;
+        runtimes?: WorkspaceAgentRuntimeView[];
+        capabilities?: AgentCapabilitiesView;
+    }>;
+    /** 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>;
+    listThreads(): Promise<{
+        threads: ThreadSummaryView[];
+    }>;
+    getThread(id: string): Promise<ThreadDetailView>;
+    createAgent(input: NewWorkspaceAgent): Promise<unknown>;
+    deleteAgent(id: string): Promise<unknown>;
+    setAgentEnabled(id: string, enabled: boolean): Promise<unknown>;
+    updateAgent(id: string, patch: AgentConfigPatch): Promise<unknown>;
+    createThread(input: NewThread): Promise<CreateThreadResult>;
+    previewThread(assignee?: string): Promise<{
+        targets: RoutingPreviewTarget[];
+    }>;
+    assignThread(id: string, assignee?: string): Promise<unknown>;
+    previewReply(id: string, text: string): Promise<{
+        targets: RoutingPreviewTarget[];
+    }>;
+    postReply(id: string, text: string): Promise<unknown>;
+    markDone(id: string): Promise<unknown>;
+    cancelRun(threadId: string, runId: string): Promise<unknown>;
+    /** Live events; absent in tests and older daemons, which then poll. */
+    subscribe?(onEvent: (event: AgentLiveEvent) => void, onState: (state: AgentStreamState) => void): () => void;
+    /** Answers a tool approval an agent is waiting on. */
+    respondToPermission?(sessionId: string, requestId: string, optionId: string): Promise<unknown>;
+}
+export declare function createThreadsHttpApi(baseUrl: string, token: string | undefined, workspaceCwd: string): ThreadsApi;
+export {};

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

@@ -0,0 +1,36 @@
+import { type ComponentProps } from 'react';
+import type { ChatEditor } from '../ChatEditor';
+import type { WebShellAtProvider } from '../../customization';
+import type { useI18n } from '../../i18n';
+type Submit = ComponentProps<typeof ChatEditor>['onSubmit'];
+/**
+ * The tail of the conversation an agent was mentioned from, so a thread
+ * started mid-conversation does not begin blind.
+ */
+export declare function conversationContext(messages: readonly {
+    role: string;
+    content?: unknown;
+}[]): string;
+export declare function useAgentChatEntry({ enabled, cwd, baseUrl, token, onSubmit, onOpen, onError, getContext, onCreateAgent, t, }: {
+    enabled: boolean;
+    cwd?: string;
+    baseUrl: string;
+    token?: string;
+    onSubmit: Submit;
+    onOpen: (id: string, cwd: string) => void;
+    onError: (message: string) => void;
+    /** The conversation so far, when mentioning from a chat that has one. */
+    getContext?: () => string;
+    /** Offered as the picker's last item: open the New agent page. */
+    onCreateAgent?: () => void;
+    /**
+     * The caller's translator. App calls this hook above its I18nProvider, where
+     * useI18n() would hand back the default that echoes keys.
+     */
+    t: ReturnType<typeof useI18n>['t'];
+}): {
+    providers: WebShellAtProvider[];
+    submit: (text: string, images?: import("../../adapters/promptTypes").PromptImage[], files?: import("../../adapters/promptTypes").PromptFile[], commitAccepted?: import("../../hooks/useComposerCore").ComposerSubmitCommit, metadata?: import("../../hooks/useComposerCore").ComposerSubmitMetadata) => boolean | void;
+    pending: boolean;
+};
+export {};

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

@@ -0,0 +1,10 @@
+import type { DaemonSessionSummary } from '@qwen-code/sdk/daemon';
+export declare const COLLABORATION_SOURCE = "workspace_collaboration";
+export declare function useProjectConversations(cwds: readonly string[]): {
+    scope: string;
+    sessions: DaemonSessionSummary[];
+    error?: string;
+} | {
+    sessions: never[];
+    error: undefined;
+};

package/dist/types/customization.d.ts

@@ -362,6 +362,11 @@ export interface WebShellAtItem {
     iconTooltip?: string;
     insertText?: string;
     composerTag?: WebShellComposerTag;
+    /**
+     * Makes the item an action instead of a reference: choosing it removes the
+     * typed `@query` and calls this, inserting nothing.
+     */
+    onSelect?: () => void;
 }
 export type WebShellBuiltinAtProviderId = 'files' | 'extensions' | 'mcp-resources';
 export type WebShellBuiltinAtProvidersConfig = boolean | readonly WebShellBuiltinAtProviderId[] | {
@@ -389,6 +394,11 @@ export interface WebShellAtProvider {
     order?: number;
     tabs?: readonly WebShellAtProviderTab[];
     renderItem?: WebShellAtItemRenderer;
+    /**
+     * Claims a typed `@query` that names no category, so it searches this
+     * provider instead of falling back to files.
+     */
+    claimsTypedQuery?(query: string): boolean;
     search(params: {
         query: string;
         signal: AbortSignal;