klaus-agent 0.2.1 → 0.3.0

package/src/providers/openai-responses.ts

@@ -0,0 +1,152 @@
+// OpenAI Responses API provider
+// Uses the official OpenAI SDK's client.responses.create() for streaming.
+
+import OpenAI from "openai";
+import type { ResponseCreateParamsStreaming, ResponseStreamEvent } from "openai/resources/responses/responses.js";
+import type {
+  LLMProvider,
+  LLMRequestOptions,
+  AssistantMessageEvent,
+  AssistantMessage,
+  AssistantContentBlock,
+  TokenUsage,
+  ThinkingLevel,
+} from "../llm/types.js";
+import { withRetry, RETRYABLE_PATTERNS, mapReasoningEffort } from "./shared.js";
+import { mapMessages, mapTools } from "./openai-responses-shared.js";
+
+export class OpenAIResponsesProvider implements LLMProvider {
+  private client: OpenAI;
+
+  constructor(apiKey?: string, baseUrl?: string) {
+    this.client = new OpenAI({
+      apiKey: apiKey || process.env.OPENAI_API_KEY,
+      ...(baseUrl ? { baseURL: baseUrl } : {}),
+    });
+  }
+
+  async *stream(options: LLMRequestOptions): AsyncIterable<AssistantMessageEvent> {
+    yield* withRetry(() => this._streamOnce(options), RETRYABLE_PATTERNS.openai);
+  }
+
+  private async *_streamOnce(options: LLMRequestOptions): AsyncIterable<AssistantMessageEvent> {
+    const { model, systemPrompt, messages, tools, thinkingLevel, maxTokens, signal } = options;
+
+    const effort = mapReasoningEffort(thinkingLevel);
+
+    const params: ResponseCreateParamsStreaming = {
+      model,
+      instructions: systemPrompt,
+      input: mapMessages(messages) as ResponseCreateParamsStreaming["input"],
+      stream: true,
+      store: false,
+      max_output_tokens: maxTokens ?? 8192,
+      include: ["reasoning.encrypted_content"],
+      ...(tools?.length ? {
+        tools: mapTools(tools) as ResponseCreateParamsStreaming["tools"],
+        tool_choice: "auto" as const,
+      } : {}),
+      ...(effort ? { reasoning: { effort, summary: "auto" as const } } : {}),
+    };
+
+    const contentBlocks: AssistantContentBlock[] = [];
+    const toolCalls = new Map<string, { id: string; name: string; args: string; callId: string }>();
+    let usage: TokenUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+
+    const stream = await this.client.responses.create(params, { signal });
+
+    for await (const event of stream as AsyncIterable<ResponseStreamEvent>) {
+      const type = event.type;
+
+      // Text delta
+      if (type === "response.output_text.delta") {
+        const delta = event.delta;
+        if (delta) {
+          if (contentBlocks.length === 0 || contentBlocks[contentBlocks.length - 1].type !== "text") {
+            contentBlocks.push({ type: "text", text: "" });
+          }
+          const block = contentBlocks[contentBlocks.length - 1];
+          if (block.type === "text") block.text += delta;
+          yield { type: "text", text: delta };
+        }
+      }
+
+      // Reasoning/thinking summary delta
+      if (type === "response.reasoning_summary_text.delta") {
+        const delta = event.delta;
+        if (delta) {
+          if (contentBlocks.length === 0 || contentBlocks[contentBlocks.length - 1].type !== "thinking") {
+            contentBlocks.push({ type: "thinking", thinking: "" });
+          }
+          const block = contentBlocks[contentBlocks.length - 1];
+          if (block.type === "thinking") block.thinking += delta;
+          yield { type: "thinking", thinking: delta };
+        }
+      }
+
+      // New output item (function call start)
+      if (type === "response.output_item.added") {
+        const item = event.item;
+        if (item?.type === "function_call") {
+          const id = item.id || item.call_id || `call_${toolCalls.size}`;
+          const callId = item.call_id || id;
+          const name = item.name || "";
+          toolCalls.set(id, { id, name, args: "", callId });
+          contentBlocks.push({ type: "tool_call", id: callId, name, input: {} });
+          yield { type: "tool_call_start", id: callId, name };
+        }
+      }
+
+      // Function call arguments delta
+      if (type === "response.function_call_arguments.delta") {
+        const itemId = event.item_id;
+        const delta = event.delta;
+        if (itemId && delta) {
+          const entry = toolCalls.get(itemId);
+          if (entry) {
+            entry.args += delta;
+            yield { type: "tool_call_delta", id: entry.callId, input: delta };
+          }
+        }
+      }
+
+      // Response completed or incomplete — extract usage
+      if (type === "response.completed" || type === "response.incomplete") {
+        const resp = event.response;
+        if (resp?.usage) {
+          usage = {
+            inputTokens: resp.usage.input_tokens ?? 0,
+            outputTokens: resp.usage.output_tokens ?? 0,
+            totalTokens: (resp.usage.input_tokens ?? 0) + (resp.usage.output_tokens ?? 0),
+            cacheReadTokens: resp.usage.input_tokens_details?.cached_tokens,
+          };
+        }
+      }
+
+      // Error / failure
+      if (type === "error") {
+        const err = (event as any).error;
+        throw new Error(`OpenAI Responses error: ${err?.message || err?.code || JSON.stringify(event)}`);
+      }
+      if (type === "response.failed") {
+        const resp = event.response;
+        throw new Error(resp?.error?.message || "OpenAI Responses request failed");
+      }
+    }
+
+    // Finalize tool call inputs
+    for (const [, entry] of toolCalls) {
+      const block = contentBlocks.find((b) => b.type === "tool_call" && b.id === entry.callId);
+      if (block && block.type === "tool_call") {
+        try {
+          block.input = JSON.parse(entry.args || "{}");
+        } catch {
+          block.input = {};
+        }
+      }
+    }
+
+    const message: AssistantMessage = { role: "assistant", content: contentBlocks };
+    yield { type: "done", message, usage };
+  }
+}

package/src/providers/openai.ts

@@ -11,14 +11,7 @@ import type {
   ThinkingLevel,
   Message,
 } from "../llm/types.js";
-import { withRetry, RETRYABLE_PATTERNS } from "./shared.js";
-
-function mapReasoningEffort(level?: ThinkingLevel): "low" | "medium" | "high" | undefined {
-  if (!level || level === "off") return undefined;
-  if (level === "minimal" || level === "low") return "low";
-  if (level === "medium") return "medium";
-  return "high";
-}
+import { withRetry, RETRYABLE_PATTERNS, mapReasoningEffort } from "./shared.js";
 
 export class OpenAIProvider implements LLMProvider {
   private client: OpenAI;

package/src/providers/shared.ts

@@ -1,6 +1,6 @@
 // Shared streaming utilities for LLM providers
 
-import type { AssistantMessageEvent, ThinkingLevel } from "../llm/types.js";
+import type { AssistantMessageEvent, ModelCost, TokenUsage, ThinkingLevel, UsageCost } from "../llm/types.js";
 
 // Retryable error patterns common across providers
 const COMMON_RETRYABLE = ["429", "500", "503", "ECONNRESET"];
@@ -59,3 +59,21 @@ export function mapThinkingBudget(level?: ThinkingLevel): number | undefined {
   };
   return budgets[level];
 }
+
+/** Maps ThinkingLevel to OpenAI reasoning_effort (shared by OpenAI and OpenAI Responses). */
+export function mapReasoningEffort(level?: ThinkingLevel): "low" | "medium" | "high" | undefined {
+  if (!level || level === "off") return undefined;
+  if (level === "minimal" || level === "low") return "low";
+  if (level === "medium") return "medium";
+  return "high";
+}
+
+/** Calculate actual dollar cost from token counts and per-million-token pricing. */
+export function calculateCost(cost: ModelCost | undefined, usage: TokenUsage): UsageCost | undefined {
+  if (!cost) return undefined;
+  const input = (cost.input / 1_000_000) * usage.inputTokens;
+  const output = (cost.output / 1_000_000) * usage.outputTokens;
+  const cacheRead = ((cost.cacheRead ?? 0) / 1_000_000) * (usage.cacheReadTokens ?? 0);
+  const cacheWrite = ((cost.cacheWrite ?? 0) / 1_000_000) * (usage.cacheWriteTokens ?? 0);
+  return { input, output, cacheRead, cacheWrite, total: input + output + cacheRead + cacheWrite };
+}

package/src/types.ts

@@ -7,6 +7,8 @@ import type {
   ToolResultMessage,
   AssistantMessageEvent,
   TokenUsage,
+  ModelCost,
+  UsageCost,
   ThinkingLevel,
   ModelConfig,
   ContentBlock,
@@ -78,6 +80,8 @@ export type {
   ToolResultMessage,
   AssistantMessageEvent,
   TokenUsage,
+  ModelCost,
+  UsageCost,
   ThinkingLevel,
   ModelConfig,
   ContentBlock,

package/src/providers/index.ts

@@ -1,7 +0,0 @@
-export { AnthropicProvider } from "./anthropic.js";
-export { OpenAIProvider } from "./openai.js";
-export { OpenAICodexProvider } from "./openai-codex.js";
-export { GeminiProvider } from "./google.js";
-export { MiniMaxProvider } from "./minimax.js";
-export { KimiProvider } from "./kimi.js";
-export { VolcengineProvider } from "./volcengine.js";

package/src/providers/kimi.ts

@@ -1,12 +0,0 @@
-// Kimi LLM provider (Anthropic Messages API compatible)
-
-import { AnthropicProvider } from "./anthropic.js";
-
-export class KimiProvider extends AnthropicProvider {
-  constructor(apiKey?: string, baseUrl?: string) {
-    super(
-      apiKey ?? process.env.KIMI_API_KEY,
-      baseUrl ?? "https://api.kimi.com/coding",
-    );
-  }
-}

package/src/providers/minimax.ts

@@ -1,12 +0,0 @@
-// MiniMax LLM provider (Anthropic Messages API compatible)
-
-import { AnthropicProvider } from "./anthropic.js";
-
-export class MiniMaxProvider extends AnthropicProvider {
-  constructor(apiKey?: string, baseUrl?: string) {
-    super(
-      apiKey ?? process.env.MINIMAX_API_KEY,
-      baseUrl ?? "https://api.minimaxi.com/anthropic",
-    );
-  }
-}

package/src/providers/volcengine.ts

@@ -1,12 +0,0 @@
-// Volcengine (Doubao) LLM provider (OpenAI Chat Completions API compatible)
-
-import { OpenAIProvider } from "./openai.js";
-
-export class VolcengineProvider extends OpenAIProvider {
-  constructor(apiKey?: string, baseUrl?: string) {
-    super(
-      apiKey ?? process.env.VOLCENGINE_API_KEY,
-      baseUrl ?? "https://ark.cn-beijing.volces.com/api/v3",
-    );
-  }
-}