@radaros/core 0.3.2 → 0.3.4

package/src/tools/tool-executor.ts

@@ -1,17 +1,65 @@
 import { createRequire } from "node:module";
 import type { ToolCall } from "../models/types.js";
 import type { RunContext } from "../agent/run-context.js";
-import type { ToolDef, ToolCallResult } from "./types.js";
+import type { ToolDef, ToolCallResult, ToolResult } from "./types.js";
 
 const _require = createRequire(import.meta.url);
 
+interface CacheEntry {
+  result: string | ToolResult;
+  expiresAt: number;
+}
+
 export class ToolExecutor {
   private tools: Map<string, ToolDef>;
   private concurrency: number;
+  private cache = new Map<string, CacheEntry>();
+  private cachedDefs: Array<{
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  }> | null = null;
 
   constructor(tools: ToolDef[], concurrency: number = 5) {
     this.tools = new Map(tools.map((t) => [t.name, t]));
     this.concurrency = concurrency;
+    this.cachedDefs = this.buildToolDefinitions();
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  private getCacheKey(toolName: string, args: Record<string, unknown>): string {
+    const sortedArgs = JSON.stringify(args, Object.keys(args).sort());
+    return `${toolName}:${sortedArgs}`;
+  }
+
+  private getCached(toolName: string, args: Record<string, unknown>): (string | ToolResult) | undefined {
+    const tool = this.tools.get(toolName);
+    if (!tool?.cache) return undefined;
+
+    const key = this.getCacheKey(toolName, args);
+    const entry = this.cache.get(key);
+    if (!entry) return undefined;
+
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return undefined;
+    }
+
+    return entry.result;
+  }
+
+  private setCache(toolName: string, args: Record<string, unknown>, result: string | ToolResult): void {
+    const tool = this.tools.get(toolName);
+    if (!tool?.cache) return;
+
+    const key = this.getCacheKey(toolName, args);
+    this.cache.set(key, {
+      result,
+      expiresAt: Date.now() + tool.cache.ttl,
+    });
   }
 
   async executeAll(
@@ -66,6 +114,24 @@ export class ToolExecutor {
       args: toolCall.arguments,
     });
 
+    const cachedResult = this.getCached(toolCall.name, toolCall.arguments);
+    if (cachedResult !== undefined) {
+      const resultContent =
+        typeof cachedResult === "string" ? cachedResult : cachedResult.content;
+
+      ctx.eventBus.emit("tool.result", {
+        runId: ctx.runId,
+        toolName: toolCall.name,
+        result: `[cached] ${resultContent}`,
+      });
+
+      return {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        result: cachedResult,
+      };
+    }
+
     const parsed = tool.parameters.safeParse(toolCall.arguments);
     if (!parsed.success) {
       const errMsg = `Invalid arguments: ${parsed.error.message}`;
@@ -89,6 +155,8 @@ export class ToolExecutor {
     const resultContent =
       typeof rawResult === "string" ? rawResult : rawResult.content;
 
+    this.setCache(toolCall.name, toolCall.arguments, rawResult);
+
     ctx.eventBus.emit("tool.result", {
       runId: ctx.runId,
       toolName: toolCall.name,
@@ -106,6 +174,16 @@ export class ToolExecutor {
     name: string;
     description: string;
     parameters: Record<string, unknown>;
+  }> {
+    if (this.cachedDefs) return this.cachedDefs;
+    this.cachedDefs = this.buildToolDefinitions();
+    return this.cachedDefs;
+  }
+
+  private buildToolDefinitions(): Array<{
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
   }> {
     const { zodToJsonSchema } = _require("zod-to-json-schema");
     const defs: Array<{
@@ -123,13 +201,17 @@ export class ToolExecutor {
         });
       } else {
         const jsonSchema = zodToJsonSchema(tool.parameters, {
-          target: "openApi3",
-        });
+          target: "jsonSchema7",
+          $refStrategy: "none",
+        }) as Record<string, unknown>;
+
+        delete jsonSchema["$schema"];
+        delete jsonSchema["additionalProperties"];
 
         defs.push({
           name: tool.name,
           description: tool.description,
-          parameters: jsonSchema as Record<string, unknown>,
+          parameters: jsonSchema,
         });
       }
     }

package/src/tools/types.ts

@@ -12,6 +12,11 @@ export interface ToolResult {
   artifacts?: Artifact[];
 }
 
+export interface ToolCacheConfig {
+  /** Time-to-live in milliseconds. Cached results expire after this duration. */
+  ttl: number;
+}
+
 export interface ToolDef {
   name: string;
   description: string;
@@ -19,6 +24,8 @@ export interface ToolDef {
   execute: (args: Record<string, unknown>, ctx: RunContext) => Promise<string | ToolResult>;
   /** Raw JSON Schema to send to the LLM, bypassing Zod-to-JSON conversion (used by MCP tools). */
   rawJsonSchema?: Record<string, unknown>;
+  /** Enable result caching for this tool. */
+  cache?: ToolCacheConfig;
 }
 
 export interface ToolCallResult {

package/src/utils/retry.ts

@@ -0,0 +1,56 @@
+export interface RetryConfig {
+  maxRetries: number;
+  initialDelayMs: number;
+  maxDelayMs: number;
+  retryableErrors?: (error: unknown) => boolean;
+}
+
+const DEFAULT_CONFIG: RetryConfig = {
+  maxRetries: 3,
+  initialDelayMs: 500,
+  maxDelayMs: 10_000,
+  retryableErrors: isRetryableError,
+};
+
+function isRetryableError(error: unknown): boolean {
+  if (error && typeof error === "object") {
+    const status = (error as any).status ?? (error as any).statusCode;
+    if (status === 429 || (status >= 500 && status < 600)) return true;
+
+    const code = (error as any).code;
+    if (code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ENOTFOUND") return true;
+
+    const msg = (error as any).message;
+    if (typeof msg === "string" && /rate.limit|too.many.requests|overloaded/i.test(msg)) return true;
+  }
+  return false;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  config?: Partial<RetryConfig>
+): Promise<T> {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= cfg.maxRetries || !cfg.retryableErrors!(error)) throw error;
+
+      const delay = Math.min(
+        cfg.initialDelayMs * Math.pow(2, attempt) + Math.random() * 200,
+        cfg.maxDelayMs
+      );
+      await sleep(delay);
+    }
+  }
+
+  throw lastError;
+}