@radaros/core 0.3.2 → 0.3.3

package/package.json

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

package/src/agent/agent.ts

@@ -22,6 +22,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 +51,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 +71,7 @@ export class Agent {
       temperature: config.temperature,
       structuredOutput: config.structuredOutput,
       logger: this.logger,
+      reasoning: config.reasoning,
     });
   }
 
@@ -76,6 +81,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({
@@ -139,10 +145,28 @@ export class Agent {
         ]);
       }
 
+      if (this.config.userMemory && userId) {
+        try {
+          await 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({
@@ -250,6 +275,21 @@ export class Agent {
           ]);
         }
 
+        if (this.config.userMemory && userId) {
+          try {
+            await 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: {
@@ -288,6 +328,15 @@ 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;
+      }
+    }
+
     if (systemContent) {
       messages.push({ role: "system", content: systemContent });
     }

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";
@@ -24,6 +25,7 @@ export class LLMLoop {
   private maxTokens?: number;
   private structuredOutput?: z.ZodSchema;
   private logger?: Logger;
+  private reasoning?: ReasoningConfig;
 
   constructor(
     provider: ModelProvider,
@@ -34,6 +36,7 @@ export class LLMLoop {
       maxTokens?: number;
       structuredOutput?: z.ZodSchema;
       logger?: Logger;
+      reasoning?: ReasoningConfig;
     }
   ) {
     this.provider = provider;
@@ -43,12 +46,15 @@ export class LLMLoop {
     this.maxTokens = options.maxTokens;
     this.structuredOutput = options.structuredOutput;
     this.logger = options.logger;
+    this.reasoning = options.reasoning;
   }
 
   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 +65,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 = {
@@ -75,6 +82,11 @@ export class LLMLoop {
 
       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 +104,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 +161,9 @@ export class LLMLoop {
         promptTokens: totalPromptTokens,
         completionTokens: totalCompletionTokens,
         totalTokens: totalPromptTokens + totalCompletionTokens,
+        ...(totalReasoningTokens > 0 ? { reasoningTokens: totalReasoningTokens } : {}),
       },
+      ...(thinkingContent ? { thinking: thinkingContent } : {}),
     };
   }
 
@@ -165,6 +182,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<{

package/src/agent/types.ts

@@ -4,9 +4,10 @@ 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";
 
 export interface AgentConfig {
   name: string;
@@ -30,6 +31,10 @@ 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;
 }
 
 export interface RunOpts {
@@ -46,6 +51,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";

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));

package/src/memory/user-memory.ts

@@ -0,0 +1,191 @@
+import { v4 as uuidv4 } from "uuid";
+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";
+
+const USER_MEMORY_NS = "memory:user";
+
+export interface UserMemoryConfig {
+  storage?: StorageDriver;
+  /** LLM used for auto-extraction of facts from conversations. */
+  model?: ModelProvider;
+  /** Maximum number of facts stored per user (default 100). */
+  maxFacts?: number;
+  /** Whether auto-extraction is enabled (default true). */
+  enabled?: boolean;
+}
+
+export interface UserFact {
+  id: string;
+  fact: string;
+  createdAt: Date;
+  source: "auto" | "manual";
+}
+
+const EXTRACTION_PROMPT = `You are a memory extraction assistant. Analyze the conversation below and extract important facts about the user that would be useful for future personalization.
+
+Rules:
+- Extract concrete facts like preferences, location, profession, interests, goals, communication style
+- Each fact should be a short, self-contained statement (e.g., "Lives in Mumbai", "Prefers concise answers")
+- Do NOT extract transient information (e.g., "asked about weather today")
+- Do NOT extract information about the assistant
+- If there are no new meaningful facts, return an empty array
+- Return ONLY a valid JSON array of strings, nothing else
+
+Existing facts about this user (avoid duplicates):
+{existingFacts}
+
+Conversation:
+{conversation}
+
+Return a JSON array of new fact strings:`;
+
+export class UserMemory {
+  private storage: StorageDriver;
+  private model?: ModelProvider;
+  private maxFacts: number;
+  private enabled: boolean;
+  private initPromise: Promise<void> | null = null;
+
+  constructor(config?: UserMemoryConfig) {
+    this.storage = config?.storage ?? new InMemoryStorage();
+    this.model = config?.model;
+    this.maxFacts = config?.maxFacts ?? 100;
+    this.enabled = config?.enabled ?? true;
+  }
+
+  private ensureInitialized(): Promise<void> {
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        if (typeof (this.storage as any).initialize === "function") {
+          await (this.storage as any).initialize();
+        }
+      })();
+    }
+    return this.initPromise;
+  }
+
+  async getFacts(userId: string): Promise<UserFact[]> {
+    await this.ensureInitialized();
+    return (await this.storage.get<UserFact[]>(USER_MEMORY_NS, userId)) ?? [];
+  }
+
+  async addFacts(userId: string, facts: string[], source: "auto" | "manual" = "manual"): Promise<void> {
+    await this.ensureInitialized();
+    const existing = await this.getFacts(userId);
+    const existingSet = new Set(existing.map((f) => f.fact.toLowerCase()));
+
+    const newFacts: UserFact[] = [];
+    for (const fact of facts) {
+      const normalized = fact.trim();
+      if (!normalized || existingSet.has(normalized.toLowerCase())) continue;
+      newFacts.push({
+        id: uuidv4(),
+        fact: normalized,
+        createdAt: new Date(),
+        source,
+      });
+      existingSet.add(normalized.toLowerCase());
+    }
+
+    if (newFacts.length === 0) return;
+
+    let updated = [...existing, ...newFacts];
+    if (updated.length > this.maxFacts) {
+      updated = updated.slice(updated.length - this.maxFacts);
+    }
+
+    await this.storage.set(USER_MEMORY_NS, userId, updated);
+  }
+
+  async removeFact(userId: string, factId: string): Promise<void> {
+    await this.ensureInitialized();
+    const existing = await this.getFacts(userId);
+    const updated = existing.filter((f) => f.id !== factId);
+    await this.storage.set(USER_MEMORY_NS, userId, updated);
+  }
+
+  async clear(userId: string): Promise<void> {
+    await this.ensureInitialized();
+    await this.storage.delete(USER_MEMORY_NS, userId);
+  }
+
+  async getContextString(userId: string): Promise<string> {
+    if (!this.enabled) return "";
+    const facts = await this.getFacts(userId);
+    if (facts.length === 0) return "";
+    const factList = facts.map((f) => `- ${f.fact}`).join("\n");
+    return `What you know about this user:\n${factList}`;
+  }
+
+  async extractAndStore(
+    userId: string,
+    messages: ChatMessage[],
+    fallbackModel?: ModelProvider
+  ): Promise<void> {
+    if (!this.enabled) return;
+
+    const model = this.model ?? fallbackModel;
+    if (!model) return;
+
+    try {
+      const existing = await this.getFacts(userId);
+      const existingStr =
+        existing.length > 0
+          ? existing.map((f) => `- ${f.fact}`).join("\n")
+          : "(none)";
+
+      const conversationStr = messages
+        .filter((m) => m.role === "user" || m.role === "assistant")
+        .map((m) => {
+          const content = typeof m.content === "string" ? m.content : "(multimodal)";
+          return `${m.role}: ${content}`;
+        })
+        .join("\n");
+
+      const prompt = EXTRACTION_PROMPT
+        .replace("{existingFacts}", existingStr)
+        .replace("{conversation}", conversationStr);
+
+      const response = await model.generate(
+        [{ role: "user", content: prompt }],
+        { temperature: 0, maxTokens: 500 }
+      );
+
+      const text =
+        typeof response.message.content === "string"
+          ? response.message.content
+          : "";
+
+      if (!text) return;
+
+      const jsonStr = this.extractJsonArray(text);
+      const parsed = JSON.parse(jsonStr);
+
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        const validFacts = parsed.filter(
+          (f: unknown) => typeof f === "string" && f.trim().length > 0
+        );
+        if (validFacts.length > 0) {
+          await this.addFacts(userId, validFacts, "auto");
+        }
+      }
+    } catch (err) {
+      console.warn("[UserMemory] extractAndStore failed:", (err as Error).message ?? err);
+    }
+  }
+
+  private extractJsonArray(text: string): string {
+    const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+    if (fenceMatch) return fenceMatch[1].trim();
+
+    const bracketStart = text.indexOf("[");
+    const bracketEnd = text.lastIndexOf("]");
+    if (bracketStart !== -1 && bracketEnd > bracketStart) {
+      return text.slice(bracketStart, bracketEnd + 1);
+    }
+
+    return text.trim();
+  }
+}

package/src/models/providers/anthropic.ts

@@ -81,6 +81,13 @@ export class AnthropicProvider implements ModelProvider {
     if (options?.tools?.length) {
       params.tools = this.toAnthropicTools(options.tools);
     }
+    if (options?.reasoning?.enabled) {
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: options.reasoning.budgetTokens ?? 10000,
+      };
+      delete params.temperature;
+    }
 
     const client = this.getClient(options?.apiKey);
     const response = await client.messages.create(params);
@@ -109,11 +116,19 @@ export class AnthropicProvider implements ModelProvider {
     if (options?.tools?.length) {
       params.tools = this.toAnthropicTools(options.tools);
     }
+    if (options?.reasoning?.enabled) {
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: options.reasoning.budgetTokens ?? 10000,
+      };
+      delete params.temperature;
+    }
 
     const client = this.getClient(options?.apiKey);
     const stream = await client.messages.create(params);
 
     let currentToolId = "";
+    let inThinkingBlock = false;
 
     for await (const event of stream) {
       switch (event.type) {
@@ -127,11 +142,15 @@ export class AnthropicProvider implements ModelProvider {
                 name: event.content_block.name,
               },
             };
+          } else if (event.content_block?.type === "thinking") {
+            inThinkingBlock = true;
           }
           break;
         }
         case "content_block_delta": {
-          if (event.delta?.type === "text_delta") {
+          if (event.delta?.type === "thinking_delta") {
+            yield { type: "thinking", text: event.delta.thinking };
+          } else if (event.delta?.type === "text_delta") {
             yield { type: "text", text: event.delta.text };
           } else if (event.delta?.type === "input_json_delta") {
             yield {
@@ -143,7 +162,9 @@ export class AnthropicProvider implements ModelProvider {
           break;
         }
         case "content_block_stop": {
-          if (currentToolId) {
+          if (inThinkingBlock) {
+            inThinkingBlock = false;
+          } else if (currentToolId) {
             yield { type: "tool_call_end", toolCallId: currentToolId };
             currentToolId = "";
           }
@@ -288,13 +309,16 @@ export class AnthropicProvider implements ModelProvider {
     }));
   }
 
-  private normalizeResponse(response: any): ModelResponse {
+  private normalizeResponse(response: any): ModelResponse & { thinking?: string } {
     const toolCalls: ToolCall[] = [];
     let textContent = "";
+    let thinkingContent = "";
 
     for (const block of response.content ?? []) {
       if (block.type === "text") {
         textContent += block.text;
+      } else if (block.type === "thinking") {
+        thinkingContent += block.thinking;
       } else if (block.type === "tool_use") {
         toolCalls.push({
           id: block.id,
@@ -316,7 +340,7 @@ export class AnthropicProvider implements ModelProvider {
     if (response.stop_reason === "tool_use") finishReason = "tool_calls";
     else if (response.stop_reason === "max_tokens") finishReason = "length";
 
-    return {
+    const result: ModelResponse & { thinking?: string } = {
       message: {
         role: "assistant",
         content: textContent || null,
@@ -326,5 +350,11 @@ export class AnthropicProvider implements ModelProvider {
       finishReason,
       raw: response,
     };
+
+    if (thinkingContent) {
+      result.thinking = thinkingContent;
+    }
+
+    return result;
   }
 }

package/src/models/providers/google.ts

@@ -82,6 +82,12 @@ export class GoogleProvider implements ModelProvider {
       }
     }
 
+    if (options?.reasoning?.enabled) {
+      config.thinkingConfig = {
+        thinkingBudget: options.reasoning.budgetTokens ?? 10000,
+      };
+    }
+
     const params: Record<string, unknown> = {
       model: this.modelId,
       contents,
@@ -116,6 +122,12 @@ export class GoogleProvider implements ModelProvider {
     if (options?.topP !== undefined) config.topP = options.topP;
     if (options?.stop) config.stopSequences = options.stop;
 
+    if (options?.reasoning?.enabled) {
+      config.thinkingConfig = {
+        thinkingBudget: options.reasoning.budgetTokens ?? 10000,
+      };
+    }
+
     const params: Record<string, unknown> = {
       model: this.modelId,
       contents,
@@ -142,7 +154,9 @@ export class GoogleProvider implements ModelProvider {
       if (!candidate?.content?.parts) continue;
 
       for (const part of candidate.content.parts) {
-        if (part.text) {
+        if (part.thought) {
+          yield { type: "thinking", text: part.text ?? "" };
+        } else if (part.text) {
           yield { type: "text", text: part.text };
         }
 
@@ -313,16 +327,19 @@ export class GoogleProvider implements ModelProvider {
     return cleaned;
   }
 
-  private normalizeResponse(response: any): ModelResponse {
+  private normalizeResponse(response: any): ModelResponse & { thinking?: string } {
     const candidate = response.candidates?.[0];
     const parts = candidate?.content?.parts ?? [];
 
     let textContent = "";
+    let thinkingContent = "";
     const toolCalls: ToolCall[] = [];
     let toolCallCounter = 0;
 
     for (const part of parts) {
-      if (part.text) {
+      if (part.thought && part.text) {
+        thinkingContent += part.text;
+      } else if (part.text) {
         textContent += part.text;
       }
       if (part.functionCall) {
@@ -334,10 +351,12 @@ export class GoogleProvider implements ModelProvider {
       }
     }
 
+    const thinkingTokens = response.usageMetadata?.thoughtsTokenCount ?? 0;
     const usage: TokenUsage = {
       promptTokens: response.usageMetadata?.promptTokenCount ?? 0,
       completionTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
       totalTokens: response.usageMetadata?.totalTokenCount ?? 0,
+      ...(thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {}),
     };
 
     let finishReason: ModelResponse["finishReason"] = "stop";
@@ -347,7 +366,7 @@ export class GoogleProvider implements ModelProvider {
     else if (candidate?.finishReason === "SAFETY")
       finishReason = "content_filter";
 
-    return {
+    const result: ModelResponse & { thinking?: string } = {
       message: {
         role: "assistant",
         content: textContent || null,
@@ -357,5 +376,11 @@ export class GoogleProvider implements ModelProvider {
       finishReason,
       raw: response,
     };
+
+    if (thinkingContent) {
+      result.thinking = thinkingContent;
+    }
+
+    return result;
   }
 }