@love-moon/ai-sdk 0.2.29 → 0.2.31

package/dist/client.d.ts

@@ -1,10 +1,8 @@
-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;
@@ -12,8 +10,8 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     useSessionFileReplyStreamValue: boolean;
     sessionInfo: any;
     snapshot: {
-        backend: string;
-        provider: string;
+        backend: undefined;
+        provider: undefined;
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
@@ -31,14 +29,18 @@ 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(): {
         sessionInfo: any;
-        backend: string;
-        provider: string;
+        backend: undefined;
+        provider: undefined;
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
@@ -63,5 +65,43 @@ 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;
+    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;
+    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,13 @@ 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.snapshot = {
-            backend: this.backend,
-            provider: this.variant,
+            backend: undefined,
+            provider: undefined,
             sessionId: this.threadIdValue || undefined,
             useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
             workerReady: false,
@@ -94,17 +92,45 @@ 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 {
@@ -352,10 +378,184 @@ 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.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);
+                        }
+                    }
+                    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,
+            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,
+                sessionId: sessionSnapshot.sessionId || this.threadIdValue || undefined,
+                sessionInfo: typeof this.session?.getSessionInfo === "function"
+                    ? this.session.getSessionInfo()
+                    : sessionSnapshot.sessionInfo || this.sessionInfo || null,
+            };
+        }
+        return {
+            ...this.snapshot,
+            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;
+    }
+    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

@@ -39,6 +39,7 @@ export class ClaudeAgentSdkSession extends EventEmitter<[never]> {
     get threadId(): any;
     get threadOptions(): {
         model: any;
+        modelProvider: any;
     };
     getSnapshot(): {
         backend: string;

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

@@ -179,10 +179,14 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         return this.sessionId;
     }
     get threadOptions() {
-        const model = typeof this.options.model === "string" && this.options.model.trim()
-            ? this.options.model.trim()
-            : this.backend;
-        return { model };
+        const model = this.sessionInfo?.model ||
+            (typeof this.options.model === "string" && this.options.model.trim()
+                ? this.options.model.trim()
+                : this.backend);
+        return {
+            model,
+            modelProvider: this.sessionInfo?.modelProvider || undefined,
+        };
     }
     getSnapshot() {
         return {
@@ -414,10 +418,19 @@ export class ClaudeAgentSdkSession extends EventEmitter {
         const changed = this.sessionId !== normalizedSessionId;
         this.sessionId = normalizedSessionId;
         this.manualResumeReady = true;
+        const modelUsage = this.lastResult?.modelUsage && typeof this.lastResult.modelUsage === "object"
+            ? this.lastResult.modelUsage
+            : null;
+        const resolvedModel = typeof modelUsage?.model === "string" && modelUsage.model.trim()
+            ? modelUsage.model.trim()
+            : typeof this.options.model === "string" && this.options.model.trim()
+                ? this.options.model.trim()
+                : undefined;
         this.sessionInfo = {
             ...(this.sessionInfo || {}),
             backend: this.backend,
             sessionId: normalizedSessionId,
+            model: resolvedModel,
         };
         if (changed) {
             this.trace(`session ready id=${normalizedSessionId}`);

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

@@ -37,7 +37,8 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     trace(message: any): void;
     get threadId(): any;
     get threadOptions(): {
-        model: string;
+        model: any;
+        modelProvider: any;
     };
     getSnapshot(): {
         backend: string;
@@ -74,7 +75,7 @@ export class CodexAppServerSession extends EventEmitter<[never]> {
     getCurrentReplyTarget(): string | undefined;
     boot(): Promise<void>;
     bootInternal(): Promise<void>;
-    applyThreadInfo(thread: any, { resumeReady }?: {
+    applyThreadInfo(payload: any, { resumeReady }?: {
         resumeReady?: boolean | undefined;
     }): void;
     applySessionConfigured(params: any): void;

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

@@ -224,7 +224,10 @@ export class CodexAppServerSession extends EventEmitter {
         return this.sessionId;
     }
     get threadOptions() {
-        return { model: this.backend };
+        return {
+            model: this.sessionInfo?.model || this.backend,
+            modelProvider: this.sessionInfo?.modelProvider || undefined,
+        };
     }
     getSnapshot() {
         return {
@@ -326,9 +329,10 @@ export class CodexAppServerSession extends EventEmitter {
         else {
             result = await this.transport.request("thread/start", params);
         }
-        this.applyThreadInfo(result?.thread, { resumeReady: Boolean(this.resumeSessionId) });
+        this.applyThreadInfo(result, { resumeReady: Boolean(this.resumeSessionId) });
     }
-    applyThreadInfo(thread, { resumeReady = false } = {}) {
+    applyThreadInfo(payload, { resumeReady = false } = {}) {
+        const thread = payload?.thread && typeof payload.thread === "object" ? payload.thread : payload;
         const threadId = typeof thread?.id === "string" ? thread.id.trim() : "";
         const threadPath = typeof thread?.path === "string" ? thread.path.trim() : "";
         if (!threadId) {
@@ -336,15 +340,30 @@ export class CodexAppServerSession extends EventEmitter {
         }
         this.sessionId = threadId;
         this.threadPath = threadPath;
+        const resolvedModel = typeof payload?.model === "string" && payload.model.trim()
+            ? payload.model.trim()
+            : this.sessionInfo?.model || undefined;
+        const resolvedModelProvider = typeof payload?.modelProvider === "string" && payload.modelProvider.trim()
+            ? payload.modelProvider.trim()
+            : typeof thread?.modelProvider === "string" && thread.modelProvider.trim()
+                ? thread.modelProvider.trim()
+                : this.sessionInfo?.modelProvider || undefined;
+        const reasoningEffort = typeof payload?.reasoningEffort === "string" && payload.reasoningEffort.trim()
+            ? payload.reasoningEffort.trim()
+            : this.sessionInfo?.reasoningEffort || undefined;
         this.sessionInfo = {
+            ...(this.sessionInfo || {}),
             backend: this.backend,
             sessionId: threadId,
             sessionFilePath: threadPath || undefined,
+            model: resolvedModel,
+            modelProvider: resolvedModelProvider,
+            reasoningEffort,
         };
         if (resumeReady) {
             this.manualResumeReady = true;
         }
-        this.trace(`thread ready id=${threadId} path="${sanitizeForLog(threadPath, 180)}"`);
+        this.trace(`thread ready id=${threadId} path="${sanitizeForLog(threadPath, 180)}" model="${sanitizeForLog(resolvedModel || this.backend, 80)}" provider="${sanitizeForLog(resolvedModelProvider || this.backend, 80)}"`);
         this.emit("session", this.getSessionInfo());
     }
     applySessionConfigured(params) {
@@ -571,7 +590,7 @@ export class CodexAppServerSession extends EventEmitter {
         }
         switch (method) {
             case "thread/started":
-                this.applyThreadInfo(params?.thread, { resumeReady: Boolean(this.resumeSessionId) });
+                this.applyThreadInfo(params, { resumeReady: Boolean(this.resumeSessionId) });
                 return;
             case "sessionConfigured":
             case "session_configured":

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

@@ -60,6 +60,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
     get threadId(): any;
     get threadOptions(): {
         model: any;
+        modelProvider: any;
     };
     getSnapshot(): {
         backend: string;