@love-moon/ai-sdk 0.17.0 → 0.17.2

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @love-moon/ai-sdk
 
+## 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
+
+- 7e92c0f: When a task's model quota runs out ("You've hit your session limit · resets
+  1:20am"), fire no longer stops there. It reads the reset time, schedules a
+  one-off Conductor scheduled message to continue a minute or few after the
+  reset, and posts a single notice. Messages that arrive while waiting are queued
+  and handed to the resume turn together instead of each failing with another
+  "处理失败". The resume shows up in the task's scheduled-message list, where it
+  can be canceled. This also covers a quota hit while Claude works on its own
+  between user turns: ai-sdk now reports such a background turn that ends in an
+  error result (or a process exit after it) as a failed turn.
+
 ## 0.17.0
 
 ### Patch Changes

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

@@ -1,10 +1,10 @@
 /**
  * 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
+ * ChatGPT / Gemini / Kimi and ferries conversations through their web
  * UIs. Choose the underlying chat-web provider via:
  *
- *   - `options.chatWebProvider`: "chatgpt" | "gemini"  (preferred)
+ *   - `options.chatWebProvider`: "chatgpt" | "gemini" | "kimi"  (preferred)
  *   - `options.provider`:        same surface
  *   - `options.model`:           same surface (fallback for ergonomic
  *                                `createAiSession("chat-web", { model: "gemini" })`)
@@ -13,10 +13,10 @@
  *
  * Lifecycle:
  *   - `boot()` lazily imports `@love-moon/chat-web`, registers its built-in
- *     providers, and opens a long-lived `ChatSession` (headed by default).
+ *     providers, and opens a queued conversation tab (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.
+ *   - `close()` releases this task's tab; the broker closes an idle browser.
  *
  * Resume: chat-web's "session" is a Chromium browser context, not a
  * conversation ID — there is no native cross-process resume. We synthesise
@@ -50,6 +50,7 @@ export class ChatWebSession extends EventEmitter<[never]> {
     closed: boolean;
     currentTurn: {
         aborted: boolean;
+        controller: AbortController;
     } | null;
     currentTurnStatus: {
         source: string;
@@ -65,6 +66,7 @@ export class ChatWebSession extends EventEmitter<[never]> {
         session_file_path: undefined;
         updated_at: string;
     } | null;
+    turnAttempted: boolean;
     sessionMessageHandler: any;
     workingStatusHandler: any;
     activeReplyTarget: string;

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

@@ -4,7 +4,7 @@ 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"]);
 const DEFAULT_CHAT_WEB_PROVIDER = "chatgpt";
 const DEFAULT_TURN_TIMEOUT_MS = 5 * 60 * 1000;
 function normalizeChatWebProvider(value) {
@@ -22,9 +22,14 @@ function resolveChatWebProvider(options = {}) {
     const candidates = [options.chatWebProvider, options.provider, options.model];
     for (const candidate of candidates) {
         const normalized = normalizeChatWebProvider(candidate);
-        if (SUPPORTED_CHAT_WEB_PROVIDERS.has(normalized)) {
-            return normalized;
+        if (!normalized)
+            continue;
+        if (!SUPPORTED_CHAT_WEB_PROVIDERS.has(normalized)) {
+            const error = new Error(`Unknown chat-web provider "${normalized}". Supported: ${[...SUPPORTED_CHAT_WEB_PROVIDERS].join(", ")}`);
+            error.reason = "unknown_chat_web_provider";
+            throw error;
         }
+        return normalized;
     }
     return DEFAULT_CHAT_WEB_PROVIDER;
 }
@@ -93,10 +98,10 @@ 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
+ * ChatGPT / Gemini / Kimi and ferries conversations through their web
  * UIs. Choose the underlying chat-web provider via:
  *
- *   - `options.chatWebProvider`: "chatgpt" | "gemini"  (preferred)
+ *   - `options.chatWebProvider`: "chatgpt" | "gemini" | "kimi"  (preferred)
  *   - `options.provider`:        same surface
  *   - `options.model`:           same surface (fallback for ergonomic
  *                                `createAiSession("chat-web", { model: "gemini" })`)
@@ -105,10 +110,10 @@ function isPlaywrightMissingError(error) {
  *
  * Lifecycle:
  *   - `boot()` lazily imports `@love-moon/chat-web`, registers its built-in
- *     providers, and opens a long-lived `ChatSession` (headed by default).
+ *     providers, and opens a queued conversation tab (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.
+ *   - `close()` releases this task's tab; the broker closes an idle browser.
  *
  * Resume: chat-web's "session" is a Chromium browser context, not a
  * conversation ID — there is no native cross-process resume. We synthesise
@@ -176,6 +181,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 = "";
@@ -316,7 +322,10 @@ export class ChatWebSession extends EventEmitter {
         if (typeof mod.registerBuiltinProviders === "function") {
             mod.registerBuiltinProviders();
         }
-        if (typeof mod.ChatSession?.open !== "function") {
+        // New runtimes share a browser and schedule complete turns across workers.
+        // Keep the existing session surface for older optional chat-web versions.
+        const Session = mod.QueuedChatSession ?? mod.ChatSession;
+        if (typeof Session?.open !== "function") {
             throw new Error("Loaded @love-moon/chat-web is missing ChatSession.open");
         }
         // Forward optional browser-binary overrides to chat-web. The env vars
@@ -328,7 +337,7 @@ 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, {
             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
@@ -376,7 +385,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 +403,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: {} };
@@ -438,6 +448,8 @@ export class ChatWebSession extends EventEmitter {
         switch (this.chatWebProvider) {
             case "chatgpt":
                 return `https://chatgpt.com/c/${this.providerConversationId}`;
+            case "kimi":
+                return `https://www.kimi.com/chat/${encodeURIComponent(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 +488,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 +498,19 @@ export class ChatWebSession extends EventEmitter {
             await this.boot();
             if (this.closeRequested)
                 throw this.createSessionClosedError();
+            this.turnAttempted = true;
             const result = await this.chatSession.send(prompt, {
                 timeoutMs: this.turnTimeoutMs,
+                signal: this.currentTurn.controller.signal,
+                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.
@@ -567,12 +590,11 @@ export class ChatWebSession extends EventEmitter {
         }
     }
     async interruptCurrentTurn() {
-        // chat-web's 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();
         }
     }
     async close() {

package/dist/providers/claude-agent-sdk-session.js

@@ -553,6 +553,8 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             status_done_line: payload?.status_done_line,
             reply_preview: payload?.reply_preview,
             thread_id: this.sessionId || undefined,
+            // A turn claude ran on its own, between user turns (see dispatchLiveMessage).
+            ...(payload?.background === true ? { background: true } : {}),
         };
         this.updateCurrentTurnStatus(normalized);
         const snapshot = this.getCurrentTurnStatus();
@@ -1123,6 +1125,17 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         if (backgroundTurn) {
             await this.finishBackgroundTurn(backgroundTurn, null, failure);
         }
+        else if (failure && !this.closeRequested && !this.currentTurn) {
+            // The process died after a background turn's result, e.g. an error
+            // result (quota hit) makes claude exit right after reporting it. No turn
+            // is left to own the failure, so report it as a background one.
+            await this.emitWorkingStatus({
+                phase: "turn_failed",
+                status_done_line: failure?.message || String(failure),
+                reply_in_progress: false,
+                background: true,
+            });
+        }
     }
     /**
      * Routes the long-lived query's output. A result ends the pending turn when it
@@ -1155,9 +1168,13 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         await this.finishBackgroundTurn(target, message);
     }
     async finishBackgroundTurn(backgroundTurn, resultMessage, failure = null) {
-        const failed = Boolean(failure) || (resultMessage && resultMessage.subtype !== "success");
+        // An error result (e.g. "You've hit your session limit") can carry subtype
+        // "success"; `is_error` is what marks it.
+        const errorResult = Boolean(resultMessage && (resultMessage.subtype !== "success" || resultMessage.is_error === true));
+        const failed = Boolean(failure) || errorResult;
         const text = normalizeText(resultMessage?.result);
-        if (!failed && text && !backgroundTurn.emittedAssistantMessage) {
+        // An error result's text still reaches the chat, as it always has.
+        if (!failure && resultMessage?.subtype === "success" && text && !backgroundTurn.emittedAssistantMessage) {
             await this.emitAssistantMessage(text);
         }
         // A pending user turn owns the working status.
@@ -1167,9 +1184,11 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         await this.emitTerminalWorkingStatus(backgroundTurn, failed
             ? {
                 phase: "turn_failed",
-                status_done_line: failure?.message || extractResultErrorMessage(resultMessage),
+                status_done_line: failure?.message ||
+                    (resultMessage?.is_error === true && text ? text : extractResultErrorMessage(resultMessage)),
+                background: true,
             }
-            : { phase: "turn_completed", status_done_line: "claude finished" });
+            : { phase: "turn_completed", status_done_line: "claude finished", background: true });
     }
     async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null, suppressReply = false } = {}) {
         if (this.closeRequested) {
@@ -1262,8 +1281,11 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                     reason: "missing_result",
                 });
             }
-            if (resultMessage.subtype !== "success") {
-                const errorMessage = extractResultErrorMessage(resultMessage);
+            // An error result (e.g. "You've hit your session limit") can carry subtype
+            // "success"; `is_error` is what marks it.
+            if (resultMessage.subtype !== "success" || resultMessage.is_error === true) {
+                const errorText = resultMessage.is_error === true ? normalizeText(resultMessage.result) : "";
+                const errorMessage = errorText || extractResultErrorMessage(resultMessage);
                 this.maybeEmitAuthRequired(errorMessage, errorMessage);
                 await this.emitTerminalWorkingStatus(currentTurn, {
                     phase: "turn_failed",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "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.0"
+    "@love-moon/chat-web": "^0.17.2"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
     "tsx": "^4.20.6",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "2799bc0"
+  "gitCommitId": "1671ee1"
 }