@radaros/core 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radaros/core",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "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,
@@ -22,6 +23,7 @@ export class Agent {
   private sessionManager: SessionManager;
   private llmLoop: LLMLoop;
   private logger: Logger;
+  private storageInitPromise: Promise<void> | null = null;
 
   get tools() {
     return this.config.tools ?? [];
@@ -50,6 +52,9 @@ export class Agent {
     this.eventBus = config.eventBus ?? new EventBus();
 
     const storage = config.storage ?? new InMemoryStorage();
+    if (typeof (storage as any).initialize === "function") {
+      this.storageInitPromise = (storage as any).initialize();
+    }
     this.sessionManager = new SessionManager(storage);
 
     this.logger = new Logger({
@@ -67,6 +72,8 @@ export class Agent {
       temperature: config.temperature,
       structuredOutput: config.structuredOutput,
       logger: this.logger,
+      reasoning: config.reasoning,
+      retry: config.retry,
     });
   }
 
@@ -76,6 +83,7 @@ export class Agent {
     const userId = opts?.userId ?? this.config.userId;
     const inputText = typeof input === "string" ? input : getTextContent(input);
 
+    if (this.storageInitPromise) await this.storageInitPromise;
     const session = await this.sessionManager.getOrCreate(sessionId, userId);
 
     const ctx = new RunContext({
@@ -110,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;
@@ -139,10 +147,26 @@ export class Agent {
         ]);
       }
 
+      if (this.config.userMemory && userId) {
+        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}`));
+      }
+
       if (this.config.hooks?.afterRun) {
         await this.config.hooks.afterRun(ctx, output);
       }
 
+      if (output.thinking) {
+        this.logger.thinking(output.thinking);
+      }
       this.logger.agentEnd(this.name, output.text, output.usage, output.durationMs);
 
       this.eventBus.emit("run.complete", {
@@ -177,6 +201,7 @@ export class Agent {
     const userId = opts?.userId ?? this.config.userId;
     const inputText = typeof input === "string" ? input : getTextContent(input);
 
+    if (this.storageInitPromise) await this.storageInitPromise;
     const session = await this.sessionManager.getOrCreate(sessionId, userId);
 
     const ctx = new RunContext({
@@ -195,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) {
@@ -212,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;
       }
@@ -250,12 +289,25 @@ export class Agent {
           ]);
         }
 
+        if (this.config.userMemory && userId) {
+          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}`));
+        }
+
         this.eventBus.emit("run.complete", {
           runId: ctx.runId,
           output: {
             text: fullText,
             toolCalls: [],
-            usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            usage: streamUsage,
           },
         });
       }
@@ -264,7 +316,7 @@ export class Agent {
 
   private async buildMessages(
     input: MessageContent,
-    sessionId: string,
+    session: Session,
     ctx: RunContext
   ): Promise<ChatMessage[]> {
     const messages: ChatMessage[] = [];
@@ -279,7 +331,7 @@ export class Agent {
 
     if (this.config.memory) {
       const memoryContext = await this.config.memory.getContextString(
-        sessionId
+        session.sessionId
       );
       if (memoryContext) {
         systemContent = systemContent
@@ -288,6 +340,20 @@ export class Agent {
       }
     }
 
+    if (this.config.userMemory && ctx.userId) {
+      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;
+        }
+      }
+    }
+
     if (systemContent) {
       messages.push({ role: "system", content: systemContent });
     }
@@ -296,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

@@ -5,6 +5,7 @@ import {
   getTextContent,
   type ChatMessage,
   type ModelConfig,
+  type ReasoningConfig,
   type StreamChunk,
   type ToolDefinition,
 } from "../models/types.js";
@@ -13,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);
 
@@ -24,6 +26,8 @@ export class LLMLoop {
   private maxTokens?: number;
   private structuredOutput?: z.ZodSchema;
   private logger?: Logger;
+  private reasoning?: ReasoningConfig;
+  private retry?: Partial<RetryConfig>;
 
   constructor(
     provider: ModelProvider,
@@ -34,6 +38,8 @@ export class LLMLoop {
       maxTokens?: number;
       structuredOutput?: z.ZodSchema;
       logger?: Logger;
+      reasoning?: ReasoningConfig;
+      retry?: Partial<RetryConfig>;
     }
   ) {
     this.provider = provider;
@@ -43,12 +49,16 @@ export class LLMLoop {
     this.maxTokens = options.maxTokens;
     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> {
     const allToolCalls: ToolCallResult[] = [];
     let totalPromptTokens = 0;
     let totalCompletionTokens = 0;
+    let totalReasoningTokens = 0;
+    let thinkingContent = "";
     const currentMessages = [...messages];
     const toolDefs = this.toolExecutor?.getToolDefinitions() ?? [];
 
@@ -59,6 +69,7 @@ export class LLMLoop {
         modelConfig.temperature = this.temperature;
       if (this.maxTokens !== undefined) modelConfig.maxTokens = this.maxTokens;
       if (toolDefs.length > 0) modelConfig.tools = toolDefs;
+      if (this.reasoning) modelConfig.reasoning = this.reasoning;
 
       if (this.structuredOutput) {
         modelConfig.responseFormat = {
@@ -68,13 +79,18 @@ 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;
       totalCompletionTokens += response.usage.completionTokens;
+      if (response.usage.reasoningTokens) totalReasoningTokens += response.usage.reasoningTokens;
+
+      if ((response as any).thinking) {
+        thinkingContent += (thinkingContent ? "\n" : "") + (response as any).thinking;
+      }
 
       currentMessages.push(response.message);
 
@@ -92,9 +108,12 @@ export class LLMLoop {
             promptTokens: totalPromptTokens,
             completionTokens: totalCompletionTokens,
             totalTokens: totalPromptTokens + totalCompletionTokens,
+            ...(totalReasoningTokens > 0 ? { reasoningTokens: totalReasoningTokens } : {}),
           },
         };
 
+        if (thinkingContent) output.thinking = thinkingContent;
+
         if (this.structuredOutput && text) {
           try {
             const jsonStr = this.extractJson(text);
@@ -146,7 +165,9 @@ export class LLMLoop {
         promptTokens: totalPromptTokens,
         completionTokens: totalCompletionTokens,
         totalTokens: totalPromptTokens + totalCompletionTokens,
+        ...(totalReasoningTokens > 0 ? { reasoningTokens: totalReasoningTokens } : {}),
       },
+      ...(thinkingContent ? { thinking: thinkingContent } : {}),
     };
   }
 
@@ -165,6 +186,7 @@ export class LLMLoop {
         modelConfig.temperature = this.temperature;
       if (this.maxTokens !== undefined) modelConfig.maxTokens = this.maxTokens;
       if (toolDefs.length > 0) modelConfig.tools = toolDefs;
+      if (this.reasoning) modelConfig.reasoning = this.reasoning;
 
       let fullText = "";
       const pendingToolCalls: Array<{
@@ -255,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

@@ -4,9 +4,11 @@ import type { ToolDef, ToolCallResult } from "../tools/types.js";
 import type { Memory } from "../memory/memory.js";
 import type { StorageDriver } from "../storage/driver.js";
 import type { EventBus } from "../events/event-bus.js";
-import type { TokenUsage, StreamChunk, MessageContent } from "../models/types.js";
+import type { TokenUsage, StreamChunk, MessageContent, ReasoningConfig } from "../models/types.js";
 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;
@@ -30,6 +32,14 @@ export interface AgentConfig {
   eventBus?: EventBus;
   /** Logging level. Set to "debug" for tool call details, "info" for summaries, "silent" to disable. Default: "silent". */
   logLevel?: LogLevel;
+  /** Enable extended thinking / reasoning for the model. */
+  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 {
@@ -46,6 +56,8 @@ export interface RunOutput {
   usage: TokenUsage;
   /** Parsed structured output if structuredOutput schema is set. */
   structured?: unknown;
+  /** Model's internal reasoning / thinking content (when reasoning is enabled). */
+  thinking?: string;
   durationMs?: number;
 }
 

package/src/index.ts

@@ -47,6 +47,7 @@ export type {
   ModelResponse,
   StreamChunk,
   ModelConfig,
+  ReasoningConfig,
 } from "./models/types.js";
 export { getTextContent, isMultiModal } from "./models/types.js";
 export { ModelRegistry, registry, openai, anthropic, google, ollama, vertex } from "./models/registry.js";
@@ -60,7 +61,7 @@ export type { VertexAIConfig } from "./models/providers/vertex.js";
 // Tools
 export { defineTool } from "./tools/define-tool.js";
 export { ToolExecutor } from "./tools/tool-executor.js";
-export type { ToolDef, ToolResult, ToolCallResult, Artifact } from "./tools/types.js";
+export type { ToolDef, ToolResult, ToolCallResult, Artifact, ToolCacheConfig } from "./tools/types.js";
 
 // Storage
 export type { StorageDriver } from "./storage/driver.js";
@@ -103,6 +104,8 @@ export type { Session } from "./session/types.js";
 // Memory
 export { Memory } from "./memory/memory.js";
 export type { MemoryConfig, MemoryEntry } from "./memory/types.js";
+export { UserMemory } from "./memory/user-memory.js";
+export type { UserMemoryConfig, UserFact } from "./memory/user-memory.js";
 
 // Events
 export { EventBus } from "./events/event-bus.js";
@@ -112,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/logger/logger.ts

@@ -187,10 +187,23 @@ export class Logger {
     console.log(this.pipe());
   }
 
+  thinking(content: string): void {
+    if (!this.shouldLog("info")) return;
+    const truncated = content.length > 500 ? content.slice(0, 500) + "…" : content;
+    const label = this.c(C.dim + C.italic, "Thinking: ");
+    const lines = truncated.split("\n");
+    console.log(`${this.pipe()} ${label}${this.c(C.dim + C.italic, lines[0])}`);
+    const pad = " ".repeat(10);
+    for (let i = 1; i < lines.length; i++) {
+      console.log(`${this.pipe()} ${pad}${this.c(C.dim + C.italic, lines[i])}`);
+    }
+    console.log(this.pipe());
+  }
+
   agentEnd(
     agentName: string,
     output: string,
-    usage: { promptTokens: number; completionTokens: number; totalTokens: number },
+    usage: { promptTokens: number; completionTokens: number; totalTokens: number; reasoningTokens?: number },
     durationMs: number
   ): void {
     if (!this.shouldLog("info")) return;
@@ -199,7 +212,7 @@ export class Logger {
     this.printBoxLine("Output: ", output);
     console.log(this.pipe());
 
-    const tokensLine =
+    let tokensLine =
       this.c(C.dim, "Tokens: ") +
       this.c(C.brightGreen, `↑ ${usage.promptTokens}`) +
       this.c(C.dim, "  ") +
@@ -207,6 +220,10 @@ export class Logger {
       this.c(C.dim, "  ") +
       this.c(C.bold + C.brightGreen, `Σ ${usage.totalTokens}`);
 
+    if (usage.reasoningTokens) {
+      tokensLine += this.c(C.dim, "  ") + this.c(C.brightMagenta, `🧠 ${usage.reasoningTokens}`);
+    }
+
     const duration =
       this.c(C.dim, "Duration: ") +
       this.c(C.yellow, this.formatDuration(durationMs));