@love-moon/ai-sdk 0.2.16

package/dist/client.d.ts

@@ -0,0 +1,67 @@
+export function createAiSession(backend: any, options?: {}): import("./session-factory.js").CodexAppServerSession | RemoteAiSession;
+export class RemoteAiSession extends EventEmitter<[never]> {
+    constructor(backend: any, options?: {});
+    backend: string;
+    options: {};
+    logger: any;
+    variant: string;
+    threadIdValue: any;
+    threadOptionsValue: {
+        model: string;
+    };
+    useSessionFileReplyStreamValue: boolean;
+    sessionInfo: any;
+    snapshot: {
+        backend: string;
+        provider: string;
+        sessionId: any;
+        useSessionFileReplyStream: boolean;
+        workerReady: boolean;
+    };
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    pendingRequests: Map<any, any>;
+    nextRequestId: number;
+    closed: boolean;
+    workerExited: boolean;
+    child: import("child_process").ChildProcessWithoutNullStreams;
+    stdoutReader: readline.Interface;
+    stderrReader: readline.Interface;
+    exitPromise: Promise<any>;
+    resolveReady: ((value: any) => void) | null;
+    rejectReady: ((reason?: any) => void) | null;
+    readyPromise: Promise<any>;
+    get threadId(): any;
+    get threadOptions(): {
+        model: string;
+    };
+    getSnapshot(): {
+        sessionInfo: any;
+        backend: string;
+        provider: string;
+        sessionId: any;
+        useSessionFileReplyStream: boolean;
+        workerReady: boolean;
+    };
+    usesSessionFileReplyStream(): boolean;
+    getSessionInfo(): any;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTo: any): void;
+    ensureSessionInfo(): Promise<any>;
+    getSessionUsageSummary(): Promise<any>;
+    runTurn(promptText: any, options?: {}): Promise<any>;
+    close(): Promise<void>;
+    callWorker(method: any, args?: any[], { progressHandler }?: {
+        progressHandler?: null | undefined;
+    }): Promise<any>;
+    handleWorkerStderr(line: any): void;
+    handleWorkerLine(line: any): void;
+    applyReadyPayload(payload: any): void;
+    handleWorkerResponse(payload: any): void;
+    handleWorkerProgress(payload: any): void;
+    handleWorkerEvent(payload: any): Promise<void>;
+    rejectPendingRequests(error: any): void;
+}
+import { EventEmitter } from "node:events";
+import readline from "node:readline";

package/dist/client.js

@@ -0,0 +1,359 @@
+import { EventEmitter } from "node:events";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import readline from "node:readline";
+import { assertSupportedBackend, createLocalAiSession, DEFAULT_PROVIDER_VARIANT, } from "./session-factory.js";
+import { normalizeLogger, reviveError } from "./shared.js";
+const WORKER_PATH = fileURLToPath(new URL("./worker.js", import.meta.url));
+function sanitizeOptionsForWorker(options = {}) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(options)) {
+        if (typeof value === "function" || key === "logger") {
+            continue;
+        }
+        sanitized[key] = value;
+    }
+    return sanitized;
+}
+function createSessionClosedError() {
+    const error = new Error("AI session worker closed");
+    error.reason = "session_closed";
+    return error;
+}
+function toSerializablePayload(payload) {
+    return `${JSON.stringify(payload)}\n`;
+}
+export class RemoteAiSession extends EventEmitter {
+    constructor(backend, options = {}) {
+        super();
+        this.backend = assertSupportedBackend(backend);
+        this.options = options;
+        this.logger = normalizeLogger(options.logger);
+        this.variant = DEFAULT_PROVIDER_VARIANT;
+        this.threadIdValue =
+            typeof options.resumeSessionId === "string" && options.resumeSessionId.trim()
+                ? options.resumeSessionId.trim()
+                : "";
+        this.threadOptionsValue = {
+            model: this.backend || "unknown",
+        };
+        this.useSessionFileReplyStreamValue = true;
+        this.sessionInfo = null;
+        this.snapshot = {
+            backend: this.backend,
+            provider: this.variant,
+            sessionId: this.threadIdValue || undefined,
+            useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
+            workerReady: false,
+        };
+        this.sessionMessageHandler = null;
+        this.workingStatusHandler = null;
+        this.pendingRequests = new Map();
+        this.nextRequestId = 1;
+        this.closed = false;
+        this.workerExited = false;
+        this.child = spawn(process.execPath, [WORKER_PATH], {
+            env: process.env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.stdoutReader = readline.createInterface({ input: this.child.stdout });
+        this.stderrReader = readline.createInterface({ input: this.child.stderr });
+        this.stdoutReader.on("line", (line) => {
+            this.handleWorkerLine(line);
+        });
+        this.stderrReader.on("line", (line) => {
+            this.handleWorkerStderr(line);
+        });
+        this.exitPromise = new Promise((resolve) => {
+            this.child.once("exit", (code, signal) => {
+                this.workerExited = true;
+                if (this.rejectReady) {
+                    this.rejectReady(createSessionClosedError());
+                    this.resolveReady = null;
+                    this.rejectReady = null;
+                }
+                this.rejectPendingRequests(createSessionClosedError());
+                this.emit("process.exited", {
+                    pid: this.child.pid || null,
+                    code,
+                    signal,
+                });
+                resolve({ code, signal });
+            });
+        });
+        this.readyPromise = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+        this.readyPromise.catch(() => {
+            // prevent unhandled rejection when callers only use sync getters then close immediately
+        });
+        this.child.on("error", (error) => {
+            this.rejectReady?.(error);
+            this.rejectPendingRequests(error);
+        });
+        this.child.stdin.write(toSerializablePayload({
+            type: "create",
+            backend: this.backend,
+            options: sanitizeOptionsForWorker(options),
+        }));
+    }
+    get threadId() {
+        return this.threadIdValue;
+    }
+    get threadOptions() {
+        return { ...this.threadOptionsValue };
+    }
+    getSnapshot() {
+        return {
+            ...this.snapshot,
+            sessionInfo: this.sessionInfo ? { ...this.sessionInfo } : null,
+        };
+    }
+    usesSessionFileReplyStream() {
+        return Boolean(this.useSessionFileReplyStreamValue);
+    }
+    getSessionInfo() {
+        return this.sessionInfo ? { ...this.sessionInfo } : null;
+    }
+    setSessionMessageHandler(handler) {
+        this.sessionMessageHandler = typeof handler === "function" ? handler : null;
+    }
+    setWorkingStatusHandler(handler) {
+        this.workingStatusHandler = typeof handler === "function" ? handler : null;
+    }
+    setSessionReplyTarget(replyTo) {
+        void this.callWorker("setSessionReplyTarget", [replyTo]).catch((error) => {
+            if (error?.reason !== "session_closed") {
+                this.logger.log?.(`[ai-sdk] failed to set session reply target: ${error?.message || error}`);
+            }
+        });
+    }
+    async ensureSessionInfo() {
+        return this.callWorker("ensureSessionInfo", []);
+    }
+    async getSessionUsageSummary() {
+        return this.callWorker("getSessionUsageSummary", []);
+    }
+    async runTurn(promptText, options = {}) {
+        const { onProgress, ...restOptions } = options || {};
+        return this.callWorker("runTurn", [promptText, restOptions], {
+            progressHandler: typeof onProgress === "function" ? onProgress : null,
+        });
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            if (!this.workerExited) {
+                await this.callWorker("close", []);
+            }
+        }
+        catch {
+            // best effort
+        }
+        if (!this.workerExited) {
+            try {
+                this.child.kill("SIGTERM");
+            }
+            catch {
+                // ignore
+            }
+        }
+        await Promise.race([
+            this.exitPromise,
+            new Promise((resolve) => {
+                const timer = setTimeout(resolve, 1500);
+                if (typeof timer.unref === "function") {
+                    timer.unref();
+                }
+            }),
+        ]);
+        if (!this.workerExited) {
+            try {
+                this.child.kill("SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+            await this.exitPromise;
+        }
+    }
+    async callWorker(method, args = [], { progressHandler = null } = {}) {
+        if (this.closed) {
+            throw createSessionClosedError();
+        }
+        await this.readyPromise;
+        if (this.workerExited) {
+            throw createSessionClosedError();
+        }
+        const requestId = this.nextRequestId++;
+        const payload = {
+            type: "request",
+            id: requestId,
+            method,
+            args,
+        };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(requestId, {
+                resolve,
+                reject,
+                progressHandler,
+            });
+            try {
+                this.child.stdin.write(toSerializablePayload(payload));
+            }
+            catch (error) {
+                this.pendingRequests.delete(requestId);
+                reject(error);
+            }
+        });
+    }
+    handleWorkerStderr(line) {
+        const normalized = String(line || "").trim();
+        if (!normalized) {
+            return;
+        }
+        this.logger.log?.(`[ai-sdk worker] ${normalized}`);
+    }
+    handleWorkerLine(line) {
+        const normalized = String(line || "").trim();
+        if (!normalized) {
+            return;
+        }
+        let payload;
+        try {
+            payload = JSON.parse(normalized);
+        }
+        catch {
+            this.logger.log?.(`[ai-sdk worker] invalid stdout: ${normalized}`);
+            return;
+        }
+        switch (payload?.type) {
+            case "ready":
+                this.applyReadyPayload(payload);
+                this.resolveReady?.(payload);
+                this.resolveReady = null;
+                this.rejectReady = null;
+                return;
+            case "create_error": {
+                const error = reviveError(payload.error);
+                this.rejectReady?.(error);
+                this.resolveReady = null;
+                this.rejectReady = null;
+                return;
+            }
+            case "response":
+                this.handleWorkerResponse(payload);
+                return;
+            case "progress":
+                this.handleWorkerProgress(payload);
+                return;
+            case "event":
+                this.handleWorkerEvent(payload);
+                return;
+            default:
+                return;
+        }
+    }
+    applyReadyPayload(payload) {
+        const snapshot = payload?.snapshot && typeof payload.snapshot === "object" ? payload.snapshot : {};
+        this.snapshot = {
+            ...this.snapshot,
+            ...snapshot,
+            workerReady: true,
+            workerPid: payload?.workerPid || undefined,
+            workerProcessPid: payload?.workerProcessPid || undefined,
+        };
+        if (snapshot?.sessionInfo) {
+            this.sessionInfo = { ...snapshot.sessionInfo };
+        }
+        if (snapshot?.sessionId) {
+            this.threadIdValue = String(snapshot.sessionId);
+        }
+        if (snapshot?.useSessionFileReplyStream !== undefined) {
+            this.useSessionFileReplyStreamValue = Boolean(snapshot.useSessionFileReplyStream);
+        }
+    }
+    handleWorkerResponse(payload) {
+        const pending = this.pendingRequests.get(payload.id);
+        if (!pending) {
+            return;
+        }
+        this.pendingRequests.delete(payload.id);
+        if (payload.error) {
+            pending.reject(reviveError(payload.error));
+            return;
+        }
+        if (payload.result && typeof payload.result === "object" && payload.result.sessionId) {
+            this.threadIdValue = String(payload.result.sessionId);
+        }
+        if (payload.result && typeof payload.result === "object" && payload.result.sessionFilePath) {
+            this.sessionInfo = {
+                ...(this.sessionInfo || {
+                    backend: this.backend,
+                    sessionId: this.threadIdValue || undefined,
+                }),
+                sessionFilePath: payload.result.sessionFilePath,
+            };
+        }
+        pending.resolve(payload.result);
+    }
+    handleWorkerProgress(payload) {
+        const pending = this.pendingRequests.get(payload.requestId);
+        if (!pending || typeof pending.progressHandler !== "function") {
+            return;
+        }
+        try {
+            pending.progressHandler(payload.payload);
+        }
+        catch {
+            // best effort
+        }
+    }
+    async handleWorkerEvent(payload) {
+        const name = String(payload?.name || "").trim();
+        const eventPayload = payload?.payload;
+        if (name === "log" && eventPayload?.message) {
+            this.logger.log?.(String(eventPayload.message));
+            this.emit("log", eventPayload);
+            return;
+        }
+        if (name === "session" && eventPayload && typeof eventPayload === "object") {
+            this.sessionInfo = { ...eventPayload };
+            if (eventPayload.sessionId) {
+                this.threadIdValue = String(eventPayload.sessionId);
+            }
+            this.snapshot = {
+                ...this.snapshot,
+                sessionId: this.threadIdValue || undefined,
+                sessionInfo: this.sessionInfo,
+            };
+        }
+        if (name === "assistant_message" && typeof this.sessionMessageHandler === "function") {
+            await this.sessionMessageHandler(eventPayload);
+        }
+        if (name === "working_status" && typeof this.workingStatusHandler === "function") {
+            await this.workingStatusHandler(eventPayload);
+        }
+        this.emit(name, eventPayload);
+    }
+    rejectPendingRequests(error) {
+        if (this.pendingRequests.size === 0) {
+            return;
+        }
+        for (const pending of this.pendingRequests.values()) {
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+}
+export function createAiSession(backend, options = {}) {
+    const normalizedBackend = assertSupportedBackend(backend);
+    if (process.env.CONDUCTOR_AI_SDK_DISABLE_WORKER === "1") {
+        return createLocalAiSession(normalizedBackend, options);
+    }
+    return new RemoteAiSession(normalizedBackend, options);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { createAiSession, RemoteAiSession } from "./client.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { createAiSession, RemoteAiSession } from "./client.js";

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

@@ -0,0 +1,168 @@
+export class CodexAppServerSession extends EventEmitter<[never]> {
+    constructor(backend: any, options?: {});
+    backend: string;
+    options: {};
+    logger: any;
+    cwd: any;
+    resumeSessionId: any;
+    sessionId: any;
+    threadPath: string;
+    sessionInfo: any;
+    history: any[];
+    pendingHistorySeed: boolean;
+    closeRequested: boolean;
+    closed: boolean;
+    closeWaiters: Set<any>;
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    activeReplyTarget: string;
+    lastReplyTarget: string;
+    manualResumeReady: boolean;
+    nativeSessionId: string;
+    rateLimits: any;
+    tokenUsage: any;
+    turnDeadlineMs: any;
+    currentTurn: {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+    } | null;
+    bootPromise: Promise<void> | null;
+    booted: boolean;
+    transport: CodexAppServerTransport;
+    writeLog(message: any): void;
+    trace(message: any): void;
+    get threadId(): any;
+    get threadOptions(): {
+        model: string;
+    };
+    getSnapshot(): {
+        backend: string;
+        provider: string;
+        cwd: any;
+        sessionId: any;
+        sessionInfo: any;
+        useSessionFileReplyStream: boolean;
+        resumeReady: boolean;
+        manualResume: {
+            ready: boolean;
+            command: string;
+        } | null;
+        pid: number | undefined;
+    };
+    getSessionInfo(): any;
+    ensureSessionInfo(): Promise<any>;
+    getSessionUsageSummary(): Promise<{
+        sessionId: any;
+        sessionFilePath: string | undefined;
+        tokenUsagePercent: number | undefined;
+        contextUsagePercent: number | undefined;
+        tokenUsage: any;
+        rateLimits: any;
+        manualResume: {
+            ready: boolean;
+            command: string;
+        } | null;
+    }>;
+    usesSessionFileReplyStream(): boolean;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTo: any): void;
+    getCurrentReplyTarget(): string | undefined;
+    boot(): Promise<void>;
+    bootInternal(): Promise<void>;
+    applyThreadInfo(thread: any, { resumeReady }?: {
+        resumeReady?: boolean | undefined;
+    }): void;
+    applySessionConfigured(params: any): void;
+    resolveContextUsagePercent(): number | undefined;
+    normalizeWorkingStatusPayload(payload: any): {
+        source: string;
+        reply_in_progress: boolean;
+        replyTo: any;
+        state: any;
+        phase: any;
+        status_line: any;
+        status_done_line: any;
+        reply_preview: any;
+        thread_id: any;
+    };
+    emitWorkingStatus(payload: any): Promise<void>;
+    emitAssistantMessage(text: any): Promise<void>;
+    finalizeActiveAssistantMessage(currentTurn?: {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+    } | null, { messageId }?: {
+        messageId?: string | undefined;
+    }): Promise<boolean>;
+    createSessionClosedError(): Error;
+    createTurnTimeoutError(timeoutMs: any): Error;
+    createCloseGuard(): {
+        promise: Promise<any>;
+        cleanup: () => void;
+    };
+    createTurnTimeoutGuard(): {
+        promise: Promise<any>;
+        cleanup: () => void;
+    };
+    flushCloseWaiters(): void;
+    buildPrompt(promptText: any, { useInitialImages }?: {
+        useInitialImages?: boolean | undefined;
+    }): string;
+    getCurrentTurn(): {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+    } | null;
+    ensureCurrentTurn(params: any): {
+        turnId: string;
+        fullText: string;
+        activeAssistantMessageId: string;
+        activeAssistantMessageText: string;
+        resolve: null;
+        reject: null;
+    } | null;
+    queueAssistantDelta(delta: any, { messageId }?: {
+        messageId?: string | undefined;
+    }): Promise<void>;
+    handleNotification(method: any, params?: {}): Promise<void>;
+    handleTransportFailure(error: any): void;
+    handleTransportExit(payload: any): void;
+    maybeEmitAuthRequired(error: any): void;
+    interruptCurrentTurn(): Promise<void>;
+    runTurn(promptText: any, { useInitialImages }?: {
+        useInitialImages?: boolean | undefined;
+    }): Promise<{
+        text: string;
+        usage: null;
+        items: never[];
+        events: never[];
+        provider?: undefined;
+        metadata?: undefined;
+    } | {
+        text: string;
+        usage: any;
+        items: any;
+        events: never[];
+        provider: string;
+        metadata: {
+            source: string;
+            threadId: any;
+            threadPath: string | undefined;
+            nativeSessionId: string | undefined;
+        };
+    }>;
+    close(): Promise<void>;
+}
+import { EventEmitter } from "node:events";
+import { CodexAppServerTransport } from "../transports/codex-app-server-transport.js";