threadwire 0.1.13 → 0.1.15

package/src/providers/index.js

@@ -2,11 +2,12 @@
 
 import {buildClaudeCommand, claudeSessionId, createClaudeParser} from "./claude.js"
 import {buildCodexCommand, codexSessionId, parseCodexEvent} from "./codex.js"
-import {buildKimiCommand, createKimiParser, createKimiSessionId} from "./kimi.js"
+import {buildKimiCommand, createKimiCompletion, createKimiParser, createKimiSessionId} from "./kimi.js"
 import {buildOpenCodeCommand, createOpenCodeParser, createOpenCodeSessionId} from "./opencode.js"
 
 /**
- * @typedef {{name: "codex" | "claude" | "kimi" | "opencode", executable: string, arguments: string[], parse: (record: unknown) => import("../types.js").WorkerEvent[], sessionId: (record: unknown) => string | undefined}} Provider
+ * @typedef {{disposition: "retrying" | "blocked", category: "authentication" | "permission" | "rate-limit" | "quota" | "billing" | "model" | "network" | "protocol" | "unknown", retryAfterMs?: number}} ProviderHealth
+ * @typedef {{name: "codex" | "claude" | "kimi" | "opencode", executable: string, arguments: string[], parse: (record: unknown) => import("../types.js").WorkerEvent[], sessionId: (record: unknown) => string | undefined, health: (record: unknown) => ProviderHealth | undefined, completion?: (record: unknown) => boolean}} Provider
  */
 
 /** @type {readonly ["codex", "claude", "kimi", "opencode"]} */
@@ -16,19 +17,122 @@ export const PROVIDERS = ["codex", "claude", "kimi", "opencode"]
 export function createProvider(name, providerArguments, prompt, resumeSession, environment = process.env) {
   if (name === "codex") {
     const command = buildCodexCommand(providerArguments, prompt, resumeSession, environment)
-    return {...command, name: "codex", parse: parseCodexEvent, sessionId: codexSessionId}
+    return {...command, name: "codex", parse: parseCodexEvent, sessionId: codexSessionId, health: extractProviderHealth}
   }
   if (name === "claude") {
     const command = buildClaudeCommand(providerArguments, prompt, resumeSession, environment)
-    return {...command, name: "claude", parse: createClaudeParser(), sessionId: claudeSessionId}
+    return {...command, name: "claude", parse: createClaudeParser(), sessionId: claudeSessionId, health: extractProviderHealth}
   }
   if (name === "opencode") {
     const command = buildOpenCodeCommand(providerArguments, prompt, resumeSession, environment)
-    return {...command, name: "opencode", parse: createOpenCodeParser(), sessionId: createOpenCodeSessionId()}
+    return {...command, name: "opencode", parse: createOpenCodeParser(), sessionId: createOpenCodeSessionId(), health: extractProviderHealth}
   }
   if (name === "kimi") {
     const command = buildKimiCommand(providerArguments, prompt, resumeSession, environment)
-    return {...command, name: "kimi", parse: createKimiParser(), sessionId: createKimiSessionId()}
+    return {...command, name: "kimi", parse: createKimiParser(), sessionId: createKimiSessionId(), completion: createKimiCompletion(), health: extractProviderHealth}
   }
   throw new Error(`--provider must be one of: ${PROVIDERS.join(", ")}`)
 }
+
+/**
+ * Extract safe provider health information from a structured provider record.
+ * Inspects only an explicit small list of safe containers — the top-level
+ * record and known nested `error`, `part`, `part.error`, or `*.data` objects —
+ * never traverses arbitrarily nested objects and never regexes raw message
+ * text. Generic HTTP 429 → retrying rate-limit. Structured
+ * exceeded_current_quota_error / insufficient_quota / insufficient_balance →
+ * blocked quota/billing. If no structured fields are exposed — common when a
+ * provider protocol suppresses upstream error details — no health fact is
+ * written and the run status remains running/unknown; Hermes must perform an
+ * independent bounded provider probe.
+ * @param {unknown} record
+ * @returns {ProviderHealth | undefined}
+ */
+export function extractProviderHealth(record) {
+  if (!isRecord(record)) return undefined
+
+  // Explicit containers to inspect: top-level record, record.error, record.part,
+  // record.part.error. Only these bounded paths; never recursive traversal.
+  const containers = [record]
+  if (isRecord(record.error)) containers.push(record.error)
+  if (isRecord(record.part)) {
+    containers.push(record.part)
+    if (isRecord(record.part.error)) containers.push(record.part.error)
+  }
+
+  for (const container of containers) {
+    const health = extractFromContainer(container)
+    if (health !== undefined) return health
+  }
+
+  return undefined
+}
+
+/**
+ * Inspect one safe container for structured health fields.
+ * @param {Record<string, unknown>} container
+ * @returns {ProviderHealth | undefined}
+ */
+function extractFromContainer(container) {
+  // Inspect structured data sub-object when present.
+  if (isRecord(container.data)) return extractFromContainer(container.data)
+
+  const httpStatus = container.http_status ?? container.httpStatus ?? container.status_code ?? container.statusCode
+  if (typeof httpStatus === "number" && Number.isSafeInteger(httpStatus)) {
+    if (httpStatus === 429) {
+      const retryAfterMs = safeRetryMs(container.retryAfterMs ?? container.retry_after_ms)
+      return {disposition: "retrying", category: "rate-limit", ...(retryAfterMs === undefined ? {} : {retryAfterMs})}
+    }
+    if (httpStatus >= 500 && httpStatus < 600) {
+      return {disposition: "retrying", category: "unknown"}
+    }
+  }
+
+  const code = container.code ?? container.error_code ?? container.errorCode ?? container.error_type ?? container.errorType
+  if (typeof code === "string") {
+    if (code === "exceeded_current_quota_error" || code === "insufficient_quota" || code === "quota_exceeded") {
+      return {disposition: "blocked", category: "quota"}
+    }
+    if (code === "insufficient_balance" || code === "billing_error" || code === "payment_required") {
+      return {disposition: "blocked", category: "billing"}
+    }
+    if (code === "invalid_api_key" || code === "unauthorized" || code === "auth_error" || code === "authentication_error") {
+      return {disposition: "blocked", category: "authentication"}
+    }
+    if (code === "forbidden" || code === "permission_denied") {
+      return {disposition: "blocked", category: "permission"}
+    }
+    if (code === "model_not_found" || code === "invalid_model" || code === "model_unavailable") {
+      return {disposition: "blocked", category: "model"}
+    }
+  }
+
+  if (container.insufficient_quota === true || container.quota_exceeded === true) {
+    return {disposition: "blocked", category: "quota"}
+  }
+  if (container.insufficient_balance === true) {
+    return {disposition: "blocked", category: "billing"}
+  }
+
+  return undefined
+}
+
+/**
+ * Extract a safe retry duration in milliseconds. Only explicit millisecond
+ * fields (retryAfterMs, retry_after_ms) are used; ambiguous short fields such
+ * as retry_after (seconds) are never interpreted as milliseconds.
+ * @param {unknown} value
+ */
+function safeRetryMs(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value > 0) return value
+  if (typeof value === "string" && /^\d+$/u.test(value)) {
+    const parsed = Number(value)
+    if (Number.isSafeInteger(parsed) && parsed > 0) return parsed
+  }
+  return undefined
+}
+
+/** @param {unknown} value @returns {value is Record<string, unknown>} */
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}

package/src/providers/kimi.js

@@ -67,6 +67,36 @@ export function createKimiSessionId() {
   }
 }
 
+/**
+ * Provider-owned protocol completion. Kimi confirms a completed run with a
+ * final assistant response (assistant content without further tool calls) plus
+ * its session handoff record; the two records may arrive in either order. The
+ * detector reports completion exactly once and never treats intermediate tool
+ * activity as completion.
+ * @returns {(record: unknown) => boolean}
+ */
+export function createKimiCompletion() {
+  let finalResponseSeen = false
+  let resumeHintSeen = false
+  let completed = false
+  return (record) => {
+    if (completed || !isRecord(record)) return false
+    if (isFinalAssistantResponse(record)) finalResponseSeen = true
+    else if (recognizeKimiRecord(record, undefined).sessionId !== undefined) resumeHintSeen = true
+    if (!finalResponseSeen || !resumeHintSeen) return false
+    completed = true
+    return true
+  }
+}
+
+/** @param {Record<string, unknown>} record */
+function isFinalAssistantResponse(record) {
+  return record.role === "assistant"
+    && exactOptionalKeys(record, ["role"], ["content", "tool_calls"])
+    && typeof record.content === "string"
+    && record.tool_calls === undefined
+}
+
 /** @returns {(record: unknown) => import("../types.js").WorkerEvent[]} */
 export function createKimiParser() {
   const state = createKimiRecordState()