@love-moon/ai-sdk 0.2.30 → 0.2.32

package/dist/client.d.ts

@@ -1,19 +1,18 @@
-export function createAiSession(backend: any, options?: {}): import("./session-factory.js").CodexAppServerSession | import("./session-factory.js").ClaudeAgentSdkSession | import("./session-factory.js").KimiCliSession | import("./session-factory.js").OpencodeSdkSession | RemoteAiSession;
+export function createAiSession(backend: any, options?: {}): RemoteAiSession | LocalAiSessionProxy;
 export class RemoteAiSession extends EventEmitter<[never]> {
     constructor(backend: any, options?: {});
-    backend: string;
     options: {};
     logger: any;
-    variant: string;
     threadIdValue: any;
     threadOptionsValue: {
         model: any;
     };
     useSessionFileReplyStreamValue: boolean;
     sessionInfo: any;
+    currentTurnStatus: any;
     snapshot: {
-        backend: string;
-        provider: string;
+        backend: undefined;
+        provider: undefined;
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
@@ -31,20 +30,26 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     resolveReady: ((value: any) => void) | null;
     rejectReady: ((reason?: any) => void) | null;
     readyPromise: Promise<any>;
+    initializeSession(backend: any, options: any): Promise<void>;
+    backend: any;
+    variant: any;
     get threadId(): any;
     get threadOptions(): {
+        modelProvider?: any;
         model: any;
     };
     getSnapshot(): {
+        currentTurnStatus: any;
         sessionInfo: any;
-        backend: string;
-        provider: string;
+        backend: undefined;
+        provider: undefined;
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
     };
     usesSessionFileReplyStream(): boolean;
     getSessionInfo(): any;
+    getCurrentTurnStatus(): any;
     setSessionMessageHandler(handler: any): void;
     setWorkingStatusHandler(handler: any): void;
     setSessionReplyTarget(replyTo: any): void;
@@ -63,5 +68,45 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     handleWorkerEvent(payload: any): Promise<void>;
     rejectPendingRequests(error: any): void;
 }
+declare class LocalAiSessionProxy extends EventEmitter<[never]> {
+    constructor(backend: any, options?: {});
+    backend: any;
+    options: {};
+    threadIdValue: any;
+    threadOptionsValue: {
+        model: any;
+    };
+    useSessionFileReplyStreamValue: boolean;
+    sessionInfo: any;
+    currentTurnStatus: any;
+    session: any;
+    closed: boolean;
+    sessionMessageHandler: any;
+    workingStatusHandler: any;
+    replyTarget: any;
+    snapshot: {
+        backend: undefined;
+        provider: undefined;
+        sessionId: any;
+        useSessionFileReplyStream: boolean;
+        workerReady: boolean;
+    };
+    readyPromise: Promise<any>;
+    initializeSession(backend: any, options: any): Promise<any>;
+    get threadId(): any;
+    get threadOptions(): any;
+    getSnapshot(): any;
+    usesSessionFileReplyStream(): boolean;
+    getSessionInfo(): any;
+    getCurrentTurnStatus(): any;
+    setSessionMessageHandler(handler: any): void;
+    setWorkingStatusHandler(handler: any): void;
+    setSessionReplyTarget(replyTarget: any): void;
+    ensureSessionInfo(): Promise<any>;
+    getSessionUsageSummary(): Promise<any>;
+    runTurn(promptText: any, options?: {}): Promise<any>;
+    close(): Promise<void>;
+}
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
+export {};

package/dist/client.js

@@ -26,10 +26,8 @@ function toSerializablePayload(payload) {
 export class RemoteAiSession extends EventEmitter {
     constructor(backend, options = {}) {
         super();
-        this.backend = assertSupportedBackend(backend);
         this.options = options;
         this.logger = normalizeLogger(options.logger);
-        this.variant = providerVariantForBackend(this.backend);
         this.threadIdValue =
             typeof options.resumeSessionId === "string" && options.resumeSessionId.trim()
                 ? options.resumeSessionId.trim()
@@ -37,13 +35,14 @@ export class RemoteAiSession extends EventEmitter {
         this.threadOptionsValue = {
             model: typeof options.model === "string" && options.model.trim()
                 ? options.model.trim()
-                : this.backend || "unknown",
+                : String(backend || "unknown").trim() || "unknown",
         };
         this.useSessionFileReplyStreamValue = true;
         this.sessionInfo = null;
+        this.currentTurnStatus = null;
         this.snapshot = {
-            backend: this.backend,
-            provider: this.variant,
+            backend: undefined,
+            provider: undefined,
             sessionId: this.threadIdValue || undefined,
             useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
             workerReady: false,
@@ -94,21 +93,50 @@ export class RemoteAiSession extends EventEmitter {
             this.rejectReady?.(error);
             this.rejectPendingRequests(error);
         });
-        this.child.stdin.write(toSerializablePayload({
-            type: "create",
-            backend: this.backend,
-            options: sanitizeOptionsForWorker(options),
-        }));
+        void this.initializeSession(backend, options);
+    }
+    async initializeSession(backend, options) {
+        try {
+            this.backend = await assertSupportedBackend(backend, options);
+            this.variant = await providerVariantForBackend(backend, options);
+            this.snapshot.backend = this.backend;
+            this.snapshot.provider = this.variant;
+            this.threadOptionsValue.model =
+                typeof options.model === "string" && options.model.trim() ? options.model.trim() : this.backend || "unknown";
+            this.child.stdin.write(toSerializablePayload({
+                type: "create",
+                backend: this.backend,
+                options: sanitizeOptionsForWorker(options),
+            }));
+        }
+        catch (error) {
+            this.rejectReady?.(error);
+            this.resolveReady = null;
+            this.rejectReady = null;
+            this.rejectPendingRequests(error);
+            try {
+                this.child.kill("SIGTERM");
+            }
+            catch {
+                // ignore
+            }
+        }
     }
     get threadId() {
         return this.threadIdValue;
     }
     get threadOptions() {
-        return { ...this.threadOptionsValue };
+        const sessionInfo = this.sessionInfo && typeof this.sessionInfo === "object" ? this.sessionInfo : null;
+        return {
+            ...this.threadOptionsValue,
+            ...(sessionInfo?.model ? { model: sessionInfo.model } : {}),
+            ...(sessionInfo?.modelProvider ? { modelProvider: sessionInfo.modelProvider } : {}),
+        };
     }
     getSnapshot() {
         return {
             ...this.snapshot,
+            currentTurnStatus: this.getCurrentTurnStatus(),
             sessionInfo: this.sessionInfo ? { ...this.sessionInfo } : null,
         };
     }
@@ -118,6 +146,9 @@ export class RemoteAiSession extends EventEmitter {
     getSessionInfo() {
         return this.sessionInfo ? { ...this.sessionInfo } : null;
     }
+    getCurrentTurnStatus() {
+        return this.currentTurnStatus ? { ...this.currentTurnStatus } : null;
+    }
     setSessionMessageHandler(handler) {
         this.sessionMessageHandler = typeof handler === "function" ? handler : null;
     }
@@ -278,6 +309,9 @@ export class RemoteAiSession extends EventEmitter {
         if (snapshot?.useSessionFileReplyStream !== undefined) {
             this.useSessionFileReplyStreamValue = Boolean(snapshot.useSessionFileReplyStream);
         }
+        if (snapshot?.currentTurnStatus && typeof snapshot.currentTurnStatus === "object") {
+            this.currentTurnStatus = { ...snapshot.currentTurnStatus };
+        }
     }
     handleWorkerResponse(payload) {
         const pending = this.pendingRequests.get(payload.id);
@@ -305,6 +339,9 @@ export class RemoteAiSession extends EventEmitter {
     }
     handleWorkerProgress(payload) {
         const pending = this.pendingRequests.get(payload.requestId);
+        if (payload?.payload && typeof payload.payload === "object") {
+            this.currentTurnStatus = { ...payload.payload };
+        }
         if (!pending || typeof pending.progressHandler !== "function") {
             return;
         }
@@ -337,6 +374,11 @@ export class RemoteAiSession extends EventEmitter {
         if (name === "assistant_message" && typeof this.sessionMessageHandler === "function") {
             await this.sessionMessageHandler(eventPayload);
         }
+        if (name === "working_status") {
+            if (eventPayload && typeof eventPayload === "object") {
+                this.currentTurnStatus = { ...eventPayload };
+            }
+        }
         if (name === "working_status" && typeof this.workingStatusHandler === "function") {
             await this.workingStatusHandler(eventPayload);
         }
@@ -352,10 +394,199 @@ export class RemoteAiSession extends EventEmitter {
         this.pendingRequests.clear();
     }
 }
+const LOCAL_SESSION_EVENT_NAMES = ["session", "assistant_message", "working_status", "auth_required", "process.exited"];
+class LocalAiSessionProxy extends EventEmitter {
+    constructor(backend, options = {}) {
+        super();
+        this.backend = undefined;
+        this.options = options;
+        this.threadIdValue =
+            typeof options.resumeSessionId === "string" && options.resumeSessionId.trim()
+                ? options.resumeSessionId.trim()
+                : "";
+        this.threadOptionsValue = {
+            model: typeof options.model === "string" && options.model.trim()
+                ? options.model.trim()
+                : String(backend || "unknown").trim() || "unknown",
+        };
+        this.useSessionFileReplyStreamValue = true;
+        this.sessionInfo = null;
+        this.currentTurnStatus = null;
+        this.session = null;
+        this.closed = false;
+        this.sessionMessageHandler = null;
+        this.workingStatusHandler = null;
+        this.replyTarget = undefined;
+        this.snapshot = {
+            backend: undefined,
+            provider: undefined,
+            sessionId: this.threadIdValue || undefined,
+            useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
+            workerReady: false,
+        };
+        this.readyPromise = this.initializeSession(backend, options);
+        this.readyPromise.catch(() => {
+            // keep parity with RemoteAiSession and avoid unhandled rejections
+        });
+    }
+    async initializeSession(backend, options) {
+        const session = await createLocalAiSession(backend, options);
+        if (this.closed) {
+            await session.close?.();
+            return session;
+        }
+        this.session = session;
+        for (const eventName of LOCAL_SESSION_EVENT_NAMES) {
+            if (typeof session.on === "function") {
+                session.on(eventName, async (payload) => {
+                    if (eventName === "session" && payload && typeof payload === "object") {
+                        this.sessionInfo = { ...payload };
+                        if (payload.sessionId) {
+                            this.threadIdValue = String(payload.sessionId);
+                        }
+                    }
+                    if (eventName === "working_status" && payload && typeof payload === "object") {
+                        this.currentTurnStatus = { ...payload };
+                    }
+                    this.emit(eventName, payload);
+                });
+            }
+        }
+        if (this.sessionMessageHandler && typeof session.setSessionMessageHandler === "function") {
+            session.setSessionMessageHandler(this.sessionMessageHandler);
+        }
+        if (this.workingStatusHandler && typeof session.setWorkingStatusHandler === "function") {
+            session.setWorkingStatusHandler(this.workingStatusHandler);
+        }
+        if (this.replyTarget !== undefined && typeof session.setSessionReplyTarget === "function") {
+            session.setSessionReplyTarget(this.replyTarget);
+        }
+        const snapshot = typeof session.getSnapshot === "function" ? session.getSnapshot() : {};
+        this.backend = snapshot.backend || session.backend || this.backend;
+        this.threadIdValue = session.threadId || snapshot.sessionId || this.threadIdValue;
+        this.threadOptionsValue = session.threadOptions ? { ...session.threadOptions } : this.threadOptionsValue;
+        this.useSessionFileReplyStreamValue =
+            typeof session.usesSessionFileReplyStream === "function"
+                ? Boolean(session.usesSessionFileReplyStream())
+                : snapshot.useSessionFileReplyStream !== undefined
+                    ? Boolean(snapshot.useSessionFileReplyStream)
+                    : this.useSessionFileReplyStreamValue;
+        this.sessionInfo =
+            typeof session.getSessionInfo === "function"
+                ? session.getSessionInfo()
+                : snapshot.sessionInfo && typeof snapshot.sessionInfo === "object"
+                    ? { ...snapshot.sessionInfo }
+                    : this.sessionInfo;
+        this.snapshot = {
+            ...this.snapshot,
+            ...snapshot,
+            backend: this.backend,
+            sessionId: this.threadIdValue || undefined,
+            sessionInfo: this.sessionInfo,
+            currentTurnStatus: typeof session.getCurrentTurnStatus === "function" ? session.getCurrentTurnStatus() : this.currentTurnStatus,
+            useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
+            workerReady: true,
+        };
+        return session;
+    }
+    get threadId() {
+        return this.session?.threadId || this.threadIdValue;
+    }
+    get threadOptions() {
+        return this.session?.threadOptions ? { ...this.session.threadOptions } : { ...this.threadOptionsValue };
+    }
+    getSnapshot() {
+        const sessionSnapshot = typeof this.session?.getSnapshot === "function" ? this.session.getSnapshot() : null;
+        if (sessionSnapshot) {
+            return {
+                ...this.snapshot,
+                ...sessionSnapshot,
+                backend: sessionSnapshot.backend || this.snapshot.backend,
+                currentTurnStatus: typeof this.session?.getCurrentTurnStatus === "function"
+                    ? this.session.getCurrentTurnStatus()
+                    : sessionSnapshot.currentTurnStatus || this.currentTurnStatus || null,
+                sessionId: sessionSnapshot.sessionId || this.threadIdValue || undefined,
+                sessionInfo: typeof this.session?.getSessionInfo === "function"
+                    ? this.session.getSessionInfo()
+                    : sessionSnapshot.sessionInfo || this.sessionInfo || null,
+            };
+        }
+        return {
+            ...this.snapshot,
+            currentTurnStatus: this.getCurrentTurnStatus(),
+            sessionInfo: this.sessionInfo ? { ...this.sessionInfo } : null,
+        };
+    }
+    usesSessionFileReplyStream() {
+        if (typeof this.session?.usesSessionFileReplyStream === "function") {
+            return Boolean(this.session.usesSessionFileReplyStream());
+        }
+        return Boolean(this.useSessionFileReplyStreamValue);
+    }
+    getSessionInfo() {
+        if (typeof this.session?.getSessionInfo === "function") {
+            return this.session.getSessionInfo();
+        }
+        return this.sessionInfo ? { ...this.sessionInfo } : null;
+    }
+    getCurrentTurnStatus() {
+        if (typeof this.session?.getCurrentTurnStatus === "function") {
+            return this.session.getCurrentTurnStatus();
+        }
+        return this.currentTurnStatus ? { ...this.currentTurnStatus } : null;
+    }
+    setSessionMessageHandler(handler) {
+        this.sessionMessageHandler = typeof handler === "function" ? handler : null;
+        if (typeof this.session?.setSessionMessageHandler === "function") {
+            this.session.setSessionMessageHandler(this.sessionMessageHandler);
+        }
+    }
+    setWorkingStatusHandler(handler) {
+        this.workingStatusHandler = typeof handler === "function" ? handler : null;
+        if (typeof this.session?.setWorkingStatusHandler === "function") {
+            this.session.setWorkingStatusHandler(this.workingStatusHandler);
+        }
+    }
+    setSessionReplyTarget(replyTarget) {
+        this.replyTarget = replyTarget;
+        if (typeof this.session?.setSessionReplyTarget === "function") {
+            this.session.setSessionReplyTarget(replyTarget);
+        }
+    }
+    async ensureSessionInfo() {
+        const session = await this.readyPromise;
+        const sessionInfo = await session.ensureSessionInfo();
+        this.sessionInfo = sessionInfo && typeof sessionInfo === "object" ? { ...sessionInfo } : sessionInfo;
+        if (sessionInfo?.sessionId) {
+            this.threadIdValue = String(sessionInfo.sessionId);
+        }
+        return sessionInfo;
+    }
+    async getSessionUsageSummary() {
+        const session = await this.readyPromise;
+        return await session.getSessionUsageSummary();
+    }
+    async runTurn(promptText, options = {}) {
+        const session = await this.readyPromise;
+        return await session.runTurn(promptText, options);
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        try {
+            const session = await this.readyPromise;
+            await session.close?.();
+        }
+        catch {
+            // best effort
+        }
+    }
+}
 export function createAiSession(backend, options = {}) {
-    const normalizedBackend = assertSupportedBackend(backend);
     if (process.env.CONDUCTOR_AI_SDK_DISABLE_WORKER === "1") {
-        return createLocalAiSession(normalizedBackend, options);
+        return new LocalAiSessionProxy(backend, options);
     }
-    return new RemoteAiSession(normalizedBackend, options);
+    return new RemoteAiSession(backend, options);
 }

package/dist/external-provider-registry.d.ts

@@ -0,0 +1,4 @@
+export function getExternalProviderRegistry(options?: {}): Promise<any>;
+export function resolveExternalBackend(backend: any, options?: {}): Promise<any>;
+export function getExternalProviderDescriptor(backend: any, options?: {}): Promise<any>;
+export function resetExternalProviderRegistryForTests(): void;

package/dist/external-provider-registry.js

@@ -0,0 +1,143 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { loadEnvConfig } from "./shared.js";
+const BUILT_IN_BACKENDS = new Set(["codex", "claude", "kimi", "opencode"]);
+const registryPromises = new Map();
+let externalProviderImportNonce = 0;
+function normalizeProviderPathEnv(value) {
+    return String(value || "").trim();
+}
+function listProviderModulePathsFromValue(rawValue) {
+    const raw = normalizeProviderPathEnv(rawValue);
+    if (!raw) {
+        return [];
+    }
+    const parts = raw
+        .split(process.platform === "win32" ? ";" : ":")
+        .map((item) => item.trim())
+        .filter(Boolean);
+    return [...new Set(parts)];
+}
+function resolveProviderPathEnv(options = {}) {
+    const envValue = normalizeProviderPathEnv(process.env.AISDK_PROVIDER_PATH);
+    if (envValue) {
+        return envValue;
+    }
+    const envConfig = loadEnvConfig(options.configFile);
+    return normalizeProviderPathEnv(envConfig?.AISDK_PROVIDER_PATH);
+}
+function normalizeName(value) {
+    return String(value || "").trim().toLowerCase();
+}
+function createRegistry() {
+    return {
+        descriptors: [],
+        byBackend: new Map(),
+        aliasToBackend: new Map(),
+    };
+}
+function registerAlias(registry, alias, backend, sourcePath) {
+    const normalizedAlias = normalizeName(alias);
+    if (!normalizedAlias) {
+        return;
+    }
+    if (BUILT_IN_BACKENDS.has(normalizedAlias) && normalizedAlias !== backend) {
+        throw new Error(`External AI SDK provider alias "${normalizedAlias}" from ${sourcePath} conflicts with built-in backend "${normalizedAlias}".`);
+    }
+    const existingBackend = registry.aliasToBackend.get(normalizedAlias);
+    if (existingBackend && existingBackend !== backend) {
+        throw new Error(`External AI SDK provider alias "${normalizedAlias}" from ${sourcePath} conflicts with backend "${existingBackend}".`);
+    }
+    registry.aliasToBackend.set(normalizedAlias, backend);
+}
+function validateDescriptor(descriptor, sourcePath) {
+    if (!descriptor || typeof descriptor !== "object") {
+        throw new Error(`External AI SDK provider module ${sourcePath} contains an invalid provider descriptor.`);
+    }
+    const backend = normalizeName(descriptor.backend);
+    if (!backend) {
+        throw new Error(`External AI SDK provider module ${sourcePath} is missing provider.backend.`);
+    }
+    if (BUILT_IN_BACKENDS.has(backend)) {
+        throw new Error(`External AI SDK provider backend "${backend}" from ${sourcePath} conflicts with a built-in backend.`);
+    }
+    const variant = String(descriptor.variant || "").trim();
+    if (!variant) {
+        throw new Error(`External AI SDK provider "${backend}" from ${sourcePath} is missing provider.variant.`);
+    }
+    if (typeof descriptor.createSession !== "function") {
+        throw new Error(`External AI SDK provider "${backend}" from ${sourcePath} is missing provider.createSession().`);
+    }
+    const aliases = Array.isArray(descriptor.aliases) ? descriptor.aliases.map((item) => normalizeName(item)).filter(Boolean) : [];
+    return {
+        backend,
+        variant,
+        aliases,
+        createSession: descriptor.createSession,
+        isSupported: typeof descriptor.isSupported === "function" ? descriptor.isSupported : null,
+        sourcePath,
+    };
+}
+async function loadRegistry(modulePaths) {
+    const registry = createRegistry();
+    for (const modulePath of modulePaths) {
+        let importedModule;
+        try {
+            const resolvedPath = path.isAbsolute(modulePath) ? modulePath : path.resolve(modulePath);
+            const moduleUrl = pathToFileURL(resolvedPath);
+            moduleUrl.searchParams.set("conductor-ai-sdk-provider-attempt", String(++externalProviderImportNonce));
+            importedModule = await import(moduleUrl.href);
+        }
+        catch (error) {
+            throw new Error(`Failed to load external AI SDK provider module ${modulePath}: ${error?.message || error}`);
+        }
+        const providers = Array.isArray(importedModule?.providers) ? importedModule.providers : [];
+        if (providers.length === 0) {
+            throw new Error(`External AI SDK provider module ${modulePath} must export a non-empty providers array.`);
+        }
+        for (const rawDescriptor of providers) {
+            const descriptor = validateDescriptor(rawDescriptor, modulePath);
+            if (registry.byBackend.has(descriptor.backend)) {
+                throw new Error(`External AI SDK provider backend "${descriptor.backend}" is declared more than once (latest: ${modulePath}).`);
+            }
+            registry.descriptors.push(descriptor);
+            registry.byBackend.set(descriptor.backend, descriptor);
+            registerAlias(registry, descriptor.backend, descriptor.backend, modulePath);
+            for (const alias of descriptor.aliases) {
+                registerAlias(registry, alias, descriptor.backend, modulePath);
+            }
+        }
+    }
+    return registry;
+}
+export async function getExternalProviderRegistry(options = {}) {
+    const providerPathEnv = resolveProviderPathEnv(options);
+    if (!registryPromises.has(providerPathEnv)) {
+        const loadPromise = loadRegistry(listProviderModulePathsFromValue(providerPathEnv)).catch((error) => {
+            registryPromises.delete(providerPathEnv);
+            throw error;
+        });
+        registryPromises.set(providerPathEnv, loadPromise);
+    }
+    return registryPromises.get(providerPathEnv);
+}
+export async function resolveExternalBackend(backend, options = {}) {
+    const normalized = normalizeName(backend);
+    if (!normalized) {
+        return "";
+    }
+    const registry = await getExternalProviderRegistry(options);
+    return registry.aliasToBackend.get(normalized) || normalized;
+}
+export async function getExternalProviderDescriptor(backend, options = {}) {
+    const normalized = normalizeName(backend);
+    if (!normalized) {
+        return null;
+    }
+    const registry = await getExternalProviderRegistry(options);
+    const resolvedBackend = registry.aliasToBackend.get(normalized) || normalized;
+    return registry.byBackend.get(resolvedBackend) || null;
+}
+export function resetExternalProviderRegistryForTests() {
+    registryPromises.clear();
+}

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

@@ -31,6 +31,9 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     } | null;
     lastResult: any;
     rateLimitInfo: any;
+    currentTurnStatus: any;
+    currentTurnActivityAt: number;
+    now: any;
     turnDeadlineMs: any;
     sdkModulePromise: Promise<any> | Promise<typeof import("@anthropic-ai/claude-agent-sdk")> | null;
     env: any;
@@ -39,6 +42,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     get threadId(): any;
     get threadOptions(): {
         model: any;
+        modelProvider: any;
     };
     getSnapshot(): {
         backend: string;
@@ -55,11 +59,13 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
             ready: boolean;
             command: string;
         } | null;
+        currentTurnStatus: any;
     };
     getSessionInfo(): {
         backend: string;
         sessionId: any;
     } | null;
+    getCurrentTurnStatus(): any;
     ensureSessionInfo(): Promise<{
         backend: string;
         sessionId: any;
@@ -81,6 +87,9 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     setWorkingStatusHandler(handler: any): void;
     setSessionReplyTarget(replyTo: any): void;
     getCurrentReplyTarget(): string | undefined;
+    touchTurnActivity(): void;
+    updateCurrentTurnStatus(payload: any): void;
+    markTurnStartedStatus(): void;
     emitWorkingStatus(payload: any, onProgress?: null): Promise<void>;
     emitAssistantMessage(text: any): Promise<void>;
     emitTerminalWorkingStatus(currentTurn: any, payload: any, onProgress?: null): Promise<void>;