@love-moon/ai-sdk 0.7.7 → 0.9.0

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";