@theokit/sdk 4.31.0 → 4.31.1

package/dist/{chunk-TLG444A6.js → chunk-XDNGF5BY.js}

@@ -1,10 +1,10 @@
 import { currentCredentialPool, computeBackoffMs, sleepWithAbort, newPooledCredential, CredentialPool } from './chunk-6CLRANZA.js';
 import { invalidateSessionCache } from './chunk-EEZ7CFMM.js';
 import { tryJson, isPlainObject, sanitizeToolInput } from './chunk-U54XCYG3.js';
-import { reconstructMessages, SessionTranscript } from './chunk-ZZWTY3RX.js';
+import { reconstructMessages, SessionTranscript } from './chunk-VGUOUAM2.js';
 import { estimateTokens } from './chunk-WA3FO4R7.js';
 import { globalSingleton, registerProvider, registerBuiltins, getProviderProfile, inferModelDialect, inferRegionFromModelId, stripBedrockPrefix, resolveBedrockBaseUrl, resolveVertexBaseUrl, stripVertexPrefix } from './chunk-KAP4GJHO.js';
-import { NetworkError, AuthenticationError, RateLimitError, ConfigurationError, UnknownAgentError, CredentialPoolExhaustedError } from './chunk-WLKFWQSJ.js';
+import { NetworkError, AuthenticationError, RateLimitError, ConfigurationError, UnknownAgentError, CredentialPoolExhaustedError, isTransientError, TheokitAgentError } from './chunk-WLKFWQSJ.js';
 import { redactSecrets } from './chunk-JTFYYKDT.js';
 import { existsSync, readFileSync } from 'fs';
 import { readdir } from 'fs/promises';
@@ -472,6 +472,22 @@ function releaseReader(reader) {
   }
 }
 
+// src/internal/llm/transport-error.ts
+function ehAbort(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const nome = err.name;
+  return nome === "AbortError" || nome === "TimeoutError";
+}
+function wrapTransportError(err, ctx) {
+  if (ehAbort(err)) return err;
+  if (err instanceof NetworkError) return err;
+  const detalhe = err instanceof Error ? err.message : String(err);
+  return new NetworkError(`${ctx.providerId} transport failure on ${ctx.endpoint}: ${detalhe}`, {
+    code: "transport_failure",
+    cause: err
+  });
+}
+
 // src/internal/llm/anthropic.ts
 var AnthropicClient = class {
   constructor(options) {
@@ -492,12 +508,17 @@ var AnthropicClient = class {
       "anthropic-version": this.options.version ?? "2023-06-01"
     };
     if (this.options.extraHeaders !== void 0) Object.assign(headers, this.options.extraHeaders);
-    const response = await this.fetchImpl(`${this.baseUrl}/v1/messages`, {
-      method: "POST",
-      signal,
-      headers,
-      body: JSON.stringify(body)
-    });
+    let response;
+    try {
+      response = await this.fetchImpl(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        signal,
+        headers,
+        body: JSON.stringify(body)
+      });
+    } catch (fetchErr) {
+      throw wrapTransportError(fetchErr, { providerId: this.name, endpoint: "/v1/messages" });
+    }
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       let body2 = text;
@@ -1462,7 +1483,7 @@ var OpenAIClient = class {
         endpoint: "/v1/chat/completions"
       });
       if (mapped !== void 0) throw mapped;
-      throw fetchErr;
+      throw wrapTransportError(fetchErr, { providerId, endpoint: "/v1/chat/completions" });
     }
     if (!response.ok) {
       const text = await response.text().catch(() => "");
@@ -1923,60 +1944,6 @@ function abortError(signal) {
   return new Error("AbortError");
 }
 
-// src/internal/llm/retrying-client.ts
-var MAX_TENTATIVAS = 3;
-function ehTransitorio(err) {
-  if (err instanceof AuthenticationError) return false;
-  if (err instanceof RateLimitError) {
-    const status = err.metadata?.statusCode ?? 429;
-    return status !== 402;
-  }
-  return err instanceof Error && !/\b4\d\d\b/.test(err.message);
-}
-function dicaDeRetryAfterMs(err) {
-  if (!(err instanceof RateLimitError)) return void 0;
-  const segundos = err.metadata?.retryAfter;
-  return typeof segundos === "number" && segundos > 0 ? segundos * 1e3 : void 0;
-}
-var RetryingLlmClient = class {
-  #inner;
-  #rng;
-  constructor(inner, opts) {
-    this.#inner = inner;
-    this.#rng = opts?.rng;
-  }
-  get name() {
-    return this.#inner.name;
-  }
-  async *stream(request, signal) {
-    let ultimoErro;
-    for (let tentativa = 0; tentativa < MAX_TENTATIVAS; tentativa++) {
-      if (signal.aborted) throw ultimoErro ?? new Error("aborted");
-      try {
-        const gen = this.#inner.stream(request, signal);
-        let passo = await gen.next();
-        while (passo.done !== true) {
-          yield passo.value;
-          passo = await gen.next();
-        }
-        return passo.value;
-      } catch (err) {
-        ultimoErro = err;
-        const ultima = tentativa === MAX_TENTATIVAS - 1;
-        if (ultima || !ehTransitorio(err)) throw err;
-        const dica = dicaDeRetryAfterMs(err);
-        const ms = computeBackoffMs({
-          attempt: tentativa,
-          ...dica !== void 0 ? { retryAfterMs: dica } : {},
-          ...this.#rng !== void 0 ? { rng: this.#rng } : {}
-        });
-        await sleepWithAbort(ms, signal);
-      }
-    }
-    throw ultimoErro ?? new Error("retry esgotado sem erro registrado");
-  }
-};
-
 // src/internal/llm/responses.ts
 function messageToInputItems(message) {
   const items = [];
@@ -2172,6 +2139,92 @@ var ResponsesApiClient = class {
   }
 };
 
+// src/internal/llm/abort-error.ts
+function abortError2(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  return new Error(signal.reason !== void 0 ? String(signal.reason) : "aborted");
+}
+
+// src/internal/llm/retrying-client.ts
+var MAX_TENTATIVAS = 3;
+function ehTransitorio(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) {
+  if (!(err instanceof RateLimitError)) return void 0;
+  const segundos = err.metadata?.retryAfter;
+  return typeof segundos === "number" && segundos > 0 ? segundos * 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();
+  }
+  return passo.value;
+}
+function podeReexecutar(err, emitiu, tentativa) {
+  if (emitiu) return false;
+  if (tentativa === MAX_TENTATIVAS - 1) return false;
+  return ehTransitorio(err);
+}
+var RetryingLlmClient = class {
+  #inner;
+  #rng;
+  constructor(inner, opts) {
+    this.#inner = inner;
+    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.
+   */
+  get inner() {
+    return this.#inner;
+  }
+  get name() {
+    return this.#inner.name;
+  }
+  /**
+   * Espera o backoff da tentativa `n`, honrando o `Retry-After` do provider quando ele veio.
+   *
+   * 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.
+   */
+  async #esperarBackoff(err, tentativa, signal) {
+    const dica = dicaDeRetryAfterMs(err);
+    const ms = computeBackoffMs({
+      attempt: tentativa,
+      ...dica !== void 0 ? { retryAfterMs: dica } : {},
+      ...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 };
+      try {
+        return yield* consumir(this.#inner.stream(request, signal), estado);
+      } catch (err) {
+        ultimoErro = err;
+        if (!podeReexecutar(err, estado.emitiu, tentativa)) throw err;
+        await this.#esperarBackoff(err, tentativa, signal);
+      }
+    }
+    throw ultimoErro ?? new Error("retry esgotado sem erro registrado");
+  }
+};
+
 // src/internal/error-mappers/vertex.ts
 var VERTEX_RULES = [
   { test: (s, e) => s === 429 || e === "RESOURCE_EXHAUSTED", code: "rate_limit" },
@@ -2434,7 +2487,12 @@ function buildClient(name, routerOptions) {
   const ambient = currentCredentialPool(name);
   if (ambient !== void 0) {
     return new RetryingLlmClient(
-      new PoolAwareLlmClient(ambient, (apiKey) => selectTransport(profile, apiKey), void 0, resilience)
+      new PoolAwareLlmClient(
+        ambient,
+        (apiKey) => selectTransport(profile, apiKey),
+        void 0,
+        resilience
+      )
     );
   }
   const poolKeys = filterPoolKeys(routerOptions.apiKeys?.[name]);
@@ -2461,7 +2519,12 @@ function buildPoolOrSingle(args) {
     const pool = new CredentialPool(name, entries, strategy);
     const resilience = routerOptions.onRateLimit !== void 0 ? { onRateLimit: routerOptions.onRateLimit } : {};
     return new RetryingLlmClient(
-      new PoolAwareLlmClient(pool, (apiKey2) => selectTransport(profile, apiKey2), void 0, resilience)
+      new PoolAwareLlmClient(
+        pool,
+        (apiKey2) => selectTransport(profile, apiKey2),
+        void 0,
+        resilience
+      )
     );
   }
   const apiKey = poolKeys?.[0] ?? resolveApiKey(profile.envVars) ?? sentinelForNoAuth(profile) ?? sentinelForLazyAuth(profile);
@@ -2885,5 +2948,5 @@ async function autoCompactIfNeeded(opts) {
 }
 
 export { COMPACT_SUMMARY_MARKER, COMPACT_USER_MESSAGE_MAX_TOKENS, CircuitBreaker, autoCompactIfNeeded, buildDefaultSummarizer, compactSessionTranscript, detectPrimaryProvider, discoverProviderPlugins, inferProviderFromApiKey, isCompactSummary, mapOllamaHttpError, mapOllamaTransportError, mapOpenAICompatibleError, parseSseStream, relayStream, renderToolResultContentText, resolveProviderChain, resolveSummarizerRoute, shouldAutoCompact, tryFirstEvent };
-//# sourceMappingURL=chunk-TLG444A6.js.map
-//# sourceMappingURL=chunk-TLG444A6.js.map
+//# sourceMappingURL=chunk-XDNGF5BY.js.map
+//# sourceMappingURL=chunk-XDNGF5BY.js.map