@love-moon/ai-sdk 0.7.7 → 0.9.0

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

@@ -22,6 +22,9 @@ export class KimiCliSession extends EventEmitter<[never]> {
     currentTurn: {
         fullText: string;
         bufferedAssistantText: string;
+        thinkText: string;
+        thinkStatusLine: string;
+        thinkStatusLineAt: number;
         items: never[];
         toolCalls: Map<any, any>;
         onProgress: null;
@@ -80,6 +83,11 @@ export class KimiCliSession extends EventEmitter<[never]> {
             command: any;
         } | null;
         currentTurnStatus: any;
+        capabilities: {
+            media: Readonly<{
+                image: "native";
+            }>;
+        };
         pid: any;
     };
     getSessionInfo(): {
@@ -136,6 +144,8 @@ export class KimiCliSession extends EventEmitter<[never]> {
     bootInternal(): Promise<void>;
     updateUsageFromStatus(payload: any): void;
     appendAssistantText(currentTurn: any, text: any): void;
+    appendThinkText(currentTurn: any, text: any): void;
+    thinkStatusLine(currentTurn: any): any;
     finalizeAssistantMessage(currentTurn: any): Promise<boolean>;
     maybeEmitAuthRequired(error: any): void;
     failUnexpectedInteractiveRequest(id: any, requestType: any, payload: any): Promise<void>;
@@ -144,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;
@@ -11,6 +14,8 @@ const DEFAULT_STATUS_THROTTLE_MS = 450;
 const DEFAULT_REASONING_STATUS_THROTTLE_MS = 2500;
 const DEFAULT_STATUS_PREVIEW_DELTA_CHARS = 24;
 const MAX_STATUS_TIMING_MS = 10 * 1000;
+const THINK_STATUS_LINE_MAX_CHARS = 120;
+const THINK_TAIL_BUFFER_CHARS = 400;
 function waitForever() {
     return new Promise(() => { });
 }
@@ -228,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,
         };
     }
@@ -603,6 +609,29 @@ export class KimiCliSession extends EventEmitter {
         }
         currentTurn.bufferedAssistantText += normalized;
     }
+    appendThinkText(currentTurn, text) {
+        const normalized = normalizeText(text);
+        if (!normalized) {
+            return;
+        }
+        currentTurn.thinkText = `${currentTurn.thinkText}${normalized}`.slice(-THINK_TAIL_BUFFER_CHARS);
+    }
+    thinkStatusLine(currentTurn) {
+        const now = this.now();
+        if (currentTurn.thinkStatusLine &&
+            now - currentTurn.thinkStatusLineAt < this.reasoningStatusThrottleMs) {
+            return currentTurn.thinkStatusLine;
+        }
+        const sanitized = sanitizeSummary(currentTurn.thinkText, THINK_TAIL_BUFFER_CHARS);
+        const snippet = sanitized.length > THINK_STATUS_LINE_MAX_CHARS
+            ? `…${sanitized.slice(-THINK_STATUS_LINE_MAX_CHARS)}`
+            : sanitized;
+        if (snippet && snippet !== currentTurn.thinkStatusLine) {
+            currentTurn.thinkStatusLine = snippet;
+            currentTurn.thinkStatusLineAt = now;
+        }
+        return currentTurn.thinkStatusLine || statusLineForPhase("reasoning");
+    }
     async finalizeAssistantMessage(currentTurn) {
         if (!currentTurn) {
             return false;
@@ -707,8 +736,23 @@ export class KimiCliSession extends EventEmitter {
                 return;
             case "TurnEnd":
                 currentTurn.seenTurnEnd = true;
+                if (currentTurn.bufferedAssistantText) {
+                    await this.finalizeAssistantMessage(currentTurn);
+                }
+                // Clear reply_in_progress as soon as the wire reports the turn ended,
+                // decoupled from the `prompt` JSON-RPC promise. Without this, a delayed
+                // or dropped prompt RPC response leaves the web UI pinned on
+                // "Kimi is writing the reply" until reload. emitTerminalWorkingStatus is
+                // idempotent, so the later runTurn call becomes a harmless no-op.
+                await this.emitTerminalWorkingStatus(currentTurn, {
+                    phase: "turn_completed",
+                    status_done_line: "Kimi finished",
+                }, currentTurn.onProgress);
                 return;
             case "StepBegin":
+                if (currentTurn.bufferedAssistantText) {
+                    await this.finalizeAssistantMessage(currentTurn);
+                }
                 await this.emitWorkingStatus({
                     phase: "reasoning",
                     reply_in_progress: true,
@@ -734,10 +778,11 @@ export class KimiCliSession extends EventEmitter {
                 return;
             case "ContentPart":
                 if (normalizedPayload.type === "think") {
+                    this.appendThinkText(currentTurn, normalizedPayload.think);
                     await this.emitWorkingStatus({
                         phase: "reasoning",
                         reply_in_progress: true,
-                        status_line: statusLineForPhase("reasoning"),
+                        status_line: this.thinkStatusLine(currentTurn),
                     }, currentTurn.onProgress);
                     return;
                 }
@@ -832,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);
         }
@@ -860,6 +909,9 @@ export class KimiCliSession extends EventEmitter {
         const currentTurn = {
             fullText: "",
             bufferedAssistantText: "",
+            thinkText: "",
+            thinkStatusLine: "",
+            thinkStatusLineAt: 0,
             items: [],
             toolCalls: new Map(),
             onProgress,
@@ -886,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 };