@love-moon/ai-sdk 0.2.30 → 0.2.32

package/dist/providers/opencode-sdk-session.js

@@ -154,6 +154,9 @@ export class OpencodeSdkSession extends EventEmitter {
         this.currentTurn = null;
         this.lastUsage = null;
         this.lastAssistantInfo = null;
+        this.currentTurnStatus = null;
+        this.currentTurnActivityAt = 0;
+        this.now = typeof options.now === "function" ? options.now : () => Date.now();
         this.turnDeadlineMs = getBoundedEnvInt("CONDUCTOR_TURN_DEADLINE_MS", DEFAULT_TURN_DEADLINE_MS, MIN_TURN_DEADLINE_MS, MAX_TURN_DEADLINE_MS);
         this.client = null;
         this.sdkModulePromise = null;
@@ -200,10 +203,14 @@ export class OpencodeSdkSession extends EventEmitter {
         return this.sessionId;
     }
     get threadOptions() {
-        const model = typeof this.options.model === "string" && this.options.model.trim()
-            ? this.options.model.trim()
-            : this.backend;
-        return { model };
+        const model = this.sessionInfo?.model ||
+            (typeof this.options.model === "string" && this.options.model.trim()
+                ? this.options.model.trim()
+                : this.backend);
+        return {
+            model,
+            modelProvider: this.sessionInfo?.modelProvider || undefined,
+        };
     }
     getSnapshot() {
         return {
@@ -215,12 +222,16 @@ export class OpencodeSdkSession extends EventEmitter {
             useSessionFileReplyStream: this.usesSessionFileReplyStream(),
             resumeReady: Boolean(this.sessionId),
             manualResume: null,
+            currentTurnStatus: this.getCurrentTurnStatus(),
             pid: this.transport.pid || undefined,
         };
     }
     getSessionInfo() {
         return this.sessionInfo ? { ...this.sessionInfo } : null;
     }
+    getCurrentTurnStatus() {
+        return this.currentTurnStatus ? { ...this.currentTurnStatus } : null;
+    }
     async ensureSessionInfo() {
         await this.boot();
         return this.getSessionInfo();
@@ -256,6 +267,39 @@ export class OpencodeSdkSession extends EventEmitter {
     getCurrentReplyTarget() {
         return this.activeReplyTarget || this.lastReplyTarget || undefined;
     }
+    touchTurnActivity() {
+        this.currentTurnActivityAt = this.now();
+    }
+    updateCurrentTurnStatus(payload) {
+        const updatedAtMs = this.now();
+        this.currentTurnActivityAt = updatedAtMs;
+        this.currentTurnStatus = {
+            ...payload,
+            updated_at: new Date(updatedAtMs).toISOString(),
+        };
+    }
+    markTurnStartedStatus() {
+        this.updateCurrentTurnStatus({
+            source: OPENCODE_PROVIDER_VARIANT,
+            reply_in_progress: true,
+            replyTo: this.getCurrentReplyTarget(),
+            phase: "turn_started",
+            status_line: "opencode is working",
+            thread_id: this.sessionId || undefined,
+            session_id: this.sessionId || undefined,
+            session_file_path: undefined,
+        });
+    }
+    async failPendingTurnStart(error, onProgress = null) {
+        if (this.closeRequested || error?.reason === "session_closed") {
+            return;
+        }
+        await this.emitWorkingStatus({
+            phase: "turn_failed",
+            reply_in_progress: false,
+            status_done_line: error instanceof Error ? error.message : String(error),
+        }, onProgress);
+    }
     async emitWorkingStatus(payload, onProgress = null) {
         const normalized = {
             source: OPENCODE_PROVIDER_VARIANT,
@@ -270,15 +314,18 @@ export class OpencodeSdkSession extends EventEmitter {
             session_id: this.sessionId || undefined,
             session_file_path: undefined,
         };
+        this.updateCurrentTurnStatus(normalized);
+        const snapshot = this.getCurrentTurnStatus();
         if (typeof onProgress === "function") {
-            onProgress(normalized);
+            onProgress(snapshot);
         }
         if (typeof this.workingStatusHandler === "function") {
-            await this.workingStatusHandler(normalized);
+            await this.workingStatusHandler(snapshot);
         }
-        this.emit("working_status", normalized);
+        this.emit("working_status", snapshot);
     }
     async emitAssistantMessage(text) {
+        this.touchTurnActivity();
         const payload = {
             text,
             preserveWhitespace: true,
@@ -352,8 +399,27 @@ export class OpencodeSdkSession extends EventEmitter {
             };
         }
         let timer = null;
-        const promise = new Promise((_, reject) => {
+        let settled = false;
+        const schedule = (reject) => {
+            const now = this.now();
+            const lastActivityAt = Number.isFinite(this.currentTurnActivityAt) && this.currentTurnActivityAt > 0
+                ? this.currentTurnActivityAt
+                : now;
+            const elapsedMs = Math.max(0, now - lastActivityAt);
+            const waitMs = Math.max(1, this.turnDeadlineMs - elapsedMs);
             timer = setTimeout(() => {
+                if (settled) {
+                    return;
+                }
+                const activityNow = this.now();
+                const latestActivityAt = Number.isFinite(this.currentTurnActivityAt) && this.currentTurnActivityAt > 0
+                    ? this.currentTurnActivityAt
+                    : activityNow;
+                if (activityNow - latestActivityAt < this.turnDeadlineMs) {
+                    schedule(reject);
+                    return;
+                }
+                settled = true;
                 try {
                     onTimeout?.();
                 }
@@ -361,14 +427,18 @@ export class OpencodeSdkSession extends EventEmitter {
                     // best effort
                 }
                 reject(this.createTurnTimeoutError(this.turnDeadlineMs));
-            }, this.turnDeadlineMs);
-            if (typeof timer.unref === "function") {
+            }, waitMs);
+            if (typeof timer?.unref === "function") {
                 timer.unref();
             }
+        };
+        const promise = new Promise((_, reject) => {
+            schedule(reject);
         });
         return {
             promise,
             cleanup: () => {
+                settled = true;
                 if (timer) {
                     clearTimeout(timer);
                 }
@@ -536,9 +606,20 @@ export class OpencodeSdkSession extends EventEmitter {
         }
         const changed = this.sessionId !== normalizedSessionId;
         this.sessionId = normalizedSessionId;
+        const resolvedModel = typeof this.lastAssistantInfo?.model?.modelID === "string" && this.lastAssistantInfo.model.modelID.trim()
+            ? this.lastAssistantInfo.model.modelID.trim()
+            : typeof this.options.model === "string" && this.options.model.trim()
+                ? this.options.model.trim()
+                : undefined;
+        const resolvedModelProvider = typeof this.lastAssistantInfo?.model?.providerID === "string" && this.lastAssistantInfo.model.providerID.trim()
+            ? this.lastAssistantInfo.model.providerID.trim()
+            : undefined;
         this.sessionInfo = {
+            ...(this.sessionInfo || {}),
             backend: this.backend,
             sessionId: normalizedSessionId,
+            model: resolvedModel,
+            modelProvider: resolvedModelProvider,
         };
         if (changed) {
             this.trace(`session ready id=${normalizedSessionId}`);
@@ -874,6 +955,9 @@ export class OpencodeSdkSession extends EventEmitter {
                 this.activeReplyTarget = "";
                 this.lastUsage = this.buildUsageFromAssistantInfo(currentTurn.lastAssistantInfo);
                 this.lastAssistantInfo = currentTurn.lastAssistantInfo || null;
+                this.applySessionInfo({
+                    id: this.sessionId,
+                });
                 await this.emitTerminalWorkingStatus(currentTurn, {
                     phase: "turn_completed",
                     status_done_line: "opencode finished",
@@ -1058,14 +1142,21 @@ export class OpencodeSdkSession extends EventEmitter {
         if (!effectivePrompt) {
             return buildEmptyTurnResult();
         }
-        await this.boot();
         if (this.currentTurn) {
             throw createTurnError("Opencode turn already running", {
                 reason: "turn_already_running",
             });
         }
-        if (!this.client?.session || typeof this.client.session.promptAsync !== "function") {
-            throw new Error("Opencode session client is unavailable");
+        this.markTurnStartedStatus();
+        try {
+            await this.boot();
+            if (!this.client?.session || typeof this.client.session.promptAsync !== "function") {
+                throw new Error("Opencode session client is unavailable");
+            }
+        }
+        catch (error) {
+            await this.failPendingTurnStart(error, onProgress);
+            throw error;
         }
         this.history.push({ role: "user", content: promptText });
         const abortController = new AbortController();

package/dist/session-factory.d.ts

@@ -1,8 +1,8 @@
-export function normalizeBackend(backend: any): string;
-export function isSupportedBackend(backend: any): boolean;
-export function providerVariantForBackend(backend: any): "codex-app-server" | "claude-agent-sdk" | "kimi-cli-wire" | "opencode-sdk";
-export function assertSupportedBackend(backend: any): "codex" | "claude" | "kimi" | "opencode";
-export function createLocalAiSession(backend: any, options?: {}): CodexAppServerSession | ClaudeAgentSdkSession | KimiCliSession | OpencodeSdkSession;
+export function normalizeBackend(backend: any, options?: {}): Promise<any>;
+export function isSupportedBackend(backend: any, options?: {}): Promise<boolean>;
+export function providerVariantForBackend(backend: any, options?: {}): Promise<any>;
+export function assertSupportedBackend(backend: any, options?: {}): Promise<any>;
+export function createLocalAiSession(backend: any, options?: {}): Promise<any>;
 export const DEFAULT_PROVIDER_VARIANT: "codex-app-server";
 export const CLAUDE_PROVIDER_VARIANT: "claude-agent-sdk";
 export const KIMI_PROVIDER_VARIANT: "kimi-cli-wire";

package/dist/session-factory.js

@@ -2,11 +2,12 @@ import { CodexAppServerSession } from "./providers/codex-app-server-session.js";
 import { ClaudeAgentSdkSession } from "./providers/claude-agent-sdk-session.js";
 import { KimiCliSession } from "./providers/kimi-cli-session.js";
 import { OpencodeSdkSession } from "./providers/opencode-sdk-session.js";
+import { getExternalProviderDescriptor, resolveExternalBackend, } from "./external-provider-registry.js";
 export const DEFAULT_PROVIDER_VARIANT = "codex-app-server";
 export const CLAUDE_PROVIDER_VARIANT = "claude-agent-sdk";
 export const KIMI_PROVIDER_VARIANT = "kimi-cli-wire";
 export const OPENCODE_PROVIDER_VARIANT = "opencode-sdk";
-export function normalizeBackend(backend) {
+function normalizeBuiltInBackendName(backend) {
     const normalized = String(backend || "").trim().toLowerCase();
     if (normalized === "code") {
         return "codex";
@@ -22,12 +23,23 @@ export function normalizeBackend(backend) {
     }
     return normalized;
 }
-export function isSupportedBackend(backend) {
-    const normalized = normalizeBackend(backend);
-    return normalized === "codex" || normalized === "claude" || normalized === "kimi" || normalized === "opencode";
+export async function normalizeBackend(backend, options = {}) {
+    const normalized = normalizeBuiltInBackendName(backend);
+    if (normalized === "codex" || normalized === "claude" || normalized === "kimi" || normalized === "opencode") {
+        return normalized;
+    }
+    return await resolveExternalBackend(normalized, options);
+}
+export async function isSupportedBackend(backend, options = {}) {
+    const normalized = await normalizeBackend(backend, options);
+    if (normalized === "codex" || normalized === "claude" || normalized === "kimi" || normalized === "opencode") {
+        return true;
+    }
+    const descriptor = await getExternalProviderDescriptor(normalized, options);
+    return Boolean(descriptor);
 }
-export function providerVariantForBackend(backend) {
-    const normalized = normalizeBackend(backend);
+export async function providerVariantForBackend(backend, options = {}) {
+    const normalized = await normalizeBackend(backend, options);
     if (normalized === "claude") {
         return CLAUDE_PROVIDER_VARIANT;
     }
@@ -37,17 +49,28 @@ export function providerVariantForBackend(backend) {
     if (normalized === "opencode") {
         return OPENCODE_PROVIDER_VARIANT;
     }
+    if (normalized === "codex") {
+        return DEFAULT_PROVIDER_VARIANT;
+    }
+    const descriptor = await getExternalProviderDescriptor(normalized, options);
+    if (descriptor?.variant) {
+        return descriptor.variant;
+    }
     return DEFAULT_PROVIDER_VARIANT;
 }
-export function assertSupportedBackend(backend) {
-    const normalized = normalizeBackend(backend);
+export async function assertSupportedBackend(backend, options = {}) {
+    const normalized = await normalizeBackend(backend, options);
     if (normalized === "codex" || normalized === "claude" || normalized === "kimi" || normalized === "opencode") {
         return normalized;
     }
-    throw new Error(`Unsupported AI SDK backend "${backend}". Only codex app-server, claude agent-sdk, kimi cli wire, and opencode sdk are supported.`);
+    const descriptor = await getExternalProviderDescriptor(normalized, options);
+    if (descriptor) {
+        return normalized;
+    }
+    throw new Error(`Unsupported AI SDK backend "${backend}". Built-in backends are codex app-server, claude agent-sdk, kimi cli wire, and opencode sdk. Set AISDK_PROVIDER_PATH to load external providers.`);
 }
-export function createLocalAiSession(backend, options = {}) {
-    const normalized = assertSupportedBackend(backend);
+export async function createLocalAiSession(backend, options = {}) {
+    const normalized = await assertSupportedBackend(backend, options);
     if (normalized === "claude") {
         return new ClaudeAgentSdkSession(normalized, options);
     }
@@ -57,7 +80,14 @@ export function createLocalAiSession(backend, options = {}) {
     if (normalized === "opencode") {
         return new OpencodeSdkSession(normalized, options);
     }
-    return new CodexAppServerSession(normalized, options);
+    if (normalized === "codex") {
+        return new CodexAppServerSession(normalized, options);
+    }
+    const descriptor = await getExternalProviderDescriptor(normalized, options);
+    if (!descriptor) {
+        throw new Error(`External AI SDK provider "${normalized}" is unavailable.`);
+    }
+    return await descriptor.createSession(normalized, options);
 }
 export { CodexAppServerSession };
 export { ClaudeAgentSdkSession };

package/dist/worker.js

@@ -33,7 +33,7 @@ async function handleCreate(message) {
         throw new Error("AI worker session already created");
     }
     sessionCreated = true;
-    session = createLocalAiSession(message.backend, {
+    session = await createLocalAiSession(message.backend, {
         ...(message.options && typeof message.options === "object" ? message.options : {}),
         logger: {
             log: (line) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.2.30",
+  "version": "0.2.32",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,5 +25,5 @@
     "@types/node": "^22.10.2",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "e6a71ad"
+  "gitCommitId": "c749d4b"
 }