@qwen-code/web-shell 0.24.1-preview.1 → 0.24.3-nightly.20260921.2800e9bb4f

package/dist/types/live/useLiveBrowserHost.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type RefObject } from 'react';
+import type { DaemonLiveStatus } from '@qwen-code/sdk';
+/**
+ * Makes this page the Live Voice audio endpoint: it holds the daemon's single
+ * Host lease over WS `/live/web`, streams the microphone up and plays the
+ * model's speech. The call itself is still driven through `/live/*` (start,
+ * stop, mute); this hook only moves audio and mirrors the pushed status.
+ */
+export declare const LIVE_WEB_HOST_PATH = "/live/web";
+/**
+ * What the capture callback last saw. `at` is the `performance.now()` of that
+ * frame: a meter that only kept the level would go on showing the last value
+ * after the callback stops firing (a suspended AudioContext, a device change),
+ * which is exactly when it is being looked at.
+ */
+export interface LiveInputLevel {
+    /** RMS of the frame, 0..1. Zero while input is muted. */
+    level: number;
+    at: number;
+    /**
+     * The call is running but frames are not being sent: the socket is backed
+     * up. The microphone is fine and the daemon is still not hearing it. Held
+     * for a moment after the last dropped frame, so it does not flicker.
+     */
+    dropping: boolean;
+}
+/**
+ * `worklet`: microphone frames are produced, converted and measured on the
+ * audio rendering thread. `script-processor`: the deprecated main-thread
+ * node, kept as the fallback for wherever the worklet module cannot be
+ * loaded — a browser without AudioWorklet, or an embedding whose library build
+ * inlines the module as a `data:` URL the CSP refuses.
+ */
+export type LiveCaptureMode = 'worklet' | 'script-processor';
+export type LiveBrowserHostPhase = 'idle' | 'connecting' | 'connected' | 'error';
+export type LiveBrowserHostCloseReason = 
+/** Another Host holds the lease (4009). `connect({ takeover })` may help. */
+'occupied'
+/** A native Host took over (4010). */
+ | 'superseded-native'
+/** Another Web Shell tab took over (4010). */
+ | 'superseded-tab'
+/** Live Voice is off, or the workspace is not trusted (4003). */
+ | 'refused' | 'microphone' | 'lost';
+export interface UseLiveBrowserHostOptions {
+    baseUrl: string;
+    token?: string;
+    /** Status pushed by the daemon; fresher than polling `/live/status`. */
+    onStatus?: (status: DaemonLiveStatus) => void;
+}
+export interface UseLiveBrowserHostResult {
+    phase: LiveBrowserHostPhase;
+    closeReason: LiveBrowserHostCloseReason | undefined;
+    errorMessage: string | undefined;
+    /** How the microphone is being captured; undefined until connected. */
+    captureMode: LiveCaptureMode | undefined;
+    /**
+     * Most recent microphone frame, for a meter. A ref rather than state:
+     * at 64 ms frames this changes ~16 times a second, and re-rendering the
+     * dialog that often would steal the main thread from the very
+     * ScriptProcessor callback that produces the audio.
+     */
+    inputLevel: RefObject<LiveInputLevel>;
+    /** Must run inside a user gesture: it asks for the microphone. */
+    connect: (options?: {
+        takeover?: boolean;
+    }) => void;
+    disconnect: () => void;
+    /** What the model can see, and when it last looked. */
+    screenShare: LiveScreenShareState;
+    /** Must run inside a user gesture: it asks which screen to share. */
+    startSharingScreen: () => Promise<void>;
+    stopSharingScreen: () => void;
+}
+export interface LiveScreenShareState {
+    /** False where `getDisplayMedia` is unavailable, so the share is never offered. */
+    supported: boolean;
+    sharing: boolean;
+    /** The track's own name for what is shared, e.g. a window title. */
+    label: string | undefined;
+    errorMessage: string | undefined;
+    /** `performance.now()` of the last frame the model was given, for the UI. */
+    lastLookAt: number | undefined;
+    /** The model asked while nothing was shared, so the UI can offer to start. */
+    requestedWhileIdle: boolean;
+}
+export declare function useLiveBrowserHost({ baseUrl, token, onStatus, }: UseLiveBrowserHostOptions): UseLiveBrowserHostResult;

package/dist/types/live/useLiveVoice.d.ts

@@ -4,8 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type { DaemonLiveMuteUpdate, DaemonLiveStatus } from '@qwen-code/sdk';
+import { type UseLiveBrowserHostResult } from './useLiveBrowserHost';
 export interface UseLiveVoiceResult {
+    /** Either kind of Host is available on this daemon. */
     supported: boolean;
+    nativeSupported: boolean;
+    browserSupported: boolean;
+    /** This page as the audio endpoint; idle until the user connects it. */
+    browserHost: UseLiveBrowserHostResult;
     status: DaemonLiveStatus | undefined;
     loading: boolean;
     mutating: boolean;

package/dist/types/session-catalog/session-catalog-store.d.ts

@@ -54,6 +54,13 @@ export declare class SessionCatalogStore {
     private visibilityListening;
     constructor(client: DaemonClient);
     getSnapshot(query: SessionCatalogQuery): SessionCatalogSnapshot;
+    /**
+     * Reads a display name the catalog already holds for a session, scheduling
+     * nothing. A history session's name exists only here — neither the load
+     * response nor the metadata events carry it — so the header seeds the title
+     * from this cache instead of waiting for a round-trip.
+     */
+    peekSessionDisplayName(sessionId: string, workspaceCwd: string | undefined): string | undefined;
     getEmptySnapshot(): SessionCatalogSnapshot;
     retainWorkspaceLiveState(workspaceCwd: string): () => void;
     isWorkspaceLiveStateEnabled(workspaceCwd: string): boolean;
@@ -140,4 +147,6 @@ export declare function getSessionCatalogStore(client: DaemonClient): SessionCat
 export declare function loadSessionCatalogOnce(client: DaemonClient, query: SessionCatalogQuery, options?: {
     fresh?: boolean;
 }): Promise<DaemonSessionListPage>;
+/** Sync read of a cached display name; see `SessionCatalogStore.peekSessionDisplayName`. */
+export declare function peekSessionCatalogDisplayName(client: DaemonClient, sessionId: string | undefined, workspaceCwd: string | undefined): string | undefined;
 export {};

package/dist/types/settings.d.ts

@@ -58,13 +58,15 @@ declare const SETTING_KEYS: {
     readonly 'setting:voice-model': "voiceModel";
     readonly 'setting:image-model': "imageModel";
 };
-declare const BUILTIN_IDS: readonly ["builtin:chat-width", "builtin:browser-notifications", "builtin:live-setup", "builtin:local-control", "builtin:model-management"];
+declare const BUILTIN_IDS: readonly ["builtin:chat-width", "builtin:browser-notifications", "builtin:live-setup", "builtin:local-control", "builtin:connections", "builtin:model-management"];
 export type WebShellSettingItemId = keyof typeof SETTING_KEYS | (typeof BUILTIN_IDS)[number];
 export declare const WEB_SHELL_SETTING_ITEM_IDS: readonly WebShellSettingItemId[];
 export interface WebShellSettingsOptions {
-    /** Hide native settings items. Presentation only; other commands/APIs remain available. */
+    /** Show only these eligible native items; an empty list hides all. Presentation only. */
+    includeItems?: readonly WebShellSettingItemId[];
+    /** Hide native items, taking precedence over includeItems. Other commands/APIs remain available. */
     excludeItems?: readonly WebShellSettingItemId[];
 }
-export declare function isItemExcluded(id: WebShellSettingItemId, options?: WebShellSettingsOptions): boolean;
-export declare function isSettingExcluded(key: string, options?: WebShellSettingsOptions): boolean;
+export declare function isItemVisible(id: WebShellSettingItemId, options?: WebShellSettingsOptions): boolean;
+export declare function isSettingVisible(key: string, options?: WebShellSettingsOptions): boolean;
 export {};

package/dist/types/trajectory/buildTrajectory.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Trajectory, TrajectoryEntry } from './types';
+/**
+ * Fold a run of raw entries into turns and rows, pairing each timing frame with
+ * what it measured.
+ *
+ * Nothing here invents a duration. A row whose frame never arrived — an
+ * in-flight call, a session written before timing frames existed — carries no
+ * timing at all rather than a value derived from arrival times.
+ */
+export declare function buildTrajectory(entries: readonly TrajectoryEntry[]): Trajectory;

package/dist/types/trajectory/projectTrajectoryWindow.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type DaemonEvent } from '@qwen-code/sdk/daemon';
+import type { TrajectoryEntry } from './types';
+/**
+ * Project one contiguous run of raw daemon events into ordered trajectory
+ * entries: the blocks the SDK reducer materializes, with each timing frame
+ * placed where its telemetry record was written.
+ *
+ * A timing frame's position is the block count at the moment it arrived. The
+ * telemetry record for a model request is written after that round's tool
+ * results — which update blocks already in the list rather than appending — and
+ * before the next assistant record, which appends. So "after the current last
+ * block" lands the frame between the two, matching the record order on disk.
+ *
+ * A timing frame is never normalized at all. Every other reader turns it into
+ * nothing, and leaning on that would put a row in the table the day a
+ * normalizer started surfacing it.
+ */
+export declare function projectTrajectoryWindow(events: readonly DaemonEvent[]): TrajectoryEntry[];

package/dist/types/trajectory/transcriptPageLoader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TrajectoryPageLoader, TrajectoryPageResult } from './useTrajectoryWindow';
+/**
+ * The one client method this view needs. Narrower than `DaemonClient` so the
+ * trajectory modules stay independent of the rest of its surface.
+ */
+export interface TrajectoryTranscriptClient {
+    getSessionTranscriptPage(sessionId: string, opts: {
+        direction?: 'backward';
+        limit?: number;
+    }): Promise<TrajectoryPageResult>;
+}
+/**
+ * A page loader for one session, stable per (client, session).
+ *
+ * Identity matters: the loader is the window hook's effect dependency, so a
+ * fresh function on every render would refetch the newest page on every render.
+ *
+ * Reads ask for the newest page, which is the one the reader wants — the newest
+ * turn is the one they just watched run. It deliberately goes through the raw
+ * client rather than
+ * `DaemonSessionClient.getTranscriptPage`, which hydrates attachments and would
+ * fetch image bytes this table never shows, and it never asks for the
+ * `summary` projection, which rewrites the event stream the timing frames sit
+ * in.
+ */
+export declare function createTrajectoryPageLoader(client: TrajectoryTranscriptClient, sessionId: string): TrajectoryPageLoader;

package/dist/types/trajectory/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonTextTranscriptBlock, DaemonToolTranscriptBlock, DaemonTranscriptBlock, DaemonTranscriptTimingMeta, DaemonTurnUsage } from '@qwen-code/sdk/daemon';
+/**
+ * One item of a trajectory window in wire order: either a materialized
+ * transcript block or a timing frame sitting where the telemetry record that
+ * produced it was written.
+ *
+ * Timing frames are kept out of the block stream on purpose. Paged replay emits
+ * one per telemetry record with no pairing of its own, precisely so a page
+ * boundary cannot separate a request from its timing; pairing happens here,
+ * over a window that is contiguous by construction.
+ */
+export type TrajectoryEntry = {
+    kind: 'block';
+    block: DaemonTranscriptBlock;
+} | {
+    kind: 'timing';
+    timing: DaemonTranscriptTimingMeta;
+    /** Persisted record uuid of the telemetry record, when stamped. */
+    recordId?: string;
+}
+/**
+ * One round's token counts, kept at the position the daemon reported them.
+ *
+ * The reducer folds these onto the round's assistant block, and a round that
+ * produced only a thought and tool calls has no assistant block of its own —
+ * its counts sum into the previous round's. Reading the frame where it
+ * arrived is what keeps each round's tokens on the round that spent them.
+ */
+ | {
+    kind: 'usage';
+    usage: DaemonTurnUsage;
+};
+/**
+ * Recorded span of one row. Only values the daemon actually measured appear
+ * here — a missing field means "not recorded", never "zero".
+ */
+export interface TrajectoryTiming {
+    durationMs: number;
+    /**
+     * Requests only. Tool calls are logged in one loop after their whole batch
+     * settles, so the recorded timestamp is the batch's end for every tool in it
+     * and no honest per-tool start can be derived.
+     */
+    startedAt?: number;
+    /** Requests only: dispatch to first user-visible content. */
+    ttftMs?: number;
+}
+/** What a subagent spent, rolled up onto the tool call that spawned it. */
+export interface TrajectorySubagentSummary {
+    requests: number;
+    tools: number;
+    /** Summed request durations; 0 when none were recorded. */
+    requestMs: number;
+}
+interface TrajectoryRowBase {
+    /**
+     * Identity that survives re-projection and page prepends. Derived from
+     * persisted record / call identity, never from array position.
+     */
+    key: string;
+    turnIndex: number;
+    /** 0 for the main session, 1 for anything a subagent produced. */
+    depth: number;
+    /** Main-session request this row belongs to, when one was recorded. */
+    requestIndex?: number;
+}
+export interface TrajectoryUserRow extends TrajectoryRowBase {
+    kind: 'user';
+    block: DaemonTextTranscriptBlock;
+}
+export interface TrajectoryRequestRow extends TrajectoryRowBase {
+    kind: 'request';
+    /** `unknown` when the frame recorded no status. */
+    status: 'ok' | 'error' | 'unknown';
+    timing: TrajectoryTiming;
+    model?: string;
+    /** Folded from the round's assistant block; absent when none carried it. */
+    usage?: DaemonTurnUsage;
+    responseId?: string;
+    promptId?: string;
+    /** Set when a subagent issued the request. */
+    subagentId?: string;
+    /** Main-session tool call that spawned the subagent, when resolvable. */
+    parentToolCallId?: string;
+}
+export interface TrajectoryMessageRow extends TrajectoryRowBase {
+    kind: 'message';
+    block: DaemonTextTranscriptBlock;
+    thought: boolean;
+}
+export interface TrajectoryToolRow extends TrajectoryRowBase {
+    kind: 'tool';
+    block: DaemonToolTranscriptBlock;
+    /** Absent for an in-flight call, or a window with no timing frames. */
+    timing?: TrajectoryTiming;
+    toolStatus?: 'success' | 'error' | 'cancelled';
+    /** Present on a tool call that spawned a subagent. */
+    subagentSummary?: TrajectorySubagentSummary;
+}
+/** Shell output, permission prompts, status markers — carried, not paired. */
+export interface TrajectoryOtherRow extends TrajectoryRowBase {
+    kind: 'other';
+    block: DaemonTranscriptBlock;
+}
+export type TrajectoryRow = TrajectoryUserRow | TrajectoryRequestRow | TrajectoryMessageRow | TrajectoryToolRow | TrajectoryOtherRow;
+export interface TrajectoryTurn {
+    /** 1-based within the loaded window; not a session-wide turn number. */
+    index: number;
+    /** Absent when the window starts inside the turn. */
+    userRowKey?: string;
+    rowKeys: string[];
+    requestCount: number;
+    /** Top-level tool rows; subagent tools are in the parent's summary. */
+    toolCount: number;
+    /** Summed main-session request durations; 0 when none were recorded. */
+    requestMs: number;
+    /** The window cut this turn's head off. */
+    partial: boolean;
+}
+export interface Trajectory {
+    turns: TrajectoryTurn[];
+    rows: TrajectoryRow[];
+    rowIndexByKey: Map<string, number>;
+}
+export {};

package/dist/types/trajectory/useTrajectoryWindow.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { DaemonEvent } from '@qwen-code/sdk/daemon';
+import type { Trajectory } from './types';
+/**
+ * Records asked for per read. The daemon caps a page at 500 records and at
+ * 4 MB, whichever binds first, so a session whose tools wrote a lot comes back
+ * shorter than this — `truncated` is what says so, never the count.
+ */
+export declare const TRAJECTORY_PAGE_SIZE = 250;
+/**
+ * The fields of a transcript page this view reads. Narrower than the daemon's
+ * own page type on purpose: the client's page satisfies it structurally, and a
+ * test can hand back a page without standing up the rest of the envelope.
+ */
+export interface TrajectoryPageResult {
+    events: readonly DaemonEvent[];
+    hasMore: boolean;
+    partial?: true;
+    replayError?: string;
+}
+/**
+ * Fetches the newest page of the session's transcript.
+ *
+ * Supplied by the host rather than called here so the panel never reaches for
+ * a daemon client of its own. There is no cancellation: the daemon client
+ * exposes no abort, so a superseded request is discarded on arrival by
+ * generation rather than stopped in flight.
+ */
+export type TrajectoryPageLoader = (opts: {
+    limit: number;
+}) => Promise<TrajectoryPageResult>;
+/**
+ * Why the last read failed. `partial` is not a message — the daemon reports it
+ * as a flag — so it is carried as a kind for the view to name, rather than as
+ * a word that would end up quoted at the reader.
+ */
+export type TrajectoryWindowFailure = {
+    kind: 'partial';
+} | {
+    kind: 'unreadable';
+    message: string;
+};
+export interface TrajectoryWindow {
+    trajectory: Trajectory | undefined;
+    status: 'idle' | 'loading' | 'ready' | 'error';
+    error?: TrajectoryWindowFailure;
+    /**
+     * The session has history older than what this page carries. Nothing here
+     * can reach it yet, so the view says so rather than offering an action.
+     */
+    truncated: boolean;
+    /** Re-read the newest page. Also how a failed read is retried. */
+    refresh: () => void;
+}
+/**
+ * Hold the newest page of one session's transcript and fold it into a
+ * trajectory.
+ *
+ * The page is this view's own: paged replay is the only path that emits timing
+ * frames, and the chat store is fed by the live stream and by bulk replay,
+ * neither of which carries them. Reading here also keeps the window contiguous
+ * by construction, which is what lets the projection pair a frame with what it
+ * measured.
+ *
+ * `refresh` replaces the page rather than splicing into it: page boundaries
+ * are chosen per request, so a fresh page and the held one overlap by an
+ * unknown amount and cannot be joined without dropping or repeating records.
+ */
+export declare function useTrajectoryWindow(loadPage: TrajectoryPageLoader | undefined, options?: {
+    pageSize?: number;
+}): TrajectoryWindow;

package/dist/types/utils/assistantFeedback.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Persisted satisfied / not-satisfied marks for assistant answers.
+ *
+ * The mark is Web Shell's own UI state: the host is notified through
+ * `customization.assistantFeedback.onRate`, but never feeds state back. Storage
+ * is therefore best-effort and local to this browser — a failure to read or
+ * write must never affect the click that just happened.
+ */
+import type { WebShellAssistantFeedbackInfo, WebShellAssistantFeedbackOptions, WebShellAssistantFeedbackUserMessage } from '../customization';
+import type { TranscriptRenderMode } from '../transcriptRenderMode';
+/**
+ * Whether an assistant answer may carry satisfied / not-satisfied marks.
+ *
+ * Two conditions, both required: a session to store the mark under, and an
+ * interactive rendering — read-only and document transcripts stay untouched
+ * however much session context they carry.
+ */
+export declare function shouldOfferAssistantFeedback({ renderMode, sessionId, options, }: {
+    renderMode: TranscriptRenderMode;
+    sessionId?: string;
+    options?: WebShellAssistantFeedbackOptions;
+}): boolean;
+/**
+ * Tells the host about a mark the user just made. The host is a listener, not
+ * an authority: it cannot veto the mark, and a throw here must not reach the
+ * click handler.
+ */
+export declare function notifyAssistantFeedback(handler: ((info: WebShellAssistantFeedbackInfo) => void) | undefined, info: WebShellAssistantFeedbackInfo): void;
+export type AssistantFeedbackRating = 'up' | 'down';
+/** Session id -> turn prompt id -> mark. */
+export type AssistantFeedbackStore = Record<string, Record<string, AssistantFeedbackRating>>;
+export declare const ASSISTANT_FEEDBACK_STORAGE_KEY = "qwen-web-shell-assistant-feedback";
+/** Sessions kept in storage; the rest age out oldest-first. */
+export declare const MAX_ASSISTANT_FEEDBACK_SESSIONS = 10;
+/** Characters of the turn's prompt forwarded to the host. */
+export declare const FEEDBACK_USER_MESSAGE_MAX_CHARS = 100;
+/**
+ * Summarises the turn's prompt for the host. Only the tail is kept: the end of
+ * a prompt is what distinguishes it from its neighbours in a list of marks.
+ */
+export declare function describeFeedbackUserMessage(message: {
+    content: string;
+    images?: readonly unknown[];
+    files?: readonly unknown[];
+    timestamp?: number;
+}): WebShellAssistantFeedbackUserMessage;
+/**
+ * The prompt that started the turn whose head message is `turnId`. A shell
+ * turn's prompt is its command; anything else is reported as unknown rather
+ * than guessed.
+ */
+export declare function feedbackUserMessageOf(messages: readonly {
+    id: string;
+    role: string;
+    content?: string;
+    command?: string;
+    images?: readonly unknown[];
+    files?: readonly unknown[];
+    timestamp?: number;
+}[], turnId: string): WebShellAssistantFeedbackUserMessage;
+/**
+ * Reads the persisted marks, dropping anything unrecognizable rather than
+ * guessing: a hand-edited or future payload must degrade to "nothing marked".
+ */
+export declare function readAssistantFeedbackStore(): AssistantFeedbackStore;
+export declare function writeAssistantFeedbackStore(store: AssistantFeedbackStore): void;
+/**
+ * Returns a new store with `promptId` marked (or cleared when `rating` is
+ * null). Pure so React can run it inside a state updater.
+ */
+export declare function setAssistantFeedbackRating(store: AssistantFeedbackStore, sessionId: string, promptId: string, rating: AssistantFeedbackRating | null): AssistantFeedbackStore;

package/dist/types/utils/commitGraph.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/** A line segment drawn across one row, addressed by lane index. */
+export interface CommitGraphLine {
+    column: number;
+    color: number;
+}
+export interface CommitGraphRow {
+    /** Lane holding this commit's node. */
+    column: number;
+    /** Colour index of the node and of the lane it continues. */
+    color: number;
+    /** Lanes entering the node from the row above (own lane and merged children). */
+    incoming: CommitGraphLine[];
+    /** Lanes leaving the node toward the row below (one per parent). */
+    outgoing: CommitGraphLine[];
+    /** Lanes that cross this row without touching the node. */
+    through: CommitGraphLine[];
+    /** Lanes still open below this row; drawn straight through expanded rows. */
+    after: CommitGraphLine[];
+    /** Highest lane index touched on this row plus one. */
+    width: number;
+}
+/**
+ * Lay out commits (newest first, parents never before children) into lanes.
+ *
+ * Each lane waits for one commit. A commit takes the lowest lane waiting for
+ * it, or a fresh lane when none is; every other lane waiting for it merges in
+ * at its node, so a mainline never jogs sideways to meet a fork. Its first
+ * parent continues the lane; further parents each get the lane already
+ * waiting for them or a new one.
+ */
+export declare function layoutCommitGraph(entries: ReadonlyArray<{
+    sha: string;
+    parents: string[];
+}>): CommitGraphRow[];

package/dist/types/utils/contextCompression.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Structured companion to the English sentence `/compress` streams over ACP.
+ *
+ * The daemon ships on its own release cadence, so this is parsed defensively:
+ * an unreadable payload falls back to rendering the sentence as before rather
+ * than dropping the message.
+ */
+export interface ContextCompressionResult {
+    originalTokenCount: number;
+    newTokenCount: number;
+    originalTokenCountIsEstimated: boolean;
+    newTokenCountIsEstimated: boolean;
+    /** Server-authored advisory. Free-form text, not a translation key. */
+    warning?: string;
+}
+export type ContextCompressionMeta = {
+    phase: 'notice';
+    instructionsLimit: number;
+} | {
+    phase: 'progress';
+} | {
+    phase: 'noop';
+} | {
+    phase: 'done';
+    result: ContextCompressionResult;
+};
+export declare function parseContextCompressionMeta(value: unknown): ContextCompressionMeta | undefined;
+/**
+ * Token count for a compression line, grouped for the UI language rather than
+ * the browser's locale. `~` marks a locally estimated count, the same
+ * convention the TUI banner uses (#9309).
+ */
+export declare function formatCompressionTokens(count: number, isEstimated: boolean, language: string): string;

package/dist/types/utils/sessionPreparation.d.ts

@@ -3,6 +3,7 @@ import type { ReasoningSelection } from '@qwen-code/sdk/daemon';
 type PromptSessionActions = {
     createSession: (options?: {
         workspaceCwd?: string;
+        getCurrentWorkspaceCwd?: () => string | undefined;
         sessionContext?: DaemonProductSessionContext;
         modelServiceId?: string;
         approvalMode?: DaemonApprovalMode;
@@ -40,7 +41,7 @@ type PromptSessionActions = {
     }) => Promise<void>;
 };
 export declare function isDaemonApprovalMode(mode: string): mode is DaemonApprovalMode;
-export declare function createAndAttachSessionForPrompt({ sessionActions, modelId, reasoningEffort, modeId, planMode, workspaceCwd, sessionContext, worktree, branch, sessionSourceType, onSessionCreated, onSessionAllocated, getCurrentSessionId, warn, }: {
+export declare function createAndAttachSessionForPrompt({ sessionActions, modelId, reasoningEffort, modeId, planMode, workspaceCwd, sessionContext, worktree, branch, sessionSourceType, onSessionCreated, onSessionAllocated, getCurrentSessionId, getCurrentWorkspaceCwd, warn, }: {
     sessionActions: PromptSessionActions;
     modelId?: string;
     reasoningEffort?: ReasoningSelection;
@@ -62,6 +63,7 @@ export declare function createAndAttachSessionForPrompt({ sessionActions, modelI
     onSessionCreated?: (sessionId: string) => Promise<void> | void;
     onSessionAllocated?: (sessionId: string) => void;
     getCurrentSessionId: () => string | undefined;
+    getCurrentWorkspaceCwd?: () => string | undefined;
     warn?: (message?: unknown, ...optionalParams: unknown[]) => void;
 }): Promise<{
     worktree?: {

package/dist/types/voice/capture-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Transport-agnostic pieces of browser microphone capture, shared by voice
+ * dictation (`/voice/stream`) and the Live Voice browser Host (`/live/web`).
+ */
+export declare function toVoiceWebSocketUrl(baseUrl: string, streamPath: string): string;
+export declare const WS_AUTH_SUBPROTOCOL = "qwen-ws";
+export declare function bearerSubprotocol(token: string): string;
+export declare function describeMicError(err: unknown): string;
+/** Float32 [-1,1] frame → Int16 PCM + RMS level. */
+export declare function floatToPcm16(input: Float32Array): {
+    pcm: ArrayBuffer;
+    level: number;
+};
+/** `Sec-WebSocket-Protocol` values that carry the daemon bearer token. */
+export declare function voiceWebSocketProtocols(token?: string): string[] | undefined;
+/** Microphone constraints: mono, with the browser's echo and noise handling. */
+export declare const MICROPHONE_CONSTRAINTS: MediaStreamConstraints;

package/dist/types/voice/useVoiceCapture.d.ts

@@ -3,6 +3,8 @@
  * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
+import { toVoiceWebSocketUrl } from './capture-utils';
+export { toVoiceWebSocketUrl };
 /**
  * Captures 16 kHz mono PCM in the browser and streams it to the immutable
  * workspace owner selected when recording starts. Credentials remain in the
@@ -38,5 +40,4 @@ export interface UseVoiceCaptureReturn {
     stop: () => void;
     abort: () => void;
 }
-export declare function toVoiceWebSocketUrl(baseUrl: string, streamPath: string): string;
 export declare function useVoiceCapture({ baseUrl, token, target, onFinal, onError, onUnexpectedClose, }: UseVoiceCaptureOptions): UseVoiceCaptureReturn;