@keo-ai/axiom 0.1.3 → 0.1.5

package/dist/function_call_loop/types.d.ts

@@ -0,0 +1,206 @@
+/**
+ * LLM 对话消息。支持 system、user、assistant、tool 四种角色。
+ * assistant 角色可携带 tool_calls；tool 角色需携带 tool_call_id。
+ */
+export interface Message {
+    readonly role: 'system' | 'user' | 'assistant' | 'tool';
+    readonly content: string;
+    readonly tool_calls?: ReadonlyArray<ToolCall>;
+    readonly tool_call_id?: string;
+}
+/**
+ * LLM 返回的工具调用。
+ */
+export interface ToolCall {
+    readonly id: string;
+    readonly type: 'function';
+    readonly function: {
+        readonly name: string;
+        readonly arguments: string;
+    };
+}
+/**
+ * 暴露给 LLM 的工具定义。
+ */
+export interface ToolDefinition {
+    readonly type: 'function';
+    readonly function: {
+        readonly name: string;
+        readonly description: string;
+        readonly parameters: unknown;
+    };
+}
+/**
+ * Harness 记录的执行状态。
+ */
+export type HarnessRecordStatus = 'pending' | 'success' | 'error' | 'timeout' | 'cancelled';
+/**
+ * 单条执行历史记录。
+ */
+export interface HarnessRecord {
+    readonly id: string;
+    readonly turn: number;
+    readonly globalIndex: number;
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly rawArgs: string;
+    readonly status: HarnessRecordStatus;
+    readonly result?: unknown;
+    readonly error?: string;
+    readonly startedAt: number;
+    readonly durationMs: number;
+}
+/**
+ * 执行前事件。
+ */
+export interface ToolExecutionStartEvent {
+    readonly type: 'execution:start';
+    readonly callId: string;
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly turn: number;
+}
+/**
+ * 执行后事件（同时携带结果）。
+ */
+export interface ToolExecutionEndEvent {
+    readonly type: 'execution:end';
+    readonly callId: string;
+    readonly toolName: string;
+    readonly status: HarnessRecordStatus;
+    readonly durationMs: number;
+    readonly result?: unknown;
+    readonly error?: string;
+    readonly turn: number;
+}
+/**
+ * Loop 生命周期事件。
+ */
+export type LoopEvent = ToolExecutionStartEvent | ToolExecutionEndEvent;
+/**
+ * Tool 发现函数的返回结果。
+ */
+export interface ToolDiscoverResult {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: unknown;
+    readonly visible: boolean;
+}
+/**
+ * Tool 执行上下文。
+ */
+export interface ToolExecuteContext {
+    readonly harness: ReadonlyArray<HarnessRecord>;
+    readonly turn: number;
+    readonly metadata: unknown;
+}
+/**
+ * Tool 审批配置。
+ * 当 tool 被调用时，先执行 createTicket 生成审批单，暂停 Loop 等待外部审批。
+ * createTicket 可通过 context.metadata 访问 LoopConfig 传入的 metadata，用于携带业务上下文（如用户ID、会话ID等）。
+ * 审批通过后恢复执行时，应通过某种方式（如 createTicket 内部查库）让 Loop 直接执行，无需去掉 approval 配置。
+ */
+export interface ApprovalConfig {
+    readonly createTicket: (args: unknown, context: ToolExecuteContext) => Promise<{
+        ticketId: string;
+        approved?: boolean;
+    }>;
+}
+/**
+ * 注册到 Loop 中的 Tool。
+ */
+export interface Tool {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: unknown;
+    readonly discover?: (harness: ReadonlyArray<HarnessRecord>, metadata: unknown) => ToolDiscoverResult | Promise<ToolDiscoverResult>;
+    readonly execute: (args: unknown, context: ToolExecuteContext) => unknown | Promise<unknown>;
+    readonly approval?: ApprovalConfig;
+}
+/**
+ * Turn Policy 决策结果。
+ */
+export interface TurnPolicyResult {
+    /** 继续执行前作为 system 消息注入 */
+    readonly injectMessage?: string;
+}
+/**
+ * 全局轮次策略。
+ */
+export type TurnPolicy = (harness: ReadonlyArray<HarnessRecord>, turn: number, metadata: unknown) => TurnPolicyResult | Promise<TurnPolicyResult>;
+/**
+ * 上下文压缩配置。
+ */
+export interface CompactConfig {
+    readonly keepRounds: number;
+    readonly compress: (messages: ReadonlyArray<ReadonlyArray<Message>>) => Message[] | Promise<Message[]>;
+}
+/**
+ * LLM 调用可选参数。
+ */
+export interface LLMCallOptions {
+    readonly model?: string;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly topP?: number;
+    readonly reasoningEffort?: 'low' | 'medium' | 'high';
+}
+/**
+ * LLM 调用接口。由外部注入，Loop 内部不绑定具体 Provider。
+ */
+export interface LLMCaller {
+    readonly call: (messages: ReadonlyArray<Message>, tools: ReadonlyArray<ToolDefinition>, options?: LLMCallOptions) => Promise<{
+        readonly content: string | null;
+        readonly tool_calls?: ReadonlyArray<ToolCall>;
+    }>;
+}
+/**
+ * Loop 配置。
+ */
+export interface LoopConfig {
+    /** 初始消息列表，直接作为对话起点 */
+    readonly messages: ReadonlyArray<Message>;
+    readonly tools: ReadonlyArray<Tool>;
+    readonly llmCaller?: LLMCaller;
+    readonly maxTurns?: number;
+    readonly turnPolicy?: TurnPolicy;
+    readonly compact?: CompactConfig;
+    readonly metadata?: unknown;
+    /** 告警文本：当 turnPolicy 未自定义且当前轮次等于 maxTurns - 1 时塞入 Messages */
+    readonly warningMessage?: string;
+    /** 终止文本：当 turnPolicy 未自定义且当前轮次等于 maxTurns 时塞入 Messages */
+    readonly terminateMessage?: string;
+    /** 事件监听器 */
+    readonly onEvent?: (event: LoopEvent) => void | Promise<void>;
+    /** 取消信号 */
+    readonly signal?: AbortSignal;
+    /** 模型名称。未设置时从环境变量或 Provider 默认值读取 */
+    readonly model?: import('../llm_provider/models').Model;
+    /** 采样温度，范围 0~2 */
+    readonly temperature?: number;
+    /** 单次 LLM 调用的最大输出 token 数 */
+    readonly maxTokens?: number;
+    /** 核采样概率阈值，范围 0~1 */
+    readonly topP?: number;
+    /** 推理深度。仅部分模型支持 */
+    readonly reasoningEffort?: 'low' | 'medium' | 'high';
+}
+/**
+ * 待审批信息。
+ */
+export interface PendingApprovalInfo {
+    readonly ticketId: string;
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly callId: string;
+}
+/**
+ * Loop 执行结果。
+ */
+export interface LoopResult {
+    readonly messages: Message[];
+    readonly harness: ReadonlyArray<HarnessRecord>;
+    readonly finalContent: string | null;
+    readonly turns: number;
+    readonly pendingApproval?: PendingApprovalInfo;
+}

package/dist/function_call_loop/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -26,9 +26,12 @@ export type { LLMProvider, PredictorOptions } from './predict';
 export { Predictor } from './predict';
 /** 百炼 Provider 实现 */
 export { BailianProvider } from './predict';
-/** 模型注册表，定义模型与 Provider 的映射关系 */
-export { MODEL_REGISTRY } from './predict';
-export type { Model, PredictConfig, PredictWithMessagesConfig } from './predict';
+/** 模型注册表与枚举，定义模型与 Provider 的映射关系 */
+export { MODEL_REGISTRY } from './llm_provider';
+export type { Model } from './llm_provider';
+export type { PredictConfig, PredictWithMessagesConfig } from './predict';
 /** 向量检索（Embedding + pgvector + Rerank） */
 export { EmbeddingSearch, embed } from './embedding_search';
 export type { EmbeddingSearchConfig, SearchResult } from './embedding_search';
+/** Function Call Loop */
+export * as FunctionCallLoop from './function_call_loop';

package/dist/index.js

@@ -19,8 +19,41 @@
  *
  * @packageDocumentation
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.embed = exports.EmbeddingSearch = exports.MODEL_REGISTRY = exports.BailianProvider = exports.Predictor = exports.LLM = void 0;
+exports.FunctionCallLoop = exports.embed = exports.EmbeddingSearch = exports.MODEL_REGISTRY = exports.BailianProvider = exports.Predictor = exports.LLM = void 0;
 /** LLM 静态入口类，封装 Provider 连接、故障转移和返回解析 */
 var predict_1 = require("./predict");
 Object.defineProperty(exports, "LLM", { enumerable: true, get: function () { return predict_1.LLM; } });
@@ -30,10 +63,12 @@ Object.defineProperty(exports, "Predictor", { enumerable: true, get: function ()
 /** 百炼 Provider 实现 */
 var predict_3 = require("./predict");
 Object.defineProperty(exports, "BailianProvider", { enumerable: true, get: function () { return predict_3.BailianProvider; } });
-/** 模型注册表，定义模型与 Provider 的映射关系 */
-var predict_4 = require("./predict");
-Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return predict_4.MODEL_REGISTRY; } });
+/** 模型注册表与枚举，定义模型与 Provider 的映射关系 */
+var llm_provider_1 = require("./llm_provider");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return llm_provider_1.MODEL_REGISTRY; } });
 /** 向量检索（Embedding + pgvector + Rerank） */
 var embedding_search_1 = require("./embedding_search");
 Object.defineProperty(exports, "EmbeddingSearch", { enumerable: true, get: function () { return embedding_search_1.EmbeddingSearch; } });
 Object.defineProperty(exports, "embed", { enumerable: true, get: function () { return embedding_search_1.embed; } });
+/** Function Call Loop */
+exports.FunctionCallLoop = __importStar(require("./function_call_loop"));

package/dist/llm_provider/bailian.d.ts

@@ -0,0 +1,28 @@
+import type { LLMProvider } from './llm';
+import type { LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+/**
+ * 阿里云百炼（兼容 OpenAI 协议）Provider 实现。
+ * 支持非流式调用和流式 SSE 输出。
+ */
+export declare class BailianProvider implements LLMProvider {
+    readonly config: ProviderConfig;
+    readonly name = "bailian";
+    private static readonly SUPPORTED_MODELS;
+    constructor(config: ProviderConfig);
+    supports(model: string): boolean;
+    /**
+     * 发送非流式 chat completion 请求到百炼服务。
+     * @param request - 标准化 LLM 请求
+     * @returns 解析后的模型响应（含 content、usage、model）
+     * @throws Error - 网络异常时抛 `[bailian] ...`；HTTP 非 2xx 时抛 `[bailian] HTTP {status}: ...`
+     */
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * 发送流式 chat completion 请求，解析 SSE 响应逐块返回。
+     * @param request - 标准化 LLM 请求
+     * @yields 内容片段（`content`）或结束标记（`finish`）
+     * @throws Error - 网络异常或 HTTP 错误时抛出
+     */
+    stream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    private buildRequestBody;
+}

package/dist/llm_provider/bailian.js

@@ -0,0 +1,174 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BailianProvider = void 0;
+const index_1 = require("./index");
+/**
+ * 阿里云百炼（兼容 OpenAI 协议）Provider 实现。
+ * 支持非流式调用和流式 SSE 输出。
+ */
+class BailianProvider {
+    constructor(config) {
+        this.config = config;
+        this.name = 'bailian';
+    }
+    supports(model) {
+        return BailianProvider.SUPPORTED_MODELS.has(model);
+    }
+    /**
+     * 发送非流式 chat completion 请求到百炼服务。
+     * @param request - 标准化 LLM 请求
+     * @returns 解析后的模型响应（含 content、usage、model）
+     * @throws Error - 网络异常时抛 `[bailian] ...`；HTTP 非 2xx 时抛 `[bailian] HTTP {status}: ...`
+     */
+    generate(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const body = this.buildRequestBody(request);
+            const data = yield (0, index_1.callChatCompletions)(this.config.baseUrl, this.config.apiKey, Object.assign(Object.assign({}, body), { stream: false }), this.name);
+            const choice = data.choices[0];
+            return {
+                content: choice.message.content,
+                usage: data.usage
+                    ? {
+                        promptTokens: data.usage.prompt_tokens,
+                        completionTokens: data.usage.completion_tokens,
+                        totalTokens: data.usage.total_tokens,
+                    }
+                    : undefined,
+                model: (_a = data.model) !== null && _a !== void 0 ? _a : body.model,
+            };
+        });
+    }
+    /**
+     * 发送流式 chat completion 请求，解析 SSE 响应逐块返回。
+     * @param request - 标准化 LLM 请求
+     * @yields 内容片段（`content`）或结束标记（`finish`）
+     * @throws Error - 网络异常或 HTTP 错误时抛出
+     */
+    stream(request) {
+        return __asyncGenerator(this, arguments, function* stream_1() {
+            var _a, _b;
+            const url = `${this.config.baseUrl}/chat/completions`;
+            const body = this.buildRequestBody(request);
+            let response;
+            try {
+                response = yield __await(fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.config.apiKey}`,
+                    },
+                    body: JSON.stringify(Object.assign(Object.assign({}, body), { stream: true })),
+                }));
+            }
+            catch (cause) {
+                throw new Error(`[${this.name}] ${cause instanceof Error ? cause.message : String(cause)}`);
+            }
+            if (!response.ok) {
+                const text = yield __await(response.text());
+                throw new Error(`[${this.name}] HTTP ${response.status}: ${text}`);
+            }
+            if (!response.body) {
+                throw new Error(`[${this.name}] Response body is null`);
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = yield __await(reader.read());
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = (_a = lines.pop()) !== null && _a !== void 0 ? _a : '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || !trimmed.startsWith('data: '))
+                            continue;
+                        const data = trimmed.slice(6);
+                        if (data === '[DONE]')
+                            continue;
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(data);
+                        }
+                        catch (_c) {
+                            continue;
+                        }
+                        const choice = (_b = parsed.choices) === null || _b === void 0 ? void 0 : _b[0];
+                        if (!choice)
+                            continue;
+                        const delta = choice.delta;
+                        if (delta.content) {
+                            yield yield __await({ type: 'content', delta: delta.content });
+                        }
+                        if (choice.finish_reason && parsed.usage) {
+                            yield yield __await({
+                                type: 'finish',
+                                usage: {
+                                    promptTokens: parsed.usage.prompt_tokens,
+                                    completionTokens: parsed.usage.completion_tokens,
+                                    totalTokens: parsed.usage.total_tokens,
+                                },
+                            });
+                        }
+                    }
+                }
+                yield yield __await({ type: 'finish' });
+            }
+            finally {
+                reader.releaseLock();
+            }
+        });
+    }
+    buildRequestBody(request) {
+        var _a;
+        return {
+            model: (_a = request.model) !== null && _a !== void 0 ? _a : this.config.defaultModel,
+            messages: request.messages.map((m) => ({
+                role: m.role,
+                content: m.content,
+            })),
+            temperature: request.temperature,
+            max_tokens: request.maxTokens,
+            top_p: request.topP,
+            response_format: request.responseFormat
+                ? { type: request.responseFormat === 'json' ? 'json_object' : 'text' }
+                : undefined,
+        };
+    }
+}
+exports.BailianProvider = BailianProvider;
+BailianProvider.SUPPORTED_MODELS = new Set([
+    'qwen3.7-max',
+    'qwen-plus',
+    'qwen-turbo',
+    'qwq-plus',
+    'deepseek-v4-pro',
+    'deepseek-v4-flash',
+    'kimi-k2.6',
+    'qwen-vl-plus',
+]);

package/dist/llm_provider/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * LLM Provider 底层 HTTP 调用层。
+ * Predict 模块和 Function Call Loop 模块共用，只负责纯粹的请求/响应/错误处理。
+ */
+export interface OpenAIChatMessage {
+    role: string;
+    content: string | null;
+    tool_calls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    tool_call_id?: string;
+}
+export interface OpenAIChatTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: unknown;
+    };
+}
+export interface OpenAIChatRequest {
+    model: string;
+    messages: OpenAIChatMessage[];
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    tools?: OpenAIChatTool[];
+    response_format?: {
+        type: 'text' | 'json_object';
+    };
+    stream?: boolean;
+}
+export interface OpenAIChatResponse {
+    choices: Array<{
+        message: {
+            content: string | null;
+            tool_calls?: Array<{
+                id: string;
+                type: 'function';
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+            }>;
+        };
+        finish_reason: string | null;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    model?: string;
+}
+/**
+ * 发送 OpenAI 兼容的 chat completions 请求。
+ * 只做 HTTP 层：构造请求、fetch、错误处理、基础解析。
+ * 业务层（请求体组装、结果转换）由调用方负责。
+ */
+export declare function callChatCompletions(baseUrl: string, apiKey: string, body: OpenAIChatRequest, errorPrefix?: string): Promise<OpenAIChatResponse>;
+/** 模型枚举与注册表 */
+export type { Model, ModelConfig } from './models';
+export { MODEL_REGISTRY } from './models';
+/** 标准化类型 */
+export type { Message, LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+/** Provider 接口与实现 */
+export type { LLMProvider } from './llm';
+export { BailianProvider } from './bailian';

package/dist/llm_provider/index.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * LLM Provider 底层 HTTP 调用层。
+ * Predict 模块和 Function Call Loop 模块共用，只负责纯粹的请求/响应/错误处理。
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BailianProvider = exports.MODEL_REGISTRY = void 0;
+exports.callChatCompletions = callChatCompletions;
+/**
+ * 发送 OpenAI 兼容的 chat completions 请求。
+ * 只做 HTTP 层：构造请求、fetch、错误处理、基础解析。
+ * 业务层（请求体组装、结果转换）由调用方负责。
+ */
+function callChatCompletions(baseUrl_1, apiKey_1, body_1) {
+    return __awaiter(this, arguments, void 0, function* (baseUrl, apiKey, body, errorPrefix = 'llm') {
+        var _a;
+        const url = `${baseUrl}/chat/completions`;
+        let response;
+        try {
+            response = yield fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (cause) {
+            throw new Error(`[${errorPrefix}] ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+        if (!response.ok) {
+            const text = yield response.text();
+            throw new Error(`[${errorPrefix}] HTTP ${response.status}: ${text}`);
+        }
+        let data;
+        try {
+            data = (yield response.json());
+        }
+        catch (cause) {
+            throw new Error(`[${errorPrefix}] Failed to parse response: ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+        const choice = (_a = data.choices) === null || _a === void 0 ? void 0 : _a[0];
+        if (!choice) {
+            throw new Error(`[${errorPrefix}] No choice in response`);
+        }
+        return data;
+    });
+}
+var models_1 = require("./models");
+Object.defineProperty(exports, "MODEL_REGISTRY", { enumerable: true, get: function () { return models_1.MODEL_REGISTRY; } });
+var bailian_1 = require("./bailian");
+Object.defineProperty(exports, "BailianProvider", { enumerable: true, get: function () { return bailian_1.BailianProvider; } });

package/dist/llm_provider/llm.d.ts

@@ -0,0 +1,32 @@
+import type { LLMRequest, LLMResponse, ProviderConfig, StreamChunk } from './types';
+/**
+ * LLM Provider 抽象接口。每个 Provider 实现负责对接具体的模型服务
+ *（如百炼、OpenAI、Anthropic 等），处理 HTTP 请求、流式解析和错误转换。
+ */
+export interface LLMProvider {
+    /** Provider 标识名，用于路由和故障转移日志 */
+    readonly name: string;
+    /** Provider 配置（API Key、Base URL、默认模型等） */
+    readonly config: ProviderConfig;
+    /**
+     * 校验当前 Provider 是否支持指定模型。
+     * 框架层在 MODEL_REGISTRY 候选过滤后，再调用此方法做二次确认。
+     * @param model - 模型标识名
+     * @returns true 表示支持，false 表示不支持（将自动轮询下一个候选）
+     */
+    supports(model: string): boolean;
+    /**
+     * 发送非流式请求，返回完整的模型响应。
+     * @param request - LLM 请求参数
+     * @returns 模型生成的完整响应
+     * @throws 网络异常、HTTP 错误、解析失败等均抛 {@link Error}
+     */
+    generate(request: LLMRequest): Promise<LLMResponse>;
+    /**
+     * 发送流式请求，逐块返回模型输出。
+     * @param request - LLM 请求参数
+     * @yields 内容片段或结束标记
+     * @throws 网络异常、HTTP 错误等均抛 {@link Error}
+     */
+    stream(request: LLMRequest): AsyncGenerator<StreamChunk, void, unknown>;
+}

package/dist/llm_provider/llm.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/llm_provider/models.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 支持的模型枚举。项目层通过此枚举选择模型，Axiom 内部路由到对应 Provider。
+ */
+export type Model = 'qwen3.7-max' | 'qwen-plus' | 'qwen-turbo' | 'qwq-plus' | 'deepseek-v4-pro' | 'deepseek-v4-flash' | 'kimi-k2.6' | 'qwen-vl-plus';
+/** 模型到 Provider 的映射配置 */
+export interface ModelConfig {
+    readonly model: string;
+    readonly provider: string;
+}
+/**
+ * 模型注册表。每个模型对应一个或多个 Provider 候选，按优先级排序。
+ * 当首选 Provider 失败时，Predictor 按此表顺序尝试下一个。
+ */
+export declare const MODEL_REGISTRY: Readonly<Record<Model, ReadonlyArray<ModelConfig>>>;