@love-moon/ai-sdk 0.8.0 → 0.9.0

package/dist/providers/kimi-cli-session.d.ts

@@ -83,6 +83,11 @@ export class KimiCliSession extends EventEmitter<[never]> {
             command: any;
         } | null;
         currentTurnStatus: any;
+        capabilities: {
+            media: Readonly<{
+                image: "native";
+            }>;
+        };
         pid: any;
     };
     getSessionInfo(): {
@@ -149,7 +154,7 @@ export class KimiCliSession extends EventEmitter<[never]> {
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, onProgress, jsonSchema }?: {
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
         jsonSchema?: null | undefined;

package/dist/providers/kimi-cli-session.js

@@ -1,6 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { KIMI_CLI_WIRE_VARIANT as KIMI_PROVIDER_VARIANT } from "../built-in-backends.js";
+import { appendContextFilesToPrompt } from "../context-files.js";
+import { PROVIDER_MEDIA_CAPABILITIES, buildKimiContent } from "../media-adapters.js";
+import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { KimiWireTransport } from "../transports/kimi-wire-transport.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
@@ -230,6 +233,7 @@ export class KimiCliSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
+            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[KIMI_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -873,11 +877,15 @@ export class KimiCliSession extends EventEmitter {
         }
         return false;
     }
-    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();
         }
-        let effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
+        const media = resolveTurnMedia(this.options, { useInitialImages, media: mediaInput });
+        assertMediaCapabilities(media, this.backend, PROVIDER_MEDIA_CAPABILITIES[KIMI_PROVIDER_VARIANT]);
+        let effectivePrompt = this.buildPrompt(promptText, { useInitialImages: false }) ||
+            (media.length ? defaultPromptForMedia(media) : "");
+        effectivePrompt = appendContextFilesToPrompt(effectivePrompt, contextFiles).prompt;
         if (jsonSchema && typeof jsonSchema === "object" && effectivePrompt) {
             effectivePrompt = injectJsonSchemaPrompt(effectivePrompt, jsonSchema);
         }
@@ -930,7 +938,9 @@ export class KimiCliSession extends EventEmitter {
             }, onProgress);
             const promptResult = await Promise.race([
                 this.transport.request("prompt", {
-                    user_input: effectivePrompt,
+                    user_input: media.length === 0
+                        ? effectivePrompt
+                        : buildKimiContent(effectivePrompt, media),
                 }),
                 turnFailurePromise,
                 closeGuard.promise,

package/dist/providers/kimi-print-session.d.ts

@@ -60,6 +60,13 @@ export class KimiPrintSession extends EventEmitter<[never]> {
             command: string;
         } | null;
         currentTurnStatus: any;
+        capabilities: {
+            media: Readonly<{
+                image: "unsupported";
+            }> | Readonly<{
+                image: "native";
+            }>;
+        };
         pid: any;
     };
     getSessionInfo(): {
@@ -100,15 +107,15 @@ export class KimiPrintSession extends EventEmitter<[never]> {
     emitAssistantMessage(text: any): Promise<void>;
     buildPrompt(promptText: any): string;
     buildPrintArgs(promptText?: string): string[];
-    buildUserMessage(promptText: any, { useInitialImages }?: {
-        useInitialImages?: boolean | undefined;
+    buildUserMessage(promptText: any, { media }?: {
+        media?: never[] | undefined;
     }): {
         role: string;
         content: any;
     };
     maybeEmitAuthRequired(stderrTail: any): void;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, onProgress, jsonSchema }?: {
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
         jsonSchema?: null | undefined;

package/dist/providers/kimi-print-session.js

@@ -5,6 +5,9 @@ import { randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
 import { KIMI_CLI_PRINT_VARIANT as KIMI_PRINT_PROVIDER_VARIANT } from "../built-in-backends.js";
+import { appendContextFilesToPrompt } from "../context-files.js";
+import { PROVIDER_MEDIA_CAPABILITIES, UNSUPPORTED_MEDIA_CAPABILITIES, buildKimiContent, } 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;
@@ -165,31 +168,6 @@ function normalizeTextContent(content) {
     }
     return "";
 }
-function guessMimeType(filePath) {
-    const ext = path.extname(String(filePath || "")).toLowerCase();
-    switch (ext) {
-        case ".png":
-            return "image/png";
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".gif":
-            return "image/gif";
-        case ".webp":
-            return "image/webp";
-        case ".bmp":
-            return "image/bmp";
-        case ".svg":
-            return "image/svg+xml";
-        default:
-            return "application/octet-stream";
-    }
-}
-function filePathToDataUri(filePath) {
-    const buffer = fs.readFileSync(filePath);
-    const mimeType = guessMimeType(filePath);
-    return `data:${mimeType};base64,${buffer.toString("base64")}`;
-}
 export class KimiPrintSession extends EventEmitter {
     constructor(backend, options = {}) {
         super();
@@ -291,6 +269,11 @@ export class KimiPrintSession extends EventEmitter {
                 }
                 : null,
             currentTurnStatus: this.getCurrentTurnStatus(),
+            capabilities: {
+                media: this.cliMode === "prompt"
+                    ? UNSUPPORTED_MEDIA_CAPABILITIES
+                    : PROVIDER_MEDIA_CAPABILITIES[KIMI_PRINT_PROVIDER_VARIANT],
+            },
             pid: this.currentTurn?.child?.pid || undefined,
         };
     }
@@ -444,31 +427,16 @@ export class KimiPrintSession extends EventEmitter {
         }
         return args;
     }
-    buildUserMessage(promptText, { useInitialImages = false } = {}) {
-        const images = useInitialImages && Array.isArray(this.options.initialImages)
-            ? this.options.initialImages.filter((item) => typeof item === "string" && item.trim())
-            : [];
-        if (images.length === 0) {
+    buildUserMessage(promptText, { media = [] } = {}) {
+        if (media.length === 0) {
             return {
                 role: "user",
                 content: promptText,
             };
         }
-        const content = [];
-        if (promptText) {
-            content.push({ type: "text", text: promptText });
-        }
-        for (const imagePath of images) {
-            content.push({
-                type: "image_url",
-                image_url: {
-                    url: filePathToDataUri(imagePath),
-                },
-            });
-        }
         return {
             role: "user",
-            content,
+            content: buildKimiContent(promptText, media),
         };
     }
     maybeEmitAuthRequired(stderrTail) {
@@ -500,7 +468,7 @@ export class KimiPrintSession extends EventEmitter {
             return false;
         }
     }
-    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();
         }
@@ -509,21 +477,23 @@ export class KimiPrintSession extends EventEmitter {
                 reason: "turn_already_running",
             });
         }
+        const media = resolveTurnMedia(this.options, { useInitialImages, media: mediaInput });
+        assertMediaCapabilities(media, this.backend, PROVIDER_MEDIA_CAPABILITIES[KIMI_PRINT_PROVIDER_VARIANT]);
         let effectivePrompt = this.buildPrompt(promptText);
-        const imagePaths = useInitialImages && Array.isArray(this.options.initialImages)
-            ? this.options.initialImages.filter((item) => typeof item === "string" && item.trim())
-            : [];
+        effectivePrompt = appendContextFilesToPrompt(effectivePrompt, contextFiles).prompt;
         if (jsonSchema && typeof jsonSchema === "object") {
-            const promptWithSchema = effectivePrompt || (imagePaths.length > 0 ? "Analyze the attached images." : "");
+            const promptWithSchema = effectivePrompt || (media.length > 0 ? defaultPromptForMedia(media) : "");
             if (promptWithSchema) {
                 effectivePrompt = injectJsonSchemaPrompt(promptWithSchema, jsonSchema);
             }
         }
-        if (this.cliMode === "prompt" && imagePaths.length > 0) {
-            const imageContext = imagePaths.map((item, index) => `${index + 1}. ${item}`).join("\n");
-            effectivePrompt = `${effectivePrompt || "Analyze the attached images."}\n\nAttached image files:\n${imageContext}`;
+        if (this.cliMode === "prompt" && media.length > 0) {
+            throw createTurnError("Kimi prompt mode does not support media input", {
+                reason: "unsupported_media",
+                backend: this.backend,
+            });
         }
-        if (!effectivePrompt && imagePaths.length === 0) {
+        if (!effectivePrompt && media.length === 0) {
             return buildEmptyTurnResult();
         }
         this.announceSession();
@@ -685,7 +655,7 @@ export class KimiPrintSession extends EventEmitter {
                     });
                 });
                 if (this.cliMode === "legacy-print") {
-                    const userMessage = this.buildUserMessage(effectivePrompt, { useInitialImages });
+                    const userMessage = this.buildUserMessage(effectivePrompt || defaultPromptForMedia(media), { media });
                     child.stdin.write(`${JSON.stringify(userMessage)}\n`);
                 }
                 child.stdin.end();

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

@@ -78,6 +78,11 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
         resumeReady: boolean;
         manualResume: null;
         currentTurnStatus: any;
+        capabilities: {
+            media: Readonly<{
+                image: "native";
+            }>;
+        };
         pid: any;
     };
     getSessionInfo(): {
@@ -164,7 +169,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
     interruptCurrentTurn(): Promise<boolean>;
-    runTurn(promptText: any, { useInitialImages, onProgress, jsonSchema }?: {
+    runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;
         jsonSchema?: null | undefined;

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

@@ -1,5 +1,8 @@
 import { EventEmitter } from "node:events";
 import { OPENCODE_SDK_VARIANT as OPENCODE_PROVIDER_VARIANT } from "../built-in-backends.js";
+import { appendContextFilesToPrompt } from "../context-files.js";
+import { PROVIDER_MEDIA_CAPABILITIES, buildOpencodeParts } from "../media-adapters.js";
+import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { OpencodeServerTransport } from "../transports/opencode-server-transport.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, proxyToEnv, sanitizeForLog, } from "../shared.js";
 const DEFAULT_TURN_DEADLINE_MS = 12 * 60 * 1000;
@@ -223,6 +226,7 @@ export class OpencodeSdkSession extends EventEmitter {
             resumeReady: Boolean(this.sessionId),
             manualResume: null,
             currentTurnStatus: this.getCurrentTurnStatus(),
+            capabilities: { media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -1136,12 +1140,15 @@ export class OpencodeSdkSession extends EventEmitter {
         }
         return true;
     }
-    async runTurn(promptText, { useInitialImages = false, onProgress = null, jsonSchema = null } = {}) {
+    async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();
         }
-        const effectivePrompt = this.buildPrompt(promptText, { useInitialImages });
-        if (!effectivePrompt) {
+        const media = resolveTurnMedia(this.options, { useInitialImages, media: mediaInput });
+        assertMediaCapabilities(media, this.backend, PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT]);
+        const effectivePrompt = appendContextFilesToPrompt(this.buildPrompt(promptText, { useInitialImages: false }) ||
+            (media.length ? defaultPromptForMedia(media) : ""), contextFiles).prompt;
+        if (!effectivePrompt && media.length === 0) {
             return buildEmptyTurnResult();
         }
         if (this.currentTurn) {
@@ -1216,12 +1223,7 @@ export class OpencodeSdkSession extends EventEmitter {
                         format: jsonSchema && typeof jsonSchema === "object"
                             ? { type: "json_schema", schema: jsonSchema }
                             : undefined,
-                        parts: [
-                            {
-                                type: "text",
-                                text: effectivePrompt,
-                            },
-                        ],
+                        parts: buildOpencodeParts(effectivePrompt, media),
                     }, {
                         throwOnError: true,
                         responseStyle: "data",

package/dist/resume/dsh.d.ts

@@ -0,0 +1,23 @@
+/**
+ * dsh sessions persist as JSONL logs written by the runtime's
+ * `@deepseek-ai/dsh-session-persistence-jsonl` plugin under the session root
+ * DshSdkSession sets via DSH_SESSION_ROOT:
+ *
+ *   <root>/<projectKey(cwd)>/<sessionId>/session.jsonl
+ *
+ * The first line of session.jsonl is a `{"type":"session",...}` header that
+ * carries the workspace `cwd`, which is what resume needs back.
+ */
+export function buildCliArgs(sessionId: any): string[];
+export function findSessionPath(sessionId: any, options?: {}): Promise<string | null>;
+export function resolveResumeContext(sessionId: any, options?: {}): Promise<{
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+}>;
+export const BACKEND: "dsh";

package/dist/resume/dsh.js

@@ -0,0 +1,122 @@
+import { promises as fsp } from "node:fs";
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import { defaultDshSessionRoot } from "../providers/dsh-sdk-session.js";
+import { buildResumeContext, isExistingDirectory, normalizeSessionId, } from "./shared.js";
+export const BACKEND = "dsh";
+/**
+ * dsh sessions persist as JSONL logs written by the runtime's
+ * `@deepseek-ai/dsh-session-persistence-jsonl` plugin under the session root
+ * DshSdkSession sets via DSH_SESSION_ROOT:
+ *
+ *   <root>/<projectKey(cwd)>/<sessionId>/session.jsonl
+ *
+ * The first line of session.jsonl is a `{"type":"session",...}` header that
+ * carries the workspace `cwd`, which is what resume needs back.
+ */
+export function buildCliArgs(sessionId) {
+    // dsh has no standalone CLI resume command inside conductor (the runtime is
+    // relaunched by DshSdkSession through the SDK client), but the resume
+    // contract requires a stable arg vector; consumers ignore it for dsh.
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    return [`--resume-session-id=${normalizedSessionId}`];
+}
+function resolveSessionRoot(options = {}) {
+    if (typeof options.dshSessionRoot === "string" && options.dshSessionRoot.trim()) {
+        return options.dshSessionRoot.trim();
+    }
+    return defaultDshSessionRoot();
+}
+export async function findSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const root = resolveSessionRoot(options);
+    let projectEntries = [];
+    try {
+        projectEntries = await fsp.readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const projectEntry of projectEntries) {
+        if (!projectEntry.isDirectory()) {
+            continue;
+        }
+        const sessionDir = path.join(root, projectEntry.name, normalizedSessionId);
+        for (const filename of ["session.jsonl", "session.jsonl.zstd"]) {
+            const candidate = path.join(sessionDir, filename);
+            try {
+                const stats = await fsp.stat(candidate);
+                if (stats.isFile()) {
+                    return candidate;
+                }
+            }
+            catch {
+                // keep scanning
+            }
+        }
+    }
+    return null;
+}
+async function readHeaderLine(sessionPath) {
+    if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+        return null;
+    }
+    const rl = readline.createInterface({
+        input: fs.createReadStream(sessionPath),
+        crlfDelay: Infinity,
+    });
+    try {
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+    return null;
+}
+export async function resolveResumeContext(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const sessionPath = await findSessionPath(normalizedSessionId, options);
+    if (!sessionPath) {
+        throw new Error(`Invalid --resume session id for dsh: ${normalizedSessionId}`);
+    }
+    const header = await readHeaderLine(sessionPath);
+    const cwdFromHeader = header && header.type === "session" && typeof header.cwd === "string" && header.cwd.trim()
+        ? header.cwd.trim()
+        : "";
+    const cwd = cwdFromHeader ||
+        (typeof options?.cwd === "string" && options.cwd.trim() ? options.cwd.trim() : "");
+    if (!cwd) {
+        throw new Error(`Could not resolve workspace for dsh session ${normalizedSessionId}`);
+    }
+    if (!(await isExistingDirectory(cwd))) {
+        throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    return buildResumeContext({
+        provider: "dsh",
+        sessionId: normalizedSessionId,
+        sessionPath,
+        cwd,
+        cwdSource: cwdFromHeader ? "session" : "options_cwd",
+    });
+}

package/dist/resume/index.js

@@ -4,6 +4,7 @@ import * as chatWeb from "./chat-web.js";
 import * as claude from "./claude.js";
 import * as codex from "./codex.js";
 import * as copilot from "./copilot.js";
+import * as dsh from "./dsh.js";
 import * as kimi from "./kimi.js";
 import * as opencode from "./opencode.js";
 import { buildResumeContext, isExistingDirectory, normalizeBackend, normalizeProjectPathCandidate, normalizeSessionId, resolveSessionRunDirectory, } from "./shared.js";
@@ -27,6 +28,7 @@ const RESUME_MODULES_BY_BACKEND = new Map([
     ["kimi", kimi],
     ["opencode", opencode],
     ["chat-web", chatWeb],
+    ["dsh", dsh],
 ]);
 // Sanity-check at module load:
 // (1) Every registered resume module must point at a real built-in backend.

package/dist/session-factory.d.ts

@@ -11,6 +11,7 @@ export const KIMI_PROVIDER_VARIANT: "kimi-cli-wire";
 export const KIMI_PRINT_PROVIDER_VARIANT: "kimi-cli-print";
 export const OPENCODE_PROVIDER_VARIANT: "opencode-sdk";
 export const CHAT_WEB_PROVIDER_VARIANT: "chat-web-session";
+export const DSH_PROVIDER_VARIANT: "dsh-sdk";
 import { BUILT_IN_BACKENDS } from "./built-in-backends.js";
 import { ChatWebSession } from "./providers/chat-web-session.js";
 import { CodexAppServerSession } from "./providers/codex-app-server-session.js";
@@ -20,4 +21,5 @@ import { CopilotSdkSession } from "./providers/copilot-sdk-session.js";
 import { KimiCliSession } from "./providers/kimi-cli-session.js";
 import { KimiPrintSession } from "./providers/kimi-print-session.js";
 import { OpencodeSdkSession } from "./providers/opencode-sdk-session.js";
-export { BUILT_IN_BACKENDS, ChatWebSession, CodexAppServerSession, CodexExecSession, ClaudeAgentSdkSession, CopilotSdkSession, KimiCliSession, KimiPrintSession, OpencodeSdkSession };
+import { DshSdkSession } from "./providers/dsh-sdk-session.js";
+export { BUILT_IN_BACKENDS, ChatWebSession, CodexAppServerSession, CodexExecSession, ClaudeAgentSdkSession, CopilotSdkSession, KimiCliSession, KimiPrintSession, OpencodeSdkSession, DshSdkSession };

package/dist/session-factory.js

@@ -1,9 +1,10 @@
-import { BUILT_IN_BACKENDS, CHAT_WEB_SESSION_VARIANT, CLAUDE_AGENT_SDK_VARIANT, CODEX_APP_SERVER_VARIANT, CODEX_EXEC_VARIANT, COPILOT_SDK_VARIANT, KIMI_CLI_PRINT_VARIANT, KIMI_CLI_WIRE_VARIANT, OPENCODE_SDK_VARIANT, getBuiltInBackendEntry, isBuiltInBackend, listBuiltInBackends, normalizeBuiltInBackend, } from "./built-in-backends.js";
+import { BUILT_IN_BACKENDS, CHAT_WEB_SESSION_VARIANT, CLAUDE_AGENT_SDK_VARIANT, CODEX_APP_SERVER_VARIANT, CODEX_EXEC_VARIANT, COPILOT_SDK_VARIANT, DSH_SDK_VARIANT, KIMI_CLI_PRINT_VARIANT, KIMI_CLI_WIRE_VARIANT, OPENCODE_SDK_VARIANT, getBuiltInBackendEntry, isBuiltInBackend, listBuiltInBackends, normalizeBuiltInBackend, } from "./built-in-backends.js";
 import { ChatWebSession } from "./providers/chat-web-session.js";
 import { CodexAppServerSession } from "./providers/codex-app-server-session.js";
 import { CodexExecSession } from "./providers/codex-exec-session.js";
 import { ClaudeAgentSdkSession } from "./providers/claude-agent-sdk-session.js";
 import { CopilotSdkSession } from "./providers/copilot-sdk-session.js";
+import { DshSdkSession } from "./providers/dsh-sdk-session.js";
 import { KimiCliSession } from "./providers/kimi-cli-session.js";
 import { resolveKimiCliMode } from "./providers/kimi-cli-mode.js";
 import { KimiPrintSession } from "./providers/kimi-print-session.js";
@@ -17,6 +18,7 @@ export const KIMI_PROVIDER_VARIANT = KIMI_CLI_WIRE_VARIANT;
 export const KIMI_PRINT_PROVIDER_VARIANT = KIMI_CLI_PRINT_VARIANT;
 export const OPENCODE_PROVIDER_VARIANT = OPENCODE_SDK_VARIANT;
 export const CHAT_WEB_PROVIDER_VARIANT = CHAT_WEB_SESSION_VARIANT;
+export const DSH_PROVIDER_VARIANT = DSH_SDK_VARIANT;
 const SESSION_FACTORIES_BY_BACKEND = new Map([
     [
         "codex",
@@ -47,6 +49,7 @@ const SESSION_FACTORIES_BY_BACKEND = new Map([
     ],
     ["opencode", (backend, options) => new OpencodeSdkSession(backend, options)],
     ["chat-web", (backend, options) => new ChatWebSession(backend, options)],
+    ["dsh", (backend, options) => new DshSdkSession(backend, options)],
 ]);
 function hasStructuredOutputPreference(options = {}) {
     if (!options || typeof options !== "object") {
@@ -131,3 +134,4 @@ export { CopilotSdkSession };
 export { KimiCliSession };
 export { KimiPrintSession };
 export { OpencodeSdkSession };
+export { DshSdkSession };

package/dsh/cordis.yml

@@ -0,0 +1,100 @@
+# Conductor-owned DeepSeek Harness runtime composition for the ai-sdk `dsh`
+# backend. Launched by src/providers/dsh-sdk-session.js through
+# @deepseek-ai/dsh-sdk-client (stdio JSON-RPC); stdout is reserved for
+# JSON-RPC, so no console logger or terminal UI may be mounted here.
+#
+# Modeled on deepseek-harness's examples/jsonrpc-agent/cordis.yml (the
+# upstream unattended coding-agent reference) and the Python SDK's bundled
+# zero-config composition. Plugin versions are pinned in package.json; bare
+# plugin names resolve from this file's directory up into the ai-sdk
+# node_modules tree.
+#
+# Environment contract (set by DshSdkSession when spawning the runtime):
+#   DEEPSEEK_API_KEY   required; resolved by the llm-deepseek adapter
+#   DEEPSEEK_BASE_URL  optional API endpoint override
+#   DSH_CWD            workspace directory for bash/fs tools
+#   DSH_SESSION_ROOT   JSONL session persistence root
+#   DSH_SYSTEM_PROMPT  optional persona override
+
+# Stdio JSON-RPC server entry; without it the agent has no SDK client.
+- id: sdk-jsonrpc-server
+  name: '@deepseek-ai/dsh-sdk-jsonrpc-server'
+
+# Stock DeepSeek adapter. Resolves DEEPSEEK_API_KEY / DEEPSEEK_BASE_URL from
+# the launching environment; nothing secret is inlined here.
+- id: llm-deepseek
+  name: '@deepseek-ai/dsh-llm-deepseek'
+
+# Managed child-process groups for the bash executor.
+- id: subprocess
+  name: '@deepseek-ai/dsh-subprocess-local'
+
+- id: bash
+  name: '@deepseek-ai/dsh-bash-local'
+  config:
+    cwd: !!js process.env.DSH_CWD ?? process.cwd()
+    timeoutMs: 60000
+
+# Agent spine: agent loop, system prompt, core coding tools.
+- id: agent-spine
+  name: '@deepseek-ai/dsh-agent-spine-demo'
+  config:
+    persona: !!js process.env.DSH_SYSTEM_PROMPT ?? 'You are a coding agent.'
+    workspaceContext:
+      maxBytes: 65536
+
+# JSONL persistence. Compression stays off so the resume dispatcher
+# (src/resume/dsh.js) can read the header line back for cwd recovery.
+- id: sessions
+  name: '@deepseek-ai/dsh-session-persistence-jsonl'
+  config:
+    root: !!js process.env.DSH_SESSION_ROOT ?? './.sessions'
+    compression: none
+
+- id: session-checkpoints
+  name: '@deepseek-ai/dsh-session-checkpoint-policy'
+
+# Subagent delegation (in-process spawn provider).
+- id: subagent
+  name: '@deepseek-ai/dsh-subagent'
+
+- id: subagent-spawn-in-process
+  name: '@deepseek-ai/dsh-subagent-spawn-in-process'
+  config:
+    providerName: spawn
+
+- id: tool-subagent
+  name: '@deepseek-ai/dsh-tool-subagent'
+  config:
+    provider: spawn
+    toolName: subagent
+    enableRunInBackground: false
+
+- id: tool-todo
+  name: '@deepseek-ai/dsh-tool-todo'
+  config:
+    allowParallelInProgress: true
+
+# Filesystem tools.
+- id: fs-local
+  name: '@deepseek-ai/dsh-fs-local'
+  config:
+    cwd: !!js process.env.DSH_CWD ?? process.cwd()
+
+- id: fs-observation-policy
+  name: '@deepseek-ai/dsh-fs-observation-policy'
+
+- id: tool-fs
+  name: '@deepseek-ai/dsh-tool-fs'
+
+# Token accounting + context compaction.
+- id: token-meter
+  name: '@deepseek-ai/dsh-token-meter'
+
+- id: compaction-basic
+  name: '@deepseek-ai/dsh-compaction-basic'
+  config:
+    thresholdRatio: 0.8
+    retainRatio: 0.16
+    maxTokens: 8192
+    compactionRetries: 1