@kkelly-offical/kkcode 0.1.2

package/src/provider/openai.mjs

@@ -0,0 +1,339 @@
+import { ProviderError } from "../core/errors.mjs"
+import { requestWithRetry } from "./retry-policy.mjs"
+import { parseSSE } from "./sse.mjs"
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function mapTools(tools) {
+  if (!tools || !tools.length) return undefined
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }))
+}
+
+function mapContentBlock(block) {
+  if (block.type === "image" && block.data) {
+    return {
+      type: "image_url",
+      image_url: {
+        url: `data:${block.mediaType || "image/png"};base64,${block.data}`
+      }
+    }
+  }
+  return { type: "text", text: String(block.text || block.content || "") }
+}
+
+function mapMessages(messages) {
+  const mapped = []
+  for (const message of messages) {
+    const content = message.content
+    if (!Array.isArray(content)) {
+      mapped.push({ role: message.role, content: String(content || "") })
+      continue
+    }
+
+    // Check for native tool_use blocks (assistant message with tool calls)
+    const toolUseBlocks = content.filter((b) => b.type === "tool_use")
+    if (toolUseBlocks.length > 0 && message.role === "assistant") {
+      const textParts = content.filter((b) => b.type === "text").map((b) => b.text || "").join("\n")
+      mapped.push({
+        role: "assistant",
+        content: textParts || null,
+        tool_calls: toolUseBlocks.map((b) => ({
+          id: b.id,
+          type: "function",
+          function: {
+            name: b.name,
+            arguments: JSON.stringify(b.input || {})
+          }
+        }))
+      })
+      continue
+    }
+
+    // Check for tool_result blocks (user message with tool results)
+    const toolResultBlocks = content.filter((b) => b.type === "tool_result")
+    if (toolResultBlocks.length > 0) {
+      for (const result of toolResultBlocks) {
+        mapped.push({
+          role: "tool",
+          tool_call_id: result.tool_use_id,
+          content: String(result.content || "")
+        })
+      }
+      continue
+    }
+
+    // Regular array content (images, text)
+    mapped.push({ role: message.role, content: content.map(mapContentBlock) })
+  }
+  return mapped
+}
+
+function parseToolCalls(message) {
+  if (!Array.isArray(message?.tool_calls)) return []
+  return message.tool_calls
+    .filter((call) => call?.function?.name)
+    .map((call) => {
+      const raw = call.function.arguments || "{}"
+      let args = {}
+      try {
+        args = JSON.parse(raw)
+      } catch (parseErr) {
+        console.error(`[openai] tool_call JSON parse failed for "${call.function.name}": ${parseErr.message} (${raw.length} chars, first 200: ${raw.slice(0, 200)})`)
+        args = { __parse_error: true, __raw_length: raw.length, __error: parseErr.message }
+      }
+      return {
+        id: call.id || `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        name: call.function.name,
+        args
+      }
+    })
+}
+
+// Build system messages from structured blocks for optimal prefix caching.
+// OpenAI auto-caches matching prefixes — stable content first, dynamic last.
+function buildSystemMessages(system) {
+  if (!system) return []
+  if (system.blocks && Array.isArray(system.blocks)) {
+    const stable = []
+    const dynamic = []
+    for (const block of system.blocks) {
+      if (block.cacheable) stable.push(block.text)
+      else dynamic.push(block.text)
+    }
+    const msgs = []
+    if (stable.length) msgs.push({ role: "system", content: stable.join("\n\n") })
+    if (dynamic.length) msgs.push({ role: "system", content: dynamic.join("\n\n") })
+    return msgs
+  }
+  const text = typeof system === "string" ? system : system.text || String(system)
+  return text ? [{ role: "system", content: text }] : []
+}
+
+function timeoutSignal(ms, parentSignal = null) {
+  const own = AbortSignal.timeout(ms)
+  if (!parentSignal) return own
+  return AbortSignal.any([parentSignal, own])
+}
+
+export async function countTokensOpenAI(input) {
+  const { apiKey, baseUrl, model, system, messages, tools, timeoutMs = 10000 } = input
+  if (!apiKey) return null
+  const endpoint = `${baseUrl.replace(/\/$/, "")}/chat/completions`
+  const payload = {
+    model,
+    messages: [...buildSystemMessages(system), ...mapMessages(messages)],
+    tools: mapTools(tools),
+    max_tokens: 1,
+    stream: false
+  }
+  try {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+    if (!res.ok) return null
+    const json = await res.json()
+    return json?.usage?.prompt_tokens ?? null
+  } catch {
+    return null
+  }
+}
+
+export async function requestOpenAI(input) {
+  const { apiKey, baseUrl, model, system, messages, tools, timeoutMs = 120000, maxTokens, retry = {}, signal = null } = input
+  if (!apiKey) {
+    throw new ProviderError(`missing API key for openai provider (env: ${input.apiKeyEnv || "unknown"})`, {
+      provider: "openai"
+    })
+  }
+
+  const payload = {
+    model,
+    messages: [...buildSystemMessages(system), ...mapMessages(messages)],
+    tools: mapTools(tools),
+    tool_choice: tools?.length ? "auto" : undefined,
+    ...(maxTokens ? { max_tokens: maxTokens } : {})
+  }
+  const endpoint = `${baseUrl.replace(/\/$/, "")}/chat/completions`
+
+  return requestWithRetry({
+    attempts: Number(retry.attempts ?? 3),
+    baseDelayMs: Number(retry.baseDelayMs ?? 800),
+    signal,
+    execute: async () => {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(payload),
+        signal: timeoutSignal(timeoutMs, signal)
+      })
+
+      if (!response.ok) {
+        const text = await response.text().catch(() => "")
+        const error = new ProviderError(`openai request failed: ${response.status} ${text}`, {
+          provider: "openai",
+          model,
+          endpoint
+        })
+        error.httpStatus = response.status
+        throw error
+      }
+
+      const json = await response.json()
+      const message = json?.choices?.[0]?.message ?? {}
+      const promptTokens = json?.usage?.prompt_tokens ?? 0
+      const cachedTokens = json?.usage?.prompt_tokens_details?.cached_tokens ?? 0
+      const usage = {
+        input: promptTokens - cachedTokens,
+        output: json?.usage?.completion_tokens ?? 0,
+        cacheRead: cachedTokens,
+        cacheWrite: 0
+      }
+      const toolCalls = parseToolCalls(message)
+      const text = typeof message.content === "string" ? message.content : ""
+      return { text, usage, toolCalls }
+    }
+  })
+}
+
+export async function* requestOpenAIStream(input) {
+  const { apiKey, baseUrl, model, system, messages, tools, timeoutMs = 120000, streamIdleTimeoutMs = 120000, maxTokens, retry = {}, signal = null } = input
+  if (!apiKey) {
+    throw new ProviderError(`missing API key for openai provider (env: ${input.apiKeyEnv || "unknown"})`, {
+      provider: "openai"
+    })
+  }
+
+  const payload = {
+    model,
+    messages: [...buildSystemMessages(system), ...mapMessages(messages)],
+    tools: mapTools(tools),
+    tool_choice: tools?.length ? "auto" : undefined,
+    ...(maxTokens ? { max_tokens: maxTokens } : {}),
+    stream: true,
+    stream_options: { include_usage: true }
+  }
+  const endpoint = `${baseUrl.replace(/\/$/, "")}/chat/completions`
+  const attempts = Number(retry.attempts ?? 3)
+  const baseDelayMs = Number(retry.baseDelayMs ?? 800)
+
+  let response
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      // Use a connection-only timeout for the initial fetch.
+      // Once headers arrive, clear it — the SSE idle timeout handles the streaming phase.
+      const connController = new AbortController()
+      const connTimer = setTimeout(() => connController.abort(), timeoutMs)
+      const fetchSignal = signal
+        ? AbortSignal.any([signal, connController.signal])
+        : connController.signal
+
+      response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(payload),
+        signal: fetchSignal
+      })
+      clearTimeout(connTimer)
+
+      if (!response.ok) {
+        const text = await response.text().catch(() => "")
+        const error = new ProviderError(`openai stream failed: ${response.status} ${text}`, {
+          provider: "openai", model, endpoint
+        })
+        error.httpStatus = response.status
+        throw error
+      }
+      break
+    } catch (err) {
+      if (signal?.aborted) throw err
+      const isNetwork = err?.code === "ETIMEDOUT" || err?.code === "ECONNRESET" || err?.name === "AbortError"
+      if (!isNetwork || attempt >= attempts) throw err
+      await sleep(baseDelayMs * Math.pow(2, attempt - 1))
+    }
+  }
+
+  const toolBuffers = new Map()
+  let finishReason = null
+
+  for await (const { data } of parseSSE(response.body, signal, { idleTimeoutMs: streamIdleTimeoutMs })) {
+    let json
+    try { json = JSON.parse(data) } catch { continue }
+
+    if (json.usage) {
+      const pt = json.usage.prompt_tokens ?? 0
+      const ct = json.usage.prompt_tokens_details?.cached_tokens ?? 0
+      yield {
+        type: "usage",
+        usage: { input: pt - ct, output: json.usage.completion_tokens ?? 0, cacheRead: ct, cacheWrite: 0 }
+      }
+    }
+
+    const choice = json.choices?.[0]
+    if (choice?.finish_reason) {
+      finishReason = choice.finish_reason
+    }
+    const delta = choice?.delta
+    if (!delta) continue
+
+    if (delta.content) {
+      yield { type: "text", content: delta.content }
+    }
+
+    if (delta.tool_calls) {
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index ?? 0
+        if (!toolBuffers.has(idx)) {
+          toolBuffers.set(idx, { id: "", name: "", argsJson: "" })
+        }
+        const buf = toolBuffers.get(idx)
+        if (tc.id) buf.id = tc.id
+        if (tc.function?.name) buf.name = tc.function.name
+        if (tc.function?.arguments) buf.argsJson += tc.function.arguments
+      }
+    }
+  }
+
+  for (const [, buf] of toolBuffers) {
+    const raw = buf.argsJson || "{}"
+    let args = {}
+    try {
+      args = JSON.parse(raw)
+    } catch (parseErr) {
+      console.error(`[openai] tool_call JSON parse failed for "${buf.name}": ${parseErr.message} (${raw.length} chars, first 200: ${raw.slice(0, 200)})`)
+      args = { __parse_error: true, __raw_length: raw.length, __error: parseErr.message }
+    }
+    yield {
+      type: "tool_call",
+      call: {
+        id: buf.id || `tc_${Date.now()}`,
+        name: buf.name,
+        args
+      }
+    }
+  }
+
+  // Normalize: "stop" → "end_turn", "length" → "max_tokens", "tool_calls" → "tool_use"
+  const normalizedReason = finishReason === "length" ? "max_tokens"
+    : finishReason === "tool_calls" ? "tool_use"
+    : finishReason === "stop" ? "end_turn"
+    : finishReason || "end_turn"
+  yield { type: "stop", reason: normalizedReason }
+}

package/src/provider/retry-policy.mjs

@@ -0,0 +1,68 @@
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function classifyHttpError(status) {
+  if (status === 401 || status === 403) return "auth"
+  if (status === 429) return "rate_limit"
+  if (status === 413 || status === 400) return "context_overflow"
+  if (status >= 500) return "server"
+  if (status === 408 || status === 409 || status === 425) return "transient"
+  return "unknown"
+}
+
+function isRetryable(classification) {
+  return classification === "rate_limit" || classification === "server" || classification === "transient"
+}
+
+function jitter(ms) {
+  return Math.round(ms * (1 + (Math.random() - 0.5) * 0.4))
+}
+
+function retryDelayMs(classification, baseDelayMs, attempt) {
+  if (classification === "rate_limit") {
+    return jitter(Math.min(baseDelayMs * Math.pow(3, attempt - 1), 60000))
+  }
+  return jitter(baseDelayMs * Math.pow(2, attempt - 1))
+}
+
+export async function requestWithRetry({ execute, attempts = 3, baseDelayMs = 800, signal = null }) {
+  let lastError = null
+  for (let attempt = 1; attempt <= Math.max(1, attempts); attempt++) {
+    if (signal?.aborted) {
+      const error = new Error("request aborted")
+      error.code = "ABORT_ERR"
+      throw error
+    }
+    try {
+      return await execute(attempt)
+    } catch (error) {
+      lastError = error
+      const status = Number(error?.status || error?.httpStatus || 0)
+      const classification = classifyHttpError(status)
+
+      error.errorClass = classification
+
+      if (classification === "auth") {
+        error.message = `authentication failed (${status}): check your API key. ${error.message}`
+        throw error
+      }
+
+      if (classification === "context_overflow") {
+        error.needsCompaction = true
+        throw error
+      }
+
+      const networkRetryable = error?.code === "ETIMEDOUT" || error?.code === "ECONNRESET"
+      if ((!isRetryable(classification) && !networkRetryable) || attempt >= attempts) {
+        throw error
+      }
+
+      const delay = networkRetryable
+        ? jitter(baseDelayMs * Math.pow(2, attempt - 1))
+        : retryDelayMs(classification, baseDelayMs, attempt)
+      await sleep(delay)
+    }
+  }
+  throw lastError || new Error("request failed")
+}

package/src/provider/router.mjs

@@ -0,0 +1,228 @@
+import { requestAnthropic, requestAnthropicStream, countTokensAnthropic } from "./anthropic.mjs"
+import { requestOpenAI, requestOpenAIStream, countTokensOpenAI } from "./openai.mjs"
+import { request as requestOAICompat, requestStream as requestStreamOAICompat } from "./openai-compatible.mjs"
+import { requestOllama, requestOllamaStream } from "./ollama.mjs"
+import { ProviderError } from "../core/errors.mjs"
+
+// --- Provider Registry ---
+const registry = new Map()
+
+export function registerProvider(name, mod) {
+  if (!mod || typeof mod.request !== "function" || typeof mod.requestStream !== "function") {
+    throw new Error(`provider "${name}" must export request() and requestStream()`)
+  }
+  registry.set(name, mod)
+}
+
+export function listProviders() {
+  return [...registry.keys()]
+}
+
+export function getProvider(name) {
+  return registry.get(name) || null
+}
+
+// Built-in providers
+registerProvider("openai", { request: requestOpenAI, requestStream: requestOpenAIStream, countTokens: countTokensOpenAI })
+registerProvider("anthropic", { request: requestAnthropic, requestStream: requestAnthropicStream, countTokens: countTokensAnthropic })
+registerProvider("openai-compatible", { request: requestOAICompat, requestStream: requestStreamOAICompat, countTokens: countTokensOpenAI })
+registerProvider("ollama", { request: requestOllama, requestStream: requestOllamaStream })
+
+// --- Settings Resolution ---
+function resolveSettings(configState, providerType, overrides = {}) {
+  const llm = configState.config.provider
+
+  // Resolve registry key: direct match → config type field → fallback to openai
+  let resolvedType = providerType
+  if (!registry.has(providerType)) {
+    const providerConfig = llm[providerType]
+    if (providerConfig?.type && registry.has(providerConfig.type)) {
+      resolvedType = providerConfig.type
+    } else {
+      resolvedType = "openai"
+    }
+  }
+
+  // Read config from original provider name (e.g. "deepseek"), not resolved type
+  const defaults = llm[providerType] || llm[resolvedType] || {}
+  const normalizedModel = String(overrides.model || defaults.default_model || "").includes("/")
+    ? String(overrides.model || defaults.default_model).split("/").slice(1).join("/")
+    : String(overrides.model || defaults.default_model || "")
+  return {
+    providerType: resolvedType,
+    configKey: providerType,
+    model: normalizedModel,
+    baseUrl: overrides.baseUrl || defaults.base_url,
+    apiKeyEnv: overrides.apiKeyEnv || defaults.api_key_env
+  }
+}
+
+function classifyProviderFailure(error) {
+  const cls = String(error?.errorClass || "").toLowerCase()
+  if (["auth", "authentication"].includes(cls)) return "auth"
+  if (["rate_limit"].includes(cls)) return "rate_limit"
+  if (["context_overflow", "bad_response"].includes(cls)) return "bad_response"
+  if (["server", "transient"].includes(cls)) return "bad_response"
+
+  const status = Number(error?.status || error?.httpStatus || 0)
+  if (status === 401 || status === 403) return "auth"
+  if (status === 429) return "rate_limit"
+  if (status >= 400 && status < 500) return "bad_response"
+  if (status >= 500) return "bad_response"
+
+  const code = String(error?.code || "").toUpperCase()
+  const msg = String(error?.message || "").toLowerCase()
+  if (code === "ABORT_ERR" || msg.includes("timeout") || msg.includes("timed out")) return "timeout"
+  if (code === "ETIMEDOUT" || code === "ECONNRESET") return "timeout"
+  if (msg.includes("invalid json") || msg.includes("parse")) return "bad_response"
+  return "unknown"
+}
+
+function normalizeProviderError(error, providerType, model) {
+  const reason = classifyProviderFailure(error)
+  if (error instanceof ProviderError) {
+    error.reason = error.reason || reason
+    error.details = {
+      ...(error.details || {}),
+      provider: providerType,
+      model,
+      reason: error.reason
+    }
+    return error
+  }
+  const wrapped = new ProviderError(error?.message || "provider request failed", {
+    provider: providerType,
+    model,
+    reason
+  })
+  wrapped.reason = reason
+  wrapped.cause = error
+  return wrapped
+}
+
+// --- Non-streaming Request ---
+export async function requestProvider({
+  configState,
+  providerType,
+  model,
+  system,
+  messages,
+  tools,
+  baseUrl = null,
+  apiKeyEnv = null
+}) {
+  const resolvedProviderType = providerType || configState.config.provider.default
+  const settings = resolveSettings(configState, resolvedProviderType, {
+    model,
+    baseUrl,
+    apiKeyEnv
+  })
+  const apiKey = process.env[settings.apiKeyEnv] || ""
+  const providerCfg = configState.config.provider[settings.configKey] || configState.config.provider[settings.providerType] || {}
+
+  const input = {
+    apiKey,
+    baseUrl: settings.baseUrl,
+    apiKeyEnv: settings.apiKeyEnv,
+    model: settings.model,
+    system,
+    messages,
+    tools,
+    timeoutMs: Number(providerCfg.timeout_ms || 120000),
+    maxTokens: Number(providerCfg.max_tokens || 16384),
+    retry: {
+      attempts: Number(providerCfg.retry_attempts || 3),
+      baseDelayMs: Number(providerCfg.retry_base_delay_ms || 800)
+    },
+    thinking: providerCfg.thinking || null
+  }
+
+  const provider = registry.get(settings.providerType)
+  if (!provider) {
+    throw new Error(`unknown provider: ${settings.providerType}. registered: ${listProviders().join(", ")}`)
+  }
+  try {
+    return await provider.request(input)
+  } catch (error) {
+    throw normalizeProviderError(error, settings.providerType, settings.model)
+  }
+}
+
+// --- Streaming Request ---
+export async function* requestProviderStream({
+  configState,
+  providerType,
+  model,
+  system,
+  messages,
+  tools,
+  baseUrl = null,
+  apiKeyEnv = null,
+  signal = null,
+  compaction = null
+}) {
+  const resolvedProviderType = providerType || configState.config.provider.default
+  const settings = resolveSettings(configState, resolvedProviderType, {
+    model,
+    baseUrl,
+    apiKeyEnv
+  })
+  const apiKey = process.env[settings.apiKeyEnv] || ""
+  const providerCfg = configState.config.provider[settings.configKey] || configState.config.provider[settings.providerType] || {}
+
+  if (providerCfg.stream === false) {
+    const result = await requestProvider({
+      configState, providerType, model, system, messages, tools, baseUrl, apiKeyEnv
+    })
+    if (result.text) yield { type: "text", content: result.text }
+    for (const call of result.toolCalls) yield { type: "tool_call", call }
+    yield { type: "usage", usage: result.usage }
+    return
+  }
+
+  const input = {
+    apiKey,
+    baseUrl: settings.baseUrl,
+    apiKeyEnv: settings.apiKeyEnv,
+    model: settings.model,
+    system,
+    messages,
+    tools,
+    timeoutMs: Number(providerCfg.timeout_ms || 120000),
+    streamIdleTimeoutMs: Number(providerCfg.stream_idle_timeout_ms || 120000),
+    maxTokens: Number(providerCfg.max_tokens || 16384),
+    retry: {
+      attempts: Number(providerCfg.retry_attempts || 3),
+      baseDelayMs: Number(providerCfg.retry_base_delay_ms || 800)
+    },
+    thinking: providerCfg.thinking || null,
+    signal,
+    compaction
+  }
+
+  const provider = registry.get(settings.providerType)
+  if (!provider) {
+    throw new Error(`unknown provider: ${settings.providerType}. registered: ${listProviders().join(", ")}`)
+  }
+  try {
+    yield* provider.requestStream(input)
+  } catch (error) {
+    throw normalizeProviderError(error, settings.providerType, settings.model)
+  }
+}
+
+// --- Token Counting (Anthropic only, returns null for other providers) ---
+export async function countTokensProvider({
+  configState, providerType, model, system, messages, tools,
+  baseUrl = null, apiKeyEnv = null
+}) {
+  const resolvedProviderType = providerType || configState.config.provider.default
+  const settings = resolveSettings(configState, resolvedProviderType, { model, baseUrl, apiKeyEnv })
+  const provider = registry.get(settings.providerType)
+  if (!provider?.countTokens) return null
+  const apiKey = process.env[settings.apiKeyEnv] || ""
+  return provider.countTokens({
+    apiKey, baseUrl: settings.baseUrl, model: settings.model,
+    system, messages, tools
+  })
+}