@steerable/agent-shell 0.6.15

package/dist/llm/index.d.ts

@@ -0,0 +1,23 @@
+import { type LlmSettings } from '../storage/index.js';
+import { getSidecarSupervisor, setSidecarSupervisor, setSidecarSupervisorPending, whenSidecarSupervisor } from '../sidecar/handle.js';
+export { getSidecarSupervisor, setSidecarSupervisor, setSidecarSupervisorPending, whenSidecarSupervisor };
+import type { LlmGenerateRequest, LlmGenerateResult, LlmGenerateStreamRequest } from './types.js';
+export declare class LlmService {
+    private provider;
+    private cachedConfigSignature;
+    listModels(): Promise<string[]>;
+    generate(request: Omit<LlmGenerateRequest, 'model'> & {
+        model?: string;
+    }): Promise<LlmGenerateResult>;
+    /**
+     * 流式生成；provider 不支持时降级到一次性 generate（在结尾整体回调一次 onToken）。
+     */
+    generateStream(request: Omit<LlmGenerateStreamRequest, 'model'> & {
+        model?: string;
+    }): Promise<LlmGenerateResult>;
+    getSettings(): LlmSettings;
+    setSettings(next: LlmSettings): LlmSettings;
+    private getProvider;
+}
+export declare const llmService: LlmService;
+export * from './types.js';

package/dist/llm/index.js

@@ -0,0 +1,105 @@
+import { localStore } from '../storage/index.js';
+import { sidecarWireProvider } from '../storage/llm-settings.js';
+import { OllamaProvider } from './ollama.js';
+import { OpenAICompatProvider } from './openai-compat.js';
+import { SidecarLlmProvider } from './sidecar-provider.js';
+import { getSidecarSupervisor, isSidecarEnabled, setSidecarSupervisor, setSidecarSupervisorPending, whenSidecarSupervisor } from '../sidecar/handle.js';
+// The sidecar handle lives in the dependency-light `sidecar/handle.ts`; it is
+// re-exported here so existing callers (`main.ts`, `router.ts`) keep one
+// import site.
+export { getSidecarSupervisor, setSidecarSupervisor, setSidecarSupervisorPending, whenSidecarSupervisor };
+export class LlmService {
+    provider = null;
+    cachedConfigSignature = '';
+    async listModels() {
+        const provider = this.getProvider();
+        return provider.listModels();
+    }
+    async generate(request) {
+        const settings = this.getSettings();
+        const provider = this.getProvider();
+        // No TS-side retry: the sidecar path retries via CoreLoop RetryHooks, and
+        // the in-proc fallback only serves auxiliary calls (e.g. title gen).
+        return provider.generate({
+            ...request,
+            model: request.model || settings.model,
+            temperature: request.temperature ?? settings.temperature,
+        });
+    }
+    /**
+     * 流式生成；provider 不支持时降级到一次性 generate（在结尾整体回调一次 onToken）。
+     */
+    async generateStream(request) {
+        const settings = this.getSettings();
+        const provider = this.getProvider();
+        const merged = {
+            ...request,
+            model: request.model || settings.model,
+            temperature: request.temperature ?? settings.temperature,
+        };
+        // 当本轮带 tools 时，强制走非流式：Ollama 在 stream + tools 组合下，
+        // 部分模型版本会丢 tool_calls。我们宁可牺牲 tool 回合的打字机效果，
+        // 也要保证工具调用稳定到达。纯文本回合（无 tools）仍走流式。
+        const hasTools = Array.isArray(merged.tools) && merged.tools.length > 0;
+        if (provider.generateStream && !hasTools) {
+            return provider.generateStream(merged);
+        }
+        const result = await provider.generate(merged);
+        if (result.content) {
+            request.callbacks?.onToken?.(result.content);
+        }
+        return result;
+    }
+    getSettings() {
+        return localStore.getLlmSettings() || {
+            provider: 'ollama',
+            model: 'llama3.1:8b',
+            baseUrl: 'http://127.0.0.1:11434',
+            temperature: 0.3,
+        };
+    }
+    setSettings(next) {
+        const saved = localStore.setLlmSettings(next);
+        this.provider = null;
+        this.cachedConfigSignature = '';
+        return saved;
+    }
+    getProvider() {
+        const settings = this.getSettings();
+        const sidecarOn = isSidecarEnabled();
+        const signature = `${sidecarOn ? 'sidecar' : 'in-proc'}:${JSON.stringify(settings)}`;
+        if (this.provider && this.cachedConfigSignature === signature) {
+            return this.provider;
+        }
+        const supervisor = getSidecarSupervisor();
+        if (sidecarOn && supervisor) {
+            this.provider = new SidecarLlmProvider({
+                supervisor,
+                provider: sidecarWireProvider(settings.provider),
+                model: settings.model,
+                baseUrl: settings.baseUrl,
+                apiKey: settings.apiKey,
+                temperature: settings.temperature,
+            });
+        }
+        else if (settings.provider === 'ollama') {
+            this.provider = new OllamaProvider({
+                baseUrl: settings.baseUrl || 'http://127.0.0.1:11434',
+                model: settings.model,
+                temperature: settings.temperature,
+            });
+        }
+        else {
+            this.provider = new OpenAICompatProvider({
+                baseUrl: settings.baseUrl || 'https://api.openai.com',
+                apiKey: settings.apiKey,
+                model: settings.model,
+                temperature: settings.temperature,
+            });
+        }
+        this.cachedConfigSignature = signature;
+        return this.provider;
+    }
+}
+export const llmService = new LlmService();
+export * from './types.js';

package/dist/llm/ollama.d.ts

@@ -0,0 +1,23 @@
+import type { LlmGenerateRequest, LlmGenerateResult, LlmGenerateStreamRequest, LlmProvider } from './types.js';
+interface OllamaProviderOptions {
+    baseUrl?: string;
+    model: string;
+    temperature?: number;
+}
+export declare class OllamaProvider implements LlmProvider {
+    private readonly baseUrl;
+    private readonly model;
+    private readonly temperature?;
+    constructor(options: OllamaProviderOptions);
+    listModels(): Promise<string[]>;
+    generate(request: LlmGenerateRequest): Promise<LlmGenerateResult>;
+    /**
+     * NDJSON 流式生成。Ollama 会按 chunk 推 `{message:{content:"x"}, done:false}`，
+     * 最后一行 `{done:true, message:{tool_calls?:[]}, ...}`。
+     * 我们只在收到文本片段时回调 onToken；tool_calls 通常在 done 帧里完整给出。
+     */
+    generateStream(request: LlmGenerateStreamRequest): Promise<LlmGenerateResult>;
+    private buildPayload;
+    private parseFinalMessage;
+}
+export {};

package/dist/llm/ollama.js

@@ -0,0 +1,242 @@
+import { randomUUID } from 'crypto';
+export class OllamaProvider {
+    baseUrl;
+    model;
+    temperature;
+    constructor(options) {
+        this.baseUrl = (options.baseUrl || 'http://127.0.0.1:11434').replace(/\/$/, '');
+        this.model = options.model;
+        this.temperature = options.temperature;
+    }
+    async listModels() {
+        try {
+            const res = await fetch(`${this.baseUrl}/api/tags`);
+            if (!res.ok)
+                return [this.model];
+            const data = (await res.json());
+            const models = (data.models || []).map(item => item.name).filter((item) => Boolean(item));
+            return models.length ? models : [this.model];
+        }
+        catch {
+            return [this.model];
+        }
+    }
+    async generate(request) {
+        const payload = this.buildPayload(request, false);
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}/api/chat`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+                signal: request.signal,
+            });
+        }
+        catch (err) {
+            if (request.signal?.aborted) {
+                throw err instanceof Error ? err : new Error(String(err));
+            }
+            const cause = err instanceof Error ? err.message : String(err);
+            throw new Error(`无法连接本地 Ollama (${this.baseUrl})。请确认已运行 \`ollama serve\` 并执行过 \`ollama pull ${this.model}\`。原始错误: ${cause}`);
+        }
+        if (!res.ok) {
+            const text = await res.text();
+            if (res.status === 404 && /model.*not found/i.test(text)) {
+                throw new Error(`Ollama 模型 ${this.model} 未下载，请执行 \`ollama pull ${this.model}\` 后重试。`);
+            }
+            throw new Error(`Ollama 请求失败: ${res.status} ${text}`);
+        }
+        const data = (await res.json());
+        return this.parseFinalMessage(data.message, data.prompt_eval_count, data.eval_count);
+    }
+    /**
+     * NDJSON 流式生成。Ollama 会按 chunk 推 `{message:{content:"x"}, done:false}`，
+     * 最后一行 `{done:true, message:{tool_calls?:[]}, ...}`。
+     * 我们只在收到文本片段时回调 onToken；tool_calls 通常在 done 帧里完整给出。
+     */
+    async generateStream(request) {
+        const payload = this.buildPayload(request, true);
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}/api/chat`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: request.signal,
+            });
+        }
+        catch (err) {
+            if (request.signal?.aborted) {
+                throw err instanceof Error ? err : new Error(String(err));
+            }
+            const cause = err instanceof Error ? err.message : String(err);
+            throw new Error(`无法连接本地 Ollama (${this.baseUrl})。请确认已运行 \`ollama serve\` 并执行过 \`ollama pull ${this.model}\`。原始错误: ${cause}`);
+        }
+        if (!res.ok || !res.body) {
+            const text = await res.text().catch(() => '');
+            if (res.status === 404 && /model.*not found/i.test(text)) {
+                throw new Error(`Ollama 模型 ${this.model} 未下载，请执行 \`ollama pull ${this.model}\` 后重试。`);
+            }
+            throw new Error(`Ollama 请求失败: ${res.status} ${text}`);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let aggregatedContent = '';
+        let finalMessage;
+        const aggregatedToolCalls = [];
+        let frameCount = 0;
+        let lastFrameSample = undefined;
+        let promptEvalCount = 0;
+        let evalCount = 0;
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let nlIndex;
+                while ((nlIndex = buffer.indexOf('\n')) >= 0) {
+                    const line = buffer.slice(0, nlIndex).trim();
+                    buffer = buffer.slice(nlIndex + 1);
+                    if (!line)
+                        continue;
+                    let frame;
+                    try {
+                        frame = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    frameCount++;
+                    const piece = frame.message?.content || '';
+                    if (piece) {
+                        aggregatedContent += piece;
+                        request.callbacks?.onToken?.(piece);
+                    }
+                    const calls = frame.message?.tool_calls;
+                    if (calls && calls.length) {
+                        aggregatedToolCalls.push(...calls);
+                    }
+                    if (typeof frame.prompt_eval_count === 'number') {
+                        promptEvalCount = frame.prompt_eval_count;
+                    }
+                    if (typeof frame.eval_count === 'number') {
+                        evalCount = frame.eval_count;
+                    }
+                    if (frame.done) {
+                        finalMessage = frame.message;
+                        lastFrameSample = frame;
+                    }
+                }
+            }
+        }
+        finally {
+            try {
+                await reader.cancel();
+            }
+            catch {
+                // best-effort
+            }
+        }
+        const mergedToolCalls = aggregatedToolCalls.length
+            ? aggregatedToolCalls
+            : finalMessage?.tool_calls;
+        console.info('[ollama stream] done', {
+            model: this.model,
+            frames: frameCount,
+            contentBytes: aggregatedContent.length,
+            toolCallCount: mergedToolCalls?.length || 0,
+            doneReason: lastFrameSample?.done_reason,
+        });
+        if (!aggregatedContent && !(mergedToolCalls && mergedToolCalls.length)) {
+            // 把最后一帧打出来便于排查
+            console.warn('[ollama stream] empty response, lastFrame=', JSON.stringify(lastFrameSample));
+        }
+        return this.parseFinalMessage({
+            content: aggregatedContent || finalMessage?.content || '',
+            tool_calls: mergedToolCalls,
+        }, promptEvalCount, evalCount);
+    }
+    buildPayload(request, stream) {
+        const payload = {
+            model: request.model || this.model,
+            messages: request.messages.map(message => {
+                // Ollama 容忍 assistant 消息没 tool_calls，但为了和 OpenAI 严格协议
+                // 兼容（同一份 LlmMessage[] 喂给两种 provider 都该工作）这里也带上。
+                // Ollama 0.4+ 期望 arguments 是对象，OpenAI 期望 JSON string；故此处
+                // 直接传对象不要 stringify。
+                if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+                    return {
+                        role: 'assistant',
+                        content: message.content || '',
+                        tool_calls: message.toolCalls.map((call) => ({
+                            function: {
+                                name: call.name,
+                                arguments: call.arguments ?? {},
+                            },
+                        })),
+                    };
+                }
+                return {
+                    role: message.role === 'tool' ? 'tool' : message.role,
+                    content: message.content,
+                    ...(message.role === 'tool' && message.name ? { name: message.name } : {}),
+                };
+            }),
+            stream,
+            options: {
+                temperature: request.temperature ?? this.temperature ?? 0.3,
+            },
+        };
+        if ((request.tools || []).length > 0) {
+            payload.tools = (request.tools || []).map(tool => ({
+                type: 'function',
+                function: {
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.inputSchema || {
+                        type: 'object',
+                        properties: {},
+                    },
+                },
+            }));
+        }
+        return payload;
+    }
+    parseFinalMessage(message, promptEvalCount = 0, evalCount = 0) {
+        const content = message?.content || '';
+        const toolCalls = (message?.tool_calls || []).map(item => {
+            const args = item.function?.arguments;
+            let parsed = {};
+            if (typeof args === 'string') {
+                try {
+                    parsed = JSON.parse(args);
+                }
+                catch {
+                    parsed = {};
+                }
+            }
+            else if (args && typeof args === 'object') {
+                parsed = args;
+            }
+            return {
+                id: randomUUID(),
+                name: item.function?.name || 'unknown_tool',
+                arguments: parsed,
+            };
+        });
+        return {
+            content,
+            toolCalls,
+            tokensUsed: {
+                prompt: promptEvalCount,
+                completion: evalCount,
+                total: promptEvalCount + evalCount,
+            },
+            raw: message,
+        };
+    }
+}

package/dist/llm/openai-compat.d.ts

@@ -0,0 +1,20 @@
+import type { LlmGenerateRequest, LlmGenerateResult, LlmProvider } from './types.js';
+export { canonicalizeModelId, isForcedToolChoiceRejected, modelLikelyRejectsForcedToolChoice, rejectsForcedToolChoice, rememberForcedToolChoiceRejected, resetForcedToolChoiceCompatForTests, resolveOpenAiToolChoice, } from './tool-choice.js';
+interface OpenAICompatProviderOptions {
+    baseUrl: string;
+    apiKey?: string;
+    model: string;
+    temperature?: number;
+}
+export declare class OpenAICompatProvider implements LlmProvider {
+    private readonly baseUrl;
+    private readonly apiKey?;
+    private readonly model;
+    private readonly temperature?;
+    constructor(options: OpenAICompatProviderOptions);
+    listModels(): Promise<string[]>;
+    generate(request: LlmGenerateRequest): Promise<LlmGenerateResult>;
+    private mapResult;
+    private mapTools;
+    private mapMessage;
+}

package/dist/llm/openai-compat.js

@@ -0,0 +1,199 @@
+import { randomUUID } from 'crypto';
+import { isForcedToolChoiceRejected, rememberForcedToolChoiceRejected, resolveOpenAiToolChoice, } from './tool-choice.js';
+export { canonicalizeModelId, isForcedToolChoiceRejected, modelLikelyRejectsForcedToolChoice, rejectsForcedToolChoice, rememberForcedToolChoiceRejected, resetForcedToolChoiceCompatForTests, resolveOpenAiToolChoice, } from './tool-choice.js';
+export class OpenAICompatProvider {
+    baseUrl;
+    apiKey;
+    model;
+    temperature;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/$/, '');
+        this.apiKey = options.apiKey;
+        this.model = options.model;
+        this.temperature = options.temperature;
+    }
+    async listModels() {
+        try {
+            const headers = new Headers();
+            if (this.apiKey) {
+                headers.set('Authorization', `Bearer ${this.apiKey}`);
+            }
+            const res = await fetch(`${this.baseUrl}/v1/models`, { headers });
+            if (!res.ok) {
+                return [this.model];
+            }
+            const data = (await res.json());
+            const models = (data.data || []).map(item => item.id).filter((item) => Boolean(item));
+            return models.length ? models : [this.model];
+        }
+        catch {
+            return [this.model];
+        }
+    }
+    async generate(request) {
+        const headers = new Headers({
+            'Content-Type': 'application/json',
+        });
+        if (this.apiKey) {
+            headers.set('Authorization', `Bearer ${this.apiKey}`);
+        }
+        const payload = {
+            model: request.model || this.model,
+            messages: request.messages.map(message => this.mapMessage(message)),
+            temperature: request.temperature ?? this.temperature ?? 0.3,
+            stream: false,
+        };
+        const tools = this.mapTools(request.tools || []);
+        if (tools.length) {
+            payload.tools = tools;
+            // harness 路由判定"需要本轮新数据"时传 'required'。thinking/reasoner
+            // 模型（以及上次 400 过的未知模型）会在 resolveOpenAiToolChoice 里降成 auto。
+            payload.tool_choice = resolveOpenAiToolChoice(String(payload.model), request.toolChoice);
+        }
+        const endpoint = `${this.baseUrl}/v1/chat/completions`;
+        const maxAttempts = payload.tool_choice === 'required' ? 2 : 1;
+        let lastStatus = 0;
+        let lastErrorText = '';
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            let res;
+            try {
+                res = await fetch(endpoint, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(payload),
+                    signal: request.signal,
+                });
+            }
+            catch (err) {
+                if (request.signal?.aborted) {
+                    throw err instanceof Error ? err : new Error(String(err));
+                }
+                const cause = err instanceof Error ? err.message : String(err);
+                throw new Error(`无法连接 OpenAI 兼容网关 (${this.baseUrl})，请检查 baseUrl / 网络。原始错误: ${cause}`);
+            }
+            if (res.ok) {
+                const data = (await res.json());
+                return this.mapResult(data);
+            }
+            lastErrorText = await res.text();
+            lastStatus = res.status;
+            const canRetry = attempt === 0 &&
+                payload.tool_choice === 'required' &&
+                isForcedToolChoiceRejected(res.status, lastErrorText);
+            if (!canRetry)
+                break;
+            rememberForcedToolChoiceRejected(String(payload.model));
+            payload.tool_choice = 'auto';
+            console.info('[openai-compat] tool_choice=required rejected; retrying with auto', {
+                model: payload.model,
+                status: res.status,
+            });
+        }
+        const ctx = `model=${payload.model} baseUrl=${this.baseUrl}`;
+        if (lastStatus === 401 || lastStatus === 403) {
+            throw new Error(`OpenAI 兼容网关鉴权失败 (${lastStatus}) [${ctx}]，请检查 API Key。`);
+        }
+        throw new Error(`OpenAI 兼容请求失败: ${lastStatus} [${ctx}] ${lastErrorText}`);
+    }
+    mapResult(data) {
+        const message = data.choices?.[0]?.message;
+        const content = message?.content || '';
+        const reasoningContent = message?.reasoning_content || undefined;
+        const toolCalls = (message?.tool_calls || []).map(item => {
+            const fnArgs = item.function?.arguments || '{}';
+            let parsed = {};
+            try {
+                parsed = JSON.parse(fnArgs);
+            }
+            catch {
+                parsed = {};
+            }
+            return {
+                id: item.id || randomUUID(),
+                name: item.function?.name || 'unknown_tool',
+                arguments: parsed,
+            };
+        });
+        return {
+            content,
+            toolCalls,
+            reasoningContent,
+            tokensUsed: {
+                prompt: Number(data.usage?.prompt_tokens || 0),
+                completion: Number(data.usage?.completion_tokens || 0),
+                total: Number(data.usage?.total_tokens || 0),
+            },
+            raw: data,
+        };
+    }
+    mapTools(tools) {
+        return tools.map(tool => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.inputSchema || {
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: true,
+                },
+            },
+        }));
+    }
+    mapMessage(message) {
+        if (message.role === 'tool') {
+            return {
+                role: 'tool',
+                content: message.content,
+                tool_call_id: message.toolCallId || message.name || 'tool',
+            };
+        }
+        // assistant 消息：如果本轮触发了工具调用，必须把 tool_calls 一起发出去，
+        // 否则下一轮 messages 里的 `role: 'tool'` 会被 OpenAI 严格协议判为"孤儿"
+        // 报 400 (Messages with role 'tool' must be a response to a preceding
+        // message with 'tool_calls')。content 在这种情况下允许为空字符串。
+        //
+        // thinking 模式还要求 reasoning_content 必须原样回传——见
+        // LlmMessage.reasoningContent。非 thinking 模型该字段为 undefined，跳过
+        // 不影响兼容。
+        if (message.role === 'assistant') {
+            const out = {
+                role: 'assistant',
+                content: message.content || '',
+            };
+            if (message.toolCalls && message.toolCalls.length > 0) {
+                out.tool_calls = message.toolCalls.map((call) => ({
+                    id: call.id,
+                    type: 'function',
+                    function: {
+                        name: call.name,
+                        arguments: JSON.stringify(call.arguments ?? {}),
+                    },
+                }));
+            }
+            if (message.reasoningContent) {
+                out.reasoning_content = message.reasoningContent;
+            }
+            return out;
+        }
+        // W6-3: user messages carrying images use the OpenAI vision content-array
+        // form (`image_url` with a data URL). Text-only messages keep the plain
+        // string shorthand so existing wire bytes are unchanged.
+        if (message.role === 'user' && message.images && message.images.length > 0) {
+            return {
+                role: 'user',
+                content: [
+                    { type: 'text', text: message.content },
+                    ...message.images.map((img) => ({
+                        type: 'image_url',
+                        image_url: { url: `data:${img.mediaType};base64,${img.data}` },
+                    })),
+                ],
+            };
+        }
+        return {
+            role: message.role,
+            content: message.content,
+        };
+    }
+}

package/dist/llm/sidecar-provider.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `LlmProvider` implementation that delegates to the steerable-sidecar's
+ * `agent.chat.stream` JSON-RPC method.
+ *
+ * Activation:
+ *   Default-on once the sidecar is supervised (see `llm/index.ts`);
+ *   `STEERABLE_USE_SIDECAR=0` opts back out to in-process providers.
+ *
+ * The sidecar must already be supervised by the main process (see
+ * `src/sidecar/supervisor.ts`); this provider just routes calls through the
+ * supplied supervisor handle and aggregates streamed chunks back into the
+ * existing `LlmGenerateResult` shape so the rest of the local backend (router,
+ * harness, transcript) keeps working unchanged.
+ *
+ * NOTE: this is the first half of P5-agent-refactor. Tools are still dispatched
+ * by the local TS `ToolRouter`; tool-call delegation to the sidecar's
+ * `tool.invoke` method is tracked under p5-agent-refactor-phase2.
+ */
+import type { SidecarSupervisor } from '../sidecar/index.js';
+import type { LlmGenerateRequest, LlmGenerateResult, LlmGenerateStreamRequest, LlmProvider } from './types.js';
+export interface SidecarProviderOptions {
+    supervisor: SidecarSupervisor;
+    /** Wire-protocol provider name expected by the sidecar (openai_compat | anthropic | ollama). */
+    provider: string;
+    model: string;
+    baseUrl?: string;
+    apiKey?: string;
+    temperature?: number;
+}
+export declare class SidecarLlmProvider implements LlmProvider {
+    private readonly options;
+    constructor(options: SidecarProviderOptions);
+    listModels(): Promise<string[]>;
+    generate(request: LlmGenerateRequest): Promise<LlmGenerateResult>;
+    generateStream(request: LlmGenerateStreamRequest): Promise<LlmGenerateResult>;
+    private _stream;
+}