@anvia/core 0.13.3 → 0.13.4

package/dist/agent/index.d.ts

@@ -1,5 +1,5 @@
-import { D as DynamicContextOptions, a as DynamicToolOptions, b as AgentEventStore, c as AgentEventStoreOptions, A as Agent } from '../agent-3qSfIKIj.js';
-export { d as AgentEventAppendInput, e as AgentEventRecord, f as AgentEventStoreInclude, g as AgentSession, h as AgentToolOptions } from '../agent-3qSfIKIj.js';
+import { D as DynamicContextOptions, b as DynamicToolOptions, c as AgentEventStore, d as AgentEventStoreOptions, A as Agent } from '../agent-DJr2ITZY.js';
+export { e as AgentEventAppendInput, f as AgentEventRecord, g as AgentEventStoreInclude, h as AgentSession, i as AgentToolOptions } from '../agent-DJr2ITZY.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
 import { C as CompletionModel, f as JsonValue, t as ToolChoice } from '../types-DzdJOf35.js';
 import { GuardrailPolicyInput } from '../guardrails/index.js';

package/dist/agent/index.js

@@ -1,8 +1,8 @@
 import {
   AgentBuilder
-} from "../chunk-AWTFWDMY.js";
-import "../chunk-J3R7WC2W.js";
-import "../chunk-VPRJIWTP.js";
+} from "../chunk-IWVNXLGQ.js";
+import "../chunk-BKKHXEWS.js";
+import "../chunk-HRZV6BQL.js";
 import "../chunk-YK4WAAS4.js";
 import "../chunk-XUUY2L2D.js";
 import "../chunk-WHHQWT7D.js";

package/dist/{agent-3qSfIKIj.d.ts → agent-DJr2ITZY.d.ts}

@@ -7,6 +7,20 @@ import { e as ToolApprovalsOptions, T as Tool, A as AnyTool, f as ToolCallContex
 import { A as AgentMiddleware, e as ToolMiddleware, k as ToolSearchDocument, l as ToolSet } from './middleware-Cc_-sosu.js';
 import { V as VectorFilter, c as VectorSearchResult, a as VectorSearchIndex } from './types-C708DOhL.js';
 
+type CompletionRetryContext = {
+    error: unknown;
+    attempt: number;
+    maxAttempts: number;
+    turn: number;
+    streaming: boolean;
+};
+type CompletionRetryOptions = {
+    maxAttempts?: number | undefined;
+    initialDelayMs?: number | undefined;
+    maxDelayMs?: number | undefined;
+    shouldRetry?: ((context: CompletionRetryContext) => boolean) | undefined;
+};
+
 declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private readonly agent;
     private promptMessage;
@@ -19,6 +33,7 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private guardrailDecisions;
     private concurrency;
     private traceOptions;
+    private completionRetryOptions;
     private requestMiddlewares;
     private readonly steeringMessages;
     private runState;
@@ -28,6 +43,7 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
         memoryContext?: MemoryContext | undefined;
     }): PromptRequest<M>;
     maxTurns(maxTurns: number): this;
+    withCompletionRetries(options?: CompletionRetryOptions): this;
     withHook(hook: PromptHook): this;
     approvals(options: ToolApprovalsOptions): this;
     guardrails(policies: GuardrailPolicyInput): this;
@@ -54,6 +70,8 @@ declare class PromptRequest<M extends CompletionModel = CompletionModel> {
     private runCompletion;
     private providerTraceRequest;
     private generationStartArgs;
+    private retryOptionsForFailure;
+    private scheduleCompletionRetry;
     private executeToolCalls;
     private runOutputGuardrailsForResponse;
     private recordGuardrailDecision;
@@ -209,4 +227,4 @@ declare class AgentSession<M extends CompletionModel = CompletionModel> {
     clear(): Promise<void>;
 }
 
-export { Agent as A, type DynamicContextOptions as D, PromptRequest as P, type DynamicToolOptions as a, type AgentEventStore as b, type AgentEventStoreOptions as c, type AgentEventAppendInput as d, type AgentEventRecord as e, type AgentEventStoreInclude as f, AgentSession as g, type AgentToolOptions as h, type AgentEventStoreRegistration as i, type AgentOptions as j, DEFAULT_MAX_TURNS as k, type DynamicContextRegistration as l, type DynamicToolRegistration as m };
+export { Agent as A, type CompletionRetryContext as C, type DynamicContextOptions as D, PromptRequest as P, type CompletionRetryOptions as a, type DynamicToolOptions as b, type AgentEventStore as c, type AgentEventStoreOptions as d, type AgentEventAppendInput as e, type AgentEventRecord as f, type AgentEventStoreInclude as g, AgentSession as h, type AgentToolOptions as i, type AgentEventStoreRegistration as j, type AgentOptions as k, DEFAULT_MAX_TURNS as l, type DynamicContextRegistration as m, type DynamicToolRegistration as n };

package/dist/{chunk-J3R7WC2W.js → chunk-BKKHXEWS.js}

@@ -1,6 +1,6 @@
 import {
   PromptRequest
-} from "./chunk-VPRJIWTP.js";
+} from "./chunk-HRZV6BQL.js";
 import {
   isSkillTool
 } from "./chunk-YK4WAAS4.js";
@@ -207,4 +207,4 @@ export {
   Agent,
   AgentSession
 };
-//# sourceMappingURL=chunk-J3R7WC2W.js.map
+//# sourceMappingURL=chunk-BKKHXEWS.js.map

package/dist/{chunk-VPRJIWTP.js → chunk-HRZV6BQL.js}

@@ -1277,6 +1277,155 @@ var ActiveToolObservers = class {
   }
 };
 
+// src/request/retry.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_INITIAL_DELAY_MS = 100;
+var DEFAULT_MAX_DELAY_MS = 1e3;
+var MAX_TIMER_DELAY_MS = 2147483647;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 409, 425, 429]);
+var RETRYABLE_NUMERIC_ERROR_CODES = /* @__PURE__ */ new Set([4, 8, 14]);
+var RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "APIConnectionError",
+  "APIConnectionTimeoutError",
+  "TimeoutError"
+]);
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "DEADLINE_EXCEEDED",
+  "EAI_AGAIN",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETDOWN",
+  "ENETUNREACH",
+  "EPIPE",
+  "ETIMEDOUT",
+  "RESOURCE_EXHAUSTED",
+  "UNAVAILABLE",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_SOCKET"
+]);
+function resolveCompletionRetryOptions(options) {
+  const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+  const initialDelayMs = options.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS;
+  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError("Completion retry maxAttempts must be a positive integer.");
+  }
+  assertDelay(initialDelayMs, "initialDelayMs");
+  assertDelay(maxDelayMs, "maxDelayMs");
+  if (maxDelayMs < initialDelayMs) {
+    throw new RangeError(
+      "Completion retry maxDelayMs must be greater than or equal to initialDelayMs."
+    );
+  }
+  if (options.shouldRetry !== void 0 && typeof options.shouldRetry !== "function") {
+    throw new TypeError("Completion retry shouldRetry must be a function.");
+  }
+  return {
+    maxAttempts,
+    initialDelayMs,
+    maxDelayMs,
+    shouldRetry: options.shouldRetry ?? defaultShouldRetry
+  };
+}
+function completionRetryDelayMs(options, failedAttempt) {
+  const exponentialDelay = options.initialDelayMs * 2 ** (failedAttempt - 1);
+  const cappedDelay = Math.min(options.maxDelayMs, exponentialDelay);
+  return Math.random() * cappedDelay;
+}
+function completionRetryErrorAttributes(error) {
+  const errors = errorChain(error);
+  const errorName = errors.map((candidate) => stringProperty(candidate, "name")).find((value) => value !== void 0);
+  const statusCode = firstStatusCode(errors);
+  const errorCode = errors.map((candidate) => errorCodeProperty(candidate)).find((value) => value !== void 0);
+  return {
+    errorName,
+    statusCode,
+    errorCode
+  };
+}
+async function waitForCompletionRetry(delayMs) {
+  if (delayMs === 0) {
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function defaultShouldRetry(context) {
+  const errors = errorChain(context.error);
+  if (errors.some((error) => stringProperty(error, "name") === "AbortError")) {
+    return false;
+  }
+  const statusCode = firstStatusCode(errors);
+  if (statusCode !== void 0) {
+    return RETRYABLE_STATUS_CODES.has(statusCode) || statusCode >= 500 && statusCode <= 599;
+  }
+  return errors.some((error) => {
+    const name = stringProperty(error, "name");
+    if (name !== void 0 && RETRYABLE_ERROR_NAMES.has(name)) {
+      return true;
+    }
+    const code = stringProperty(error, "code")?.toUpperCase();
+    if (code !== void 0 && RETRYABLE_ERROR_CODES.has(code)) {
+      return true;
+    }
+    const numericCode = numberProperty(error, "code");
+    return numericCode !== void 0 && RETRYABLE_NUMERIC_ERROR_CODES.has(numericCode);
+  });
+}
+function firstStatusCode(errors) {
+  for (const error of errors) {
+    const status = numberProperty(error, "status") ?? numberProperty(error, "statusCode");
+    if (status !== void 0) {
+      return status;
+    }
+    const code = numberProperty(error, "code");
+    if (code !== void 0 && code >= 100 && code <= 599) {
+      return code;
+    }
+  }
+  return void 0;
+}
+function errorChain(error) {
+  const errors = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (isObject(current) && !seen.has(current)) {
+    seen.add(current);
+    errors.push(current);
+    current = property(current, "cause");
+  }
+  return errors;
+}
+function assertDelay(value, name) {
+  if (!Number.isFinite(value) || value < 0 || value > MAX_TIMER_DELAY_MS) {
+    throw new RangeError(
+      `Completion retry ${name} must be between 0 and ${MAX_TIMER_DELAY_MS} milliseconds.`
+    );
+  }
+}
+function numberProperty(value, name) {
+  const candidate = property(value, name);
+  return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : void 0;
+}
+function stringProperty(value, name) {
+  const candidate = property(value, name);
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function errorCodeProperty(value) {
+  return stringProperty(value, "code") ?? numberProperty(value, "code");
+}
+function property(value, name) {
+  try {
+    return value[name];
+  } catch {
+    return void 0;
+  }
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
 // src/request/prompt-request.ts
 var PromptRequest = class _PromptRequest {
   constructor(agent, promptMessage, initialHistory = [], memoryContext = void 0) {
@@ -1301,6 +1450,7 @@ var PromptRequest = class _PromptRequest {
   guardrailDecisions = [];
   concurrency = 1;
   traceOptions;
+  completionRetryOptions;
   requestMiddlewares = [];
   steeringMessages = [];
   runState = "idle";
@@ -1313,6 +1463,10 @@ var PromptRequest = class _PromptRequest {
     this.maxTurnCount = maxTurns;
     return this;
   }
+  withCompletionRetries(options = {}) {
+    this.completionRetryOptions = resolveCompletionRetryOptions(options);
+    return this;
+  }
   withHook(hook) {
     this.activeHook = hook;
     return this;
@@ -1608,26 +1762,46 @@ var PromptRequest = class _PromptRequest {
         const emittedToolCallIds = /* @__PURE__ */ new Set();
         let response;
         try {
-          for await (const event of this.agent.model.streamCompletion(request)) {
-            if (firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
-              firstDeltaMs = Date.now() - generationStartedAt;
-            }
-            const mapped = accumulator.accept(event);
-            if (event.type === "error") {
-              throw event.error;
-            }
-            if (mapped !== void 0) {
-              await generationObservers.update?.({ turn: currentTurns, delta: mapped });
-              if (mapped.type === "tool_call") {
-                emittedToolCallIds.add(mapped.toolCall.id);
+          for (let attempt = 1; ; attempt += 1) {
+            let hasProviderProgress = false;
+            try {
+              for await (const event of this.agent.model.streamCompletion(request)) {
+                if (event.type === "error") {
+                  throw event.error;
+                }
+                hasProviderProgress = true;
+                if (firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
+                  firstDeltaMs = Date.now() - generationStartedAt;
+                }
+                const mapped = accumulator.accept(event);
+                if (mapped !== void 0) {
+                  await generationObservers.update?.({ turn: currentTurns, delta: mapped });
+                  if (mapped.type === "tool_call") {
+                    emittedToolCallIds.add(mapped.toolCall.id);
+                  }
+                  const shouldBuffer = bufferResponseEvents || bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
+                  if (!shouldBuffer) {
+                    yield await emit(addTurn(currentTurns, mapped));
+                  }
+                }
               }
-              const shouldBuffer = bufferResponseEvents || bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
-              if (!shouldBuffer) {
-                yield await emit(addTurn(currentTurns, mapped));
+              response = accumulator.response();
+              break;
+            } catch (error) {
+              const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, currentTurns, true);
+              if (retryOptions === void 0) {
+                throw error;
               }
+              await this.scheduleCompletionRetry(
+                error,
+                attempt,
+                currentTurns,
+                true,
+                retryOptions,
+                runObservers
+              );
             }
           }
-          response = accumulator.response();
         } catch (error) {
           await generationObservers.error({ turn: currentTurns, error });
           await this.runCompletionErrorHook(prompt, error, newMessages);
@@ -1801,9 +1975,28 @@ var PromptRequest = class _PromptRequest {
       this.generationStartArgs(turn, request, providerRequest)
     );
     try {
-      const response = await this.agent.model.completion(request);
-      await generationObservers.end({ turn, response });
-      return response;
+      for (let attempt = 1; ; attempt += 1) {
+        let response;
+        try {
+          response = await this.agent.model.completion(request);
+        } catch (error) {
+          const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
+          if (retryOptions === void 0) {
+            throw error;
+          }
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            turn,
+            false,
+            retryOptions,
+            runObservers
+          );
+          continue;
+        }
+        await generationObservers.end({ turn, response });
+        return response;
+      }
     } catch (error) {
       await generationObservers.error({ turn, error });
       throw error;
@@ -1833,6 +2026,37 @@ var PromptRequest = class _PromptRequest {
     }
     return args;
   }
+  retryOptionsForFailure(error, attempt, turn, streaming) {
+    const options = this.completionRetryOptions;
+    if (options === void 0 || attempt >= options.maxAttempts) {
+      return void 0;
+    }
+    const shouldRetry = options.shouldRetry({
+      error,
+      attempt,
+      maxAttempts: options.maxAttempts,
+      turn,
+      streaming
+    });
+    return shouldRetry ? options : void 0;
+  }
+  async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers) {
+    const delayMs = completionRetryDelayMs(options, attempt);
+    await runObservers.event({
+      name: "completion.retry",
+      level: "WARNING",
+      attributes: {
+        turn,
+        attempt,
+        nextAttempt: attempt + 1,
+        maxAttempts: options.maxAttempts,
+        delayMs,
+        streaming,
+        ...completionRetryErrorAttributes(error)
+      }
+    });
+    await waitForCompletionRetry(delayMs);
+  }
   async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
     const executor = new ToolCallExecutor(
       this.agent,
@@ -2203,4 +2427,4 @@ export {
   extractRagText,
   PromptRequest
 };
-//# sourceMappingURL=chunk-VPRJIWTP.js.map
+//# sourceMappingURL=chunk-HRZV6BQL.js.map