@qwen-code/web-shell 0.26.1-nightly.20261025.8e28d5380c → 0.26.2-preview.0

package/dist/types/components/ChatEditor.d.ts

@@ -8,8 +8,9 @@ import type { DaemonSessionGroupPresetColor, DaemonWorkspaceGitStatus, Reasoning
 import type { CommandDisplayCategoryOrder } from '../utils/commandDisplay';
 import type { SkillInfo } from '../completions/slashCompletion';
 import type { DaemonReasoningControls } from '@qwen-code/web-shell/daemon-react-sdk';
-import { type WebShellComposerInput, type WebShellComposerTagIconMap, type WebShellAtProvider, type WebShellBuiltinAtProvidersConfig } from '../customization';
+import { type WebShellComposerInput, type WebShellComposerTag, type WebShellComposerTagIconMap, type WebShellAtProvider, type WebShellBuiltinAtProvidersConfig } from '../customization';
 import { type ComposerSubmitMetadata, type EditorHandle } from '../hooks/useComposerCore';
+import { type UseFileUploadOptions } from '../hooks/useFileUpload';
 import type { ContextCompressionControls } from '../hooks/useContextUsageControls';
 import type { WebShellUnavailableModel, WebShellUnavailableModelTooltipMount } from '../unavailableModels';
 import type { VoiceStatusRevision, VoiceWorkspaceTarget } from '../voice/voice-workspace-target';
@@ -136,6 +137,9 @@ interface ChatEditorProps {
     shellModeEnabled?: boolean;
     workspaceFeaturesEnabled?: boolean;
     fileReferenceActions?: AtMentionWorkspaceActions;
+    fileUploadTarget?: UseFileUploadOptions & {
+        createReference(path: string): WebShellComposerTag;
+    };
     persistFileReferences?: boolean;
     attachmentsEnabled?: boolean;
     onChatWidthModeChange?: (mode: '1000' | 'wide') => void;

package/dist/types/components/MessageItem.d.ts

@@ -35,6 +35,7 @@ interface MessageItemProps {
     onBranchSession?: (branchRecordId?: string) => void | Promise<void>;
     branchRecordId?: string;
     showAssistantActions?: boolean;
+    assistantFooterAlwaysVisible?: boolean;
     showAssistantBranch?: boolean;
     /** Turn id marks are keyed by; unset hides the marks for this message. */
     assistantFeedbackTurnId?: string;

package/dist/types/components/managed/ManagedSessionActions.d.ts

@@ -1,7 +1,7 @@
 import type { ManagedAgentSessionSummary, ManagedLifecycleAction } from './managed-agent-provider';
 import type { ManagedLifecycleState } from './use-managed-session-lifecycle';
 export declare function managedSessionActions(session: ManagedAgentSessionSummary): ManagedLifecycleAction[];
-export declare function ManagedSessionActions({ session, sidebar, lifecycle, exporting, state, onAction, onExport, onConfirm, }: {
+export declare function ManagedSessionActions({ session, sidebar, lifecycle, exporting, state, onAction, onExport, onConfirm, onRename, }: {
     session: ManagedAgentSessionSummary;
     sidebar?: boolean;
     lifecycle: boolean;
@@ -10,6 +10,7 @@ export declare function ManagedSessionActions({ session, sidebar, lifecycle, exp
     onAction: (session: ManagedAgentSessionSummary, action: ManagedLifecycleAction) => void;
     onExport?: (sessionId: string, format: 'html' | 'md') => void;
     onConfirm: (sessionId: string) => void;
+    onRename?: () => void;
 }): import("react/jsx-runtime").JSX.Element | null;
 export declare function ManagedLifecycleConfirmation({ session, action, onConfirm, onClose, }: {
     session: ManagedAgentSessionSummary;

package/dist/types/components/managed/ManagedSessionsPage.d.ts

@@ -2,7 +2,7 @@ import type { WorkspaceSelectorOption } from '../WorkspaceSelector';
 import type { ManagedCreationSkillsSource } from './managed-creation-skills';
 import { type ManagedArchivedSessionsStatus } from './ManagedArchivedSessions';
 import type { ManagedAgentProvider, ManagedAgentWorkspace } from './managed-agent-provider';
-export declare function ManagedSessionsPage({ sessionId, workspaceCreationOpen, onWorkspaceCreationOpenChange, onWorkspaceCreated, onOpenLocalWorkspace, daemonWorkspaces, onSelectDaemonWorkspace, onWorkspacesChange, onSelectSession, onOpenSession, workspaceId, onSelectWorkspace, onSessionWorkspaceChange, managedAgentProvider, navigationTarget, archivedNavigationTarget, onArchivedSessionsStatusChange, interactive, creationSkills, onManageSkills, navigationActive, navigationSearch, }: {
+export declare function ManagedSessionsPage({ sessionId, workspaceCreationOpen, onWorkspaceCreationOpenChange, onWorkspaceCreated, onOpenLocalWorkspace, daemonWorkspaces, onSelectDaemonWorkspace, onWorkspacesChange, onSelectSession, onOpenSession, workspaceId, onSelectWorkspace, onSessionWorkspaceChange, managedAgentProvider, navigationTarget, archivedNavigationTarget, onArchivedSessionsStatusChange, interactive, creationSkills, navigationActive, navigationSearch, }: {
     sessionId?: string;
     workspaceCreationOpen?: boolean;
     onWorkspaceCreationOpenChange?: (open: boolean) => void;
@@ -23,7 +23,6 @@ export declare function ManagedSessionsPage({ sessionId, workspaceCreationOpen,
     onArchivedSessionsStatusChange?: (status: ManagedArchivedSessionsStatus) => void;
     interactive?: boolean;
     creationSkills?: ManagedCreationSkillsSource;
-    onManageSkills?: () => void;
     navigationActive?: boolean;
     navigationSearch?: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/managed/WorkspaceBindingCreator.d.ts

@@ -1,7 +1,7 @@
 import { type ManagedCreationSkillsSource } from './managed-creation-skills';
 import type { WorkspaceSelectorOption } from '../WorkspaceSelector';
 import type { ManagedAgentProvider } from './managed-agent-provider';
-export declare function WorkspaceBindingCreator({ provider, workspaceCreationOpen, onWorkspaceCreationOpenChange, onOpenLocalWorkspace, daemonWorkspaces, onSelectDaemonWorkspace, creationOnly, clientId, onCreated, onAbandoned, workspaceId: explicitWorkspaceId, onSelectWorkspace, onWorkspaceCreated, interactive, creationSkills, onManageSkills, handoff, onOpenHandoffSource, }: {
+export declare function WorkspaceBindingCreator({ provider, workspaceCreationOpen, onWorkspaceCreationOpenChange, onOpenLocalWorkspace, daemonWorkspaces, onSelectDaemonWorkspace, creationOnly, clientId, onCreated, onAbandoned, workspaceId: explicitWorkspaceId, onSelectWorkspace, onWorkspaceCreated, interactive, creationSkills, handoff, onOpenHandoffSource, }: {
     provider: ManagedAgentProvider;
     workspaceCreationOpen?: boolean;
     onWorkspaceCreationOpenChange?: (open: boolean) => void;
@@ -17,7 +17,6 @@ export declare function WorkspaceBindingCreator({ provider, workspaceCreationOpe
     onWorkspaceCreated?: (workspaceId: string) => void;
     interactive?: boolean;
     creationSkills?: ManagedCreationSkillsSource;
-    onManageSkills?: () => void;
     handoff?: import('./managed-recovery-handoff').ManagedRecoveryHandoff;
     onOpenHandoffSource?: () => void;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -150,23 +150,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/agent/web-shell/v1/sessions/cwd/change": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /** @description W2, implemented: the camelCase twin of the public changeSessionCwd with the matched refusal order: 400 invalid_request for a missing or malformed field; 401 actor_required without a trusted actor; 400 invalid_idempotency_key for a malformed idempotencyKey — with two documented divergences: a key over 128 characters is refused during request validation with 400 invalid_request before the service's check, and a blank idempotencyKey is refused there too, while the public header answers 400 invalid_idempotency_key for both shapes; 400 invalid_cwd for a lexical violation and 400 invalid_request for an expectedContextRevision below 1; 404 session_not_found for an unknown Session id; 400 unsupported_feature for an unbound Session; 404 session_not_found for an unreadable Session; 409 idempotency_conflict when one key carries different content, and a completed change under the same key always replays instead, before the role refusal; 403 session_operation_forbidden when a readable actor's Workspace role is below OPERATOR; 409 workspace_unavailable when execution is disabled; 404 session_not_found for a deleted Session; then 409 session_state_conflict, 409 workspace_unavailable from moved Registry facts (the recorded create-command actor's grant included, and the settlement re-checks the V56-persisted initiator the same way, so demoting either actor fails the operation, exactly like the public surface), 409 context_revision_conflict and 409 session_context_busy. Poll the operation or await session.context.changed; do not treat 202 as activation. */
-        post: operations["webShellChangeCwd"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/agent/web-shell/v1/operations/query": {
         parameters: {
             query?: never;
@@ -1034,6 +1017,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/agent/web-shell/v1/workspaces/files/upload": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload one binary file to a persisted Workspace
+         * @description Requires a trusted actor with OPERATOR or OWNER access, enabled Workspace files, verified LOCAL or SSH_LOCAL storage and an updated CLI. Uploads are limited to 8 MiB, require an existing parent directory and never overwrite an occupied path. A durable physical storage hold excludes tool execution and retirement until the original upload has a definite terminal result. Repeating the same upload ID reconciles its original command without replaying mutation; changed requests conflict. CSI is unsupported and never falls back to a primary Workspace. An uncertain result returns 503 workspace_upload_pending and must be queried by the original upload ID.
+         */
+        post: operations["webShellWorkspaceFilesUpload"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/agent/web-shell/v1/workspaces/files/uploads/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Reconcile the original Workspace upload
+         * @description Only the admitting actor with a current Workspace operator grant can query the upload. Status checks use the frozen original storage target and never execute an upload or select a replacement Runtime. Reconciliation remains available through storage fencing; pending commands retain their durable hold. The server also reconciles pending uploads after client cancellation or restart.
+         */
+        post: operations["webShellWorkspaceFilesUploadQuery"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1270,7 +1293,8 @@ export interface components {
         };
         WebShellSessionCapabilities: {
             /**
-             * @description True when Workspace files are enabled, the bound Session is active and undeleted, the caller holds OPERATOR or above on the Workspace and the exact ACTIVE Registry generation/storage and create-command-actor OPERATOR/OWNER grant still hold, matching cwd admission. This does not promise an idle Session and is independent of workspaceTurns execution-profile gates. Missing means false. Existing operations remain queryable under read authorization even when this capability is false.
+             * @deprecated
+             * @description Retired: Session directory-change submission has been removed; always false.
              * @default false
              */
             cwdChange?: boolean;
@@ -1484,15 +1508,6 @@ export interface components {
                 canCreateSession?: true;
             }) | null;
         };
-        WebShellChangeCwdRequest: {
-            /** Format: uuid */
-            sessionId: string;
-            idempotencyKey: string;
-            cwdRelative: components["schemas"]["WorkspaceRelativePath"];
-            /** Format: int64 */
-            expectedContextRevision: number;
-            requestId?: string | null;
-        };
         WebShellOperationRequest: {
             /** Format: uuid */
             sessionId: string;
@@ -2104,6 +2119,8 @@ export interface components {
             directory: string;
             entries: components["schemas"]["WebShellWorkspaceFileEntry"][];
             truncated: boolean;
+            /** @description Present only when the selected CLI supports durable Workspace uploads. */
+            maxUploadBytes?: number;
         };
         WebShellWorkspaceFileSnapshot: {
             scopeRevision: string;
@@ -2482,6 +2499,29 @@ export interface components {
             idempotencyKey: string;
             command: components["schemas"]["ManagedExtensionApplySelection"];
         };
+        WebShellWorkspaceFileUploadResult: {
+            scopeRevision: string;
+            /** Format: uuid */
+            uploadId: string;
+            path: string;
+            sizeBytes: number;
+            sha256: string;
+        };
+        WebShellWorkspaceFileUploadStatus: {
+            scopeRevision: string;
+            /** Format: uuid */
+            uploadId: string;
+            path: string;
+            sizeBytes: number;
+            sha256: string;
+            /** @enum {string} */
+            state: "completed" | "failed" | "pending";
+            code?: string;
+        };
+        WebShellWorkspaceFileUploadQueryRequest: {
+            /** Format: uuid */
+            uploadId: string;
+        };
     };
     responses: {
         /** @description The authenticated actor belongs to another tenant than X-Qwen-Tenant-Id or has an invalid ID (actor_scope_mismatch, which the tenant filter answers on every /v1/agents/ and WebShell route), or the resource is readable but the actor lacks this operation or the original Action responder permission. Artifact content reads may also return artifact_content_forbidden when the actor cannot read the original bytes. */
@@ -2851,36 +2891,6 @@ export interface operations {
             413: components["responses"]["PayloadTooLarge"];
         };
     };
-    webShellChangeCwd: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["WebShellChangeCwdRequest"];
-            };
-        };
-        responses: {
-            /** @description Durable cwd operation; acceptance does not mean the new cwd is active. */
-            202: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["WebShellCwdOperation"];
-                };
-            };
-            400: components["responses"]["BadRequest"];
-            401: components["responses"]["Unauthorized"];
-            403: components["responses"]["Forbidden"];
-            404: components["responses"]["NotFound"];
-            409: components["responses"]["Conflict"];
-            413: components["responses"]["PayloadTooLarge"];
-        };
-    };
     webShellQueryCwdOperation: {
         parameters: {
             query?: never;
@@ -4630,4 +4640,88 @@ export interface operations {
             };
         };
     };
+    webShellWorkspaceFilesUpload: {
+        parameters: {
+            query: {
+                workspaceId: string;
+                cwdRelative: string;
+                path: string;
+                expectedScopeRevision: string;
+                uploadId: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/octet-stream": string;
+            };
+        };
+        responses: {
+            /** @description Workspace upload result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspaceFileUploadResult"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            /** @description The upload exceeds the 8 MiB binary limit. */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            /** @description Uploads require unencoded application/octet-stream bytes. */
+            415: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorEnvelope"];
+                };
+            };
+            503: components["responses"]["Unavailable"];
+        };
+    };
+    webShellWorkspaceFilesUploadQuery: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["WebShellWorkspaceFileUploadQueryRequest"];
+            };
+        };
+        responses: {
+            /** @description Workspace upload result. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["WebShellWorkspaceFileUploadStatus"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            401: components["responses"]["Unauthorized"];
+            403: components["responses"]["Forbidden"];
+            404: components["responses"]["NotFound"];
+            409: components["responses"]["Conflict"];
+            503: components["responses"]["Unavailable"];
+        };
+    };
 }

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

@@ -100,6 +100,14 @@ export declare class JavaManagedAgentClient {
     createWorkspace(request: Schemas['WebShellWorkspaceCreateRequest'], signal?: AbortSignal): Promise<JavaAgentWorkspace>;
     queryWorkspaceFiles(request: Schemas['WebShellWorkspaceFileQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFilePage']>;
     readWorkspaceFile(request: Schemas['WebShellWorkspaceFileReadRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileSnapshot']>;
+    uploadWorkspaceFile(request: {
+        workspaceId: string;
+        cwdRelative: string;
+        path: string;
+        expectedScopeRevision: string;
+        uploadId: string;
+    }, data: Blob, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileUploadResult']>;
+    queryWorkspaceFileUpload(uploadId: string, signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceFileUploadStatus']>;
     workspaceDirectories(request: Schemas['WebShellWorkspaceDirectoryQueryRequest'], signal?: AbortSignal): Promise<Schemas['WebShellWorkspaceDirectoryPage']>;
     getSessionApproval(sessionId: string, signal?: AbortSignal): Promise<Schemas['WebShellSessionApproval']>;
     changeApproval(request: Schemas['WebShellChangeApprovalRequest'], signal?: AbortSignal): Promise<Schemas['WebShellApprovalChangeResult']>;
@@ -173,7 +181,6 @@ export declare class JavaManagedAgentClient {
     respondAction(request: Schemas['WebShellActionRespondRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCommandOperation']>;
     /** Reads an operation's latest durable status; polling is not a replay. */
     queryOperation(request: Schemas['WebShellOperationRequest'], signal?: AbortSignal): Promise<Schemas['WebShellOperation']>;
-    changeCwd(request: Schemas['WebShellChangeCwdRequest'], signal?: AbortSignal): Promise<Schemas['WebShellCwdOperation']>;
     compressContext(request: Schemas['WebShellContextCompressionRequest'], signal?: AbortSignal): Promise<Schemas['WebShellContextCompressionOperation']>;
     getSessionModels(sessionId: string, signal?: AbortSignal): Promise<{
         models: components["schemas"]["WebShellModelOption"][];
@@ -302,5 +309,6 @@ export declare class JavaManagedAgentClient {
     }>;
     private post;
     private request;
+    private fetchRequest;
 }
 export {};

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

@@ -120,7 +120,6 @@ export interface ManagedAgentSessionSummary {
         artifacts?: boolean;
         /** The caller may submit later Turns to this Workspace-bound Session. */
         workspaceTurns?: boolean;
-        cwdChange?: boolean;
         modelChange?: boolean;
         contextCompression?: boolean;
         approvalModeChange?: boolean;
@@ -163,7 +162,6 @@ export interface ManagedAgentRequestOptions {
 export interface ManagedAgentCommandOptions extends ManagedAgentRequestOptions {
     idempotencyKey: string;
 }
-export type ManagedCwdOperation = components['schemas']['WebShellCwdOperation'];
 export type ManagedContextCompressionOperation = components['schemas']['WebShellContextCompressionOperation'];
 export type ManagedTask = components['schemas']['WebShellTask'];
 export type ManagedTaskPage = components['schemas']['WebShellTaskPage'];
@@ -276,13 +274,6 @@ export interface ManagedAgentProvider {
             query(sessionId: string, taskId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedTaskCancelOperation>;
         };
     };
-    readonly cwdChange?: {
-        submit(sessionId: string, request: {
-            cwdRelative: string;
-            expectedContextRevision: number;
-        }, options: ManagedAgentCommandOptions): Promise<ManagedCwdOperation>;
-        query(sessionId: string, operationId: string, options: ManagedAgentRequestOptions): Promise<ManagedCwdOperation>;
-    };
     readonly contextCompression?: {
         submit(sessionId: string, request: {
             expectedCompactionRevision: number;
@@ -310,6 +301,14 @@ export interface ManagedAgentProvider {
     readonly workspaceFiles?: {
         query(request: components['schemas']['WebShellWorkspaceFileQueryRequest'], options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFilePage']>;
         read(request: components['schemas']['WebShellWorkspaceFileReadRequest'], options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileSnapshot']>;
+        upload?(request: {
+            workspaceId: string;
+            cwdRelative: string;
+            path: string;
+            expectedScopeRevision: string;
+            uploadId: string;
+        }, data: Blob, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileUploadResult']>;
+        queryUpload?(uploadId: string, options: ManagedAgentRequestOptions): Promise<components['schemas']['WebShellWorkspaceFileUploadStatus']>;
     };
     readonly workspaceBinding?: {
         readonly agentId: string;

package/dist/types/components/managed/use-managed-file-references.d.ts

@@ -1,5 +1,6 @@
 import type { AtMentionWorkspaceActions } from '../../hooks/useAtMentionSources';
 import type { ComposerSubmitMetadata } from '../../hooks/useComposerCore';
+import type { WebShellComposerTag } from '../../customization';
 import type { ManagedAgentProvider } from './managed-agent-provider';
 import type { PromptFile } from '../../adapters/promptTypes';
 export declare function useManagedFileReferences(provider: ManagedAgentProvider, clientId: string, workspace: {
@@ -9,6 +10,12 @@ export declare function useManagedFileReferences(provider: ManagedAgentProvider,
     state?: string;
 } | undefined, sessionId?: string): {
     actions: AtMentionWorkspaceActions | undefined;
+    uploadTarget: {
+        client: import("../../hooks/useFileUpload").FileUploadClient;
+        targetKey: string;
+        maxBytes: number;
+        createReference(path: string): WebShellComposerTag;
+    } | undefined;
     busy: boolean;
     prepareInput: (text: string, files?: readonly PromptFile[], metadata?: ComposerSubmitMetadata) => Promise<{
         text: string;

package/dist/types/components/managed/use-managed-file-upload.d.ts

@@ -0,0 +1,23 @@
+import type { FileUploadClient } from '../../hooks/useFileUpload';
+import type { WebShellComposerTag } from '../../customization';
+import type { ManagedAgentProvider } from './managed-agent-provider';
+export interface ManagedUploadReference {
+    version: 1;
+    source: string;
+    scopeRevision: string;
+    path: string;
+}
+interface UploadScope {
+    workspaceId: string;
+    cwdRelative: string;
+    source: string;
+    scopeRevision: string;
+    maxUploadBytes: number;
+}
+export declare function useManagedFileUpload(provider: ManagedAgentProvider, clientId: string, scope: UploadScope | undefined): {
+    client: FileUploadClient;
+    targetKey: string;
+    maxBytes: number;
+    createReference(path: string): WebShellComposerTag;
+} | undefined;
+export {};

package/dist/types/components/managed/use-managed-session-rename.d.ts

@@ -1,12 +1,12 @@
 import type { ManagedAgentProvider, ManagedAgentSessionSummary } from './managed-agent-provider';
-export declare function useManagedSessionRename(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, interactive: boolean, onRenamed: (displayName: string) => void): {
+export declare function useManagedSessionRename(provider: ManagedAgentProvider, clientId: string, sessionId: string | undefined, summary: ManagedAgentSessionSummary | undefined, interactive: boolean, onRenamed: (sessionId: string, displayName: string) => void): {
     supported: boolean;
     editor: {
         value: string;
         busy: boolean;
         error?: string;
     } | undefined;
-    open(): void;
+    open(session?: ManagedAgentSessionSummary | undefined): void;
     close(): void;
     setValue(value: string): void;
     submit(displayName: string): Promise<void>;

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

@@ -10,6 +10,7 @@ interface AssistantMessageProps {
     timestamp?: number;
     onBranchSession?: () => void | Promise<void>;
     showFooterActions?: boolean;
+    footerAlwaysVisible?: boolean;
     showBranchAction?: boolean;
     /** Satisfied / not-satisfied marks are only offered when this is set. */
     showAssistantFeedback?: boolean;

package/dist/types/components/plugins/PluginManagerPage.d.ts

@@ -1,4 +1,5 @@
 import { type Ref } from 'react';
+import type { ManagedExtensionsManagerPageProps } from '../managed/ManagedExtensionsManagerPage';
 import { type ManagedMcpManagerPageProps } from '../managed/ManagedMcpManagerPage';
 type PluginTab = 'extensions' | 'mcp' | 'skills' | 'agents';
 interface PluginManagerPageProps {
@@ -9,7 +10,8 @@ interface PluginManagerPageProps {
     skillsWorkspaceCwd?: string;
     onSkillsWorkspaceChange?: (cwd: string) => void;
     managedSkills?: boolean;
+    managedExtensions?: Omit<ManagedExtensionsManagerPageProps, 'onClose'>;
     managedMcp?: ManagedMcpManagerPageProps;
 }
-export declare function PluginManagerPage({ onClose, onUseSkill, initialFocusRef, initialTab, skillsWorkspaceCwd, onSkillsWorkspaceChange, managedSkills, managedMcp, }: PluginManagerPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function PluginManagerPage({ onClose, onUseSkill, initialFocusRef, initialTab, skillsWorkspaceCwd, onSkillsWorkspaceChange, managedSkills, managedExtensions, managedMcp, }: PluginManagerPageProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/ui/tooltip.d.ts

@@ -3,5 +3,7 @@ import { Tooltip as TooltipPrimitive } from 'radix-ui';
 declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
 declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
-declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement> & {
+    variant?: "default" | "black";
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
 export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/types/settings.d.ts

@@ -62,6 +62,7 @@ declare const SETTING_KEYS: {
     readonly 'setting:omni-media-delivery': "omni.enabled";
     readonly 'setting:artifacts': "experimental.artifact";
     readonly 'setting:tool-use-summaries': "experimental.emitToolUseSummaries";
+    readonly 'setting:unified-agent-loop': "experimental.unifiedAgentLoop";
     readonly 'setting:voice-model': "voiceModel";
     readonly 'setting:image-model': "imageModel";
 };

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

@@ -1,4 +1,5 @@
 export declare function getReplySelectionRange(body: HTMLElement): Range | null;
+export declare function getSelectedReplyText(body: HTMLElement, range: Range): string | null;
 export declare function getSelectedReplyContent(body: HTMLElement, range: Range): {
     text: string;
     markdown: string;

package/dist/types/utils/selectionClipboard.transcript-stub.d.ts

@@ -0,0 +1 @@
+export declare function getSelectedReplyText(body: HTMLElement): string;

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

@@ -0,0 +1 @@
+export declare function formatTurnDuration(ms: number): string;