@actalk/inkos-core 1.2.0 → 1.3.0

package/dist/llm/provider.js

@@ -1,5 +1,5 @@
-import OpenAI from "openai";
-import Anthropic from "@anthropic-ai/sdk";
+import { streamSimple as piStreamSimple, stream as piStream, completeSimple as piCompleteSimple, complete as piComplete, } from "@mariozechner/pi-ai";
+import { resolveServicePreset } from "./service-presets.js";
 export function createStreamMonitor(onProgress, intervalMs = 30000) {
     let totalChars = 0;
     let chineseChars = 0;
@@ -45,31 +45,42 @@ export function createLLMClient(config) {
     };
     const apiFormat = config.apiFormat ?? "chat";
     const stream = config.stream ?? true;
-    if (config.provider === "anthropic") {
-        // Anthropic SDK appends /v1/ internally — strip if user included it
-        const baseURL = config.baseUrl.replace(/\/v1\/?$/, "");
-        return {
-            provider: "anthropic",
-            apiFormat,
-            stream,
-            _anthropic: new Anthropic({ apiKey: config.apiKey, baseURL }),
-            defaults,
-        };
-    }
-    // openai or custom — both use OpenAI SDK
+    // --- Build pi-ai Model object ---
+    const serviceName = config.service ?? "custom";
+    const preset = resolveServicePreset(serviceName);
+    const piApi = resolvePiApi(serviceName, config.apiFormat, preset?.api);
+    const baseUrl = config.baseUrl || preset?.baseUrl || "";
     const extraHeaders = config.headers ?? parseEnvHeaders();
+    const provider = config.provider === "anthropic" ? "anthropic" : "openai";
+    const piModel = {
+        id: config.model,
+        name: config.model,
+        api: piApi,
+        provider,
+        baseUrl,
+        reasoning: (config.thinkingBudget ?? 0) > 0,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128_000,
+        maxTokens: config.maxTokens ?? 8192,
+        ...(extraHeaders ? { headers: extraHeaders } : {}),
+    };
     return {
-        provider: "openai",
+        provider,
+        service: serviceName,
         apiFormat,
         stream,
-        _openai: new OpenAI({
-            apiKey: config.apiKey,
-            baseURL: config.baseUrl,
-            ...(extraHeaders ? { defaultHeaders: extraHeaders } : {}),
-        }),
+        _piModel: piModel,
+        _apiKey: config.apiKey,
         defaults,
     };
 }
+function resolvePiApi(serviceName, apiFormat, presetApi) {
+    if (serviceName === "custom") {
+        return apiFormat === "responses" ? "openai-responses" : "openai-completions";
+    }
+    return (presetApi ?? "openai-completions");
+}
 function parseEnvHeaders() {
     const raw = process.env.INKOS_LLM_HEADERS;
     if (!raw)
@@ -173,15 +184,274 @@ function wrapLLMError(error, context) {
     }
     return error instanceof Error ? error : new Error(msg);
 }
-function wrapStreamRequiredError(streamError, syncError, context) {
-    const ctxLine = context
-        ? `\n  (baseUrl: ${context.baseUrl}, model: ${context.model})`
-        : "";
-    return new Error(`API 提供方要求使用流式请求（stream:true），不能回退到同步模式。` +
-        `\n  这次失败不是模型名错误，而是前一次流式请求先失败了，随后同步回退又被提供方拒绝。` +
-        `\n  建议：保持 stream:true，并检查该提供方/代理的 SSE 流是否稳定。` +
-        `\n  原始流式错误：${String(streamError)}` +
-        `\n  同步回退错误：${String(syncError)}${ctxLine}`);
+function shouldUseNativeCustomTransport(client) {
+    return client.provider === "openai" && client.service === "custom";
+}
+function buildCustomHeaders(client) {
+    return {
+        Authorization: `Bearer ${client._apiKey ?? ""}`,
+        "Content-Type": "application/json",
+        ...(client._piModel?.headers ?? {}),
+    };
+}
+function joinSystemPrompt(messages) {
+    const systemParts = messages
+        .filter((message) => message.role === "system" && message.content.trim().length > 0)
+        .map((message) => message.content.trim());
+    return systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
+}
+function buildChatMessages(messages) {
+    return messages
+        .filter((message) => message.role !== "system")
+        .map((message) => ({
+        role: message.role,
+        content: message.content,
+    }));
+}
+function buildResponsesInput(messages) {
+    return messages
+        .filter((message) => message.role !== "system")
+        .map((message) => ({
+        role: message.role,
+        content: [{ type: "input_text", text: message.content }],
+    }));
+}
+async function readErrorResponse(res) {
+    const text = await res.text().catch(() => "");
+    try {
+        const json = JSON.parse(text);
+        if (typeof json.error === "string" && json.error)
+            return `${res.status} ${json.error}`;
+        if (json.error && typeof json.error === "object" && typeof json.error.message === "string") {
+            return `${res.status} ${json.error.message}`;
+        }
+        if (typeof json.detail === "string" && json.detail)
+            return `${res.status} ${json.detail}`;
+    }
+    catch {
+        // fall through
+    }
+    return `${res.status} ${text || res.statusText}`.trim();
+}
+function parseSseEvents(buffer) {
+    const chunks = buffer.split(/\n\n/);
+    const rest = chunks.pop() ?? "";
+    const events = [];
+    for (const chunk of chunks) {
+        const lines = chunk.split(/\r?\n/);
+        let eventName;
+        const dataLines = [];
+        for (const line of lines) {
+            if (line.startsWith("event:")) {
+                eventName = line.slice("event:".length).trim();
+            }
+            else if (line.startsWith("data:")) {
+                dataLines.push(line.slice("data:".length).trimStart());
+            }
+        }
+        if (eventName || dataLines.length > 0) {
+            events.push({
+                ...(eventName ? { event: eventName } : {}),
+                ...(dataLines.length > 0 ? { data: dataLines.join("\n") } : {}),
+            });
+        }
+    }
+    return { events, rest };
+}
+function extractChatContent(json) {
+    const content = json?.choices?.[0]?.message?.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => typeof item?.text === "string" ? item.text : typeof item?.content === "string" ? item.content : "")
+            .join("");
+    }
+    return "";
+}
+function extractResponsesContent(json) {
+    const output = Array.isArray(json?.output) ? json.output : [];
+    return output
+        .flatMap((item) => Array.isArray(item?.content) ? item.content : [])
+        .map((part) => {
+        if (typeof part?.text === "string")
+            return part.text;
+        if (typeof part?.content === "string")
+            return part.content;
+        if (typeof part?.output_text === "string")
+            return part.output_text;
+        return "";
+    })
+        .join("");
+}
+async function chatCompletionViaCustomOpenAICompatible(client, model, messages, resolved, onStreamProgress, onTextDelta) {
+    const baseUrl = client._piModel?.baseUrl ?? "";
+    const headers = buildCustomHeaders(client);
+    const errorCtx = { baseUrl, model };
+    const monitor = createStreamMonitor(onStreamProgress);
+    const extra = stripReservedKeys(resolved.extra);
+    if (client.apiFormat === "responses") {
+        const payload = {
+            model,
+            input: buildResponsesInput(messages),
+            stream: client.stream,
+            store: false,
+            max_output_tokens: resolved.maxTokens,
+            temperature: resolved.temperature,
+            ...extra,
+        };
+        const instructions = joinSystemPrompt(messages);
+        if (instructions)
+            payload.instructions = instructions;
+        const response = await fetch(`${baseUrl.replace(/\/$/, "")}/responses`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw wrapLLMError(new Error(await readErrorResponse(response)), errorCtx);
+        }
+        if (!client.stream) {
+            const json = await response.json();
+            const content = extractResponsesContent(json);
+            if (!content) {
+                throw wrapLLMError(new Error("LLM returned empty response"), errorCtx);
+            }
+            return {
+                content,
+                usage: {
+                    promptTokens: json?.usage?.input_tokens ?? 0,
+                    completionTokens: json?.usage?.output_tokens ?? 0,
+                    totalTokens: json?.usage?.total_tokens ?? 0,
+                },
+            };
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw wrapLLMError(new Error("Streaming body unavailable"), errorCtx);
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let content = "";
+        let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+        try {
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parsed = parseSseEvents(buffer);
+                buffer = parsed.rest;
+                for (const event of parsed.events) {
+                    if (!event.data)
+                        continue;
+                    const json = JSON.parse(event.data);
+                    if (json.type === "response.output_text.delta" && typeof json.delta === "string") {
+                        content += json.delta;
+                        monitor.onChunk(json.delta);
+                        onTextDelta?.(json.delta);
+                    }
+                    if (json.type === "response.completed") {
+                        usage = {
+                            promptTokens: json.response?.usage?.input_tokens ?? 0,
+                            completionTokens: json.response?.usage?.output_tokens ?? 0,
+                            totalTokens: json.response?.usage?.total_tokens ?? 0,
+                        };
+                        if (!content) {
+                            content = extractResponsesContent(json.response);
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            monitor.stop();
+        }
+        if (!content) {
+            throw wrapLLMError(new Error("LLM returned empty response from stream"), errorCtx);
+        }
+        return { content, usage };
+    }
+    const payload = {
+        model,
+        messages: [
+            ...messages
+                .filter((message) => message.role === "system")
+                .map((message) => ({ role: "system", content: message.content })),
+            ...buildChatMessages(messages),
+        ],
+        stream: client.stream,
+        temperature: resolved.temperature,
+        max_tokens: resolved.maxTokens,
+        ...extra,
+    };
+    if (client.stream) {
+        payload.stream_options = { include_usage: true };
+    }
+    const response = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        throw wrapLLMError(new Error(await readErrorResponse(response)), errorCtx);
+    }
+    if (!client.stream) {
+        const json = await response.json();
+        const content = extractChatContent(json);
+        if (!content) {
+            throw wrapLLMError(new Error("LLM returned empty response"), errorCtx);
+        }
+        return {
+            content,
+            usage: {
+                promptTokens: json?.usage?.prompt_tokens ?? 0,
+                completionTokens: json?.usage?.completion_tokens ?? 0,
+                totalTokens: json?.usage?.total_tokens ?? 0,
+            },
+        };
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw wrapLLMError(new Error("Streaming body unavailable"), errorCtx);
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let content = "";
+    let usage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    try {
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const parsed = parseSseEvents(buffer);
+            buffer = parsed.rest;
+            for (const event of parsed.events) {
+                if (!event.data || event.data === "[DONE]")
+                    continue;
+                const json = JSON.parse(event.data);
+                const delta = json?.choices?.[0]?.delta?.content;
+                if (typeof delta === "string") {
+                    content += delta;
+                    monitor.onChunk(delta);
+                    onTextDelta?.(delta);
+                }
+                if (json?.usage) {
+                    usage = {
+                        promptTokens: json.usage.prompt_tokens ?? usage.promptTokens,
+                        completionTokens: json.usage.completion_tokens ?? usage.completionTokens,
+                        totalTokens: json.usage.total_tokens ?? usage.totalTokens,
+                    };
+                }
+            }
+        }
+    }
+    finally {
+        monitor.stop();
+    }
+    if (!content) {
+        throw wrapLLMError(new Error("LLM returned empty response from stream"), errorCtx);
+    }
+    return { content, usage };
 }
 // === Simple Chat (used by all agents via BaseAgent.chat()) ===
 export async function chatCompletion(client, model, messages, options) {
@@ -194,21 +464,12 @@ export async function chatCompletion(client, model, messages, options) {
     };
     const onStreamProgress = options?.onStreamProgress;
     const onTextDelta = options?.onTextDelta;
-    const errorCtx = { baseUrl: client._openai?.baseURL ?? "(anthropic)", model };
+    const errorCtx = { baseUrl: client._piModel?.baseUrl ?? "(unknown)", model };
     try {
-        if (client.provider === "anthropic") {
-            return client.stream
-                ? await chatCompletionAnthropic(client._anthropic, model, messages, resolved, client.defaults.thinkingBudget, onStreamProgress, onTextDelta)
-                : await chatCompletionAnthropicSync(client._anthropic, model, messages, resolved, client.defaults.thinkingBudget, onTextDelta);
-        }
-        if (client.apiFormat === "responses") {
-            return client.stream
-                ? await chatCompletionOpenAIResponses(client._openai, model, messages, resolved, options?.webSearch, onStreamProgress, onTextDelta)
-                : await chatCompletionOpenAIResponsesSync(client._openai, model, messages, resolved, options?.webSearch, onTextDelta);
+        if (shouldUseNativeCustomTransport(client)) {
+            return await chatCompletionViaCustomOpenAICompatible(client, model, messages, resolved, onStreamProgress, onTextDelta);
         }
-        return client.stream
-            ? await chatCompletionOpenAIChat(client._openai, model, messages, resolved, options?.webSearch, onStreamProgress, onTextDelta)
-            : await chatCompletionOpenAIChatSync(client._openai, model, messages, resolved, options?.webSearch, onTextDelta);
+        return await chatCompletionViaPiAi(client, model, messages, resolved, onStreamProgress, onTextDelta);
     }
     catch (error) {
         // Stream interrupted but partial content is usable — return truncated response
@@ -218,51 +479,9 @@ export async function chatCompletion(client, model, messages, options) {
                 usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
             };
         }
-        // Auto-fallback: if streaming failed, retry with sync (many proxies don't support SSE)
-        if (client.stream) {
-            const isStreamRelated = isLikelyStreamError(error);
-            if (isStreamRelated) {
-                try {
-                    if (client.provider === "anthropic") {
-                        return await chatCompletionAnthropicSync(client._anthropic, model, messages, resolved, client.defaults.thinkingBudget);
-                    }
-                    if (client.apiFormat === "responses") {
-                        return await chatCompletionOpenAIResponsesSync(client._openai, model, messages, resolved, options?.webSearch);
-                    }
-                    return await chatCompletionOpenAIChatSync(client._openai, model, messages, resolved, options?.webSearch);
-                }
-                catch (syncError) {
-                    if (isStreamRequiredError(syncError)) {
-                        throw wrapStreamRequiredError(error, syncError, errorCtx);
-                    }
-                    throw wrapLLMError(syncError, errorCtx);
-                }
-            }
-        }
         throw wrapLLMError(error, errorCtx);
     }
 }
-function isLikelyStreamError(error) {
-    const msg = String(error).toLowerCase();
-    // Common indicators that streaming specifically is the problem:
-    // - SSE parse errors, chunked transfer issues, content-type mismatches
-    // - Some proxies return 400/415 when stream=true
-    // - "stream" mentioned in error, or generic network errors during streaming
-    return (msg.includes("stream") ||
-        msg.includes("text/event-stream") ||
-        msg.includes("chunked") ||
-        msg.includes("unexpected end") ||
-        msg.includes("premature close") ||
-        msg.includes("terminated") ||
-        msg.includes("econnreset") ||
-        (msg.includes("400") && !msg.includes("content")));
-}
-function isStreamRequiredError(error) {
-    const msg = String(error).toLowerCase();
-    return (msg.includes("stream must be set to true") ||
-        (msg.includes("stream") && msg.includes("must be set to true")) ||
-        (msg.includes("stream") && msg.includes("required")));
-}
 // === Tool-calling Chat (used by agent loop) ===
 export async function chatWithTools(client, model, messages, tools, options) {
     try {
@@ -270,375 +489,172 @@ export async function chatWithTools(client, model, messages, tools, options) {
             temperature: clampTemperatureForModel(model, options?.temperature ?? client.defaults.temperature),
             maxTokens: options?.maxTokens ?? client.defaults.maxTokens,
         };
-        // Tool-calling always uses streaming (only used by agent loop, not by writer/auditor)
-        if (client.provider === "anthropic") {
-            return await chatWithToolsAnthropic(client._anthropic, model, messages, tools, resolved, client.defaults.thinkingBudget);
-        }
-        if (client.apiFormat === "responses") {
-            return await chatWithToolsOpenAIResponses(client._openai, model, messages, tools, resolved);
-        }
-        return await chatWithToolsOpenAIChat(client._openai, model, messages, tools, resolved);
+        return await chatWithToolsViaPiAi(client, model, messages, tools, resolved);
     }
     catch (error) {
         throw wrapLLMError(error);
     }
 }
-// === OpenAI Chat Completions API Implementation (default) ===
-async function chatCompletionOpenAIChat(client, model, messages, options, webSearch, onStreamProgress, onTextDelta) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const createParams = {
-        model,
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: options.temperature,
-        max_tokens: options.maxTokens,
-        stream: true,
-        ...(webSearch ? { web_search_options: { search_context_size: "medium" } } : {}),
-        ...stripReservedKeys(options.extra),
-    };
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const stream = await client.chat.completions.create(createParams);
-    const chunks = [];
-    let inputTokens = 0;
-    let outputTokens = 0;
-    const monitor = createStreamMonitor(onStreamProgress);
-    try {
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta?.content;
-            if (delta) {
-                chunks.push(delta);
-                monitor.onChunk(delta);
-                onTextDelta?.(delta);
-            }
-            if (chunk.usage) {
-                inputTokens = chunk.usage.prompt_tokens ?? 0;
-                outputTokens = chunk.usage.completion_tokens ?? 0;
-            }
-        }
-    }
-    catch (streamError) {
-        monitor.stop();
-        const partial = chunks.join("");
-        if (partial.length >= MIN_SALVAGEABLE_CHARS) {
-            throw new PartialResponseError(partial, streamError);
-        }
-        throw streamError;
-    }
-    finally {
-        monitor.stop();
-    }
-    const content = chunks.join("");
-    if (!content)
-        throw new Error("LLM returned empty response from stream");
-    return {
-        content,
-        usage: {
-            promptTokens: inputTokens,
-            completionTokens: outputTokens,
-            totalTokens: inputTokens + outputTokens,
-        },
-    };
-}
-async function chatCompletionOpenAIChatSync(client, model, messages, options, _webSearch, onTextDelta) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const syncParams = {
-        model,
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        temperature: options.temperature,
-        max_tokens: options.maxTokens,
-        stream: false,
-        ...stripReservedKeys(options.extra),
-    };
-    const response = await client.chat.completions.create(syncParams);
-    const content = response.choices[0]?.message?.content ?? "";
-    if (!content)
-        throw new Error("LLM returned empty response");
-    onTextDelta?.(content);
-    return {
-        content,
-        usage: {
-            promptTokens: response.usage?.prompt_tokens ?? 0,
-            completionTokens: response.usage?.completion_tokens ?? 0,
-            totalTokens: response.usage?.total_tokens ?? 0,
-        },
-    };
+// === pi-ai Unified Implementation ===
+/**
+ * Build a pi-ai Model<Api> for a specific per-call model name.
+ * The base template comes from client._piModel (created in createLLMClient);
+ * we override .id / .name when the caller passes a different model string
+ * (e.g. agent overrides).
+ */
+function resolvePiModel(client, model) {
+    const base = client._piModel;
+    if (base.id === model)
+        return base;
+    return { ...base, id: model, name: model };
 }
-async function chatWithToolsOpenAIChat(client, model, messages, tools, options) {
-    const openaiMessages = agentMessagesToOpenAIChat(messages);
-    const openaiTools = tools.map((t) => ({
-        type: "function",
-        function: {
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-        },
-    }));
-    const stream = await client.chat.completions.create({
-        model,
-        messages: openaiMessages,
-        tools: openaiTools,
-        temperature: options.temperature,
-        max_tokens: options.maxTokens,
-        stream: true,
-    });
-    let content = "";
-    const toolCallMap = new Map();
-    for await (const chunk of stream) {
-        const delta = chunk.choices[0]?.delta;
-        if (delta?.content)
-            content += delta.content;
-        if (delta?.tool_calls) {
-            for (const tc of delta.tool_calls) {
-                const existing = toolCallMap.get(tc.index);
-                if (existing) {
-                    existing.arguments += tc.function?.arguments ?? "";
-                }
-                else {
-                    toolCallMap.set(tc.index, {
-                        id: tc.id ?? "",
-                        name: tc.function?.name ?? "",
-                        arguments: tc.function?.arguments ?? "",
-                    });
-                }
-            }
+/** Convert inkos LLMMessage[] to pi-ai Context. */
+function toPiContext(messages) {
+    const systemParts = messages.filter((m) => m.role === "system").map((m) => m.content);
+    const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
+    const piMessages = messages
+        .filter((m) => m.role !== "system")
+        .map((m) => {
+        if (m.role === "user") {
+            return { role: "user", content: m.content, timestamp: Date.now() };
         }
-    }
-    const toolCalls = [...toolCallMap.values()];
-    return { content, toolCalls };
+        // assistant
+        return {
+            role: "assistant",
+            content: [{ type: "text", text: m.content }],
+            api: "openai-completions",
+            provider: "openai",
+            model: "",
+            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+            stopReason: "stop",
+            timestamp: Date.now(),
+        };
+    });
+    return { systemPrompt, messages: piMessages };
 }
-function agentMessagesToOpenAIChat(messages) {
-    const result = [];
+/** Convert inkos AgentMessage[] to pi-ai Context (with tool calls/results). */
+function agentMessagesToPiContext(messages) {
+    const systemParts = messages.filter((m) => m.role === "system").map((m) => m.content);
+    const systemPrompt = systemParts.length > 0 ? systemParts.join("\n\n") : undefined;
+    const piMessages = [];
     for (const msg of messages) {
-        if (msg.role === "system") {
-            result.push({ role: "system", content: msg.content });
+        if (msg.role === "system")
             continue;
-        }
         if (msg.role === "user") {
-            result.push({ role: "user", content: msg.content });
+            piMessages.push({ role: "user", content: msg.content, timestamp: Date.now() });
             continue;
         }
         if (msg.role === "assistant") {
-            const assistantMsg = {
-                role: "assistant",
-                content: msg.content ?? null,
-            };
-            if (msg.toolCalls && msg.toolCalls.length > 0) {
-                assistantMsg.tool_calls = msg.toolCalls.map((tc) => ({
-                    id: tc.id,
-                    type: "function",
-                    function: { name: tc.name, arguments: tc.arguments },
-                }));
+            const content = [];
+            if (msg.content)
+                content.push({ type: "text", text: msg.content });
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    content.push({
+                        type: "toolCall",
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: JSON.parse(tc.arguments),
+                    });
+                }
             }
-            result.push(assistantMsg);
+            if (content.length === 0)
+                content.push({ type: "text", text: "" });
+            piMessages.push({
+                role: "assistant",
+                content,
+                api: "openai-completions",
+                provider: "openai",
+                model: "",
+                usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+                stopReason: "stop",
+                timestamp: Date.now(),
+            });
             continue;
         }
         if (msg.role === "tool") {
-            result.push({
-                role: "tool",
-                tool_call_id: msg.toolCallId,
-                content: msg.content,
+            piMessages.push({
+                role: "toolResult",
+                toolCallId: msg.toolCallId,
+                toolName: "",
+                content: [{ type: "text", text: msg.content }],
+                isError: false,
+                timestamp: Date.now(),
             });
         }
     }
-    return result;
-}
-// === OpenAI Responses API Implementation (optional) ===
-async function chatCompletionOpenAIResponses(client, model, messages, options, webSearch, onStreamProgress, onTextDelta) {
-    const input = messages.map((m) => ({
-        role: m.role,
-        content: m.content,
-    }));
-    const tools = webSearch
-        ? [{ type: "web_search_preview" }]
-        : undefined;
-    const stream = await client.responses.create({
-        model,
-        input,
-        temperature: options.temperature,
-        max_output_tokens: options.maxTokens,
-        stream: true,
-        ...(tools ? { tools } : {}),
-    });
-    const chunks = [];
-    let inputTokens = 0;
-    let outputTokens = 0;
-    const monitor = createStreamMonitor(onStreamProgress);
-    try {
-        for await (const event of stream) {
-            if (event.type === "response.output_text.delta") {
-                chunks.push(event.delta);
-                monitor.onChunk(event.delta);
-                onTextDelta?.(event.delta);
-            }
-            if (event.type === "response.completed") {
-                inputTokens = event.response.usage?.input_tokens ?? 0;
-                outputTokens = event.response.usage?.output_tokens ?? 0;
-            }
-        }
-    }
-    catch (streamError) {
-        monitor.stop();
-        const partial = chunks.join("");
-        if (partial.length >= MIN_SALVAGEABLE_CHARS) {
-            throw new PartialResponseError(partial, streamError);
-        }
-        throw streamError;
-    }
-    finally {
-        monitor.stop();
-    }
-    const content = chunks.join("");
-    if (!content)
-        throw new Error("LLM returned empty response from stream");
-    return {
-        content,
-        usage: {
-            promptTokens: inputTokens,
-            completionTokens: outputTokens,
-            totalTokens: inputTokens + outputTokens,
-        },
-    };
-}
-async function chatCompletionOpenAIResponsesSync(client, model, messages, options, _webSearch, onTextDelta) {
-    const input = messages.map((m) => ({
-        role: m.role,
-        content: m.content,
-    }));
-    const response = await client.responses.create({
-        model,
-        input,
-        temperature: options.temperature,
-        max_output_tokens: options.maxTokens,
-        stream: false,
-    });
-    const content = response.output
-        .filter((item) => item.type === "message")
-        .flatMap((item) => item.content)
-        .filter((block) => block.type === "output_text")
-        .map((block) => block.text)
-        .join("");
-    if (!content)
-        throw new Error("LLM returned empty response");
-    onTextDelta?.(content);
-    return {
-        content,
-        usage: {
-            promptTokens: response.usage?.input_tokens ?? 0,
-            completionTokens: response.usage?.output_tokens ?? 0,
-            totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
-        },
-    };
+    return { systemPrompt, messages: piMessages };
 }
-async function chatWithToolsOpenAIResponses(client, model, messages, tools, options) {
-    const input = agentMessagesToResponsesInput(messages);
-    const responsesTools = tools.map((t) => ({
-        type: "function",
+/** Convert inkos ToolDefinition[] to pi-ai Tool[]. */
+function toPiTools(tools) {
+    return tools.map((t) => ({
         name: t.name,
         description: t.description,
         parameters: t.parameters,
-        strict: false,
     }));
-    const stream = await client.responses.create({
-        model,
-        input,
-        tools: responsesTools,
-        temperature: options.temperature,
-        max_output_tokens: options.maxTokens,
-        stream: true,
-    });
-    let content = "";
-    const toolCalls = [];
-    for await (const event of stream) {
-        if (event.type === "response.output_text.delta") {
-            content += event.delta;
-        }
-        if (event.type === "response.output_item.done" && event.item.type === "function_call") {
-            toolCalls.push({
-                id: event.item.call_id,
-                name: event.item.name,
-                arguments: event.item.arguments,
-            });
-        }
-    }
-    return { content, toolCalls };
 }
-function agentMessagesToResponsesInput(messages) {
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "system") {
-            result.push({ role: "system", content: msg.content });
-            continue;
-        }
-        if (msg.role === "user") {
-            result.push({ role: "user", content: msg.content });
-            continue;
-        }
-        if (msg.role === "assistant") {
-            if (msg.content) {
-                result.push({ role: "assistant", content: msg.content });
-            }
-            if (msg.toolCalls) {
-                for (const tc of msg.toolCalls) {
-                    result.push({
-                        type: "function_call",
-                        call_id: tc.id,
-                        name: tc.name,
-                        arguments: tc.arguments,
-                    });
-                }
-            }
-            continue;
+async function chatCompletionViaPiAi(client, model, messages, resolved, onStreamProgress, onTextDelta) {
+    const piModel = resolvePiModel(client, model);
+    const context = toPiContext(messages);
+    const streamOpts = {
+        temperature: resolved.temperature,
+        maxTokens: resolved.maxTokens,
+        apiKey: client._apiKey,
+        headers: piModel.headers,
+    };
+    if (!client.stream) {
+        const response = await piCompleteSimple(piModel, context, streamOpts);
+        if (response.stopReason === "error" && response.errorMessage) {
+            throw new Error(response.errorMessage);
         }
-        if (msg.role === "tool") {
-            result.push({
-                type: "function_call_output",
-                call_id: msg.toolCallId,
-                output: msg.content,
-            });
+        const content = response.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        if (!content) {
+            const diag = `usage=${response.usage.input}+${response.usage.output}`;
+            console.warn(`[inkos] LLM 非流式响应无文本内容 (${diag})`);
+            throw new Error(`LLM returned empty response (${diag})`);
         }
+        return {
+            content,
+            usage: {
+                promptTokens: response.usage.input,
+                completionTokens: response.usage.output,
+                totalTokens: response.usage.totalTokens,
+            },
+        };
     }
-    return result;
-}
-// === Anthropic Implementation ===
-async function chatCompletionAnthropic(client, model, messages, options, thinkingBudget = 0, onStreamProgress, onTextDelta) {
-    const systemText = messages
-        .filter((m) => m.role === "system")
-        .map((m) => m.content)
-        .join("\n\n");
-    const nonSystem = messages.filter((m) => m.role !== "system");
-    const stream = await client.messages.create({
-        model,
-        ...(systemText ? { system: systemText } : {}),
-        messages: nonSystem.map((m) => ({
-            role: m.role,
-            content: m.content,
-        })),
-        ...(thinkingBudget > 0
-            ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
-            : { temperature: options.temperature }),
-        max_tokens: options.maxTokens,
-        stream: true,
-    });
+    const eventStream = piStreamSimple(piModel, context, streamOpts);
     const chunks = [];
+    const monitor = createStreamMonitor(onStreamProgress);
     let inputTokens = 0;
     let outputTokens = 0;
-    const monitor = createStreamMonitor(onStreamProgress);
     try {
-        for await (const event of stream) {
-            if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-                chunks.push(event.delta.text);
-                monitor.onChunk(event.delta.text);
-                onTextDelta?.(event.delta.text);
-            }
-            if (event.type === "message_start") {
-                inputTokens = event.message.usage?.input_tokens ?? 0;
+        for await (const event of eventStream) {
+            if (event.type === "text_delta") {
+                chunks.push(event.delta);
+                monitor.onChunk(event.delta);
+                onTextDelta?.(event.delta);
             }
-            if (event.type === "message_delta") {
-                outputTokens = (event.usage?.output_tokens) ?? 0;
+            if (event.type === "done" || event.type === "error") {
+                const msg = event.type === "done" ? event.message : event.error;
+                inputTokens = msg.usage.input;
+                outputTokens = msg.usage.output;
+                if (event.type === "error" && msg.errorMessage) {
+                    const partial = chunks.join("");
+                    if (partial.length >= MIN_SALVAGEABLE_CHARS) {
+                        throw new PartialResponseError(partial, new Error(msg.errorMessage));
+                    }
+                    throw new Error(msg.errorMessage);
+                }
             }
         }
     }
     catch (streamError) {
         monitor.stop();
+        if (streamError instanceof PartialResponseError)
+            throw streamError;
         const partial = chunks.join("");
         if (partial.length >= MIN_SALVAGEABLE_CHARS) {
             throw new PartialResponseError(partial, streamError);
@@ -649,8 +665,11 @@ async function chatCompletionAnthropic(client, model, messages, options, thinkin
         monitor.stop();
     }
     const content = chunks.join("");
-    if (!content)
-        throw new Error("LLM returned empty response from stream");
+    if (!content) {
+        const diag = `usage=${inputTokens}+${outputTokens}`;
+        console.warn(`[inkos] LLM 流式响应无文本内容 (${diag})`);
+        throw new Error(`LLM returned empty response from stream (${diag})`);
+    }
     return {
         content,
         usage: {
@@ -660,139 +679,52 @@ async function chatCompletionAnthropic(client, model, messages, options, thinkin
         },
     };
 }
-async function chatCompletionAnthropicSync(client, model, messages, options, thinkingBudget = 0, onTextDelta) {
-    const systemText = messages
-        .filter((m) => m.role === "system")
-        .map((m) => m.content)
-        .join("\n\n");
-    const nonSystem = messages.filter((m) => m.role !== "system");
-    const response = await client.messages.create({
-        model,
-        ...(systemText ? { system: systemText } : {}),
-        messages: nonSystem.map((m) => ({
-            role: m.role,
-            content: m.content,
-        })),
-        ...(thinkingBudget > 0
-            ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
-            : { temperature: options.temperature }),
-        max_tokens: options.maxTokens,
-    });
-    const content = response.content
-        .filter((block) => block.type === "text")
-        .map((block) => block.text)
-        .join("");
-    if (!content)
-        throw new Error("LLM returned empty response");
-    onTextDelta?.(content);
-    return {
-        content,
-        usage: {
-            promptTokens: response.usage?.input_tokens ?? 0,
-            completionTokens: response.usage?.output_tokens ?? 0,
-            totalTokens: (response.usage?.input_tokens ?? 0) + (response.usage?.output_tokens ?? 0),
-        },
+async function chatWithToolsViaPiAi(client, model, messages, tools, resolved) {
+    const piModel = resolvePiModel(client, model);
+    const context = agentMessagesToPiContext(messages);
+    context.tools = toPiTools(tools);
+    const streamOpts = {
+        temperature: resolved.temperature,
+        maxTokens: resolved.maxTokens,
+        apiKey: client._apiKey,
+        headers: piModel.headers,
     };
-}
-async function chatWithToolsAnthropic(client, model, messages, tools, options, thinkingBudget = 0) {
-    const systemText = messages
-        .filter((m) => m.role === "system")
-        .map((m) => m.content)
-        .join("\n\n");
-    const nonSystem = messages.filter((m) => m.role !== "system");
-    const anthropicMessages = agentMessagesToAnthropic(nonSystem);
-    const anthropicTools = tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.parameters,
-    }));
-    const stream = await client.messages.create({
-        model,
-        ...(systemText ? { system: systemText } : {}),
-        messages: anthropicMessages,
-        tools: anthropicTools,
-        ...(thinkingBudget > 0
-            ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } }
-            : { temperature: options.temperature }),
-        max_tokens: options.maxTokens,
-        stream: true,
-    });
+    if (!client.stream) {
+        const response = await piComplete(piModel, context, streamOpts);
+        if (response.stopReason === "error" && response.errorMessage) {
+            throw new Error(response.errorMessage);
+        }
+        const content = response.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        const toolCalls = response.content
+            .filter((block) => block.type === "toolCall")
+            .map((block) => ({
+            id: block.id,
+            name: block.name,
+            arguments: JSON.stringify(block.arguments),
+        }));
+        return { content, toolCalls };
+    }
+    const eventStream = piStream(piModel, context, streamOpts);
     let content = "";
     const toolCalls = [];
-    let currentBlock = null;
-    for await (const event of stream) {
-        if (event.type === "content_block_start" && event.content_block.type === "tool_use") {
-            currentBlock = {
-                id: event.content_block.id,
-                name: event.content_block.name,
-                input: "",
-            };
-        }
-        if (event.type === "content_block_delta") {
-            if (event.delta.type === "text_delta") {
-                content += event.delta.text;
-            }
-            if (event.delta.type === "input_json_delta" && currentBlock) {
-                currentBlock.input += event.delta.partial_json;
-            }
+    for await (const event of eventStream) {
+        if (event.type === "text_delta") {
+            content += event.delta;
         }
-        if (event.type === "content_block_stop" && currentBlock) {
+        if (event.type === "toolcall_end") {
             toolCalls.push({
-                id: currentBlock.id,
-                name: currentBlock.name,
-                arguments: currentBlock.input,
+                id: event.toolCall.id,
+                name: event.toolCall.name,
+                arguments: JSON.stringify(event.toolCall.arguments),
             });
-            currentBlock = null;
         }
-    }
-    return { content, toolCalls };
-}
-function agentMessagesToAnthropic(messages) {
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role === "system")
-            continue;
-        if (msg.role === "user") {
-            result.push({ role: "user", content: msg.content });
-            continue;
-        }
-        if (msg.role === "assistant") {
-            const blocks = [];
-            if (msg.content) {
-                blocks.push({ type: "text", text: msg.content });
-            }
-            if (msg.toolCalls) {
-                for (const tc of msg.toolCalls) {
-                    blocks.push({
-                        type: "tool_use",
-                        id: tc.id,
-                        name: tc.name,
-                        input: JSON.parse(tc.arguments),
-                    });
-                }
-            }
-            if (blocks.length === 0) {
-                blocks.push({ type: "text", text: "" });
-            }
-            result.push({ role: "assistant", content: blocks });
-            continue;
-        }
-        if (msg.role === "tool") {
-            const toolResult = {
-                type: "tool_result",
-                tool_use_id: msg.toolCallId,
-                content: msg.content,
-            };
-            // Merge consecutive tool results into one user message (Anthropic requires alternating roles)
-            const prev = result[result.length - 1];
-            if (prev && prev.role === "user" && Array.isArray(prev.content)) {
-                prev.content.push(toolResult);
-            }
-            else {
-                result.push({ role: "user", content: [toolResult] });
-            }
+        if (event.type === "error" && event.error.errorMessage) {
+            throw new Error(event.error.errorMessage);
         }
     }
-    return result;
+    return { content, toolCalls };
 }
 //# sourceMappingURL=provider.js.map