@gt-fe/eap-runtime 0.0.8

package/dist/providers/http-llm-provider.js

@@ -0,0 +1,404 @@
+/**
+ * HTTP LLM Provider — OpenAI 兼容 API
+ *
+ * 支持：
+ * - 真流式输出（stream: true + SSE chunk 解析）
+ * - function calling（tools / tool_choice 参数）
+ * - tool_calls 解析（同步 & 流式）
+ */
+import { resolveLlmModelName } from './resolve-llm-model.js';
+export class HttpLLMProvider {
+    apiKey;
+    baseUrl;
+    defaultModel;
+    timeoutMs;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl ?? 'https://api.openai.com/v1').replace(/\/$/, '');
+        this.defaultModel = config.defaultModel ?? 'DeepSeek-V4-Pro';
+        this.timeoutMs = config.timeoutMs ?? 60000;
+    }
+    async invoke(messages, config) {
+        const body = this.buildRequestBody(messages, config, false);
+        // [DEBUG] 打印真实发给 LLM 的请求（tools/system 是否齐全，定位 XML 伪 tool_call 问题）
+        if (process.env.EAP_LLM_DEBUG === '1') {
+            const firstMsg = Array.isArray(body.messages) && body.messages.length > 0
+                ? body.messages[0]
+                : null;
+            const systemHead = firstMsg && typeof firstMsg.content === 'string'
+                ? firstMsg.content.slice(0, 300)
+                : '';
+            console.log('[LLM-DEBUG] invoke request:', JSON.stringify({
+                model: body.model,
+                toolsCount: Array.isArray(body.tools) ? body.tools.length : 0,
+                toolNames: Array.isArray(body.tools)
+                    ? body.tools.map(t => t?.function?.name)
+                    : [],
+                messages: body.messages.map((m) => ({
+                    role: m.role,
+                    contentLen: String(m.content ?? '').length,
+                    hasToolCalls: Boolean(m.tool_calls || m.toolCalls),
+                    toolCallId: m.tool_call_id ?? m.toolCallId,
+                    hasReasoning: typeof m.reasoning_content === 'string' || typeof m.reasoningContent === 'string',
+                    reasoningLen: typeof m.reasoning_content === 'string'
+                        ? m.reasoning_content.length
+                        : typeof m.reasoningContent === 'string'
+                            ? m.reasoningContent.length
+                            : 0,
+                })),
+                systemPromptHead: systemHead,
+            }, null, 2));
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const url = `${this.baseUrl}/chat/completions`;
+        try {
+            let response;
+            try {
+                response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            catch (err) {
+                throw new Error(this.formatNetworkError(url, err));
+            }
+            if (!response.ok) {
+                const errText = await response.text();
+                throw new Error(`LLM API error ${response.status}: ${errText}`);
+            }
+            const data = (await response.json());
+            const choice = data.choices?.[0];
+            const content = choice?.message?.content ?? '';
+            const reasoningContent = typeof choice?.message?.reasoning_content === 'string'
+                ? choice.message.reasoning_content
+                : undefined;
+            const toolCalls = this.parseToolCalls(choice?.message?.tool_calls);
+            // [DEBUG] 打印 LLM 返回的原始 tool_calls 与 finish_reason
+            if (process.env.EAP_LLM_DEBUG === '1') {
+                console.log('[LLM-DEBUG] invoke response:', JSON.stringify({
+                    finishReason: choice?.finish_reason,
+                    toolCallsCount: toolCalls.length,
+                    toolCalls: toolCalls.map(tc => ({ id: tc.id, name: tc.name })),
+                    contentHead: content.slice(0, 300),
+                    reasoningLen: reasoningContent?.length ?? 0,
+                    usage: data.usage,
+                }, null, 2));
+            }
+            return {
+                content,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                ...(reasoningContent ? { reasoningContent } : {}),
+                inputTokens: data.usage?.prompt_tokens ?? 0,
+                outputTokens: data.usage?.completion_tokens ?? 0,
+                // model 字段优先级：config（用户显式配置） > data.model（网关返回，可能是路由别名如 "/mnt/fast"） > defaultModel
+                model: config.model ?? (typeof data.model === 'string' && !data.model.includes('/') ? data.model : undefined) ?? this.defaultModel,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async *stream(messages, config) {
+        const body = this.buildRequestBody(messages, config, true);
+        // [DEBUG] 打印流式请求（与 invoke 一致）
+        if (process.env.EAP_LLM_DEBUG === '1') {
+            const firstMsg = Array.isArray(body.messages) && body.messages.length > 0
+                ? body.messages[0]
+                : null;
+            const systemHead = firstMsg && typeof firstMsg.content === 'string'
+                ? firstMsg.content.slice(0, 300)
+                : '';
+            console.log('[LLM-DEBUG] stream request:', JSON.stringify({
+                model: body.model,
+                toolsCount: Array.isArray(body.tools) ? body.tools.length : 0,
+                toolNames: Array.isArray(body.tools)
+                    ? body.tools.map(t => t?.function?.name)
+                    : [],
+                messagesCount: Array.isArray(body.messages) ? body.messages.length : 0,
+                messages: Array.isArray(body.messages)
+                    ? body.messages.map((m) => ({
+                        role: m.role,
+                        contentLen: String(m.content ?? '').length,
+                        hasToolCalls: Boolean(m.tool_calls || m.toolCalls),
+                        hasReasoning: typeof m.reasoning_content === 'string',
+                        reasoningLen: typeof m.reasoning_content === 'string' ? m.reasoning_content.length : 0,
+                    }))
+                    : [],
+                systemPromptHead: systemHead,
+            }, null, 2));
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        const url = `${this.baseUrl}/chat/completions`;
+        try {
+            let response;
+            try {
+                response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.apiKey}`,
+                    },
+                    body: JSON.stringify(body),
+                    signal: controller.signal,
+                });
+            }
+            catch (err) {
+                throw new Error(this.formatNetworkError(url, err));
+            }
+            if (!response.ok) {
+                const errText = await response.text();
+                throw new Error(`LLM API error ${response.status}: ${errText}`);
+            }
+            if (!response.body) {
+                throw new Error('LLM API returned no response body for streaming');
+            }
+            // 真流式：逐 SSE chunk 解析
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            const toolCallAccumulators = new Map();
+            let inputTokens = 0;
+            let outputTokens = 0;
+            let usageEmitted = false;
+            let model = config.model ?? this.defaultModel;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                // 保留最后一个可能不完整的行
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed || !trimmed.startsWith('data: '))
+                        continue;
+                    const payload = trimmed.slice(6);
+                    if (payload === '[DONE]')
+                        continue;
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(payload);
+                    }
+                    catch {
+                        continue; // 跳过无法解析的 chunk
+                    }
+                    // 仅当 chunk.model 是合法模型名（不含 '/'）时覆盖，过滤掉网关返回的路由别名（如 "/mnt/fast"）
+                    if (chunk.model && typeof chunk.model === 'string' && !chunk.model.includes('/')) {
+                        model = chunk.model;
+                    }
+                    if (chunk.usage) {
+                        inputTokens = chunk.usage.prompt_tokens ?? 0;
+                        outputTokens = chunk.usage.completion_tokens ?? 0;
+                    }
+                    const delta = chunk.choices?.[0]?.delta;
+                    const finishReason = chunk.choices?.[0]?.finish_reason;
+                    // 累积 tool_calls delta
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index;
+                            if (!toolCallAccumulators.has(idx)) {
+                                toolCallAccumulators.set(idx, {
+                                    id: tc.id ?? '',
+                                    name: tc.function?.name ?? '',
+                                    arguments: '',
+                                });
+                            }
+                            const acc = toolCallAccumulators.get(idx);
+                            if (tc.id)
+                                acc.id = tc.id;
+                            if (tc.function?.name)
+                                acc.name = tc.function.name;
+                            if (tc.function?.arguments)
+                                acc.arguments += tc.function.arguments;
+                        }
+                    }
+                    // 产出内容 / reasoning chunk
+                    const content = delta?.content ?? '';
+                    const reasoningContent = typeof delta?.reasoning_content === 'string' ? delta.reasoning_content : '';
+                    const isEnd = finishReason === 'stop' || finishReason === 'tool_calls';
+                    const hasUsage = Boolean(chunk.usage);
+                    if (content || reasoningContent || isEnd) {
+                        const result = {
+                            content,
+                            isEnd,
+                            ...(reasoningContent ? { reasoningContent } : {}),
+                        };
+                        if (isEnd) {
+                            // usage 常在 finish 之后单独 chunk 到达；此处有则带上，无则留给收尾 chunk
+                            if (hasUsage || inputTokens > 0 || outputTokens > 0) {
+                                result.inputTokens = inputTokens;
+                                result.outputTokens = outputTokens;
+                                if (hasUsage)
+                                    usageEmitted = true;
+                            }
+                            if (toolCallAccumulators.size > 0) {
+                                result.toolCalls = this.finalizeToolCalls(toolCallAccumulators);
+                            }
+                        }
+                        yield result;
+                    }
+                    else if (hasUsage) {
+                        // OpenAI/兼容网关：stream_options.include_usage 的 usage 独立 chunk（choices 为空）
+                        usageEmitted = true;
+                        yield {
+                            content: '',
+                            isEnd: true,
+                            inputTokens,
+                            outputTokens,
+                            toolCalls: toolCallAccumulators.size > 0
+                                ? this.finalizeToolCalls(toolCallAccumulators)
+                                : undefined,
+                        };
+                    }
+                }
+            }
+            // 流结束仍未产出 usage 时，若有累计值再补一发（避免调用方锁死在 0）
+            if (!usageEmitted && (inputTokens > 0 || outputTokens > 0)) {
+                yield {
+                    content: '',
+                    isEnd: true,
+                    inputTokens,
+                    outputTokens,
+                    toolCalls: toolCallAccumulators.size > 0
+                        ? this.finalizeToolCalls(toolCallAccumulators)
+                        : undefined,
+                };
+            }
+            // [DEBUG] 流结束后打印累积 tool_calls
+            if (process.env.EAP_LLM_DEBUG === '1') {
+                console.log('[LLM-DEBUG] stream response summary:', JSON.stringify({
+                    toolCallsCount: toolCallAccumulators.size,
+                    toolNames: Array.from(toolCallAccumulators.values()).map(a => a.name),
+                    inputTokens,
+                    outputTokens,
+                }, null, 2));
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    // ─────────────────────────────────────────────
+    // Private helpers
+    // ─────────────────────────────────────────────
+    buildRequestBody(messages, config, stream) {
+        const apiMessages = [];
+        if (config.systemPrompt) {
+            apiMessages.push({ role: 'system', content: config.systemPrompt });
+        }
+        for (const m of messages) {
+            const msg = { role: m.role, content: m.content };
+            // DeepSeek thinking：assistant 须回传 reasoning_content（有则带上）
+            if (m.role === 'assistant' && typeof m.reasoningContent === 'string') {
+                msg.reasoning_content = m.reasoningContent;
+            }
+            // 如果消息来自 assistant 且包含 toolCalls，附带 tool_calls 字段
+            if (m.role === 'assistant' && m.toolCalls?.length) {
+                msg.tool_calls = m.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+                }));
+            }
+            // 如果消息是 tool 角色，附带 tool_call_id
+            if (m.role === 'tool') {
+                msg.tool_call_id = m.toolCallId ?? '';
+            }
+            apiMessages.push(msg);
+        }
+        const body = {
+            model: resolveLlmModelName(config.model, this.defaultModel),
+            messages: apiMessages,
+            temperature: config.temperature ?? 0.7,
+            max_tokens: config.maxTokens,
+            stream,
+        };
+        // 注入 tools 定义（function-calling）
+        if (config.tools?.length) {
+            body.tools = config.tools;
+            if (config.toolChoice !== undefined) {
+                body.tool_choice = config.toolChoice;
+            }
+        }
+        // 流式模式请求 usage 统计（OpenAI 兼容）
+        if (stream) {
+            body.stream_options = { include_usage: true };
+        }
+        return body;
+    }
+    /**
+     * 解析同步响应中的 tool_calls
+     */
+    parseToolCalls(rawCalls) {
+        if (!rawCalls?.length)
+            return [];
+        return rawCalls.map((tc) => {
+            let parsedArgs = {};
+            try {
+                parsedArgs = JSON.parse(tc.function.arguments);
+            }
+            catch {
+                parsedArgs = {};
+            }
+            return {
+                id: tc.id,
+                name: tc.function.name,
+                arguments: parsedArgs,
+            };
+        });
+    }
+    /**
+     * 将流式累积的 tool_calls 转换为最终结果
+     */
+    finalizeToolCalls(accumulators) {
+        const result = [];
+        for (const [, acc] of accumulators) {
+            let parsedArgs = {};
+            try {
+                parsedArgs = JSON.parse(acc.arguments);
+            }
+            catch {
+                parsedArgs = {};
+            }
+            result.push({
+                id: acc.id,
+                name: acc.name,
+                arguments: parsedArgs,
+            });
+        }
+        return result;
+    }
+    formatNetworkError(url, err) {
+        const detail = formatNetworkDetail(err);
+        return `LLM network error calling ${url}: ${detail}`;
+    }
+}
+function formatNetworkDetail(error, depth = 0) {
+    if (depth > 5)
+        return '...';
+    if (typeof AggregateError !== 'undefined' && error instanceof AggregateError) {
+        const nested = (error.errors ?? []).map((e) => formatNetworkDetail(e, depth + 1)).filter(Boolean);
+        return nested.length > 0 ? `AggregateError(${nested.join('; ')})` : 'AggregateError';
+    }
+    if (error instanceof Error) {
+        const cause = error.cause;
+        const base = error.message?.trim() || error.name || 'Error';
+        return cause !== undefined ? `${base} (cause: ${formatNetworkDetail(cause, depth + 1)})` : base;
+    }
+    if (typeof error === 'string')
+        return error;
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return 'Unknown error';
+    }
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,7 @@
+export { EchoLLMProvider, createDefaultLLMProvider } from './echo-llm-provider.js';
+export { HttpLLMProvider, type HttpLLMProviderConfig } from './http-llm-provider.js';
+export { RoutingLLMProvider, type RoutingLLMProviderConfig } from './routing-llm-provider.js';
+export { resolveLlmModelName, canOverrideGraphModel } from './resolve-llm-model.js';
+export { createLocalLlmProvider, requireLocalLlmConnections, resolveLocalLlmConnection, parseLocalLlmConnectionRefs, hydrateLocalLlmConnections, LLM_CONNECTIONS_ENV, } from './local-llm-provider.js';
+export type { LocalLlmConnection, LocalLlmConnectionRef, LocalLlmConnectionRefs, LocalLlmConnections, } from './local-llm-provider.js';
+export type { LLMToolDefinition } from '../graph/nodes/llm-node.js';

package/dist/providers/index.js

@@ -0,0 +1,5 @@
+export { EchoLLMProvider, createDefaultLLMProvider } from './echo-llm-provider.js';
+export { HttpLLMProvider } from './http-llm-provider.js';
+export { RoutingLLMProvider } from './routing-llm-provider.js';
+export { resolveLlmModelName, canOverrideGraphModel } from './resolve-llm-model.js';
+export { createLocalLlmProvider, requireLocalLlmConnections, resolveLocalLlmConnection, parseLocalLlmConnectionRefs, hydrateLocalLlmConnections, LLM_CONNECTIONS_ENV, } from './local-llm-provider.js';

package/dist/providers/local-llm-provider.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 本地多模型 LLM：按节点 model 选网关。仅 dev。
+ * 连接表里只带 apiKeyEnv，密钥从 process.env 读取，不进 JSON。
+ */
+import type { ILLMProvider } from '../graph/nodes/llm-node.js';
+export interface LocalLlmConnection {
+    baseUrl: string;
+    apiKey: string;
+}
+export interface LocalLlmConnectionRef {
+    baseUrl: string;
+    apiKeyEnv: string;
+}
+export interface LocalLlmConnectionRefs {
+    default?: LocalLlmConnectionRef;
+    byModel?: Record<string, LocalLlmConnectionRef>;
+}
+export interface LocalLlmConnections {
+    default?: LocalLlmConnection;
+    byModel?: Record<string, LocalLlmConnection>;
+}
+export declare const LLM_CONNECTIONS_ENV = "EAP_LLM_CONNECTIONS";
+export declare function parseLocalLlmConnectionRefs(env?: NodeJS.ProcessEnv): LocalLlmConnectionRefs;
+export declare function hydrateLocalLlmConnections(refs: LocalLlmConnectionRefs, env?: NodeJS.ProcessEnv): LocalLlmConnections;
+export declare function requireLocalLlmConnections(env?: NodeJS.ProcessEnv): LocalLlmConnections;
+export declare function resolveLocalLlmConnection(connections: LocalLlmConnections, model?: string): LocalLlmConnection;
+export declare function createLocalLlmProvider(connections?: LocalLlmConnections): ILLMProvider;

package/dist/providers/local-llm-provider.js

@@ -0,0 +1,105 @@
+/**
+ * 本地多模型 LLM：按节点 model 选网关。仅 dev。
+ * 连接表里只带 apiKeyEnv，密钥从 process.env 读取，不进 JSON。
+ */
+import { HttpLLMProvider } from './http-llm-provider.js';
+export const LLM_CONNECTIONS_ENV = 'EAP_LLM_CONNECTIONS';
+export function parseLocalLlmConnectionRefs(env = process.env) {
+    const raw = env[LLM_CONNECTIONS_ENV]?.trim();
+    if (raw) {
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`${LLM_CONNECTIONS_ENV} is not valid JSON.`);
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`${LLM_CONNECTIONS_ENV} must be a JSON object.`);
+        }
+        const refs = parsed;
+        return {
+            default: refs.default,
+            byModel: refs.byModel ?? {},
+        };
+    }
+    if (env.OPENAI_API_KEY) {
+        return {
+            default: {
+                baseUrl: env.OPENAI_BASE_URL || 'https://api.deepseek.com/v1',
+                apiKeyEnv: 'OPENAI_API_KEY',
+            },
+            byModel: {},
+        };
+    }
+    return { byModel: {} };
+}
+export function hydrateLocalLlmConnections(refs, env = process.env) {
+    const hydrate = (ref) => {
+        if (!ref?.apiKeyEnv)
+            return undefined;
+        const apiKey = env[ref.apiKeyEnv]?.trim();
+        if (!apiKey)
+            return undefined;
+        return { baseUrl: ref.baseUrl, apiKey };
+    };
+    const byModel = {};
+    for (const [name, ref] of Object.entries(refs.byModel ?? {})) {
+        const connection = hydrate(ref);
+        if (connection)
+            byModel[name] = connection;
+    }
+    return { default: hydrate(refs.default), byModel };
+}
+export function requireLocalLlmConnections(env = process.env) {
+    const refs = parseLocalLlmConnectionRefs(env);
+    const connections = hydrateLocalLlmConnections(refs, env);
+    if (!connections.default && Object.keys(connections.byModel ?? {}).length === 0) {
+        const wanted = [
+            refs.default?.apiKeyEnv,
+            ...Object.values(refs.byModel ?? {}).map((ref) => ref.apiKeyEnv),
+        ].filter((name, index, all) => Boolean(name) && all.indexOf(name) === index);
+        throw new Error(`Local LLM is configured but no API key resolved. Set ${wanted.join(' or ') || 'OPENAI_API_KEY'}.`);
+    }
+    return connections;
+}
+export function resolveLocalLlmConnection(connections, model) {
+    const named = model ? connections.byModel?.[model] : undefined;
+    const connection = named ?? connections.default;
+    if (!connection?.apiKey) {
+        throw new Error(model
+            ? `No local LLM gateway for model ${model}. Set runtime.llm.models["${model}"] in eap.config.json.`
+            : 'No local LLM gateway. Set runtime.llm in eap.config.json.');
+    }
+    return connection;
+}
+export function createLocalLlmProvider(connections = requireLocalLlmConnections()) {
+    return new LocalLlmProvider(connections);
+}
+class LocalLlmProvider {
+    connections;
+    cache = new Map();
+    constructor(connections) {
+        this.connections = connections;
+    }
+    invoke(messages, config) {
+        return this.providerFor(config.model).invoke(messages, config);
+    }
+    stream(messages, config) {
+        return this.providerFor(config.model).stream(messages, config);
+    }
+    providerFor(model) {
+        const connection = resolveLocalLlmConnection(this.connections, model);
+        const cacheKey = `${connection.baseUrl}\0${connection.apiKey}\0${model ?? ''}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
+        const provider = new HttpLLMProvider({
+            apiKey: connection.apiKey,
+            baseUrl: connection.baseUrl,
+            defaultModel: model,
+        });
+        this.cache.set(cacheKey, provider);
+        return provider;
+    }
+}

package/dist/providers/resolve-llm-model.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 解析实际发给上游 LLM 的 model 名。
+ *
+ * 优先级：
+ * 1. EAP_DEFAULT_MODEL — 仅 EAP_MODEL_FORCE=1 时压过 graph.model
+ * 2. graph 节点 config.model
+ * 3. Provider 构造时的 defaultModel / EAP_DEFAULT_MODEL（作兜底，不压 graph）
+ * 4. 内置兜底 DeepSeek-V4-Pro
+ *
+ * 生产与普通 dev：图内模型名优先。不要靠 EAP_DEPLOYMENT_CONTEXT=dev 盖掉多节点模型。
+ */
+export declare function canOverrideGraphModel(env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveLlmModelName(graphModel?: string | null, defaultModel?: string | null, env?: NodeJS.ProcessEnv): string;

package/dist/providers/resolve-llm-model.js

@@ -0,0 +1,30 @@
+/**
+ * 解析实际发给上游 LLM 的 model 名。
+ *
+ * 优先级：
+ * 1. EAP_DEFAULT_MODEL — 仅 EAP_MODEL_FORCE=1 时压过 graph.model
+ * 2. graph 节点 config.model
+ * 3. Provider 构造时的 defaultModel / EAP_DEFAULT_MODEL（作兜底，不压 graph）
+ * 4. 内置兜底 DeepSeek-V4-Pro
+ *
+ * 生产与普通 dev：图内模型名优先。不要靠 EAP_DEPLOYMENT_CONTEXT=dev 盖掉多节点模型。
+ */
+export function canOverrideGraphModel(env = process.env) {
+    return env.EAP_MODEL_FORCE === '1';
+}
+export function resolveLlmModelName(graphModel, defaultModel, env = process.env) {
+    const fromEnv = env.EAP_DEFAULT_MODEL?.trim();
+    if (fromEnv && canOverrideGraphModel(env)) {
+        return fromEnv;
+    }
+    return (specifiedModel(graphModel) ||
+        specifiedModel(defaultModel) ||
+        fromEnv ||
+        'DeepSeek-V4-Pro');
+}
+function specifiedModel(value) {
+    const trimmed = value?.trim();
+    if (!trimmed || trimmed.toLowerCase() === 'default')
+        return undefined;
+    return trimmed;
+}

package/dist/providers/routing-llm-provider.d.ts

@@ -0,0 +1,28 @@
+/**
+ * RoutingLLMProvider — 基于 Foundation Service 模型路由的 LLM Provider
+ *
+ * 工作流程：
+ * 1. 请求 Foundation `/models/select` 选择最佳模型
+ * 2. Foundation 返回模型名称 + Provider 连接配置（baseUrl/apiKey/headers）
+ * 3. 用返回的连接配置创建 HttpLLMProvider，发送请求
+ *
+ * 设计原则：
+ * - Runtime 不存任何 LLM 凭证，全部从 Foundation 获取
+ * - 支持任意 OpenAI 兼容 API（OpenAI / DeepSeek / 本地 Ollama 等）
+ * - 连接配置由 Foundation 统一管理，Runtime 无感知
+ */
+import type { GraphMessage } from '../graph/contracts/executable-graph.js';
+import type { ILLMProvider, LLMNodeConfig, LLMResponse, LLMChunk } from '../graph/nodes/llm-node.js';
+export interface RoutingLLMProviderConfig {
+    foundationUrl: string;
+    fallbackProvider?: ILLMProvider;
+}
+export declare class RoutingLLMProvider implements ILLMProvider {
+    private readonly foundationUrl;
+    private readonly fallback;
+    constructor(config: RoutingLLMProviderConfig);
+    invoke(messages: GraphMessage[], config: LLMNodeConfig): Promise<LLMResponse>;
+    stream(messages: GraphMessage[], config: LLMNodeConfig): AsyncIterableIterator<LLMChunk>;
+    private selectModel;
+    private createProviderForModel;
+}