@love-moon/ai-sdk 0.17.1 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # @love-moon/ai-sdk
 
+## 0.18.0
+
+### Minor Changes
+
+- 72324fd: Add a local multi-chat runtime with isolated Chromium workers, persistent profiles,
+  per-account concurrency, resumable events, request deduplication, and SDK/CLI access.
+  Add experimental Kimi and Claude webpage adapters and optional AI SDK socket transport.
+
+  Support Kimi Connect JSON envelopes and DeepSeek XHR SSE patches, with verified
+  parallel real-account text chats, independent cancellation, and restart recovery.
+
+  Add DeepSeek --deepthink / --no-deepthink controls and SDK options with persisted
+  chat defaults, per-turn overrides, verified UI state, and runtime capability checks.
+
+  Connect Conductor web-kimi and web-deepseek to managed isolated Chromium workers
+  by default. Add conductor chat-web login, account credential bootstrap, automatic
+  daemon startup and idle shutdown, stable cross-process resume IDs, and browser
+  release when tasks close. Preserve the shared-profile queue for other providers.
+  Retain cancelled conversation URLs and report confirmed stops as interruptions.
+
+### Patch Changes
+
+- bdbda18: Preserve lightweight conversation identity archives across profile/history GC so
+  Conductor can resume the same provider conversation using its existing local ID.
+  Archive idle, workerless open chats; persist the completed-turn resume guard; and
+  distinguish slow page loading from confirmed authentication failures.
+
+  Upgrading a CLI while an older managed runtime is running can report
+  RUNTIME_UPGRADE_REQUIRED when queuedStartup or durableResume support is missing.
+  After active chats finish, run `conductor chat-web runtime stop` and retry;
+  the next managed session starts the updated runtime. Alternatively, a runtime
+  with no active turns or pinned login windows exits after ten minutes without
+  requests. The CLI never terminates running chats automatically.
+
+  Profile deletion now starts only after the retention checkpoint commits, and
+  closed chats awaiting uncertainty review retain their profiles and turn history.
+  Accepted prompts refresh idle activity before collection, keeping their parent
+  conversation resident even when a client submits directly after a long idle.
+
+- 063b97c: Show daemon-host inspection and acknowledgement commands on uncertain chat-web
+  errors and REVIEW_REQUIRED, including interrupted sends and timeouts. Keep
+  acknowledgement explicit: it does not replay a request, and the user sends the
+  next message after checking the provider conversation. The web error message
+  contains the commands; acknowledgement currently runs through the host CLI.
+
+  Compact streamed event history into full text snapshots instead of failing
+  after 2000 events. Sequence numbers remain monotonic across compaction and
+  restart; replay cursors may cross gaps and recover through a message_snapshot.
+  The one-million-character text limit remains enforced.
+
+  Return CHAT*CLOSED when closing a chat races a headed resume. Strip CONDUCTOR*\*
+  identity variables from detached runtime and browser-worker environments while
+  preserving browser and proxy configuration.
+
+  Upgrade note: an already-running shared runtime continues executing its old
+  code. After active chats finish, run `conductor chat-web runtime stop` and retry
+  to launch the updated runtime. Older runtimes lacking required capabilities
+  report RUNTIME_UPGRADE_REQUIRED; unused managed runtimes exit after ten minutes
+  without requests or pinned login windows. No running chat is stopped
+  automatically during upgrade.
+
+- 31b61ea: Bound closed-chat and terminal-turn retention, reclaim browser profiles and orphan
+  directories, and keep streaming deltas in memory between durable checkpoints.
+  Defer saturated or busy chat startup to the turn queue, validate authentication at
+  allocation, and expire queued prompts before crash recovery or delayed submission.
+  Keep Gemini on its legacy transport with global runtime sockets and consume the
+  Conductor wrapper separator before forwarding a packaged CLI command.
+
+## 0.17.2
+
+### Patch Changes
+
+- b124565: Add QueuedChatSession with a shared local browser broker and a FIFO turn queue
+  across processes. Each task retains its own conversation tab; idle tasks no
+  longer hold exclusive access to the provider profile. The AI SDK uses queued
+  sessions when available and reports waiting positions through working status.
+
+  Cancel pending turns on disconnect, stop/close failed conversation tabs before
+  advancing the queue, and release the browser after its last client exits.
+  Keep the exclusive ChatSession API available for direct Playwright access.
+
+  Keep logical sessions usable after an active stop, timeout, or provider failure.
+  Restore the original provider conversation for the next explicit user operation;
+  require explicit clear when safe restoration is unavailable, and never replay a
+  failed prompt. Allow clear after a failed first submission. Correct the Windows
+  named-pipe address escaping.
+
+- 0a9488e: Add Kimi website text conversations with persistent login, multi-turn context,
+  reply progress, new chats and browser diagnostics. Expose the provider through
+  ai-sdk's chat-web backend and the web-kimi Conductor configuration alias.
+
+  Explicit unknown chat-web providers now fail with a clear error instead of
+  silently opening ChatGPT. The existing kimi CLI backend is unchanged.
+
 ## 0.17.1
 
 ### Patch Changes

package/dist/providers/chat-web-session.d.ts

@@ -1,34 +1,35 @@
 /**
  * AI SDK provider that delegates to the chat-web runtime
  * (`@love-moon/chat-web`), which automates a real Chromium browser against
- * ChatGPT / Gemini / DeepSeek and ferries conversations through their web
- * UIs. Choose the underlying chat-web provider via:
+ * chatbot web UIs. Kimi and DeepSeek use isolated persistent chat workers
+ * with an automatically started local daemon. ChatGPT/Gemini retain the
+ * shared-profile queue unless a runtime socket is explicitly configured.
+ * Choose the underlying chat-web provider via:
  *
- *   - `options.chatWebProvider`: "chatgpt" | "gemini"  (preferred)
+ *   - `options.chatWebProvider`: "chatgpt" | "gemini" | "kimi" | "deepseek"
  *   - `options.provider`:        same surface
  *   - `options.model`:           same surface (fallback for ergonomic
  *                                `createAiSession("chat-web", { model: "gemini" })`)
  *
  * Defaults to "chatgpt". Aliases: "openai"/"gpt" → chatgpt, "google" → gemini.
  *
- * Lifecycle:
- *   - `boot()` lazily imports `@love-moon/chat-web`, registers its built-in
- *     providers, and opens a long-lived `ChatSession` (headed by default).
- *   - `runTurn(prompt)` calls `session.send(prompt)` and emits a single
- *     `assistant_message` with the model's reply.
- *   - `close()` tears the Chromium context down.
- *
- * Resume: chat-web's "session" is a Chromium browser context, not a
- * conversation ID — there is no native cross-process resume. We synthesise
- * an id so the rest of ai-sdk has something stable to thread on, but
- * passing `resumeSessionId` does not reattach to a prior conversation.
+ * Login on the daemon host: conductor chat-web login kimi|deepseek.
+ * Managed runtime IDs use chat-web-runtime:<id> so restarts restore the same
+ * isolated profile and provider conversation. Legacy provider IDs are imported.
+ * Set chatWebRuntime: false to explicitly use the shared-profile queue.
+ * Explicit chatWebRuntimeSocket clients keep caller-managed lifecycle.
  */
 export class ChatWebSession extends EventEmitter<[never]> {
     constructor(backend: any, options?: {});
     backend: string;
     options: {};
     logger: any;
+    runtimeSocket: any;
     chatWebProvider: string;
+    runtimeMode: boolean;
+    managedRuntime: boolean;
+    runtimeConversationId: any;
+    runtimeProviderConversationId: any;
     headless: boolean;
     browserChannel: any;
     browserExecutablePath: any;
@@ -50,6 +51,7 @@ export class ChatWebSession extends EventEmitter<[never]> {
     closed: boolean;
     currentTurn: {
         aborted: boolean;
+        controller: AbortController;
     } | null;
     currentTurnStatus: {
         source: string;
@@ -65,6 +67,7 @@ export class ChatWebSession extends EventEmitter<[never]> {
         session_file_path: undefined;
         updated_at: string;
     } | null;
+    turnAttempted: boolean;
     sessionMessageHandler: any;
     workingStatusHandler: any;
     activeReplyTarget: string;
@@ -161,6 +164,8 @@ export class ChatWebSession extends EventEmitter<[never]> {
         manualResume: null;
     }>;
     getChatWebModule(): Promise<any>;
+    loginCommand(): string;
+    reviewInstructions(): string;
     boot(): Promise<void>;
     bootInternal(): Promise<void>;
     /**

package/dist/providers/chat-web-session.js

@@ -4,7 +4,8 @@ import { PROVIDER_MEDIA_CAPABILITIES } from "../media-adapters.js";
 import { assertMediaCapabilities, resolveTurnMedia } from "../media-input.js";
 import { normalizeContextFiles } from "../context-files.js";
 import { emitLog, normalizeLogger } from "../shared.js";
-const SUPPORTED_CHAT_WEB_PROVIDERS = new Set(["chatgpt", "gemini"]);
+const SUPPORTED_CHAT_WEB_PROVIDERS = new Set(["chatgpt", "gemini", "kimi", "deepseek"]);
+const RUNTIME_CHAT_WEB_PROVIDERS = new Set(["chatgpt", "deepseek", "kimi", "claude"]);
 const DEFAULT_CHAT_WEB_PROVIDER = "chatgpt";
 const DEFAULT_TURN_TIMEOUT_MS = 5 * 60 * 1000;
 function normalizeChatWebProvider(value) {
@@ -19,15 +20,25 @@ function normalizeChatWebProvider(value) {
     return raw;
 }
 function resolveChatWebProvider(options = {}) {
-    const candidates = [options.chatWebProvider, options.provider, options.model];
-    for (const candidate of candidates) {
+    const supported = options.chatWebRuntimeSocket || process.env.CHAT_WEB_RUNTIME_SOCKET
+        ? new Set([...SUPPORTED_CHAT_WEB_PROVIDERS, ...RUNTIME_CHAT_WEB_PROVIDERS]) : SUPPORTED_CHAT_WEB_PROVIDERS;
+    for (const candidate of [options.chatWebProvider, options.provider, options.model]) {
         const normalized = normalizeChatWebProvider(candidate);
-        if (SUPPORTED_CHAT_WEB_PROVIDERS.has(normalized)) {
-            return normalized;
+        if (!normalized)
+            continue;
+        if (!supported.has(normalized)) {
+            const error = new Error(`Unknown chat-web provider "${normalized}". Supported: ${[...supported].join(", ")}`);
+            error.reason = "unknown_chat_web_provider";
+            throw error;
         }
+        return normalized;
     }
     return DEFAULT_CHAT_WEB_PROVIDER;
 }
+function quoteRuntimeArgument(value) {
+    const text = String(value);
+    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(text) ? text : "'" + text.replaceAll("'", "'\\''") + "'";
+}
 function extractErrorMessage(error) {
     if (typeof error?.message === "string" && error.message.trim()) {
         return error.message.trim();
@@ -93,27 +104,23 @@ function isPlaywrightMissingError(error) {
 /**
  * AI SDK provider that delegates to the chat-web runtime
  * (`@love-moon/chat-web`), which automates a real Chromium browser against
- * ChatGPT / Gemini / DeepSeek and ferries conversations through their web
- * UIs. Choose the underlying chat-web provider via:
+ * chatbot web UIs. Kimi and DeepSeek use isolated persistent chat workers
+ * with an automatically started local daemon. ChatGPT/Gemini retain the
+ * shared-profile queue unless a runtime socket is explicitly configured.
+ * Choose the underlying chat-web provider via:
  *
- *   - `options.chatWebProvider`: "chatgpt" | "gemini"  (preferred)
+ *   - `options.chatWebProvider`: "chatgpt" | "gemini" | "kimi" | "deepseek"
  *   - `options.provider`:        same surface
  *   - `options.model`:           same surface (fallback for ergonomic
  *                                `createAiSession("chat-web", { model: "gemini" })`)
  *
  * Defaults to "chatgpt". Aliases: "openai"/"gpt" → chatgpt, "google" → gemini.
  *
- * Lifecycle:
- *   - `boot()` lazily imports `@love-moon/chat-web`, registers its built-in
- *     providers, and opens a long-lived `ChatSession` (headed by default).
- *   - `runTurn(prompt)` calls `session.send(prompt)` and emits a single
- *     `assistant_message` with the model's reply.
- *   - `close()` tears the Chromium context down.
- *
- * Resume: chat-web's "session" is a Chromium browser context, not a
- * conversation ID — there is no native cross-process resume. We synthesise
- * an id so the rest of ai-sdk has something stable to thread on, but
- * passing `resumeSessionId` does not reattach to a prior conversation.
+ * Login on the daemon host: conductor chat-web login kimi|deepseek.
+ * Managed runtime IDs use chat-web-runtime:<id> so restarts restore the same
+ * isolated profile and provider conversation. Legacy provider IDs are imported.
+ * Set chatWebRuntime: false to explicitly use the shared-profile queue.
+ * Explicit chatWebRuntimeSocket clients keep caller-managed lifecycle.
  */
 export class ChatWebSession extends EventEmitter {
     constructor(backend, options = {}) {
@@ -121,17 +128,25 @@ export class ChatWebSession extends EventEmitter {
         this.backend = "chat-web";
         this.options = options;
         this.logger = normalizeLogger(options.logger);
+        this.runtimeSocket = options.chatWebRuntimeSocket || process.env.CHAT_WEB_RUNTIME_SOCKET || "";
         this.chatWebProvider = resolveChatWebProvider(options);
-        // Match chat-web SDK's own default (headed). Per chat-web/core/browser.ts
-        // resolveHeadless(), headed mode is the documented safe default for
-        // anti-bot heuristics — ChatGPT/AI Studio routinely serve unauthenticated
-        // or challenge pages to chrome-headless-shell even when profile cookies
-        // are valid, which masquerades as "not logged in" downstream. The old
-        // `options.headless !== false` defaulted to true and effectively neutered
-        // chat-web's anti-bot stance whenever the caller (daemon, serve-ai)
-        // didn't explicitly pass a value. Users who actually want headless must
-        // now opt in with an explicit `headless: true`.
-        this.headless = options.headless === true;
+        if (!RUNTIME_CHAT_WEB_PROVIDERS.has(this.chatWebProvider))
+            this.runtimeSocket = "";
+        this.runtimeMode = Boolean(this.runtimeSocket) ||
+            (["kimi", "deepseek"].includes(this.chatWebProvider) && options.chatWebRuntime !== false);
+        this.managedRuntime = this.runtimeMode && !this.runtimeSocket;
+        const resumed = typeof options.resumeSessionId === "string" ? options.resumeSessionId : "";
+        const prefix = "chat-web-runtime:";
+        this.runtimeConversationId = options.chatWebConversationId ||
+            (this.managedRuntime ? (resumed.startsWith(prefix) ? resumed.slice(prefix.length) : undefined) : this.runtimeMode ? resumed : undefined);
+        this.runtimeProviderConversationId = this.managedRuntime && resumed && !resumed.startsWith(prefix) && !options.chatWebConversationId ? resumed : undefined;
+        if (options.chatWebDeepThink !== undefined &&
+            (typeof options.chatWebDeepThink !== "boolean" || this.chatWebProvider !== "deepseek" || !this.runtimeMode)) {
+            throw new Error("chatWebDeepThink requires a boolean and the DeepSeek chat runtime");
+        }
+        // Kimi requires headed Chromium with the tested login flow. DeepSeek's
+        // managed workers support headless; explicit options override either default.
+        this.headless = this.runtimeMode && this.chatWebProvider === "deepseek" ? options.headless !== false : options.headless === true;
         // Optional: use a specific Chromium-family binary (system Chrome /
         // Edge / explicit path) instead of Playwright's bundled
         // `chrome-headless-shell`. Useful when the user's network treats
@@ -176,6 +191,7 @@ export class ChatWebSession extends EventEmitter {
         this.closed = false;
         this.currentTurn = null;
         this.currentTurnStatus = null;
+        this.turnAttempted = false;
         this.sessionMessageHandler = null;
         this.workingStatusHandler = null;
         this.activeReplyTarget = "";
@@ -207,12 +223,12 @@ export class ChatWebSession extends EventEmitter {
             sessionId: this.sessionId,
             sessionInfo: this.getSessionInfo(),
             useSessionFileReplyStream: this.usesSessionFileReplyStream(),
-            resumeReady: Boolean(this.providerConversationId),
+            resumeReady: Boolean(this.runtimeMode ? this.runtimeConversationId : this.providerConversationId),
             manualResume: this.providerConversationUrl()
                 ? { ready: true, command: this.providerConversationUrl() }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { clear: true, media: PROVIDER_MEDIA_CAPABILITIES[CHAT_WEB_SESSION_VARIANT] },
+            capabilities: { clear: !this.runtimeMode, media: PROVIDER_MEDIA_CAPABILITIES[CHAT_WEB_SESSION_VARIANT] },
             chatWebProvider: this.chatWebProvider,
             providerConversationId: this.providerConversationId,
             providerUrl: this.providerConversationUrl(),
@@ -229,7 +245,7 @@ export class ChatWebSession extends EventEmitter {
         //
         // We expose `sessionIdDeferred: true` so the fire-side announce can
         // hold off until the real id arrives, then re-announce.
-        const hasRealId = Boolean(this.providerConversationId);
+        const hasRealId = Boolean(this.runtimeMode ? this.runtimeConversationId : this.providerConversationId);
         return {
             ...this.sessionInfo,
             sessionIdDeferred: !hasRealId,
@@ -294,6 +310,21 @@ export class ChatWebSession extends EventEmitter {
             throw enriched;
         }
     }
+    loginCommand() {
+        if (!this.runtimeMode)
+            return `chat-web login ${this.chatWebProvider}`;
+        if (this.managedRuntime && (!this.options.chatWebAccountId || this.options.chatWebAccountId === "default")) {
+            return `conductor chat-web login ${this.chatWebProvider}`;
+        }
+        return `conductor chat-web chat login ${this.runtimeConversationId} --socket ${this.runtimeSocket}`;
+    }
+    reviewInstructions() {
+        if (!this.runtimeConversationId || !this.runtimeSocket)
+            return "";
+        const id = quoteRuntimeArgument(this.runtimeConversationId);
+        const socket = quoteRuntimeArgument(this.runtimeSocket);
+        return ` The previous webpage request has an uncertain outcome. On the daemon host, inspect the same conversation with: conductor chat-web chat login ${id} --socket ${socket}. After checking its result, acknowledge with: conductor chat-web chat resume ${id} --acknowledge --socket ${socket}. Then resend only the message you still want to send; acknowledgement does not replay the previous request.`;
+    }
     async boot() {
         if (this.booted)
             return;
@@ -304,6 +335,13 @@ export class ChatWebSession extends EventEmitter {
             await this.bootPromise;
             this.booted = true;
         }
+        catch (error) {
+            // A failed login must release this task's browser so a fresh account
+            // snapshot can be imported when the user retries the same task.
+            await this.chatSession?.close().catch(() => undefined);
+            this.chatSession = null;
+            throw error;
+        }
         finally {
             this.bootPromise = null;
         }
@@ -316,8 +354,9 @@ export class ChatWebSession extends EventEmitter {
         if (typeof mod.registerBuiltinProviders === "function") {
             mod.registerBuiltinProviders();
         }
-        if (typeof mod.ChatSession?.open !== "function") {
-            throw new Error("Loaded @love-moon/chat-web is missing ChatSession.open");
+        const Session = this.runtimeMode ? mod.RuntimeChatSession : (mod.QueuedChatSession ?? mod.ChatSession);
+        if (typeof Session?.open !== "function") {
+            throw new Error(`Loaded @love-moon/chat-web is missing ${this.runtimeMode ? "RuntimeChatSession" : "ChatSession"}.open; upgrade chat-web`);
         }
         // Forward optional browser-binary overrides to chat-web. The env vars
         // CHAT_WEB_BROWSER_CHANNEL / CHAT_WEB_BROWSER_EXECUTABLE are also
@@ -328,7 +367,8 @@ export class ChatWebSession extends EventEmitter {
             launch.channel = this.browserChannel;
         if (this.browserExecutablePath)
             launch.executablePath = this.browserExecutablePath;
-        this.chatSession = await mod.ChatSession.open(this.chatWebProvider, {
+        this.chatSession = await Session.open(this.chatWebProvider, {
+            ...(this.runtimeMode ? { socketPath: this.managedRuntime ? undefined : this.runtimeSocket || undefined, conversationId: this.runtimeConversationId, providerConversationId: this.runtimeProviderConversationId, accountId: this.options.chatWebAccountId, deepThink: this.options.chatWebDeepThink, releaseOnClose: this.managedRuntime } : {}),
             headless: this.headless,
             // IMPORTANT: chat-web's logger contract is `{ error, warn, info, debug }`;
             // ai-sdk's normalised logger is `{ log }`. Passing the ai-sdk logger
@@ -342,9 +382,23 @@ export class ChatWebSession extends EventEmitter {
             this.chatSession = null;
             throw this.createSessionClosedError();
         }
-        const loggedIn = await this.chatSession.isLoggedIn().catch(() => false);
-        if (!loggedIn) {
-            const error = new Error(`chat-web provider "${this.chatWebProvider}" is not logged in. Run: chat-web login ${this.chatWebProvider}`);
+        if (this.runtimeMode) {
+            this.runtimeConversationId = this.chatSession.id;
+            this.runtimeSocket = this.chatSession.client?.socketPath || this.runtimeSocket;
+            this.sessionId = this.managedRuntime ? "chat-web-runtime:" + this.runtimeConversationId : this.runtimeConversationId;
+            if (this.chatSession.providerConversationId)
+                this.providerConversationId = this.chatSession.providerConversationId;
+            this.sessionInfo = { ...this.sessionInfo, sessionId: this.sessionId };
+            this.emit("session", this.getSessionInfo());
+        }
+        const readiness = this.runtimeMode && typeof this.chatSession.prepare === "function"
+            ? await this.chatSession.prepare()
+            : { ready: this.runtimeMode ? await this.chatSession.isLoggedIn() : await this.chatSession.isLoggedIn().catch(() => false), authRequired: true };
+        if (!readiness.ready && !readiness.queued) {
+            if (readiness.authRequired !== true) {
+                throw Object.assign(new Error("Chat page did not become ready; wait for it to finish loading and retry"), { code: "PAGE_NOT_READY" });
+            }
+            const error = new Error(`Chat requires login. On this daemon host run: ${this.loginCommand()}`);
             error.reason = "not_logged_in";
             this.emit("auth_required", {
                 reason: "login_required",
@@ -366,6 +420,11 @@ export class ChatWebSession extends EventEmitter {
      * for exactly this window.
      */
     async runClear() {
+        if (this.runtimeMode) {
+            const error = new Error("Create a new runtime conversation to clear an isolated chat");
+            error.reason = "unsupported_clear";
+            throw error;
+        }
         if (this.closeRequested) {
             throw this.createSessionClosedError();
         }
@@ -376,7 +435,7 @@ export class ChatWebSession extends EventEmitter {
         }
         // Nothing has been said yet — fire boots the browser at announce time, so
         // "booted" alone does not mean there is a conversation to walk away from.
-        if (!this.providerConversationId && this.history.length === 0) {
+        if (!this.providerConversationId && this.history.length === 0 && !this.turnAttempted) {
             return { clear: { status: "noop" }, usage: null, metadata: {} };
         }
         await this.boot();
@@ -394,6 +453,7 @@ export class ChatWebSession extends EventEmitter {
             providerUrl: undefined,
         };
         this.history = [];
+        this.turnAttempted = false;
         this.emit("session", this.getSessionInfo());
         // No id to report: the provider mints one on the next reply.
         return { clear: { status: "cleared" }, usage: null, metadata: {} };
@@ -415,11 +475,12 @@ export class ChatWebSession extends EventEmitter {
         if (normalized === this.providerConversationId)
             return;
         this.providerConversationId = normalized;
-        this.sessionId = normalized;
+        if (!this.runtimeMode)
+            this.sessionId = normalized;
         this.sessionInfo = {
             ...(this.sessionInfo || {}),
             backend: this.backend,
-            sessionId: normalized,
+            sessionId: this.sessionId,
             model: this.chatWebProvider,
             modelProvider: "chat-web",
             providerConversationId: normalized,
@@ -438,6 +499,12 @@ export class ChatWebSession extends EventEmitter {
         switch (this.chatWebProvider) {
             case "chatgpt":
                 return `https://chatgpt.com/c/${this.providerConversationId}`;
+            case "deepseek":
+                return `https://chat.deepseek.com/a/chat/s/${this.providerConversationId}`;
+            case "kimi":
+                return `https://www.kimi.com/chat/${encodeURIComponent(this.providerConversationId)}`;
+            case "claude":
+                return `https://claude.ai/chat/${this.providerConversationId}`;
             case "gemini":
                 // chat-web's `gemini` provider targets AI Studio
                 // (aistudio.google.com/prompts/new_chat) — that's the free web
@@ -476,7 +543,7 @@ export class ChatWebSession extends EventEmitter {
             error.reason = "turn_already_running";
             throw error;
         }
-        this.currentTurn = { aborted: false };
+        this.currentTurn = { aborted: false, controller: new AbortController() };
         await this.emitWorkingStatus({
             phase: "turn_started",
             reply_in_progress: true,
@@ -486,8 +553,29 @@ export class ChatWebSession extends EventEmitter {
             await this.boot();
             if (this.closeRequested)
                 throw this.createSessionClosedError();
+            if (this.currentTurn.aborted)
+                throw new DOMException("Aborted", "AbortError");
+            this.turnAttempted = true;
             const result = await this.chatSession.send(prompt, {
                 timeoutMs: this.turnTimeoutMs,
+                signal: this.currentTurn.controller.signal,
+                onStatus: (phase) => {
+                    if (phase === "queued" || phase === "starting")
+                        void this.emitWorkingStatus({
+                            phase: phase === "queued" ? "queued" : "turn_started",
+                            reply_in_progress: true,
+                            status_line: phase === "queued" ? `chat-web (${this.chatWebProvider}) waiting for a browser worker` : `chat-web (${this.chatWebProvider}) is working`,
+                        }, onProgress);
+                },
+                onQueue: (position) => {
+                    void this.emitWorkingStatus({
+                        phase: position > 0 ? "queued" : "turn_started",
+                        reply_in_progress: true,
+                        status_line: position > 0
+                            ? `chat-web (${this.chatWebProvider}) queued: ${position} ahead`
+                            : `chat-web (${this.chatWebProvider}) is working`,
+                    }, onProgress);
+                },
                 onProgress: (text) => {
                     // chat-web's onProgress fires while streaming text grows; we
                     // forward those as working_status updates with a short preview.
@@ -543,6 +631,17 @@ export class ChatWebSession extends EventEmitter {
         catch (error) {
             const message = extractErrorMessage(error);
             const code = typeof error?.code === "string" ? error.code : "";
+            if (this.runtimeMode && (code === "AUTH_REQUIRED" || /Provider HTTP 401/.test(message))) {
+                const login = this.loginCommand();
+                error.message = `Browser login needs renewal. On this daemon host run: ${login}.`;
+                error.reason = "not_logged_in";
+            }
+            if (this.runtimeMode && (code === "REVIEW_REQUIRED" || error?.turnStatus === "uncertain")) {
+                error.message = (error.message || message) + this.reviewInstructions();
+            }
+            if (this.runtimeMode && (code === "AUTH_REQUIRED" || /Provider HTTP 401/.test(message))) {
+                this.emit("auth_required", { reason: "login_required", message: error.message, provider: this.chatWebProvider });
+            }
             // Surface chat-web's typed "needs API key" / "permission denied"
             // errors as auth_required so the UI / daemon can route them
             // through the same flow as ChatGPT's "not logged in" — they're
@@ -557,7 +656,7 @@ export class ChatWebSession extends EventEmitter {
             }
             await this.emitTerminalWorkingStatus({
                 phase: this.currentTurn?.aborted ? "turn_interrupted" : "turn_failed",
-                status_done_line: message,
+                status_done_line: error.message || message,
             }, onProgress);
             throw error;
         }
@@ -567,13 +666,18 @@ export class ChatWebSession extends EventEmitter {
         }
     }
     async interruptCurrentTurn() {
-        // chat-web's ChatSession doesn't expose a turn abort — the underlying
+        // Direct chat-web ChatSession doesn't expose a turn abort — the underlying
         // Chromium tab is still busy with the model. We mark the turn as
         // aborted so the next status emission is "interrupted", but the
         // assistant_message may still arrive once the model finishes.
         if (this.currentTurn) {
             this.currentTurn.aborted = true;
+            // The shared broker removes a pending turn, or stops/closes the active
+            // task's tab before moving to the next task. No queued prompt is sent.
+            this.currentTurn.controller.abort();
         }
+        if (this.runtimeMode)
+            await this.chatSession?.interruptCurrentTurn?.();
     }
     async close() {
         if (this.closed)

package/dist/resume/chat-web.d.ts

@@ -1,9 +1,7 @@
 /**
- * chat-web's "session" is a Chromium browser context, not a conversation id.
- * There is no native resume primitive: closing and reopening produces a
- * fresh ChatSession with a new in-memory chat. We satisfy ai-sdk's resume
- * contract by surfacing a synthetic session id and a "best effort" context,
- * but downstream callers should treat resume here as a no-op.
+ * Managed Kimi/DeepSeek sessions use a stable chat-web-runtime:<id> token.
+ * RuntimeChatSession restores the saved isolated profile and provider URL.
+ * Other chat-web modes retain their existing provider-specific resume behavior.
  */
 export function buildCliArgs(sessionId: any): string[];
 export function findSessionPath(): Promise<null>;

package/dist/resume/chat-web.js

@@ -1,11 +1,9 @@
 import { buildResumeContext, normalizeSessionId } from "./shared.js";
 export const BACKEND = "chat-web";
 /**
- * chat-web's "session" is a Chromium browser context, not a conversation id.
- * There is no native resume primitive: closing and reopening produces a
- * fresh ChatSession with a new in-memory chat. We satisfy ai-sdk's resume
- * contract by surfacing a synthetic session id and a "best effort" context,
- * but downstream callers should treat resume here as a no-op.
+ * Managed Kimi/DeepSeek sessions use a stable chat-web-runtime:<id> token.
+ * RuntimeChatSession restores the saved isolated profile and provider URL.
+ * Other chat-web modes retain their existing provider-specific resume behavior.
  */
 export function buildCliArgs(sessionId) {
     // chat-web has no CLI to pass these args to (it's an in-process SDK), but
@@ -38,7 +36,9 @@ export async function resolveResumeContext(sessionId, options = {}) {
         cwd,
         cwdSource: "process_cwd",
         extraDebug: {
-            note: "chat-web does not support cross-process conversation resume; a fresh ChatSession will be opened.",
+            note: normalizedSessionId.startsWith("chat-web-runtime:")
+                ? "The isolated chat runtime restores this saved conversation; a missing runtime id is an error."
+                : "The selected chat-web transport resolves this provider conversation id when opening.",
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -53,12 +53,12 @@
     "zod": "^4.1.5"
   },
   "optionalDependencies": {
-    "@love-moon/chat-web": "^0.17.1"
+    "@love-moon/chat-web": "^0.18.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "e3dbbad"
+  "gitCommitId": "825d90a"
 }