@love-moon/ai-sdk 0.2.42 → 0.3.1

package/dist/resume/opencode.js

@@ -0,0 +1,63 @@
+import { buildResumeContext, isExistingDirectory, listCandidateWorkingDirectories, normalizeProjectPathCandidate, normalizeSessionId, } from "./shared.js";
+export const BACKEND = "opencode";
+export function buildCliArgs(sessionId) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return [];
+    }
+    // opencode sessions are reattached via the SDK (`session.get({ sessionID })`),
+    // not via CLI flags. We still return the canonical flag so CLI integrations
+    // that need to pass a sessionId on the command line have a consistent shape.
+    return ["--session", normalizedSessionId];
+}
+export async function findSessionPath() {
+    // opencode sessions live inside the opencode server; there is no local
+    // filesystem path to discover.
+    return null;
+}
+export async function resolveResumeContext(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const explicitCwd = normalizeProjectPathCandidate(options.cwd);
+    let selectedCwd = "";
+    let cwdSource = "";
+    if (explicitCwd) {
+        // When an explicit cwd is provided, require it to exist; do NOT fall
+        // through to PWD/process.cwd() so tests and callers get a deterministic
+        // result.
+        if (!(await isExistingDirectory(explicitCwd))) {
+            throw new Error(`Resume workspace path does not exist: ${explicitCwd}`);
+        }
+        selectedCwd = explicitCwd;
+        cwdSource = "options_cwd";
+    }
+    else {
+        for (const candidate of listCandidateWorkingDirectories(options)) {
+            if (await isExistingDirectory(candidate)) {
+                selectedCwd = candidate;
+                cwdSource = "current_working_directory";
+                break;
+            }
+        }
+    }
+    if (typeof options.resolveOpencodeCwd === "function" && !selectedCwd) {
+        const resolved = await options.resolveOpencodeCwd(normalizedSessionId, options);
+        const normalizedResolved = normalizeProjectPathCandidate(resolved);
+        if (normalizedResolved && (await isExistingDirectory(normalizedResolved))) {
+            selectedCwd = normalizedResolved;
+            cwdSource = "lookup";
+        }
+    }
+    if (!selectedCwd) {
+        throw new Error(`Could not resolve workspace for opencode session ${normalizedSessionId}. Re-run from the original workspace.`);
+    }
+    return buildResumeContext({
+        provider: "opencode",
+        sessionId: normalizedSessionId,
+        sessionPath: null,
+        cwd: selectedCwd,
+        cwdSource: cwdSource || "current_working_directory",
+    });
+}

package/dist/resume/shared.d.ts

@@ -0,0 +1,26 @@
+export function normalizeBackend(backend: any): string;
+export function normalizeSessionId(sessionId: any): string;
+export function resolveHomeDir(options: any): any;
+export function normalizeProjectPathCandidate(value: any): string;
+export function pathExists(targetPath: any, expectedType: any): Promise<boolean>;
+export function isExistingDirectory(targetPath: any): Promise<boolean>;
+export function resolveSessionRunDirectory(sessionPath: any): Promise<string>;
+export function listCandidateWorkingDirectories(options?: {}): any[];
+export function iterateJsonlEntries(sessionPath: any): AsyncGenerator<any, void, unknown>;
+export function buildResumeContext({ provider, sessionId, sessionPath, cwd, cwdSource, extraDebug, }: {
+    provider: any;
+    sessionId: any;
+    sessionPath?: null | undefined;
+    cwd: any;
+    cwdSource: any;
+    extraDebug?: {} | undefined;
+}): {
+    provider: any;
+    sessionId: any;
+    sessionPath: null;
+    cwd: any;
+    debugMetadata: {
+        cwdSource: any;
+        sessionPath: null;
+    };
+};

package/dist/resume/shared.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import { promises as fsp } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+export function normalizeBackend(backend) {
+    return String(backend || "").trim().toLowerCase();
+}
+export function normalizeSessionId(sessionId) {
+    return typeof sessionId === "string" ? sessionId.trim() : "";
+}
+export function resolveHomeDir(options) {
+    if (options?.homeDir) {
+        return options.homeDir;
+    }
+    return os.homedir();
+}
+export function normalizeProjectPathCandidate(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+export async function pathExists(targetPath, expectedType) {
+    try {
+        const stats = await fsp.stat(targetPath);
+        if (expectedType === "file") {
+            return stats.isFile();
+        }
+        if (expectedType === "directory") {
+            return stats.isDirectory();
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isExistingDirectory(targetPath) {
+    const normalizedPath = typeof targetPath === "string" ? targetPath.trim() : "";
+    if (!normalizedPath) {
+        return false;
+    }
+    try {
+        const stats = await fsp.stat(normalizedPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveSessionRunDirectory(sessionPath) {
+    const normalizedPath = typeof sessionPath === "string" ? sessionPath.trim() : "";
+    if (!normalizedPath) {
+        throw new Error("Invalid session path");
+    }
+    let stats;
+    try {
+        stats = await fsp.stat(normalizedPath);
+    }
+    catch {
+        throw new Error(`Session path does not exist: ${normalizedPath}`);
+    }
+    return stats.isDirectory() ? normalizedPath : path.dirname(normalizedPath);
+}
+export function listCandidateWorkingDirectories(options = {}) {
+    const candidates = [];
+    const push = (value) => {
+        const normalized = typeof value === "string" ? value.trim() : "";
+        if (!normalized) {
+            return;
+        }
+        if (!candidates.includes(normalized)) {
+            candidates.push(normalized);
+        }
+    };
+    push(options.cwd);
+    push(options.currentWorkingDirectory);
+    push(process.env.PWD);
+    push(process.cwd());
+    return candidates;
+}
+export async function* iterateJsonlEntries(sessionPath) {
+    if (!sessionPath || !sessionPath.endsWith(".jsonl")) {
+        return;
+    }
+    const rl = readline.createInterface({
+        input: fs.createReadStream(sessionPath),
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        let entry;
+        try {
+            entry = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        yield entry;
+    }
+}
+export function buildResumeContext({ provider, sessionId, sessionPath = null, cwd, cwdSource, extraDebug = {}, }) {
+    return {
+        provider,
+        sessionId,
+        sessionPath: sessionPath || null,
+        cwd,
+        debugMetadata: {
+            cwdSource,
+            sessionPath: sessionPath || null,
+            ...extraDebug,
+        },
+    };
+}

package/dist/session-factory.d.ts

@@ -10,6 +10,7 @@ export const COPILOT_PROVIDER_VARIANT: "copilot-sdk";
 export const KIMI_PROVIDER_VARIANT: "kimi-cli-wire";
 export const KIMI_PRINT_PROVIDER_VARIANT: "kimi-cli-print";
 export const OPENCODE_PROVIDER_VARIANT: "opencode-sdk";
+import { BUILT_IN_BACKENDS } from "./built-in-backends.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";
@@ -17,4 +18,4 @@ 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 { CodexAppServerSession, CodexExecSession, ClaudeAgentSdkSession, CopilotSdkSession, KimiCliSession, KimiPrintSession, OpencodeSdkSession };
+export { BUILT_IN_BACKENDS, CodexAppServerSession, CodexExecSession, ClaudeAgentSdkSession, CopilotSdkSession, KimiCliSession, KimiPrintSession, OpencodeSdkSession };

package/dist/session-factory.js

@@ -1,3 +1,4 @@
+import { BUILT_IN_BACKENDS, 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 { 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";
@@ -6,13 +7,30 @@ import { KimiCliSession } from "./providers/kimi-cli-session.js";
 import { KimiPrintSession } from "./providers/kimi-print-session.js";
 import { OpencodeSdkSession } from "./providers/opencode-sdk-session.js";
 import { getExternalProviderDescriptor, resolveExternalBackend, } from "./external-provider-registry.js";
-export const DEFAULT_PROVIDER_VARIANT = "codex-app-server";
-export const CODEX_EXEC_PROVIDER_VARIANT = "codex-exec";
-export const CLAUDE_PROVIDER_VARIANT = "claude-agent-sdk";
-export const COPILOT_PROVIDER_VARIANT = "copilot-sdk";
-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 DEFAULT_PROVIDER_VARIANT = CODEX_APP_SERVER_VARIANT;
+export const CODEX_EXEC_PROVIDER_VARIANT = CODEX_EXEC_VARIANT;
+export const CLAUDE_PROVIDER_VARIANT = CLAUDE_AGENT_SDK_VARIANT;
+export const COPILOT_PROVIDER_VARIANT = COPILOT_SDK_VARIANT;
+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;
+const SESSION_FACTORIES_BY_BACKEND = new Map([
+    [
+        "codex",
+        (backend, options) => hasStructuredOutputPreference(options)
+            ? new CodexExecSession(backend, options)
+            : new CodexAppServerSession(backend, options),
+    ],
+    ["claude", (backend, options) => new ClaudeAgentSdkSession(backend, options)],
+    ["copilot", (backend, options) => new CopilotSdkSession(backend, options)],
+    [
+        "kimi",
+        (backend, options) => hasStructuredOutputPreference(options)
+            ? new KimiPrintSession(backend, options)
+            : new KimiCliSession(backend, options),
+    ],
+    ["opencode", (backend, options) => new OpencodeSdkSession(backend, options)],
+]);
 function hasStructuredOutputPreference(options = {}) {
     if (!options || typeof options !== "object") {
         return false;
@@ -34,32 +52,16 @@ function hasStructuredOutputPreference(options = {}) {
     }
     return false;
 }
-function normalizeBuiltInBackendName(backend) {
-    const normalized = String(backend || "").trim().toLowerCase();
-    if (normalized === "code") {
-        return "codex";
-    }
-    if (normalized === "claude-code") {
-        return "claude";
-    }
-    if (normalized === "open-code" || normalized === "open_code") {
-        return "opencode";
-    }
-    if (normalized === "kimi-cli" || normalized === "kimi-code") {
-        return "kimi";
-    }
-    return normalized;
-}
 export async function normalizeBackend(backend, options = {}) {
-    const normalized = normalizeBuiltInBackendName(backend);
-    if (normalized === "codex" || normalized === "claude" || normalized === "copilot" || normalized === "kimi" || normalized === "opencode") {
+    const normalized = normalizeBuiltInBackend(backend);
+    if (isBuiltInBackend(normalized)) {
         return normalized;
     }
     return await resolveExternalBackend(normalized, options);
 }
 export async function isSupportedBackend(backend, options = {}) {
     const normalized = await normalizeBackend(backend, options);
-    if (normalized === "codex" || normalized === "claude" || normalized === "copilot" || normalized === "kimi" || normalized === "opencode") {
+    if (isBuiltInBackend(normalized)) {
         return true;
     }
     const descriptor = await getExternalProviderDescriptor(normalized, options);
@@ -67,20 +69,12 @@ export async function isSupportedBackend(backend, options = {}) {
 }
 export async function providerVariantForBackend(backend, options = {}) {
     const normalized = await normalizeBackend(backend, options);
-    if (normalized === "claude") {
-        return CLAUDE_PROVIDER_VARIANT;
-    }
-    if (normalized === "copilot") {
-        return COPILOT_PROVIDER_VARIANT;
-    }
-    if (normalized === "kimi") {
-        return hasStructuredOutputPreference(options) ? KIMI_PRINT_PROVIDER_VARIANT : KIMI_PROVIDER_VARIANT;
-    }
-    if (normalized === "opencode") {
-        return OPENCODE_PROVIDER_VARIANT;
-    }
-    if (normalized === "codex") {
-        return hasStructuredOutputPreference(options) ? CODEX_EXEC_PROVIDER_VARIANT : DEFAULT_PROVIDER_VARIANT;
+    const entry = getBuiltInBackendEntry(normalized);
+    if (entry) {
+        if (entry.structuredVariant && hasStructuredOutputPreference(options)) {
+            return entry.structuredVariant;
+        }
+        return entry.defaultVariant;
     }
     const descriptor = await getExternalProviderDescriptor(normalized, options);
     if (descriptor?.variant) {
@@ -90,37 +84,20 @@ export async function providerVariantForBackend(backend, options = {}) {
 }
 export async function assertSupportedBackend(backend, options = {}) {
     const normalized = await normalizeBackend(backend, options);
-    if (normalized === "codex" || normalized === "claude" || normalized === "copilot" || normalized === "kimi" || normalized === "opencode") {
+    if (isBuiltInBackend(normalized)) {
         return normalized;
     }
     const descriptor = await getExternalProviderDescriptor(normalized, options);
     if (descriptor) {
         return normalized;
     }
-    throw new Error(`Unsupported AI SDK backend "${backend}". Built-in backends are codex app-server/exec, claude agent-sdk, copilot sdk, kimi cli wire/print, and opencode sdk. Set AISDK_PROVIDER_PATH to load external providers.`);
+    throw new Error(`Unsupported AI SDK backend "${backend}". Built-in backends are ${listBuiltInBackends().join(", ")}. Set AISDK_PROVIDER_PATH to load external providers.`);
 }
 export async function createLocalAiSession(backend, options = {}) {
     const normalized = await assertSupportedBackend(backend, options);
-    if (normalized === "claude") {
-        return new ClaudeAgentSdkSession(normalized, options);
-    }
-    if (normalized === "copilot") {
-        return new CopilotSdkSession(normalized, options);
-    }
-    if (normalized === "kimi") {
-        if (hasStructuredOutputPreference(options)) {
-            return new KimiPrintSession(normalized, options);
-        }
-        return new KimiCliSession(normalized, options);
-    }
-    if (normalized === "opencode") {
-        return new OpencodeSdkSession(normalized, options);
-    }
-    if (normalized === "codex") {
-        if (hasStructuredOutputPreference(options)) {
-            return new CodexExecSession(normalized, options);
-        }
-        return new CodexAppServerSession(normalized, options);
+    const factory = SESSION_FACTORIES_BY_BACKEND.get(normalized);
+    if (factory) {
+        return factory(normalized, options);
     }
     const descriptor = await getExternalProviderDescriptor(normalized, options);
     if (!descriptor) {
@@ -128,6 +105,7 @@ export async function createLocalAiSession(backend, options = {}) {
     }
     return await descriptor.createSession(normalized, options);
 }
+export { BUILT_IN_BACKENDS };
 export { CodexAppServerSession };
 export { CodexExecSession };
 export { ClaudeAgentSdkSession };

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@love-moon/ai-sdk",
-  "version": "0.2.42",
+  "version": "0.3.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovemoon-ai/conductor.git"
+  },
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -26,5 +32,5 @@
     "@types/node": "^22.10.2",
     "typescript": "^5.6.3"
   },
-  "gitCommitId": "f79f36f"
+  "gitCommitId": "03b4582"
 }

package/dist/resume.d.ts

@@ -1,26 +0,0 @@
-export function resumeProviderForBackend(backend: any): "codex" | "claude" | "copilot" | null;
-export function findSessionPath(provider: any, sessionId: any, options?: {}): Promise<any>;
-export function findCodexSessionPath(sessionId: any, options?: {}): Promise<string | null>;
-export function findClaudeSessionPath(sessionId: any, options?: {}): Promise<any>;
-export function findCopilotSessionPath(sessionId: any, options?: {}): Promise<string | null>;
-export function resolveSessionRunDirectory(sessionPath: any): Promise<string>;
-export function inspectResumeTarget(backend: any, sessionId: any, options?: {}): Promise<{
-    provider: string;
-    sessionId: string;
-    sessionPath: any;
-    cwd: string;
-    debugMetadata: {
-        cwdSource: string;
-        sessionPath: any;
-    };
-}>;
-export function resolveResumeContext(backend: any, sessionId: any, options?: {}): Promise<{
-    provider: string;
-    sessionId: string;
-    sessionPath: any;
-    cwd: string;
-    debugMetadata: {
-        cwdSource: string;
-        sessionPath: any;
-    };
-}>;