@love-moon/ai-sdk 0.8.0 → 0.9.0

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

@@ -0,0 +1,194 @@
+export function defaultDshSessionRoot(): string;
+/**
+ * DeepSeek Harness (dsh) backend session.
+ *
+ * Drives a dsh runtime subprocess through `@deepseek-ai/dsh-sdk-client`
+ * (stdio JSON-RPC). The runtime composition is the package-owned
+ * `dsh/cordis.yml`; the pinned runtime bin comes from
+ * `@deepseek-ai/dsh-sdk-jsonrpc-demo`. One DshSdkSession owns at most one
+ * runtime subprocess across turns; the dsh-side session id is minted by us
+ * (or taken from resumeSessionId) so the same conversation resumes across
+ * runtime restarts through dsh's JSONL session persistence.
+ *
+ * Interrupt semantics: the dsh SDK wire has NO mid-turn cancel. Interrupting
+ * closes the runtime subprocess (SIGTERM ladder inside the SDK client) and
+ * the next runTurn spawns a fresh runtime resuming the same session id.
+ */
+export class DshSdkSession extends EventEmitter<[never]> {
+    static capabilities: Readonly<{
+        goal: false;
+    }>;
+    constructor(backend: any, options?: {});
+    getCapabilities(): {
+        goal: false;
+    };
+    backend: string;
+    options: {};
+    logger: any;
+    cwd: any;
+    resumeSessionId: any;
+    pendingResumeFromSessionId: any;
+    sessionId: string;
+    sessionIdUsed: boolean;
+    model: any;
+    dshProvider: any;
+    maxTokens: number | undefined;
+    sessionRoot: any;
+    sessionInfo: {
+        backend: string;
+        sessionId: string;
+        model: any;
+        modelProvider: any;
+    };
+    history: any[];
+    pendingHistorySeed: boolean;
+    closeRequested: boolean;
+    closed: boolean;
+    closeWaiters: Set<any>;
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    activeReplyTarget: string;
+    lastReplyTarget: string;
+    manualResumeReady: boolean;
+    sessionAnnounced: boolean;
+    currentTurn: {
+        emittedAssistantMessage: boolean;
+        fullText: string;
+        interrupted: boolean;
+        items: never[];
+        terminalWorkingStatusEmitted: boolean;
+        turnEndReason: null;
+        usage: null;
+    } | null;
+    harness: any;
+    lastUsage: any;
+    currentTurnStatus: any;
+    currentTurnActivityAt: number;
+    now: any;
+    turnDeadlineMs: any;
+    sdkModulePromise: Promise<any> | Promise<typeof import("@deepseek-ai/dsh-sdk-client")> | null;
+    env: any;
+    writeLog(message: any): void;
+    trace(message: any): void;
+    getSnapshot(): {
+        backend: string;
+        provider: string;
+        cwd: any;
+        sessionId: string;
+        sessionInfo: {
+            backend: string;
+            sessionId: string;
+            model: any;
+            modelProvider: any;
+        } | null;
+        useSessionFileReplyStream: boolean;
+        resumeReady: boolean;
+        manualResume: null;
+        currentTurnStatus: any;
+        capabilities: {
+            goal: false;
+        };
+    };
+    getSessionInfo(): {
+        backend: string;
+        sessionId: string;
+        model: any;
+        modelProvider: any;
+    } | null;
+    getCurrentTurnStatus(): any;
+    ensureSessionInfo(): Promise<{
+        backend: string;
+        sessionId: string;
+        model: any;
+        modelProvider: any;
+    } | null>;
+    getSessionUsageSummary(): Promise<{
+        sessionId: string;
+        sessionFilePath: undefined;
+        totalCostUsd: undefined;
+        usage: any;
+        modelUsage: null;
+        rateLimits: null;
+        manualResume: null;
+    }>;
+    usesSessionFileReplyStream(): boolean;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTo: any): void;
+    getCurrentReplyTarget(): string | undefined;
+    touchTurnActivity(): void;
+    updateCurrentTurnStatus(payload: any): void;
+    emitWorkingStatus(payload: any, onProgress?: null): Promise<void>;
+    emitAssistantMessage(text: any): Promise<void>;
+    emitTerminalWorkingStatus(currentTurn: any, payload: any, onProgress?: null): Promise<void>;
+    announceSession(): void;
+    /**
+     * Mint a fresh wire session id after the previous one's runtime was torn
+     * down (interrupt/timeout). The persisted log of the old id would collide
+     * on the next create, so the conversation continues on a new id seeded
+     * with the in-memory history; the new id is re-announced on success.
+     */
+    rotateSessionId(): void;
+    findPersistedSessionLog(sessionId: any): string | null;
+    /**
+     * Recover the user/assistant conversation from a persisted dsh JSONL log
+     * so a cross-process resume can seed it into the fresh wire session.
+     */
+    loadPersistedHistory(sessionId: any): {
+        role: string;
+        content: string;
+    }[];
+    createSessionClosedError(): Error;
+    createTurnTimeoutError(timeoutMs: any): Error;
+    createCloseGuard(onClose: any): {
+        promise: Promise<any>;
+        cleanup: () => void;
+    };
+    createTurnTimeoutGuard(onTimeout: any): {
+        promise: Promise<any>;
+        cleanup: () => void;
+    };
+    flushCloseWaiters(): void;
+    buildPrompt(promptText: any, { useInitialImages }?: {
+        useInitialImages?: boolean | undefined;
+    }): string;
+    resolveLaunchSpec(): {
+        command: any;
+        args: any;
+    };
+    buildRuntimeEnv(): any;
+    getSdkModule(): Promise<any>;
+    getHarness(): Promise<any>;
+    disposeHarness(): Promise<void>;
+    maybeEmitAuthRequired(message: any): void;
+    handleNotification(notification: any, currentTurn: any, { onProgress }: {
+        onProgress: any;
+    }): Promise<void>;
+    interruptCurrentTurn(): Promise<boolean>;
+    runTurn(promptText: any, { useInitialImages, onProgress }?: {
+        useInitialImages?: boolean | undefined;
+        onProgress?: null | undefined;
+    }): Promise<{
+        text: string;
+        usage: null;
+        items: never[];
+        events: never[];
+        provider?: undefined;
+        metadata?: undefined;
+    } | {
+        text: any;
+        usage: any;
+        items: never[];
+        events: never[];
+        provider: string;
+        metadata: {
+            source: string;
+            sessionId: string;
+            model: any;
+            modelProvider: any;
+            turnEndReason: undefined;
+        };
+    }>;
+    close(): Promise<void>;
+}
+import { EventEmitter } from "node:events";