@love-moon/ai-sdk 0.3.1 → 0.4.0

package/dist/providers/chat-web-session.d.ts

@@ -0,0 +1,218 @@
+/**
+ * AI SDK provider that delegates to the chat-web runtime
+ * (`@love-moon/chat-web`), which automates a real Chromium browser against
+ * ChatGPT / Gemini / DeepSeek and ferries conversations through their web
+ * UIs. Choose the underlying chat-web provider via:
+ *
+ *   - `options.chatWebProvider`: "chatgpt" | "gemini"  (preferred)
+ *   - `options.provider`:        same surface
+ *   - `options.model`:           same surface (fallback for ergonomic
+ *                                `createAiSession("chat-web", { model: "gemini" })`)
+ *
+ * Defaults to "chatgpt". Aliases: "openai"/"gpt" → chatgpt, "google" → gemini.
+ *
+ * Lifecycle:
+ *   - `boot()` lazily imports `@love-moon/chat-web`, registers its built-in
+ *     providers, and opens a long-lived `ChatSession` (headless by default).
+ *   - `runTurn(prompt)` calls `session.send(prompt)` and emits a single
+ *     `assistant_message` with the model's reply.
+ *   - `close()` tears the Chromium context down.
+ *
+ * Resume: chat-web's "session" is a Chromium browser context, not a
+ * conversation ID — there is no native cross-process resume. We synthesise
+ * an id so the rest of ai-sdk has something stable to thread on, but
+ * passing `resumeSessionId` does not reattach to a prior conversation.
+ */
+export class ChatWebSession extends EventEmitter<[never]> {
+    constructor(backend: any, options?: {});
+    backend: string;
+    options: {};
+    logger: any;
+    chatWebProvider: string;
+    headless: boolean;
+    browserChannel: any;
+    browserExecutablePath: any;
+    turnTimeoutMs: number;
+    cwd: any;
+    sessionId: any;
+    /** Real provider-side conversation id, populated after the first turn lands. */
+    providerConversationId: any;
+    sessionInfo: {
+        backend: string;
+        sessionId: any;
+        model: string;
+        modelProvider: string;
+    };
+    chatSession: any;
+    booted: boolean;
+    bootPromise: Promise<void> | null;
+    closeRequested: boolean;
+    closed: boolean;
+    currentTurn: {
+        aborted: boolean;
+    } | null;
+    currentTurnStatus: {
+        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;
+        session_id: any;
+        session_file_path: undefined;
+        updated_at: string;
+    } | null;
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    activeReplyTarget: string;
+    lastReplyTarget: string;
+    history: any[];
+    writeLog(message: any): void;
+    trace(message: any): void;
+    get threadId(): any;
+    get threadOptions(): {
+        model: string;
+        modelProvider: string;
+    };
+    getSnapshot(): {
+        backend: string;
+        provider: string;
+        cwd: any;
+        sessionId: any;
+        sessionInfo: {
+            sessionIdDeferred: boolean;
+            backend: string;
+            sessionId: any;
+            model: string;
+            modelProvider: string;
+        } | null;
+        useSessionFileReplyStream: boolean;
+        resumeReady: boolean;
+        manualResume: {
+            ready: boolean;
+            command: string | undefined;
+        } | null;
+        currentTurnStatus: {
+            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;
+            session_id: any;
+            session_file_path: undefined;
+            updated_at: string;
+        } | null;
+        chatWebProvider: string;
+        providerConversationId: any;
+        providerUrl: string | undefined;
+    };
+    getSessionInfo(): {
+        sessionIdDeferred: boolean;
+        backend: string;
+        sessionId: any;
+        model: string;
+        modelProvider: string;
+    } | null;
+    getCurrentTurnStatus(): {
+        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;
+        session_id: any;
+        session_file_path: undefined;
+        updated_at: string;
+    } | null;
+    usesSessionFileReplyStream(): boolean;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTo: any): void;
+    getCurrentReplyTarget(): string | undefined;
+    ensureSessionInfo(): Promise<{
+        sessionIdDeferred: boolean;
+        backend: string;
+        sessionId: any;
+        model: string;
+        modelProvider: string;
+    } | null>;
+    getSessionUsageSummary(): Promise<{
+        sessionId: any;
+        sessionFilePath: undefined;
+        totalCostUsd: undefined;
+        usage: null;
+        rateLimits: null;
+        manualResume: null;
+    }>;
+    getChatWebModule(): Promise<any>;
+    boot(): Promise<void>;
+    bootInternal(): Promise<void>;
+    /**
+     * Adopt the provider-side conversation id (ChatGPT /c/{uuid} or
+     * equivalent) as our canonical sessionId, update sessionInfo, and emit
+     * a fresh `session` event so downstream consumers (ai-sdk runner,
+     * conductor daemon, web UI) pick up the change.
+     *
+     * Idempotent on identical values. Once promoted, the id stays stable
+     * for the rest of this ChatWebSession (next runTurn won't re-promote
+     * to something else unless the provider session truly changes).
+     */
+    applyProviderConversationId(conversationId: any): void;
+    /**
+     * Build a deep-link to the provider's conversation page so the UI can
+     * render "open in ChatGPT" / "open in AI Studio" links.
+     */
+    providerConversationUrl(): string | undefined;
+    runTurn(promptText: any, { onProgress }?: {
+        onProgress?: null | undefined;
+    }): Promise<{
+        text: string;
+        usage: null;
+        items: never[];
+        events: never[];
+        provider: string;
+        metadata: {
+            source: string;
+            sessionId: any;
+            chatWebProvider: string;
+            conversationId?: undefined;
+            providerUrl?: undefined;
+            turnIndex?: undefined;
+            durationMs?: undefined;
+        };
+    } | {
+        text: string;
+        usage: null;
+        items: never[];
+        events: never[];
+        provider: string;
+        metadata: {
+            source: string;
+            sessionId: any;
+            chatWebProvider: string;
+            conversationId: any;
+            providerUrl: string | undefined;
+            turnIndex: any;
+            durationMs: any;
+        };
+    }>;
+    interruptCurrentTurn(): Promise<void>;
+    close(): Promise<void>;
+    createSessionClosedError(): Error;
+    emitWorkingStatus(payload: any, onProgress?: null): Promise<void>;
+    emitTerminalWorkingStatus(payload: any, onProgress?: null): Promise<void>;
+    emitAssistantMessage(text: any): Promise<void>;
+}
+import { EventEmitter } from "node:events";
+export const SUPPORTED_CHAT_WEB_PROVIDERS: Set<string>;
+export const DEFAULT_CHAT_WEB_PROVIDER: "chatgpt";