formagent-sdk 0.3.0 → 0.4.0

package/dist/index.js

@@ -480,6 +480,117 @@ function getProviderEnv() {
     }
   };
 }
+// src/utils/retry.ts
+var DEFAULT_RETRY_OPTIONS = {
+  maxAttempts: 3,
+  initialDelay: 1000,
+  maxDelay: 30000,
+  backoffMultiplier: 2,
+  jitter: true,
+  onRetry: () => {},
+  signal: undefined
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function calculateDelay(attempt, initialDelay, maxDelay, backoffMultiplier, jitter) {
+  const delay = Math.min(initialDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+  if (jitter) {
+    return delay * (0.5 + Math.random() * 0.5);
+  }
+  return delay;
+}
+function isRetryableStatus(status) {
+  return status >= 500 || status === 429;
+}
+function isRetryableError(error) {
+  if (error instanceof TypeError) {
+    return error.message.includes("fetch") || error.message.includes("network") || error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("ECONNRESET");
+  }
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("rate_limit") || message.includes("rate limit")) {
+      return true;
+    }
+    if (message.includes("usage_limit") || message.includes("usage limit")) {
+      return true;
+    }
+    if (message.includes("timeout") || message.includes("timed out")) {
+      return true;
+    }
+    if (message.includes("5") || message.includes("502") || message.includes("503") || message.includes("504")) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractStatusCode(error) {
+  const match = error.message.match(/(\d{3})/);
+  return match ? parseInt(match[1], 10) : null;
+}
+async function withRetry(fn, options2 = {}) {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options2 };
+  let lastError = null;
+  for (let attempt = 0;attempt < opts.maxAttempts; attempt++) {
+    if (opts.signal?.aborted) {
+      throw new Error("Request aborted");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt >= opts.maxAttempts - 1) {
+        throw lastError;
+      }
+      const statusCode = extractStatusCode(lastError);
+      const isRetryable = statusCode !== null ? isRetryableStatus(statusCode) : isRetryableError(lastError);
+      if (!isRetryable) {
+        throw lastError;
+      }
+      const delay = calculateDelay(attempt, opts.initialDelay, opts.maxDelay, opts.backoffMultiplier, opts.jitter);
+      opts.onRetry(attempt + 1, lastError);
+      await sleep(delay);
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+async function fetchWithRetry(url, init, retryOptions) {
+  return withRetry(async () => {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      let errorMessage = `HTTP ${response.status}`;
+      try {
+        const errorJson = JSON.parse(errorText);
+        if (errorJson.error?.type) {
+          errorMessage += `: ${errorJson.error.type}`;
+        }
+        if (errorJson.error?.message) {
+          errorMessage += ` - ${errorJson.error.message}`;
+        }
+      } catch {
+        if (errorText) {
+          errorMessage += ` ${errorText}`;
+        }
+      }
+      const error = new Error(errorMessage);
+      error.status = response.status;
+      error.responseText = errorText;
+      throw error;
+    }
+    return response;
+  }, {
+    signal: init.signal,
+    ...retryOptions
+  });
+}
+function getRetryOptionsFromEnv() {
+  return {
+    maxAttempts: Number.parseInt(process.env.FORMAGENT_RETRY_MAX_ATTEMPTS || "3", 10),
+    initialDelay: Number.parseInt(process.env.FORMAGENT_RETRY_INITIAL_DELAY || "1000", 10),
+    maxDelay: Number.parseInt(process.env.FORMAGENT_RETRY_MAX_DELAY || "30000", 10)
+  };
+}
 // src/utils/truncation.ts
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -2129,7 +2240,8 @@ class SessionImpl {
       const toolResult = await tool2.execute(toolInput, context);
       let content = typeof toolResult.content === "string" ? toolResult.content : JSON.stringify(toolResult.content);
       if (needsTruncation(content)) {
-        content = await truncateToolOutput(content);
+        const truncationConfig = this.config.tempDir ? { tempDir: this.config.tempDir } : undefined;
+        content = await truncateToolOutput(content, truncationConfig);
       }
       toolResponse = toolResult;
       result = {
@@ -2784,6 +2896,7 @@ class AnthropicProvider {
     /^claude-instant/
   ];
   config;
+  defaultRetryOptions;
   constructor(config = {}) {
     const apiKey = config.apiKey ?? process.env.ANTHROPIC_API_KEY;
     if (!apiKey) {
@@ -2793,7 +2906,15 @@ class AnthropicProvider {
       apiKey,
       baseUrl: config.baseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
       apiVersion: config.apiVersion ?? "2023-06-01",
-      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096,
+      retry: config.retry
+    };
+    this.defaultRetryOptions = {
+      maxAttempts: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      jitter: true
     };
   }
   supportsModel(model) {
@@ -2801,31 +2922,25 @@ class AnthropicProvider {
   }
   async complete(request) {
     const anthropicRequest = this.buildRequest(request, false);
-    const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(`${this.config.baseUrl}/v1/messages`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(anthropicRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     const data = await response.json();
     return this.convertResponse(data);
   }
   async stream(request, options2) {
     const anthropicRequest = this.buildRequest(request, true);
-    const response = await fetch(`${this.config.baseUrl}/v1/messages`, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(`${this.config.baseUrl}/v1/messages`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(anthropicRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Anthropic API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     return this.createStreamIterator(response.body, options2);
   }
   buildRequest(request, stream) {
@@ -3049,6 +3164,7 @@ class OpenAIProvider {
     /^chatgpt/
   ];
   config;
+  defaultRetryOptions;
   constructor(config = {}) {
     const apiKey = config.apiKey ?? process.env.OPENAI_API_KEY;
     if (!apiKey) {
@@ -3058,96 +3174,88 @@ class OpenAIProvider {
       apiKey,
       baseUrl: this.normalizeBaseUrl(config.baseUrl ?? process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1"),
       organization: config.organization,
-      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096,
+      retry: config.retry
+    };
+    this.defaultRetryOptions = {
+      maxAttempts: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      jitter: true
     };
   }
   supportsModel(model) {
     return this.supportedModels.some((pattern) => pattern.test(model));
   }
   async complete(request) {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
     if (this.usesResponsesApi(request.config.model)) {
       const openaiRequest2 = this.buildResponsesRequest(request, false);
-      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+      const response2 = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
         method: "POST",
         headers: this.getHeaders(),
         body: JSON.stringify(openaiRequest2),
         signal: request.abortSignal
-      });
-      if (!response2.ok) {
-        const error = await response2.text();
-        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
-      }
+      }, retryOptions);
       const data2 = await response2.json();
       return this.convertResponsesResponse(data2);
     }
     const openaiRequest = this.buildRequest(request, false);
-    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    const response = await fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      if (this.shouldFallbackToResponses(response.status, error)) {
+    }, retryOptions);
+    if (response.status === 404) {
+      const errorText = await response.clone().text();
+      if (this.shouldFallbackToResponses(404, errorText)) {
         const fallbackRequest = this.buildResponsesRequest(request, false);
-        response = await fetch(`${this.config.baseUrl}/responses`, {
+        const fallbackResponse = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
           method: "POST",
           headers: this.getHeaders(),
           body: JSON.stringify(fallbackRequest),
           signal: request.abortSignal
-        });
-        if (!response.ok) {
-          const fallbackError = await response.text();
-          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
-        }
-        const data2 = await response.json();
+        }, retryOptions);
+        const data2 = await fallbackResponse.json();
         return this.convertResponsesResponse(data2);
       }
-      throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     const data = await response.json();
     return this.convertResponse(data);
   }
   async stream(request, options2) {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
     if (this.usesResponsesApi(request.config.model)) {
       const openaiRequest2 = this.buildResponsesRequest(request, true);
-      const response2 = await fetch(`${this.config.baseUrl}/responses`, {
+      const response2 = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
         method: "POST",
         headers: this.getHeaders(),
         body: JSON.stringify(openaiRequest2),
         signal: request.abortSignal
-      });
-      if (!response2.ok) {
-        const error = await response2.text();
-        throw new Error(`OpenAI API error: ${response2.status} ${error}`);
-      }
+      }, retryOptions);
       return this.createResponsesStreamIterator(response2.body, options2);
     }
     const openaiRequest = this.buildRequest(request, true);
-    let response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+    const response = await fetchWithRetry(`${this.config.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(openaiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      if (this.shouldFallbackToResponses(response.status, error)) {
+    }, retryOptions);
+    if (response.status === 404) {
+      const errorText = await response.clone().text();
+      if (this.shouldFallbackToResponses(404, errorText)) {
         const fallbackRequest = this.buildResponsesRequest(request, true);
-        response = await fetch(`${this.config.baseUrl}/responses`, {
+        const fallbackResponse = await fetchWithRetry(`${this.config.baseUrl}/responses`, {
           method: "POST",
           headers: this.getHeaders(),
           body: JSON.stringify(fallbackRequest),
           signal: request.abortSignal
-        });
-        if (!response.ok) {
-          const fallbackError = await response.text();
-          throw new Error(`OpenAI API error: ${response.status} ${fallbackError}`);
-        }
-        return this.createResponsesStreamIterator(response.body, options2);
+        }, retryOptions);
+        return this.createResponsesStreamIterator(fallbackResponse.body, options2);
       }
-      throw new Error(`OpenAI API error: ${response.status} ${error}`);
     }
     return this.createStreamIterator(response.body, options2);
   }
@@ -3865,6 +3973,7 @@ class GeminiProvider {
   name = "Gemini";
   supportedModels = [/^gemini-/, /^models\/gemini-/];
   config;
+  defaultRetryOptions;
   constructor(config = {}) {
     const apiKey = config.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
     if (!apiKey) {
@@ -3873,7 +3982,15 @@ class GeminiProvider {
     this.config = {
       apiKey,
       baseUrl: config.baseUrl ?? process.env.GEMINI_BASE_URL ?? "https://generativelanguage.googleapis.com/v1beta",
-      defaultMaxTokens: config.defaultMaxTokens ?? 4096
+      defaultMaxTokens: config.defaultMaxTokens ?? 4096,
+      retry: config.retry
+    };
+    this.defaultRetryOptions = {
+      maxAttempts: 3,
+      initialDelay: 1000,
+      maxDelay: 30000,
+      backoffMultiplier: 2,
+      jitter: true
     };
   }
   supportsModel(model) {
@@ -3882,16 +3999,13 @@ class GeminiProvider {
   async complete(request) {
     const geminiRequest = this.buildRequest(request);
     const url = this.buildUrl(this.getModelPath(request.config.model) + ":generateContent");
-    const response = await fetch(url, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(url, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(geminiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     const data = await response.json();
     return this.convertResponse(data, request.config.model);
   }
@@ -3900,16 +4014,13 @@ class GeminiProvider {
     const url = this.buildUrl(this.getModelPath(request.config.model) + ":streamGenerateContent", {
       alt: "sse"
     });
-    const response = await fetch(url, {
+    const retryOptions = this.config.retry ?? this.defaultRetryOptions;
+    const response = await fetchWithRetry(url, {
       method: "POST",
       headers: this.getHeaders(),
       body: JSON.stringify(geminiRequest),
       signal: request.abortSignal
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} ${error}`);
-    }
+    }, retryOptions);
     const contentType = response.headers.get("content-type") ?? "";
     if (!contentType.includes("text/event-stream")) {
       const data = await response.json();
@@ -4777,10 +4888,13 @@ function isZodSchema(schema) {
   return typeof schema === "object" && schema !== null && "parse" in schema && "safeParse" in schema && typeof schema.parse === "function" && typeof schema.safeParse === "function";
 }
 function zodToJsonSchema(zodSchema) {
-  const shape = zodSchema._def?.shape;
-  const typeName = zodSchema._def?.typeName;
-  if (typeName === "ZodObject" && shape) {
-    return objectShapeToJsonSchema(shape);
+  const def = zodSchema._def;
+  const typeName = def?.typeName;
+  if (typeName === "ZodObject") {
+    const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+    if (shape) {
+      return objectShapeToJsonSchema(shape);
+    }
   }
   return {
     type: "object",
@@ -4793,13 +4907,35 @@ function objectShapeToJsonSchema(shape) {
   const required = [];
   for (const [key, value] of Object.entries(shape)) {
     const def = value?._def;
-    const typeName = def?.typeName;
-    const description = def?.description;
+    let typeName = def?.typeName;
+    let description = def?.description;
     let innerDef = def;
     let isOptional = false;
-    if (typeName === "ZodOptional") {
-      isOptional = true;
-      innerDef = def.innerType?._def;
+    while (innerDef) {
+      const innerTypeName = innerDef.typeName;
+      if (innerTypeName === "ZodOptional") {
+        isOptional = true;
+        if (!description && innerDef.description) {
+          description = innerDef.description;
+        }
+        innerDef = innerDef.innerType?._def;
+      } else if (innerTypeName === "ZodDefault") {
+        isOptional = true;
+        if (!description && innerDef.description) {
+          description = innerDef.description;
+        }
+        innerDef = innerDef.innerType?._def;
+      } else if (innerTypeName === "ZodNullable") {
+        if (!description && innerDef.description) {
+          description = innerDef.description;
+        }
+        innerDef = innerDef.innerType?._def;
+      } else {
+        if (!description && innerDef.description) {
+          description = innerDef.description;
+        }
+        break;
+      }
     }
     const prop = zodDefToJsonSchema(innerDef);
     if (description) {
@@ -4832,8 +4968,10 @@ function zodDefToJsonSchema(def) {
         type: "array",
         items: zodDefToJsonSchema(def.type?._def)
       };
-    case "ZodObject":
-      return objectShapeToJsonSchema(def.shape);
+    case "ZodObject": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      return objectShapeToJsonSchema(shape);
+    }
     case "ZodLiteral":
       return { type: typeof def.value, enum: [def.value] };
     case "ZodUnion":
@@ -5312,6 +5450,7 @@ function checkDirAccess(dirPath, options2) {
 
 // src/tools/builtin/bash.ts
 var DEFAULT_TIMEOUT = 120000;
+var DEFAULT_IDLE_TIMEOUT = 30000;
 var MAX_OUTPUT_LENGTH = 1e5;
 var DEFAULT_BLOCKED_PATTERNS = [
   "\\bsudo\\b",
@@ -5378,21 +5517,39 @@ function createBashTool(options2 = {}) {
         }
       }
       const actualTimeout = Math.min(timeout, 600000);
+      const idleTimeout = options2.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
       return new Promise((resolve2) => {
         let stdout = "";
         let stderr = "";
         let killed = false;
+        let killedReason = null;
+        let lastOutputTime = Date.now();
         const proc = spawn("bash", ["-c", command], {
           cwd: cwdAccess.resolved,
           env: process.env,
-          shell: false
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"]
         });
         const timer = setTimeout(() => {
           killed = true;
+          killedReason = "timeout";
           proc.kill("SIGTERM");
           setTimeout(() => proc.kill("SIGKILL"), 1000);
         }, actualTimeout);
+        const idleChecker = setInterval(() => {
+          const idleTime = Date.now() - lastOutputTime;
+          if (idleTime >= idleTimeout && !killed) {
+            killed = true;
+            killedReason = "idle";
+            proc.kill("SIGTERM");
+            setTimeout(() => proc.kill("SIGKILL"), 1000);
+          }
+        }, 1000);
+        const updateLastOutputTime = () => {
+          lastOutputTime = Date.now();
+        };
         proc.stdout?.on("data", (data) => {
+          updateLastOutputTime();
           stdout += data.toString();
           if (stdout.length > MAX_OUTPUT_LENGTH) {
             stdout = stdout.slice(0, MAX_OUTPUT_LENGTH) + `
@@ -5401,6 +5558,7 @@ function createBashTool(options2 = {}) {
           }
         });
         proc.stderr?.on("data", (data) => {
+          updateLastOutputTime();
           stderr += data.toString();
           if (stderr.length > MAX_OUTPUT_LENGTH) {
             stderr = stderr.slice(0, MAX_OUTPUT_LENGTH) + `
@@ -5409,17 +5567,31 @@ function createBashTool(options2 = {}) {
         });
         proc.on("close", (code) => {
           clearTimeout(timer);
+          clearInterval(idleChecker);
           if (killed) {
-            resolve2({
-              content: `Command timed out after ${actualTimeout}ms
+            if (killedReason === "idle") {
+              resolve2({
+                content: `Command terminated: no output for ${idleTimeout / 1000} seconds (likely waiting for input)
 
 Partial output:
 ${stdout}
 
 Stderr:
 ${stderr}`,
-              isError: true
-            });
+                isError: true
+              });
+            } else {
+              resolve2({
+                content: `Command timed out after ${actualTimeout}ms
+
+Partial output:
+${stdout}
+
+Stderr:
+${stderr}`,
+                isError: true
+              });
+            }
             return;
           }
           const output = stdout + (stderr ? `
@@ -5440,6 +5612,7 @@ ${output}`,
         });
         proc.on("error", (error) => {
           clearTimeout(timer);
+          clearInterval(idleChecker);
           resolve2({
             content: `Failed to execute command: ${error.message}`,
             isError: true
@@ -7091,7 +7264,7 @@ ${responseText}`;
           metadata: {
             status: response.status,
             statusText: response.statusText,
-            headers: Object.fromEntries(response.headers.entries()),
+            headers: Object.fromEntries(response.headers),
             body: responseBody
           }
         };
@@ -7902,6 +8075,7 @@ function createAgent(config) {
 }
 export {
   zodToJsonSchema,
+  withRetry,
   webTools,
   waitForEvent,
   utilityTools,
@@ -7933,6 +8107,7 @@ export {
   interactiveTools,
   globalCostTracker,
   getTodos,
+  getRetryOptionsFromEnv,
   getProviderEnv,
   getProjectSkillsPath,
   getPreset,
@@ -7949,6 +8124,7 @@ export {
   generateEnvContext,
   forkSession,
   fileTools,
+  fetchWithRetry,
   extractTitle,
   extractDescription,
   estimateTokens,