@radaros/core 0.3.3 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radaros/core",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/agent/agent.ts

@@ -7,6 +7,7 @@ import { Logger } from "../logger/logger.js";
 import { LLMLoop } from "./llm-loop.js";
 import { RunContext } from "./run-context.js";
 import { getTextContent, type ChatMessage, type MessageContent, type StreamChunk } from "../models/types.js";
+import type { Session } from "../session/types.js";
 import type {
   AgentConfig,
   RunOpts,
@@ -72,6 +73,7 @@ export class Agent {
       structuredOutput: config.structuredOutput,
       logger: this.logger,
       reasoning: config.reasoning,
+      retry: config.retry,
     });
   }
 
@@ -116,7 +118,7 @@ export class Agent {
         }
       }
 
-      const messages = await this.buildMessages(input, sessionId, ctx);
+      const messages = await this.buildMessages(input, session, ctx);
       const output = await this.llmLoop.run(messages, ctx, opts?.apiKey);
 
       output.durationMs = Date.now() - startTime;
@@ -146,18 +148,16 @@ export class Agent {
       }
 
       if (this.config.userMemory && userId) {
-        try {
-          await this.config.userMemory.extractAndStore(
+        this.config.userMemory
+          .extractAndStore(
             userId,
             [
               { role: "user", content: inputText },
               { role: "assistant", content: output.text },
             ],
             this.config.model
-          );
-        } catch (e: unknown) {
-          this.logger.warn(`UserMemory extraction failed: ${e}`);
-        }
+          )
+          .catch((e: unknown) => this.logger.warn(`UserMemory extraction failed: ${e}`));
       }
 
       if (this.config.hooks?.afterRun) {
@@ -220,6 +220,11 @@ export class Agent {
 
     let fullText = "";
     let streamOk = false;
+    let streamUsage: import("../models/types.js").TokenUsage = {
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+    };
 
     try {
       if (this.config.hooks?.beforeRun) {
@@ -237,11 +242,20 @@ export class Agent {
         }
       }
 
-      const messages = await this.buildMessages(input, sessionId, ctx);
+      const messages = await this.buildMessages(input, session, ctx);
 
       for await (const chunk of this.llmLoop.stream(messages, ctx, opts?.apiKey)) {
         if (chunk.type === "text") {
           fullText += chunk.text;
+        } else if (chunk.type === "finish" && chunk.usage) {
+          streamUsage = {
+            promptTokens: streamUsage.promptTokens + chunk.usage.promptTokens,
+            completionTokens: streamUsage.completionTokens + chunk.usage.completionTokens,
+            totalTokens: streamUsage.totalTokens + chunk.usage.totalTokens,
+            ...(chunk.usage.reasoningTokens
+              ? { reasoningTokens: (streamUsage.reasoningTokens ?? 0) + chunk.usage.reasoningTokens }
+              : {}),
+          };
         }
         yield chunk;
       }
@@ -276,18 +290,16 @@ export class Agent {
         }
 
         if (this.config.userMemory && userId) {
-          try {
-            await this.config.userMemory.extractAndStore(
+          this.config.userMemory
+            .extractAndStore(
               userId,
               [
                 { role: "user", content: inputText },
                 { role: "assistant", content: fullText },
               ],
               this.config.model
-            );
-          } catch (e: unknown) {
-            this.logger.warn(`UserMemory extraction failed: ${e}`);
-          }
+            )
+            .catch((e: unknown) => this.logger.warn(`UserMemory extraction failed: ${e}`));
         }
 
         this.eventBus.emit("run.complete", {
@@ -295,7 +307,7 @@ export class Agent {
           output: {
             text: fullText,
             toolCalls: [],
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            usage: streamUsage,
           },
         });
       }
@@ -304,7 +316,7 @@ export class Agent {
 
   private async buildMessages(
     input: MessageContent,
-    sessionId: string,
+    session: Session,
     ctx: RunContext
   ): Promise<ChatMessage[]> {
     const messages: ChatMessage[] = [];
@@ -319,7 +331,7 @@ export class Agent {
 
     if (this.config.memory) {
       const memoryContext = await this.config.memory.getContextString(
-        sessionId
+        session.sessionId
       );
       if (memoryContext) {
         systemContent = systemContent
@@ -329,11 +341,16 @@ export class Agent {
     }
 
     if (this.config.userMemory && ctx.userId) {
-      const userContext = await this.config.userMemory.getContextString(ctx.userId);
-      if (userContext) {
-        systemContent = systemContent
-          ? `${systemContent}\n\n${userContext}`
-          : userContext;
+      const hasRecallTool = (this.config.tools ?? []).some(
+        (t) => t.name === "recall_user_facts"
+      );
+      if (!hasRecallTool) {
+        const userContext = await this.config.userMemory.getContextString(ctx.userId);
+        if (userContext) {
+          systemContent = systemContent
+            ? `${systemContent}\n\n${userContext}`
+            : userContext;
+        }
       }
     }
 
@@ -345,23 +362,56 @@ export class Agent {
       const limit = this.config.numHistoryRuns
         ? this.config.numHistoryRuns * 2
         : 20;
-      const history = await this.sessionManager.getHistory(sessionId, limit);
+      let history = session.messages ?? [];
+      if (limit > 0 && history.length > limit) {
+        history = history.slice(-limit);
+      }
+
+      if (this.config.maxContextTokens) {
+        history = this.trimHistoryByTokens(history, systemContent, input);
+      }
+
       if (history.length > 0) {
-        this.logger.info(`Loaded ${history.length} history messages for session ${sessionId}`);
-        if (messages.length > 0 && messages[0].role === "system") {
-          messages[0] = {
-            ...messages[0],
-            content: `${getTextContent(messages[0].content)}\n\nThis is a multi-turn conversation. The previous messages in this session are included below. Use them to maintain context and answer questions about prior exchanges.`,
-          };
-        }
+        this.logger.info(`Loaded ${history.length} history messages for session ${session.sessionId}`);
       }
       messages.push(...history);
     }
 
     messages.push({ role: "user", content: input });
 
-    this.logger.info(`Sending ${messages.length} messages to LLM: ${messages.map(m => `[${m.role}: ${typeof m.content === 'string' ? m.content.slice(0, 40) : '(multimodal)'}]`).join(', ')}`);
+    this.logger.info(`Sending ${messages.length} messages to LLM`);
 
     return messages;
   }
+
+  private estimateTokens(text: string): number {
+    return Math.ceil(text.length / 3.5);
+  }
+
+  private trimHistoryByTokens(
+    history: ChatMessage[],
+    systemContent: string,
+    currentInput: MessageContent
+  ): ChatMessage[] {
+    const maxTokens = this.config.maxContextTokens!;
+    const inputText = typeof currentInput === "string" ? currentInput : "(multimodal)";
+    let reservedTokens = this.estimateTokens(systemContent) + this.estimateTokens(inputText) + 100;
+
+    const available = maxTokens - reservedTokens;
+    if (available <= 0) return [];
+
+    const result: ChatMessage[] = [];
+    let used = 0;
+
+    for (let i = history.length - 1; i >= 0; i--) {
+      const msg = history[i];
+      const text = typeof msg.content === "string" ? msg.content : "";
+      const tokens = this.estimateTokens(text);
+      if (used + tokens > available) break;
+      used += tokens;
+      result.unshift(msg);
+    }
+
+    return result;
+  }
 }

package/src/agent/llm-loop.ts

@@ -14,6 +14,7 @@ import type { RunContext } from "./run-context.js";
 import type { RunOutput } from "./types.js";
 import type { ToolCallResult } from "../tools/types.js";
 import type { Logger } from "../logger/logger.js";
+import { withRetry, type RetryConfig } from "../utils/retry.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -26,6 +27,7 @@ export class LLMLoop {
   private structuredOutput?: z.ZodSchema;
   private logger?: Logger;
   private reasoning?: ReasoningConfig;
+  private retry?: Partial<RetryConfig>;
 
   constructor(
     provider: ModelProvider,
@@ -37,6 +39,7 @@ export class LLMLoop {
       structuredOutput?: z.ZodSchema;
       logger?: Logger;
       reasoning?: ReasoningConfig;
+      retry?: Partial<RetryConfig>;
     }
   ) {
     this.provider = provider;
@@ -47,6 +50,7 @@ export class LLMLoop {
     this.structuredOutput = options.structuredOutput;
     this.logger = options.logger;
     this.reasoning = options.reasoning;
+    this.retry = options.retry;
   }
 
   async run(messages: ChatMessage[], ctx: RunContext, apiKey?: string): Promise<RunOutput> {
@@ -75,9 +79,9 @@ export class LLMLoop {
         };
       }
 
-      const response = await this.provider.generate(
-        currentMessages,
-        modelConfig
+      const response = await withRetry(
+        () => this.provider.generate(currentMessages, modelConfig),
+        this.retry
       );
 
       totalPromptTokens += response.usage.promptTokens;
@@ -273,7 +277,12 @@ export class LLMLoop {
   private zodToJsonSchema(schema: z.ZodSchema): Record<string, unknown> {
     try {
       const { zodToJsonSchema } = _require("zod-to-json-schema");
-      return zodToJsonSchema(schema, { target: "openApi3" }) as Record<string, unknown>;
+      const result = zodToJsonSchema(schema, {
+        target: "jsonSchema7",
+        $refStrategy: "none",
+      }) as Record<string, unknown>;
+      delete result["$schema"];
+      return result;
     } catch {
       return {};
     }

package/src/agent/types.ts

@@ -8,6 +8,7 @@ import type { TokenUsage, StreamChunk, MessageContent, ReasoningConfig } from ".
 import type { RunContext } from "./run-context.js";
 import type { LogLevel } from "../logger/logger.js";
 import type { UserMemory } from "../memory/user-memory.js";
+import type { RetryConfig } from "../utils/retry.js";
 
 export interface AgentConfig {
   name: string;
@@ -35,6 +36,10 @@ export interface AgentConfig {
   reasoning?: ReasoningConfig;
   /** User-scoped memory for cross-session personalization. */
   userMemory?: UserMemory;
+  /** Retry configuration for transient LLM API failures (429, 5xx, network errors). */
+  retry?: Partial<RetryConfig>;
+  /** Maximum context window tokens. History is auto-trimmed to fit. */
+  maxContextTokens?: number;
 }
 
 export interface RunOpts {

package/src/index.ts

@@ -115,6 +115,10 @@ export type { AgentEventMap } from "./events/types.js";
 export { Logger } from "./logger/logger.js";
 export type { LogLevel, LoggerConfig } from "./logger/logger.js";
 
+// Utils
+export { withRetry } from "./utils/retry.js";
+export type { RetryConfig } from "./utils/retry.js";
+
 // MCP
 export { MCPToolProvider } from "./mcp/mcp-client.js";
 export type { MCPToolProviderConfig } from "./mcp/mcp-client.js";

package/src/memory/user-memory.ts

@@ -1,8 +1,10 @@
 import { v4 as uuidv4 } from "uuid";
+import { z } from "zod";
 import { InMemoryStorage } from "../storage/in-memory.js";
 import type { StorageDriver } from "../storage/driver.js";
 import type { ModelProvider } from "../models/provider.js";
 import type { ChatMessage } from "../models/types.js";
+import type { ToolDef } from "../tools/types.js";
 
 const USER_MEMORY_NS = "memory:user";
 
@@ -119,6 +121,24 @@ export class UserMemory {
     return `What you know about this user:\n${factList}`;
   }
 
+  asTool(config?: { name?: string; description?: string }): ToolDef {
+    const mem = this;
+    return {
+      name: config?.name ?? "recall_user_facts",
+      description:
+        config?.description ??
+        "Retrieve stored facts about the current user — preferences, background, interests, and other personal details from past conversations. Call this when the user asks what you know or remember about them.",
+      parameters: z.object({}),
+      execute: async (_args, ctx) => {
+        const uid = ctx.userId;
+        if (!uid) return "No user identified for this session.";
+        const facts = await mem.getFacts(uid);
+        if (facts.length === 0) return "No stored facts about this user yet.";
+        return facts.map((f) => `- ${f.fact}`).join("\n");
+      },
+    };
+  }
+
   async extractAndStore(
     userId: string,
     messages: ChatMessage[],

package/src/tools/tool-executor.ts

@@ -14,10 +14,16 @@ 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 {
@@ -168,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<{
@@ -185,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/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;
+}