@love-moon/ai-sdk 0.8.0 → 0.10.0

package/dist/providers/codex-exec-session.js

@@ -6,6 +6,9 @@ import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
 import { CODEX_EXEC_VARIANT as CODEX_EXEC_PROVIDER_VARIANT } from "../built-in-backends.js";
+import { appendContextFilesToPrompt } from "../context-files.js";
+import { PROVIDER_MEDIA_CAPABILITIES } from "../media-adapters.js";
+import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, parseCommandParts, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
@@ -239,6 +242,7 @@ export class CodexExecSession extends EventEmitter {
             resumeReady: false,
             manualResume: null,
             currentTurnStatus: this.getCurrentTurnStatus(),
+            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[CODEX_EXEC_PROVIDER_VARIANT] },
             pid: this.currentTurn?.child?.pid || undefined,
         };
     }
@@ -338,7 +342,7 @@ export class CodexExecSession extends EventEmitter {
     buildPrompt(promptText) {
         return buildHistoryPrompt(this.history, promptText);
     }
-    buildExecArgs({ useInitialImages = false, schemaFilePath = "", lastMessageFilePath = "" } = {}) {
+    buildExecArgs({ media = [], schemaFilePath = "", lastMessageFilePath = "" } = {}) {
         const args = [...this.baseArgs];
         args.push("exec");
         args.push("--json");
@@ -354,11 +358,8 @@ export class CodexExecSession extends EventEmitter {
         if (typeof this.options.model === "string" && this.options.model.trim()) {
             args.push("--model", this.options.model.trim());
         }
-        const images = useInitialImages && Array.isArray(this.options.initialImages)
-            ? this.options.initialImages.filter((item) => typeof item === "string" && item.trim())
-            : [];
-        for (const imagePath of images) {
-            args.push("--image", imagePath);
+        for (const image of media.filter((item) => item.kind === "image")) {
+            args.push("--image", image.path);
         }
         return args;
     }
@@ -376,7 +377,7 @@ export class CodexExecSession extends EventEmitter {
             message: lastMessage || "Codex authentication required",
         });
     }
-    async runTurn(promptText, { useInitialImages = false, onProgress = null, jsonSchema = null } = {}) {
+    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null } = {}) {
         if (this.closeRequested || this.closed) {
             throw this.createSessionClosedError();
         }
@@ -385,12 +386,11 @@ export class CodexExecSession extends EventEmitter {
                 reason: "turn_already_running",
             });
         }
+        const media = resolveTurnMedia(this.options, { useInitialImages, media: mediaInput });
+        assertMediaCapabilities(media, this.backend, PROVIDER_MEDIA_CAPABILITIES[CODEX_EXEC_PROVIDER_VARIANT]);
         const effectivePrompt = this.buildPrompt(promptText);
-        const imagePaths = useInitialImages && Array.isArray(this.options.initialImages)
-            ? this.options.initialImages.filter((item) => typeof item === "string" && item.trim())
-            : [];
-        const stdinPrompt = effectivePrompt || (imagePaths.length > 0 ? "Analyze the attached image." : "");
-        if (!stdinPrompt && imagePaths.length === 0) {
+        const stdinPrompt = appendContextFilesToPrompt(effectivePrompt || (media.length > 0 ? defaultPromptForMedia(media) : ""), contextFiles).prompt;
+        if (!stdinPrompt && media.length === 0) {
             return buildEmptyTurnResult();
         }
         const normalizedSchema = normalizeJsonSchema(jsonSchema);
@@ -416,7 +416,7 @@ export class CodexExecSession extends EventEmitter {
                 status_line: statusLineForPhase("turn_started"),
             }, onProgress);
             const args = this.buildExecArgs({
-                useInitialImages,
+                media,
                 schemaFilePath,
                 lastMessageFilePath,
             });

package/dist/providers/copilot-sdk-session.d.ts

@@ -83,6 +83,11 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
             command: string;
         } | null;
         currentTurnStatus: any;
+        capabilities: {
+            media: Readonly<{
+                image: "native";
+            }>;
+        };
     };
     getSessionInfo(): {
         backend: string;
@@ -165,7 +170,7 @@ export class CopilotSdkSession extends EventEmitter<[never]> {
     handleCopilotEventFailure(error: any): void;
     handleCopilotEvent(event: any): Promise<void>;
     interruptCurrentTurn(): Promise<void>;
-    runTurn(promptText: any, { useInitialImages, onProgress }?: {
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
     }): Promise<{

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

@@ -3,6 +3,9 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { COPILOT_SDK_VARIANT as COPILOT_PROVIDER_VARIANT } from "../built-in-backends.js";
+import { appendContextFilesToPrompt } from "../context-files.js";
+import { PROVIDER_MEDIA_CAPABILITIES, buildCopilotAttachments } from "../media-adapters.js";
+import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, parseCommandParts, proxyToEnv, sanitizeForLog, withoutCopilotGithubTokenEnv, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
 const MIN_TURN_DEADLINE_MS = 30 * 1000;
@@ -591,6 +594,7 @@ export class CopilotSdkSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
+            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[COPILOT_PROVIDER_VARIANT] },
         };
     }
     getSessionInfo() {
@@ -1368,12 +1372,14 @@ export class CopilotSdkSession extends EventEmitter {
             }
         }
     }
-    async runTurn(promptText, { useInitialImages = false, onProgress = null } = {}) {
+    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null } = {}) {
         if (this.currentTurn) {
             throw this.createTurnAlreadyRunningError();
         }
-        const prompt = this.buildPrompt(promptText, { useInitialImages });
-        if (!prompt) {
+        const media = resolveTurnMedia(this.options, { useInitialImages, media: mediaInput });
+        assertMediaCapabilities(media, this.backend, PROVIDER_MEDIA_CAPABILITIES[COPILOT_PROVIDER_VARIANT]);
+        const prompt = appendContextFilesToPrompt(this.buildPrompt(promptText, { useInitialImages: false }) || (media.length ? defaultPromptForMedia(media) : ""), contextFiles).prompt;
+        if (!prompt && media.length === 0) {
             return {
                 text: "",
                 usage: this.lastUsage ? { ...this.lastUsage } : null,
@@ -1419,6 +1425,7 @@ export class CopilotSdkSession extends EventEmitter {
             const completion = await Promise.race([
                 this.requestOrThrow(this.session.sendAndWait({
                     prompt,
+                    attachments: buildCopilotAttachments(media),
                     mode: "immediate",
                 }, this.turnDeadlineMs + SDK_SEND_AND_WAIT_TIMEOUT_GRACE_MS)),
                 closeGuard.promise,

package/dist/providers/dsh-sdk-session.d.ts

@@ -0,0 +1,194 @@
+export function defaultDshSessionRoot(): string;
+/**
+ * DeepSeek Harness (dsh) backend session.
+ *
+ * Drives a dsh runtime subprocess through `@deepseek-ai/dsh-sdk-client`
+ * (stdio JSON-RPC). The runtime composition is the package-owned
+ * `dsh/cordis.yml`; the pinned runtime bin comes from
+ * `@deepseek-ai/dsh-sdk-jsonrpc-demo`. One DshSdkSession owns at most one
+ * runtime subprocess across turns; the dsh-side session id is minted by us
+ * (or taken from resumeSessionId) so the same conversation resumes across
+ * runtime restarts through dsh's JSONL session persistence.
+ *
+ * Interrupt semantics: the dsh SDK wire has NO mid-turn cancel. Interrupting
+ * closes the runtime subprocess (SIGTERM ladder inside the SDK client) and
+ * the next runTurn spawns a fresh runtime resuming the same session id.
+ */
+export class DshSdkSession extends EventEmitter<[never]> {
+    static capabilities: Readonly<{
+        goal: false;
+    }>;
+    constructor(backend: any, options?: {});
+    getCapabilities(): {
+        goal: false;
+    };
+    backend: string;
+    options: {};
+    logger: any;
+    cwd: any;
+    resumeSessionId: any;
+    pendingResumeFromSessionId: any;
+    sessionId: string;
+    sessionIdUsed: boolean;
+    model: any;
+    dshProvider: any;
+    maxTokens: number | undefined;
+    sessionRoot: any;
+    sessionInfo: {
+        backend: string;
+        sessionId: string;
+        model: any;
+        modelProvider: any;
+    };
+    history: any[];
+    pendingHistorySeed: boolean;
+    closeRequested: boolean;
+    closed: boolean;
+    closeWaiters: Set<any>;
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    activeReplyTarget: string;
+    lastReplyTarget: string;
+    manualResumeReady: boolean;
+    sessionAnnounced: boolean;
+    currentTurn: {
+        emittedAssistantMessage: boolean;
+        fullText: string;
+        interrupted: boolean;
+        items: never[];
+        terminalWorkingStatusEmitted: boolean;
+        turnEndReason: null;
+        usage: null;
+    } | null;
+    harness: any;
+    lastUsage: any;
+    currentTurnStatus: any;
+    currentTurnActivityAt: number;
+    now: any;
+    turnDeadlineMs: any;
+    sdkModulePromise: Promise<any> | Promise<typeof import("@deepseek-ai/dsh-sdk-client")> | null;
+    env: any;
+    writeLog(message: any): void;
+    trace(message: any): void;
+    getSnapshot(): {
+        backend: string;
+        provider: string;
+        cwd: any;
+        sessionId: string;
+        sessionInfo: {
+            backend: string;
+            sessionId: string;
+            model: any;
+            modelProvider: any;
+        } | null;
+        useSessionFileReplyStream: boolean;
+        resumeReady: boolean;
+        manualResume: null;
+        currentTurnStatus: any;
+        capabilities: {
+            goal: false;
+        };
+    };
+    getSessionInfo(): {
+        backend: string;
+        sessionId: string;
+        model: any;
+        modelProvider: any;
+    } | null;
+    getCurrentTurnStatus(): any;
+    ensureSessionInfo(): Promise<{
+        backend: string;
+        sessionId: string;
+        model: any;
+        modelProvider: any;
+    } | null>;
+    getSessionUsageSummary(): Promise<{
+        sessionId: string;
+        sessionFilePath: undefined;
+        totalCostUsd: undefined;
+        usage: any;
+        modelUsage: null;
+        rateLimits: null;
+        manualResume: null;
+    }>;
+    usesSessionFileReplyStream(): boolean;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTo: any): void;
+    getCurrentReplyTarget(): string | undefined;
+    touchTurnActivity(): void;
+    updateCurrentTurnStatus(payload: any): void;
+    emitWorkingStatus(payload: any, onProgress?: null): Promise<void>;
+    emitAssistantMessage(text: any): Promise<void>;
+    emitTerminalWorkingStatus(currentTurn: any, payload: any, onProgress?: null): Promise<void>;
+    announceSession(): void;
+    /**
+     * Mint a fresh wire session id after the previous one's runtime was torn
+     * down (interrupt/timeout). The persisted log of the old id would collide
+     * on the next create, so the conversation continues on a new id seeded
+     * with the in-memory history; the new id is re-announced on success.
+     */
+    rotateSessionId(): void;
+    findPersistedSessionLog(sessionId: any): string | null;
+    /**
+     * Recover the user/assistant conversation from a persisted dsh JSONL log
+     * so a cross-process resume can seed it into the fresh wire session.
+     */
+    loadPersistedHistory(sessionId: any): {
+        role: string;
+        content: string;
+    }[];
+    createSessionClosedError(): Error;
+    createTurnTimeoutError(timeoutMs: any): Error;
+    createCloseGuard(onClose: any): {
+        promise: Promise<any>;
+        cleanup: () => void;
+    };
+    createTurnTimeoutGuard(onTimeout: any): {
+        promise: Promise<any>;
+        cleanup: () => void;
+    };
+    flushCloseWaiters(): void;
+    buildPrompt(promptText: any, { useInitialImages }?: {
+        useInitialImages?: boolean | undefined;
+    }): string;
+    resolveLaunchSpec(): {
+        command: any;
+        args: any;
+    };
+    buildRuntimeEnv(): any;
+    getSdkModule(): Promise<any>;
+    getHarness(): Promise<any>;
+    disposeHarness(): Promise<void>;
+    maybeEmitAuthRequired(message: any): void;
+    handleNotification(notification: any, currentTurn: any, { onProgress }: {
+        onProgress: any;
+    }): Promise<void>;
+    interruptCurrentTurn(): Promise<boolean>;
+    runTurn(promptText: any, { useInitialImages, onProgress }?: {
+        useInitialImages?: boolean | undefined;
+        onProgress?: null | undefined;
+    }): Promise<{
+        text: string;
+        usage: null;
+        items: never[];
+        events: never[];
+        provider?: undefined;
+        metadata?: undefined;
+    } | {
+        text: any;
+        usage: any;
+        items: never[];
+        events: never[];
+        provider: string;
+        metadata: {
+            source: string;
+            sessionId: string;
+            model: any;
+            modelProvider: any;
+            turnEndReason: undefined;
+        };
+    }>;
+    close(): Promise<void>;
+}
+import { EventEmitter } from "node:events";