@love-moon/ai-sdk 0.2.38 → 0.2.40

package/dist/client.d.ts

@@ -55,10 +55,12 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     setSessionReplyTarget(replyTo: any): void;
     ensureSessionInfo(): Promise<any>;
     getSessionUsageSummary(): Promise<any>;
+    interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
     close(): Promise<void>;
-    callWorker(method: any, args?: any[], { progressHandler }?: {
+    callWorker(method: any, args?: any[], { progressHandler, messageType }?: {
         progressHandler?: null | undefined;
+        messageType?: string | undefined;
     }): Promise<any>;
     handleWorkerStderr(line: any): void;
     handleWorkerLine(line: any): void;
@@ -104,6 +106,7 @@ declare class LocalAiSessionProxy extends EventEmitter<[never]> {
     setSessionReplyTarget(replyTarget: any): void;
     ensureSessionInfo(): Promise<any>;
     getSessionUsageSummary(): Promise<any>;
+    interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
     close(): Promise<void>;
 }

package/dist/client.js

@@ -168,6 +168,11 @@ export class RemoteAiSession extends EventEmitter {
     async getSessionUsageSummary() {
         return this.callWorker("getSessionUsageSummary", []);
     }
+    async interruptCurrentTurn() {
+        return this.callWorker("interruptCurrentTurn", [], {
+            messageType: "control",
+        });
+    }
     async runTurn(promptText, options = {}) {
         const { onProgress, ...restOptions } = options || {};
         return this.callWorker("runTurn", [promptText, restOptions], {
@@ -214,7 +219,7 @@ export class RemoteAiSession extends EventEmitter {
             await this.exitPromise;
         }
     }
-    async callWorker(method, args = [], { progressHandler = null } = {}) {
+    async callWorker(method, args = [], { progressHandler = null, messageType = "request" } = {}) {
         if (this.closed) {
             throw createSessionClosedError();
         }
@@ -224,7 +229,7 @@ export class RemoteAiSession extends EventEmitter {
         }
         const requestId = this.nextRequestId++;
         const payload = {
-            type: "request",
+            type: messageType,
             id: requestId,
             method,
             args,
@@ -566,6 +571,13 @@ class LocalAiSessionProxy extends EventEmitter {
         const session = await this.readyPromise;
         return await session.getSessionUsageSummary();
     }
+    async interruptCurrentTurn() {
+        const session = await this.readyPromise;
+        if (typeof session.interruptCurrentTurn === "function") {
+            return await session.interruptCurrentTurn();
+        }
+        return false;
+    }
     async runTurn(promptText, options = {}) {
         const session = await this.readyPromise;
         return await session.runTurn(promptText, options);

package/dist/external-provider-registry.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { loadEnvConfig } from "./shared.js";
-const BUILT_IN_BACKENDS = new Set(["codex", "claude", "kimi", "opencode"]);
+const BUILT_IN_BACKENDS = new Set(["codex", "claude", "copilot", "kimi", "opencode"]);
 const registryPromises = new Map();
 let externalProviderImportNonce = 0;
 function appendProviderModulePaths(parts, value) {
@@ -15,13 +15,49 @@ function appendProviderModulePaths(parts, value) {
     if (!raw) {
         return;
     }
-    for (const item of raw.split(process.platform === "win32" ? ";" : ":")) {
+    for (const item of splitProviderModulePathString(raw)) {
         const normalized = item.trim();
         if (normalized) {
             parts.push(normalized);
         }
     }
 }
+function looksLikeProviderModulePath(value) {
+    const normalized = String(value || "").trim();
+    if (!normalized) {
+        return false;
+    }
+    return (normalized.startsWith("/") ||
+        normalized.startsWith("./") ||
+        normalized.startsWith("../") ||
+        normalized.startsWith("~/") ||
+        normalized.startsWith("file:") ||
+        normalized.includes("/") ||
+        normalized.includes("\\") ||
+        /\.[cm]?[jt]sx?$/i.test(normalized) ||
+        /^[A-Za-z]:[\\/]/.test(normalized));
+}
+function splitProviderModulePathString(raw) {
+    const normalized = String(raw || "").trim();
+    if (!normalized) {
+        return [];
+    }
+    const platformParts = normalized
+        .split(path.delimiter)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (platformParts.length > 1 || !normalized.includes(",")) {
+        return platformParts;
+    }
+    const commaParts = normalized
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (commaParts.length > 1 && commaParts.every(looksLikeProviderModulePath)) {
+        return commaParts;
+    }
+    return platformParts;
+}
 function listProviderModulePathsFromValue(rawValue) {
     const parts = [];
     appendProviderModulePaths(parts, rawValue);

package/dist/providers/claude-agent-sdk-session.d.ts

@@ -121,10 +121,11 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     handleSdkMessage(message: any, currentTurn: any, { onProgress }: {
         onProgress: any;
     }): Promise<void>;
-    interruptCurrentTurn(): Promise<void>;
-    runTurn(promptText: any, { useInitialImages, onProgress }?: {
+    interruptCurrentTurn(): Promise<boolean>;
+    runTurn(promptText: any, { useInitialImages, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
+        jsonSchema?: null | undefined;
     }): Promise<{
         text: string;
         usage: null;
@@ -143,6 +144,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
             sessionId: any;
             totalCostUsd: number | undefined;
             modelUsage: any;
+            structuredOutput: any;
         };
     }>;
     close(): Promise<void>;

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

@@ -550,6 +550,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             "systemPrompt",
             "thinking",
             "tools",
+            "outputFormat",
         ];
         for (const key of passthroughKeys) {
             const value = this.options[key];
@@ -680,7 +681,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
     async interruptCurrentTurn() {
         const currentTurn = this.currentTurn;
         if (!currentTurn) {
-            return;
+            return false;
         }
         try {
             await currentTurn.query?.interrupt?.();
@@ -700,8 +701,9 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         catch {
             // best effort
         }
+        return true;
     }
-    async runTurn(promptText, { useInitialImages = false, onProgress = null } = {}) {
+    async runTurn(promptText, { useInitialImages = false, onProgress = null, jsonSchema = null } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
         }
@@ -744,6 +746,10 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             abortController.abort();
             currentTurn.query?.close?.();
         });
+        const previousOutputFormat = this.options.outputFormat;
+        if (jsonSchema && typeof jsonSchema === "object") {
+            this.options.outputFormat = { type: "json_schema", schema: jsonSchema };
+        }
         try {
             await this.emitWorkingStatus({
                 phase: "turn_started",
@@ -786,9 +792,14 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                         : [],
                 });
             }
-            const responseText = normalizeText(resultMessage.result) ||
-                currentTurn.fullText ||
-                extractAssistantText(currentTurn.items.find((item) => item?.type === "assistant")?.message);
+            const structuredOutput = jsonSchema && resultMessage.structured_output && typeof resultMessage.structured_output === "object"
+                ? resultMessage.structured_output
+                : null;
+            const responseText = structuredOutput !== null
+                ? JSON.stringify(structuredOutput)
+                : normalizeText(resultMessage.result) ||
+                    currentTurn.fullText ||
+                    extractAssistantText(currentTurn.items.find((item) => item?.type === "assistant")?.message);
             if (!currentTurn.emittedAssistantMessage && responseText) {
                 await this.emitAssistantMessage(responseText);
             }
@@ -814,6 +825,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
                         ? Number(resultMessage.total_cost_usd)
                         : undefined,
                     modelUsage: resultMessage.modelUsage ? { ...resultMessage.modelUsage } : undefined,
+                    structuredOutput: structuredOutput !== null ? structuredOutput : undefined,
                 },
             };
         }
@@ -835,6 +847,14 @@ export class ClaudeAgentSdkSession extends EventEmitter {
             throw error;
         }
         finally {
+            if (jsonSchema && typeof jsonSchema === "object") {
+                if (previousOutputFormat !== undefined) {
+                    this.options.outputFormat = previousOutputFormat;
+                }
+                else {
+                    delete this.options.outputFormat;
+                }
+            }
             this.activeReplyTarget = "";
             if (this.currentTurn === currentTurn) {
                 this.currentTurn = null;

package/dist/providers/codex-app-server-session.d.ts

@@ -149,9 +149,10 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
     maybeEmitAuthRequired(error: any): void;
-    interruptCurrentTurn(): Promise<void>;
-    runTurn(promptText: any, { useInitialImages }?: {
+    interruptCurrentTurn(): Promise<boolean>;
+    runTurn(promptText: any, { useInitialImages, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
+        jsonSchema?: null | undefined;
     }): Promise<{
         text: string;
         usage: null;

package/dist/providers/codex-app-server-session.js

@@ -38,6 +38,15 @@ function buildTurnInput(promptText) {
         },
     ];
 }
+function injectJsonSchemaPrompt(promptText, jsonSchema) {
+    const schemaText = typeof jsonSchema === "string" ? jsonSchema : JSON.stringify(jsonSchema, null, 2);
+    return `You must respond with valid JSON that strictly conforms to the following JSON Schema. Do not include any markdown formatting or explanation outside the JSON object.
+
+JSON Schema:
+${schemaText}
+
+${promptText}`;
+}
 function normalizeItemId(value) {
     return typeof value === "string" ? value.trim() : "";
 }
@@ -198,7 +207,11 @@ export class CodexAppServerSession extends EventEmitter {
         const extraEnv = envConfig && typeof envConfig === "object" ? { ...envConfig, ...proxyEnv } : proxyEnv;
         this.transport = new CodexAppServerTransport({
             cwd: this.cwd,
-            env: extraEnv,
+            env: {
+                ...extraEnv,
+                ...(options.env && typeof options.env === "object" ? options.env : {}),
+            },
+            ignoreCodexApiKey: options.ignoreCodexApiKey === true,
             logger: {
                 log: (message) => {
                     this.writeLog(message);
@@ -851,23 +864,28 @@ export class CodexAppServerSession extends EventEmitter {
     async interruptCurrentTurn() {
         const currentTurn = this.currentTurn;
         if (!currentTurn || !this.sessionId || !currentTurn.turnId) {
-            return;
+            return false;
         }
         try {
             await this.transport.request("turn/interrupt", {
                 threadId: this.sessionId,
                 turnId: currentTurn.turnId,
             });
+            return true;
         }
         catch {
             // best effort
         }
+        return false;
     }
-    async runTurn(promptText, { useInitialImages = false } = {}) {
+    async runTurn(promptText, { useInitialImages = false, jsonSchema = null } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
         }
-        const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
+        let effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
+        if (jsonSchema && typeof jsonSchema === "object" && effectivePrompt) {
+            effectivePrompt = injectJsonSchemaPrompt(effectivePrompt, jsonSchema);
+        }
         if (!effectivePrompt) {
             return {
                 text: "",

package/dist/providers/codex-exec-session.d.ts

@@ -0,0 +1,116 @@
+export class CodexExecSession extends EventEmitter<[never]> {
+    constructor(backend: any, options?: {});
+    backend: string;
+    options: {};
+    logger: any;
+    cwd: any;
+    resumeSessionId: any;
+    sessionId: any;
+    sessionInfo: {
+        backend: string;
+        sessionId: any;
+        model: any;
+    };
+    history: any[];
+    closeRequested: boolean;
+    closed: boolean;
+    ignoreCodexApiKey: boolean;
+    currentTurn: {
+        child: null;
+        stdoutEvents: never[];
+        stderrTail: never[];
+        settled: boolean;
+    } | null;
+    currentTurnStatus: any;
+    sessionAnnounced: boolean;
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    activeReplyTarget: string;
+    lastReplyTarget: string;
+    turnDeadlineMs: any;
+    env: any;
+    command: string;
+    baseArgs: string[];
+    writeLog(message: any): void;
+    trace(message: any): void;
+    get threadId(): any;
+    get threadOptions(): {
+        model: any;
+        modelProvider: any;
+    };
+    getSnapshot(): {
+        backend: string;
+        provider: string;
+        cwd: any;
+        sessionId: any;
+        sessionInfo: {
+            backend: string;
+            sessionId: any;
+            model: any;
+        } | null;
+        useSessionFileReplyStream: boolean;
+        resumeReady: boolean;
+        manualResume: null;
+        currentTurnStatus: any;
+        pid: any;
+    };
+    getSessionInfo(): {
+        backend: string;
+        sessionId: any;
+        model: any;
+    } | null;
+    getCurrentTurnStatus(): any;
+    ensureSessionInfo(): Promise<{
+        backend: string;
+        sessionId: any;
+        model: any;
+    } | null>;
+    getSessionUsageSummary(): Promise<{
+        sessionId: any;
+        sessionFilePath: undefined;
+        tokenUsagePercent: undefined;
+        contextUsagePercent: undefined;
+        tokenUsage: null;
+        rateLimits: null;
+        manualResume: null;
+    }>;
+    usesSessionFileReplyStream(): boolean;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTo: any): void;
+    getCurrentReplyTarget(): string | undefined;
+    announceSession(): void;
+    createSessionClosedError(): Error;
+    updateCurrentTurnStatus(payload: any): void;
+    emitWorkingStatus(payload: any, onProgress?: null): Promise<any>;
+    emitAssistantMessage(text: any): Promise<void>;
+    buildPrompt(promptText: any): string;
+    buildExecArgs({ useInitialImages, schemaFilePath, lastMessageFilePath }?: {
+        useInitialImages?: boolean | undefined;
+        schemaFilePath?: string | undefined;
+        lastMessageFilePath?: string | undefined;
+    }): string[];
+    maybeEmitAuthRequired(stderrTail: any): void;
+    runTurn(promptText: any, { useInitialImages, onProgress, jsonSchema }?: {
+        useInitialImages?: boolean | undefined;
+        onProgress?: null | undefined;
+        jsonSchema?: null | undefined;
+    }): Promise<{
+        text: string;
+        usage: null;
+        items: never[];
+        events: never[];
+    } | {
+        text: any;
+        usage: null;
+        items: any;
+        events: any;
+        provider: string;
+        metadata: {
+            source: string;
+            sessionId: any;
+        };
+    }>;
+    close(): Promise<void>;
+}
+import { EventEmitter } from "node:events";