@love-moon/ai-sdk 0.2.37 → 0.2.39

package/dist/client.d.ts

@@ -55,10 +55,12 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     setSessionReplyTarget(replyTo: any): void;
     ensureSessionInfo(): Promise<any>;
     getSessionUsageSummary(): Promise<any>;
+    interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
     close(): Promise<void>;
-    callWorker(method: any, args?: any[], { progressHandler }?: {
+    callWorker(method: any, args?: any[], { progressHandler, messageType }?: {
         progressHandler?: null | undefined;
+        messageType?: string | undefined;
     }): Promise<any>;
     handleWorkerStderr(line: any): void;
     handleWorkerLine(line: any): void;
@@ -104,6 +106,7 @@ declare class LocalAiSessionProxy extends EventEmitter<[never]> {
     setSessionReplyTarget(replyTarget: any): void;
     ensureSessionInfo(): Promise<any>;
     getSessionUsageSummary(): Promise<any>;
+    interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
     close(): Promise<void>;
 }

package/dist/client.js

@@ -168,6 +168,11 @@ export class RemoteAiSession extends EventEmitter {
     async getSessionUsageSummary() {
         return this.callWorker("getSessionUsageSummary", []);
     }
+    async interruptCurrentTurn() {
+        return this.callWorker("interruptCurrentTurn", [], {
+            messageType: "control",
+        });
+    }
     async runTurn(promptText, options = {}) {
         const { onProgress, ...restOptions } = options || {};
         return this.callWorker("runTurn", [promptText, restOptions], {
@@ -214,7 +219,7 @@ export class RemoteAiSession extends EventEmitter {
             await this.exitPromise;
         }
     }
-    async callWorker(method, args = [], { progressHandler = null } = {}) {
+    async callWorker(method, args = [], { progressHandler = null, messageType = "request" } = {}) {
         if (this.closed) {
             throw createSessionClosedError();
         }
@@ -224,7 +229,7 @@ export class RemoteAiSession extends EventEmitter {
         }
         const requestId = this.nextRequestId++;
         const payload = {
-            type: "request",
+            type: messageType,
             id: requestId,
             method,
             args,
@@ -566,6 +571,13 @@ class LocalAiSessionProxy extends EventEmitter {
         const session = await this.readyPromise;
         return await session.getSessionUsageSummary();
     }
+    async interruptCurrentTurn() {
+        const session = await this.readyPromise;
+        if (typeof session.interruptCurrentTurn === "function") {
+            return await session.interruptCurrentTurn();
+        }
+        return false;
+    }
     async runTurn(promptText, options = {}) {
         const session = await this.readyPromise;
         return await session.runTurn(promptText, options);

package/dist/external-provider-registry.js

@@ -15,13 +15,49 @@ function appendProviderModulePaths(parts, value) {
     if (!raw) {
         return;
     }
-    for (const item of raw.split(process.platform === "win32" ? ";" : ":")) {
+    for (const item of splitProviderModulePathString(raw)) {
         const normalized = item.trim();
         if (normalized) {
             parts.push(normalized);
         }
     }
 }
+function looksLikeProviderModulePath(value) {
+    const normalized = String(value || "").trim();
+    if (!normalized) {
+        return false;
+    }
+    return (normalized.startsWith("/") ||
+        normalized.startsWith("./") ||
+        normalized.startsWith("../") ||
+        normalized.startsWith("~/") ||
+        normalized.startsWith("file:") ||
+        normalized.includes("/") ||
+        normalized.includes("\\") ||
+        /\.[cm]?[jt]sx?$/i.test(normalized) ||
+        /^[A-Za-z]:[\\/]/.test(normalized));
+}
+function splitProviderModulePathString(raw) {
+    const normalized = String(raw || "").trim();
+    if (!normalized) {
+        return [];
+    }
+    const platformParts = normalized
+        .split(path.delimiter)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (platformParts.length > 1 || !normalized.includes(",")) {
+        return platformParts;
+    }
+    const commaParts = normalized
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (commaParts.length > 1 && commaParts.every(looksLikeProviderModulePath)) {
+        return commaParts;
+    }
+    return platformParts;
+}
 function listProviderModulePathsFromValue(rawValue) {
     const parts = [];
     appendProviderModulePaths(parts, rawValue);

package/dist/providers/claude-agent-sdk-session.d.ts

@@ -121,7 +121,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     handleSdkMessage(message: any, currentTurn: any, { onProgress }: {
         onProgress: any;
     }): Promise<void>;
-    interruptCurrentTurn(): Promise<void>;
+    interruptCurrentTurn(): Promise<boolean>;
     runTurn(promptText: any, { useInitialImages, onProgress }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

package/dist/providers/claude-agent-sdk-session.js

@@ -680,7 +680,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
     async interruptCurrentTurn() {
         const currentTurn = this.currentTurn;
         if (!currentTurn) {
-            return;
+            return false;
         }
         try {
             await currentTurn.query?.interrupt?.();
@@ -700,6 +700,7 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         catch {
             // best effort
         }
+        return true;
     }
     async runTurn(promptText, { useInitialImages = false, onProgress = null } = {}) {
         if (this.closeRequested) {

package/dist/providers/codex-app-server-session.d.ts

@@ -149,7 +149,7 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
     maybeEmitAuthRequired(error: any): void;
-    interruptCurrentTurn(): Promise<void>;
+    interruptCurrentTurn(): Promise<boolean>;
     runTurn(promptText: any, { useInitialImages }?: {
         useInitialImages?: boolean | undefined;
     }): Promise<{

package/dist/providers/codex-app-server-session.js

@@ -851,17 +851,19 @@ export class CodexAppServerSession extends EventEmitter {
     async interruptCurrentTurn() {
         const currentTurn = this.currentTurn;
         if (!currentTurn || !this.sessionId || !currentTurn.turnId) {
-            return;
+            return false;
         }
         try {
             await this.transport.request("turn/interrupt", {
                 threadId: this.sessionId,
                 turnId: currentTurn.turnId,
             });
+            return true;
         }
         catch {
             // best effort
         }
+        return false;
     }
     async runTurn(promptText, { useInitialImages = false } = {}) {
         if (this.closeRequested) {

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

@@ -143,7 +143,7 @@ export class KimiCliSession extends EventEmitter<[never]> {
     handleWireEvent(type: any, payload: any): Promise<void>;
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
-    interruptCurrentTurn(): Promise<void>;
+    interruptCurrentTurn(): Promise<boolean>;
     runTurn(promptText: any, { useInitialImages, onProgress }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

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

@@ -812,14 +812,16 @@ export class KimiCliSession extends EventEmitter {
     }
     async interruptCurrentTurn() {
         if (!this.currentTurn) {
-            return;
+            return false;
         }
         try {
             await this.transport.request("cancel", {});
+            return true;
         }
         catch {
             // best effort
         }
+        return false;
     }
     async runTurn(promptText, { useInitialImages = false, onProgress = null } = {}) {
         if (this.closeRequested || this.closed) {

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

@@ -163,7 +163,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
     handleOpencodeEvent(event: any): Promise<void>;
     handleTransportFailure(error: any): void;
     handleTransportExit(payload: any): void;
-    interruptCurrentTurn(): Promise<void>;
+    interruptCurrentTurn(): Promise<boolean>;
     runTurn(promptText: any, { useInitialImages, onProgress }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

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

@@ -1119,7 +1119,7 @@ export class OpencodeSdkSession extends EventEmitter {
     async interruptCurrentTurn() {
         const currentTurn = this.currentTurn;
         if (!currentTurn || !this.client?.session || !this.sessionId) {
-            return;
+            return false;
         }
         try {
             currentTurn.abortController?.abort?.();
@@ -1129,10 +1129,12 @@ export class OpencodeSdkSession extends EventEmitter {
         }
         try {
             await this.client.session.abort({ sessionID: this.sessionId }, { throwOnError: true, responseStyle: "data" });
+            return true;
         }
         catch {
             // best effort
         }
+        return true;
     }
     async runTurn(promptText, { useInitialImages = false, onProgress = null } = {}) {
         if (this.closeRequested) {

package/dist/resume.d.ts

@@ -0,0 +1,26 @@
+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;
+    };
+}>;

package/dist/resume.js

@@ -0,0 +1,380 @@
+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";
+import yaml from "js-yaml";
+function normalizeBackend(backend) {
+    return String(backend || "").trim().toLowerCase();
+}
+function resolveHomeDir(options) {
+    if (options?.homeDir) {
+        return options.homeDir;
+    }
+    return os.homedir();
+}
+function normalizeSessionId(sessionId) {
+    return typeof sessionId === "string" ? sessionId.trim() : "";
+}
+export function resumeProviderForBackend(backend) {
+    const normalizedBackend = normalizeBackend(backend);
+    if (normalizedBackend === "codex" || normalizedBackend === "code") {
+        return "codex";
+    }
+    if (normalizedBackend === "claude" || normalizedBackend === "claude-code") {
+        return "claude";
+    }
+    if (normalizedBackend === "copilot") {
+        return "copilot";
+    }
+    return null;
+}
+export async function findSessionPath(provider, sessionId, options = {}) {
+    const normalizedProvider = String(provider || "").trim().toLowerCase();
+    if (normalizedProvider === "codex") {
+        return findCodexSessionPath(sessionId, options);
+    }
+    if (normalizedProvider === "claude") {
+        return findClaudeSessionPath(sessionId, options);
+    }
+    if (normalizedProvider === "copilot") {
+        return findCopilotSessionPath(sessionId, options);
+    }
+    throw new Error(`Unsupported provider: ${provider}`);
+}
+export async function findCodexSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const homeDir = resolveHomeDir(options);
+    const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
+    return findCodexSessionFile(sessionsDir, normalizedSessionId);
+}
+export async function findClaudeSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const homeDir = resolveHomeDir(options);
+    const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
+    const sessionEntries = await findClaudeSessionEntries(projectsDir, normalizedSessionId);
+    if (sessionEntries.length > 0) {
+        return sessionEntries[0]?.source || null;
+    }
+    const tasksDir = options.claudeTasksDir || path.join(homeDir, ".claude", "tasks");
+    const directTaskDir = path.join(tasksDir, normalizedSessionId);
+    if (await pathExists(directTaskDir, "directory")) {
+        return directTaskDir;
+    }
+    return null;
+}
+export async function findCopilotSessionPath(sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        return null;
+    }
+    const homeDir = resolveHomeDir(options);
+    const sessionStateDir = options.copilotSessionStateDir || path.join(homeDir, ".copilot", "session-state");
+    const directJsonlPath = path.join(sessionStateDir, `${normalizedSessionId}.jsonl`);
+    if (await pathExists(directJsonlPath, "file")) {
+        return directJsonlPath;
+    }
+    const directSessionDir = path.join(sessionStateDir, normalizedSessionId);
+    if (await pathExists(directSessionDir, "directory")) {
+        return directSessionDir;
+    }
+    return findPathByName(sessionStateDir, normalizedSessionId);
+}
+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 async function inspectResumeTarget(backend, sessionId, options = {}) {
+    return resolveResumeContext(backend, sessionId, options);
+}
+export async function resolveResumeContext(backend, sessionId, options = {}) {
+    const normalizedSessionId = normalizeSessionId(sessionId);
+    if (!normalizedSessionId) {
+        throw new Error("--resume requires a session id");
+    }
+    const provider = resumeProviderForBackend(backend);
+    if (!provider) {
+        throw new Error(`--resume is not supported for backend "${backend}"`);
+    }
+    const sessionPath = await findSessionPath(provider, normalizedSessionId, options);
+    if (!sessionPath) {
+        throw new Error(`Invalid --resume session id for ${provider}: ${normalizedSessionId}`);
+    }
+    const cwdFromSession = await extractResumeCwdFromSession(provider, sessionPath, normalizedSessionId);
+    const fallbackCwd = await resolveSessionRunDirectory(sessionPath);
+    const cwd = cwdFromSession || fallbackCwd;
+    if (!(await isExistingDirectory(cwd))) {
+        throw new Error(`Resume workspace path does not exist: ${cwd}`);
+    }
+    return {
+        provider,
+        sessionId: normalizedSessionId,
+        sessionPath,
+        cwd,
+        debugMetadata: {
+            cwdSource: cwdFromSession ? "session" : "session_path",
+            sessionPath,
+        },
+    };
+}
+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;
+    }
+}
+async function extractCodexResumeCwd(sessionPath) {
+    if (!sessionPath.endsWith(".jsonl")) {
+        return null;
+    }
+    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;
+        }
+        const maybeCwd = entry?.type === "session_meta" ? entry?.payload?.cwd : null;
+        if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+            return maybeCwd.trim();
+        }
+    }
+    return null;
+}
+async function extractClaudeResumeCwd(sessionPath, sessionId) {
+    if (!sessionPath.endsWith(".jsonl")) {
+        return null;
+    }
+    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;
+        }
+        const idMatches = String(entry?.sessionId || "").trim() === sessionId;
+        const maybeCwd = entry?.cwd;
+        if (idMatches && typeof maybeCwd === "string" && maybeCwd.trim()) {
+            return maybeCwd.trim();
+        }
+    }
+    return null;
+}
+async function extractCopilotResumeCwd(sessionPath) {
+    let stats;
+    try {
+        stats = await fsp.stat(sessionPath);
+    }
+    catch {
+        return null;
+    }
+    if (stats.isDirectory()) {
+        const workspaceYamlPath = path.join(sessionPath, "workspace.yaml");
+        try {
+            const yamlContent = await fsp.readFile(workspaceYamlPath, "utf8");
+            const parsed = yaml.load(yamlContent);
+            const maybeCwd = parsed && typeof parsed === "object" ? parsed.cwd : null;
+            if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+                return maybeCwd.trim();
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+    if (!sessionPath.endsWith(".jsonl")) {
+        return null;
+    }
+    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;
+        }
+        const maybeCwd = entry?.data?.context?.cwd || entry?.data?.cwd;
+        if (typeof maybeCwd === "string" && maybeCwd.trim()) {
+            return maybeCwd.trim();
+        }
+    }
+    return null;
+}
+async function extractResumeCwdFromSession(provider, sessionPath, sessionId) {
+    if (provider === "codex") {
+        return extractCodexResumeCwd(sessionPath);
+    }
+    if (provider === "claude") {
+        return extractClaudeResumeCwd(sessionPath, sessionId);
+    }
+    if (provider === "copilot") {
+        return extractCopilotResumeCwd(sessionPath);
+    }
+    return null;
+}
+async function findCodexSessionFile(rootDir, sessionId) {
+    const queue = [rootDir];
+    while (queue.length) {
+        const current = queue.pop();
+        let entries = [];
+        try {
+            entries = await fsp.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+            else if (entry.isFile() &&
+                entry.name.includes(sessionId) &&
+                entry.name.endsWith(".jsonl")) {
+                return fullPath;
+            }
+        }
+    }
+    return null;
+}
+async function findClaudeSessionEntries(projectsDir, sessionId) {
+    const entries = [];
+    let projectDirs = [];
+    try {
+        projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
+    }
+    catch {
+        return entries;
+    }
+    for (const projectDir of projectDirs) {
+        if (!projectDir.isDirectory()) {
+            continue;
+        }
+        const projectPath = path.join(projectsDir, projectDir.name);
+        let files = [];
+        try {
+            files = await fsp.readdir(projectPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            if (!file.isFile()) {
+                continue;
+            }
+            if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
+                continue;
+            }
+            const filePath = path.join(projectPath, file.name);
+            const rl = readline.createInterface({
+                input: fs.createReadStream(filePath),
+                crlfDelay: Infinity,
+            });
+            for await (const line of rl) {
+                const trimmed = line.trim();
+                if (!trimmed) {
+                    continue;
+                }
+                let entry;
+                try {
+                    entry = JSON.parse(trimmed);
+                }
+                catch {
+                    continue;
+                }
+                if (entry.sessionId === sessionId) {
+                    entries.push({ ...entry, source: filePath });
+                }
+            }
+        }
+    }
+    return entries;
+}
+async function findPathByName(rootDir, sessionId) {
+    const queue = [rootDir];
+    while (queue.length) {
+        const current = queue.pop();
+        let entries = [];
+        try {
+            entries = await fsp.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.name.includes(sessionId)) {
+                return fullPath;
+            }
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+        }
+    }
+    return null;
+}
+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;
+    }
+}