@theokit/sdk 4.37.2 → 4.39.0

package/dist/{chunk-GL7CFBVC.js → chunk-ZYB6B7QJ.js}

@@ -1,11 +1,12 @@
-import { currentCredentialPool, computeBackoffMs, sleepWithAbort, newPooledCredential, CredentialPool } from './chunk-EXQV452X.js';
-import { invalidateSessionCache } from './chunk-EEZ7CFMM.js';
+import { currentCredentialPool, computeBackoffMs, sleepWithAbort, newPooledCredential, CredentialPool } from './chunk-HWNVAUK4.js';
+import { invalidateSessionCache } from './chunk-5KOW3GLE.js';
+import { buildErrorMetadata, mapOpenAICompatibleError } from './chunk-SCFW5MJZ.js';
 import { tryJson, isPlainObject, sanitizeToolInput } from './chunk-U54XCYG3.js';
-import { reconstructMessages, SessionTranscript } from './chunk-XAEAMI5H.js';
-import { estimateTokens } from './chunk-6VP3XGEK.js';
-import { globalSingleton, registerProvider, registerBuiltins, getProviderProfile, inferModelDialect, inferRegionFromModelId, stripBedrockPrefix, resolveBedrockBaseUrl, resolveVertexBaseUrl, stripVertexPrefix } from './chunk-77WHPVXE.js';
-import { NetworkError, AuthenticationError, RateLimitError, ConfigurationError, UnknownAgentError, IntegrationNotConnectedError, CredentialPoolExhaustedError, isTransientError, TheokitAgentError } from './chunk-CD73YHEH.js';
-import { diag, redactSecrets } from './chunk-TAPQWDW2.js';
+import { reconstructMessages, SessionTranscript } from './chunk-JRLXEYR4.js';
+import { estimateTokens } from './chunk-65ONFZWM.js';
+import { globalSingleton, registerProvider, registerBuiltins, getProviderProfile, inferModelDialect, inferRegionFromModelId, stripBedrockPrefix, resolveBedrockBaseUrl, resolveVertexBaseUrl, stripVertexPrefix } from './chunk-TOTP24P6.js';
+import { NetworkError, ConfigurationError, IntegrationNotConnectedError, AuthenticationError, RateLimitError, UnknownAgentError, CredentialPoolExhaustedError, isTransientError, TheokitAgentError } from './chunk-SG5ZWT6C.js';
+import { diag } from './chunk-IVSD7L22.js';
 import { existsSync, readFileSync } from 'fs';
 import { readdir } from 'fs/promises';
 import { homedir } from 'os';
@@ -105,37 +106,6 @@ async function loadOne(dir, entryName) {
   }
 }
 
-// src/internal/error-mappers/shared.ts
-var RAW_MAX_BYTES = 2048;
-function parseRetryAfter(headers) {
-  if (headers === void 0) return void 0;
-  const raw = headers.get("retry-after");
-  if (raw === null) return void 0;
-  const n = Number(raw);
-  if (Number.isFinite(n) && n >= 0) return Math.ceil(n);
-  const dateMs = Date.parse(raw);
-  if (Number.isFinite(dateMs)) return Math.max(0, Math.ceil((dateMs - Date.now()) / 1e3));
-  return void 0;
-}
-function truncateRaw(body) {
-  if (body === null || body === void 0) return void 0;
-  const s = typeof body === "string" ? body : JSON.stringify(body);
-  const truncated = s.length <= RAW_MAX_BYTES ? s : `${s.slice(0, RAW_MAX_BYTES)}\u2026`;
-  return redactSecrets(truncated);
-}
-function buildErrorMetadata(args) {
-  const retryAfter = parseRetryAfter(args.headers);
-  const raw = truncateRaw(args.body);
-  return {
-    provider: args.provider,
-    endpoint: args.endpoint,
-    code: args.code,
-    statusCode: args.status,
-    ...retryAfter !== void 0 ? { retryAfter } : {},
-    ...raw !== void 0 ? { raw } : {}
-  };
-}
-
 // src/internal/error-mappers/anthropic.ts
 function mapAnthropicError(args) {
   const { status, body, headers, endpoint } = args;
@@ -227,6 +197,7 @@ function makeLlmFinish(state) {
   if (state.cacheReadTokens !== void 0) finish.cacheReadTokens = state.cacheReadTokens;
   if (state.cacheWriteTokens !== void 0) finish.cacheWriteTokens = state.cacheWriteTokens;
   if (state.reasoningTokens !== void 0) finish.reasoningTokens = state.reasoningTokens;
+  if (state.thinking !== void 0) finish.thinking = state.thinking;
   return finish;
 }
 
@@ -281,25 +252,28 @@ function mapAnthropicStopReason(reason) {
       return "end_turn";
   }
 }
+function thinkingToWireBlock(part) {
+  return part.signature === void 0 ? void 0 : { type: "thinking", thinking: part.text, signature: part.signature };
+}
+function partToWireBlock(part) {
+  if (part.type === "text") return { type: "text", text: part.text };
+  if (part.type === "tool_use") {
+    return { type: "tool_use", id: part.id, name: part.name, input: part.input };
+  }
+  if (part.type === "image") return { type: "image", source: part.source };
+  if (part.type === "thinking") return thinkingToWireBlock(part);
+  return {
+    type: "tool_result",
+    tool_use_id: part.toolUseId,
+    // SE7 — this wire is block-capable: strings pass through, structured
+    // text/image blocks are forwarded natively.
+    content: toBlockToolResultContent(part.content),
+    ...part.isError === true ? { is_error: true } : {}
+  };
+}
 function toAnthropicWireMessage(message) {
   const role = message.role === "system" ? "user" : message.role;
-  const content = message.content.map((part) => {
-    if (part.type === "text") return { type: "text", text: part.text };
-    if (part.type === "tool_use") {
-      return { type: "tool_use", id: part.id, name: part.name, input: part.input };
-    }
-    if (part.type === "image") {
-      return { type: "image", source: part.source };
-    }
-    return {
-      type: "tool_result",
-      tool_use_id: part.toolUseId,
-      // SE7 — this wire is block-capable: strings pass through, structured
-      // text/image blocks are forwarded natively.
-      content: toBlockToolResultContent(part.content),
-      ...part.isError === true ? { is_error: true } : {}
-    };
-  });
+  const content = message.content.map(partToWireBlock).filter((b) => b !== void 0);
   return { role, content };
 }
 function postAnthropicRequest(args) {
@@ -343,11 +317,21 @@ async function parseHttpErrorBody(response) {
     return text;
   }
 }
+function thinkingBudgetTokens(effort) {
+  if (effort === "low" || effort === "minimal") return 1024;
+  if (effort === "high" || effort === "max") return 16384;
+  return 4096;
+}
 function buildAnthropicCommonBody(request) {
   const body = {
     max_tokens: request.maxTokens ?? 4096,
     messages: request.messages.map(toAnthropicWireMessage)
   };
+  if (request.reasoning?.effort !== void 0) {
+    const budget = thinkingBudgetTokens(request.reasoning.effort);
+    body.thinking = { type: "enabled", budget_tokens: budget };
+    if (body.max_tokens <= budget) body.max_tokens = budget + 4096;
+  }
   const wireSystem = encodeAnthropicSystem(request.system);
   if (wireSystem !== void 0) body.system = wireSystem;
   if (request.temperature !== void 0) body.temperature = request.temperature;
@@ -568,9 +552,17 @@ var AnthropicStreamAccumulator = class {
   cacheWriteTokens;
   toolCalls = /* @__PURE__ */ new Map();
   toolBuffers = /* @__PURE__ */ new Map();
+  /**
+   * theokit#122 — the turn's thinking block. Text accumulates across `thinking_delta`s; the
+   * signature arrives once, on a `signature_delta` for the same block. Undefined until the model
+   * actually opens a thinking block, so a non-thinking turn reports nothing.
+   */
+  thinking;
   consume(event) {
     if (event.type === "content_block_start") {
-      this.handleToolStart(event);
+      const block = event.content_block;
+      if (block.type === "thinking") this.handleThinkingStart(event);
+      else this.handleToolStart(event);
       return [];
     }
     if (event.type === "content_block_delta") {
@@ -591,12 +583,31 @@ var AnthropicStreamAccumulator = class {
     });
     this.toolBuffers.set(start.index, "");
   }
+  handleThinkingStart(start) {
+    this.thinking = {
+      text: start.content_block.thinking ?? "",
+      ...start.content_block.signature !== void 0 ? { signature: start.content_block.signature } : {}
+    };
+  }
   handleContentDelta(delta) {
     if (delta.delta.type === "text_delta") {
       const text = delta.delta.text;
       this.text += text;
       return [{ type: "text_delta", text }];
     }
+    if (delta.delta.type === "thinking_delta") {
+      const text = delta.delta.thinking;
+      this.thinking = {
+        ...this.thinking ?? { text: "" },
+        text: (this.thinking?.text ?? "") + text
+      };
+      return [{ type: "reasoning_delta", text }];
+    }
+    if (delta.delta.type === "signature_delta") {
+      const signature = delta.delta.signature;
+      this.thinking = { text: this.thinking?.text ?? "", signature };
+      return [{ type: "reasoning_delta", text: "", signature }];
+    }
     const idx = delta.index;
     const existing = this.toolBuffers.get(idx) ?? "";
     this.toolBuffers.set(idx, existing + delta.delta.partial_json);
@@ -642,7 +653,9 @@ var AnthropicStreamAccumulator = class {
       // T3.8 — surface Anthropic native cache-token counters when the
       // request used `cache_control: {type:"ephemeral"}` on system blocks.
       cacheReadTokens: this.cacheReadTokens,
-      cacheWriteTokens: this.cacheWriteTokens
+      cacheWriteTokens: this.cacheWriteTokens,
+      // theokit#122 — carry the thinking block + its signature so the turn can be replayed.
+      ...this.thinking !== void 0 ? { thinking: { type: "thinking", ...this.thinking } } : {}
     });
   }
 };
@@ -786,69 +799,6 @@ function buildBedrockBody(request) {
   };
 }
 
-// src/internal/error-mappers/openai-compatible.ts
-function mapOpenAICompatibleError(args) {
-  const { providerId, status, body, headers, endpoint } = args;
-  const code = mapOpenAiStatusToCode(status, body);
-  const message = formatMessage2(providerId, status, code);
-  const metadata = buildErrorMetadata({
-    provider: providerId,
-    endpoint,
-    code,
-    status,
-    headers,
-    body
-  });
-  if (status === 401 || status === 403) {
-    return new AuthenticationError(message, { code: `${providerId}_auth_failed`, metadata });
-  }
-  if (status === 429) {
-    return new RateLimitError(message, { code: `${providerId}_rate_limit`, metadata });
-  }
-  if (status === 400) {
-    return new ConfigurationError(message, { code: `${providerId}_${code}`, metadata });
-  }
-  if (status === 408) {
-    return new NetworkError(message, { code: `${providerId}_timeout`, metadata });
-  }
-  if (status >= 500 && status < 600) {
-    return new NetworkError(message, { code: `${providerId}_server_error`, metadata });
-  }
-  return new UnknownAgentError(message, { code: `${providerId}_unknown`, metadata });
-}
-function extractOpenAiErrorCode(body) {
-  if (body === null || typeof body !== "object") return void 0;
-  const err = body.error;
-  if (err === void 0 || err === null) return void 0;
-  if (typeof err.code === "string") return err.code;
-  if (typeof err.type === "string") return err.type;
-  return void 0;
-}
-function mapOpenAiStatusToCode(status, body) {
-  const rawCode = extractOpenAiErrorCode(body)?.toLowerCase() ?? "";
-  if (rawCode.includes("context_length") || rawCode.includes("context_window") || rawCode.includes("too_many_tokens") || rawCode.includes("max_tokens")) {
-    return "context_too_long";
-  }
-  if (rawCode.includes("content_filter") || rawCode.includes("content_policy") || rawCode.includes("safety")) {
-    return "content_filtered";
-  }
-  if (rawCode.includes("model_not_found") || rawCode.includes("model_unavailable") || rawCode.includes("invalid_model")) {
-    return "model_unavailable";
-  }
-  if (status === 402 || rawCode.includes("insufficient_quota") || rawCode.includes("quota_exceeded")) {
-    return "quota_exceeded";
-  }
-  if (status === 401 || status === 403) return "auth_failed";
-  if (status === 429) return "rate_limit";
-  if (status === 408) return "timeout";
-  if (status === 400) return "invalid_request";
-  if (status >= 500 && status < 600) return "server_error";
-  return "unknown";
-}
-function formatMessage2(providerId, status, code) {
-  return `${providerId} API error: ${code} (HTTP ${status})`;
-}
-
 // src/internal/llm/fault-injection.ts
 var ENV_GATE_KEY = "NODE_ENV";
 var ENV_GATE_VALUE = "test";
@@ -888,7 +838,6 @@ var FaultInjectingLlmClient = class {
     }
     const text = extractText(parsed.body);
     yield { type: "text_delta", text };
-    yield { type: "stop", reason: "end_turn" };
     return {
       stopReason: "end_turn",
       text,
@@ -2247,7 +2196,6 @@ var ResponsesApiClient = class {
           };
           toolCalls.push(call);
           delete pending[id];
-          yield { type: "tool_use", id: call.id, name: call.name, input: call.input };
         } else if (t === "response.completed" || t === "response.incomplete") {
           const usage = event.response?.usage;
           if (usage !== void 0) {
@@ -2270,7 +2218,6 @@ var ResponsesApiClient = class {
       }
     }
     if (toolCalls.length > 0 && stopReason === "end_turn") stopReason = "tool_use";
-    yield { type: "stop", reason: stopReason };
     return makeLlmFinish({
       stopReason,
       text,
@@ -2289,32 +2236,32 @@ function abortError2(signal) {
 }
 
 // src/internal/llm/retrying-client.ts
-var MAX_TENTATIVAS = 3;
-function ehTransitorio(err) {
+var MAX_ATTEMPTS = 3;
+function isRetriableError(err) {
   if (!isTransientError(err)) return false;
   if (err instanceof CredentialPoolExhaustedError) return false;
   if (err instanceof TheokitAgentError && err.code === "circuit_open") return false;
   if (err instanceof RateLimitError && err.metadata?.statusCode === 402) return false;
   return true;
 }
-function dicaDeRetryAfterMs(err) {
+function retryAfterHintMs(err) {
   if (!(err instanceof RateLimitError)) return void 0;
-  const segundos = err.metadata?.retryAfter;
-  return typeof segundos === "number" && segundos > 0 ? segundos * 1e3 : void 0;
+  const seconds = err.metadata?.retryAfter;
+  return typeof seconds === "number" && seconds > 0 ? seconds * 1e3 : void 0;
 }
-async function* consumir(gen, estado) {
-  let passo = await gen.next();
-  while (passo.done !== true) {
-    estado.emitiu = true;
-    yield passo.value;
-    passo = await gen.next();
+async function* consume(gen, state) {
+  let step = await gen.next();
+  while (step.done !== true) {
+    state.emitted = true;
+    yield step.value;
+    step = await gen.next();
   }
-  return passo.value;
+  return step.value;
 }
-function podeReexecutar(err, emitiu, tentativa) {
-  if (emitiu) return false;
-  if (tentativa === MAX_TENTATIVAS - 1) return false;
-  return ehTransitorio(err);
+function canRetry(err, emitted, attempt) {
+  if (emitted) return false;
+  if (attempt === MAX_ATTEMPTS - 1) return false;
+  return isRetriableError(err);
 }
 var RetryingLlmClient = class {
   #inner;
@@ -2324,10 +2271,10 @@ var RetryingLlmClient = class {
     this.#rng = opts?.rng;
   }
   /**
-   * O cliente decorado. Público pela mesma convenção de `FaultInjectingLlmClient.inner`: os testes
-   * de fiação do router afirmam `instanceof PoolAwareLlmClient` e precisam enxergar através dos
-   * decorators. Sem isto, adicionar um decorator quebra testes cuja intenção continua válida — que
-   * foi exatamente o que o M93 fez com 4 testes pré-existentes.
+   * The decorated client. Public by the same convention as `FaultInjectingLlmClient.inner`: the
+   * router's wiring tests assert `instanceof PoolAwareLlmClient` and need to see through the
+   * decorators. Without this, adding a decorator breaks tests whose intent is still valid — which is
+   * exactly what M93 did to 4 pre-existing tests.
    */
   get inner() {
     return this.#inner;
@@ -2336,35 +2283,35 @@ var RetryingLlmClient = class {
     return this.#inner.name;
   }
   /**
-   * Espera o backoff da tentativa `n`, honrando o `Retry-After` do provider quando ele veio.
+   * Waits out attempt `n`'s backoff, honoring the provider's `Retry-After` when one arrived.
    *
-   * Método próprio porque o `stream` é um gerador com laço aninhado, e embutir aqui a montagem
-   * condicional das opções levava a complexidade cognitiva a 19 (teto do projeto: 10). O corpo do
-   * `stream` fica sendo só a máquina de tentativas.
+   * Its own method because `stream` is a generator with a nested loop, and inlining the conditional
+   * option assembly here pushed cognitive complexity to 19 (project ceiling: 10). The body of
+   * `stream` stays nothing but the attempt machine.
    */
-  async #esperarBackoff(err, tentativa, signal) {
-    const dica = dicaDeRetryAfterMs(err);
+  async #waitBackoff(err, attempt, signal) {
+    const hint = retryAfterHintMs(err);
     const ms = computeBackoffMs({
-      attempt: tentativa,
-      ...dica !== void 0 ? { retryAfterMs: dica } : {},
+      attempt,
+      ...hint !== void 0 ? { retryAfterMs: hint } : {},
       ...this.#rng !== void 0 ? { rng: this.#rng } : {}
     });
     await sleepWithAbort(ms, signal);
   }
   async *stream(request, signal) {
-    let ultimoErro;
-    for (let tentativa = 0; tentativa < MAX_TENTATIVAS; tentativa++) {
-      if (signal.aborted) throw ultimoErro ?? abortError2(signal);
-      const estado = { emitiu: false };
+    let lastError;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      if (signal.aborted) throw lastError ?? abortError2(signal);
+      const state = { emitted: false };
       try {
-        return yield* consumir(this.#inner.stream(request, signal), estado);
+        return yield* consume(this.#inner.stream(request, signal), state);
       } catch (err) {
-        ultimoErro = err;
-        if (!podeReexecutar(err, estado.emitiu, tentativa)) throw err;
-        await this.#esperarBackoff(err, tentativa, signal);
+        lastError = err;
+        if (!canRetry(err, state.emitted, attempt)) throw err;
+        await this.#waitBackoff(err, attempt, signal);
       }
     }
-    throw ultimoErro ?? new Error("retry esgotado sem erro registrado");
+    throw lastError ?? new Error("retries exhausted with no recorded error");
   }
 };
 
@@ -2743,13 +2690,13 @@ function selectTransport(profile, apiKey) {
     const ctx = { apiKey };
     return { fetch: profile.transform.fetch?.(ctx), headers: profile.transform.headers?.(ctx) };
   };
-  const comTransform = (opts, criar) => {
+  const comTransform = (opts, construct) => {
     const t = applyTransform();
     assertOAuthResolved(t);
     if (t.fetch !== void 0) opts.fetch = t.fetch;
     const merged = profile.extraHeaders !== void 0 || t.headers !== void 0 ? { ...profile.extraHeaders, ...t.headers } : void 0;
     if (merged !== void 0) opts.extraHeaders = merged;
-    return criar(opts);
+    return construct(opts);
   };
   const assertOAuthResolved = (t) => {
     if (apiKey !== "__oauth_lazy_token__") return;
@@ -3088,6 +3035,6 @@ async function autoCompactIfNeeded(opts) {
   }
 }
 
-export { COMPACT_SUMMARY_MARKER, COMPACT_USER_MESSAGE_MAX_TOKENS, CircuitBreaker, autoCompactIfNeeded, buildDefaultSummarizer, compactSessionTranscript, detectPrimaryProvider, discoverProviderPlugins, getConfiguredBaseUrl, httpRequest, inferProviderFromApiKey, isCompactSummary, isFixtureApiKey, mapOllamaHttpError, mapOllamaTransportError, mapOpenAICompatibleError, parseSseStream, readErrorResponseBody, relayStream, renderToolResultContentText, resolveProviderChain, resolveSummarizerRoute, shouldAutoCompact, shouldUseFixtureMode, shouldUseRealLocalRuntime, tryFirstEvent };
-//# sourceMappingURL=chunk-GL7CFBVC.js.map
-//# sourceMappingURL=chunk-GL7CFBVC.js.map
+export { COMPACT_SUMMARY_MARKER, COMPACT_USER_MESSAGE_MAX_TOKENS, CircuitBreaker, autoCompactIfNeeded, buildDefaultSummarizer, compactSessionTranscript, detectPrimaryProvider, discoverProviderPlugins, getConfiguredBaseUrl, httpRequest, inferProviderFromApiKey, isCompactSummary, isFixtureApiKey, mapOllamaHttpError, mapOllamaTransportError, parseSseStream, readErrorResponseBody, relayStream, renderToolResultContentText, resolveProviderChain, resolveSummarizerRoute, shouldAutoCompact, shouldUseFixtureMode, shouldUseRealLocalRuntime, tryFirstEvent };
+//# sourceMappingURL=chunk-ZYB6B7QJ.js.map
+//# sourceMappingURL=chunk-ZYB6B7QJ.js.map