@radaros/core 0.3.2 → 0.3.3

package/src/models/providers/openai.ts

@@ -72,8 +72,12 @@ export class OpenAIProvider implements ModelProvider {
       messages: this.toOpenAIMessages(messages),
     };
 
-    if (options?.temperature !== undefined)
-      params.temperature = options.temperature;
+    if (options?.reasoning?.enabled) {
+      params.reasoning_effort = options.reasoning.effort ?? "medium";
+    } else {
+      if (options?.temperature !== undefined)
+        params.temperature = options.temperature;
+    }
     if (options?.maxTokens !== undefined)
       params.max_tokens = options.maxTokens;
     if (options?.topP !== undefined) params.top_p = options.topP;
@@ -98,8 +102,12 @@ export class OpenAIProvider implements ModelProvider {
       stream: true,
     };
 
-    if (options?.temperature !== undefined)
-      params.temperature = options.temperature;
+    if (options?.reasoning?.enabled) {
+      params.reasoning_effort = options.reasoning.effort ?? "medium";
+    } else {
+      if (options?.temperature !== undefined)
+        params.temperature = options.temperature;
+    }
     if (options?.maxTokens !== undefined)
       params.max_tokens = options.maxTokens;
     if (options?.topP !== undefined) params.top_p = options.topP;
@@ -165,11 +173,16 @@ export class OpenAIProvider implements ModelProvider {
         }
       }
 
+      if (delta?.reasoning_content) {
+        yield { type: "thinking", text: delta.reasoning_content };
+      }
+
       if (choice.finish_reason) {
         for (const [, tc] of activeToolCalls) {
           yield { type: "tool_call_end", toolCallId: tc.id };
         }
 
+        const reasoningTkns = chunk.usage?.completion_tokens_details?.reasoning_tokens ?? 0;
         yield {
           type: "finish",
           finishReason:
@@ -181,6 +194,7 @@ export class OpenAIProvider implements ModelProvider {
                 promptTokens: chunk.usage.prompt_tokens ?? 0,
                 completionTokens: chunk.usage.completion_tokens ?? 0,
                 totalTokens: chunk.usage.total_tokens ?? 0,
+                ...(reasoningTkns > 0 ? { reasoningTokens: reasoningTkns } : {}),
               }
             : undefined,
         };
@@ -287,7 +301,7 @@ export class OpenAIProvider implements ModelProvider {
     }));
   }
 
-  private normalizeResponse(response: any): ModelResponse {
+  private normalizeResponse(response: any): ModelResponse & { thinking?: string } {
     const choice = response.choices[0];
     const msg = choice.message;
 
@@ -297,10 +311,12 @@ export class OpenAIProvider implements ModelProvider {
       arguments: JSON.parse(tc.function.arguments || "{}"),
     }));
 
+    const reasoningTokens = response.usage?.completion_tokens_details?.reasoning_tokens ?? 0;
     const usage: TokenUsage = {
       promptTokens: response.usage?.prompt_tokens ?? 0,
       completionTokens: response.usage?.completion_tokens ?? 0,
       totalTokens: response.usage?.total_tokens ?? 0,
+      ...(reasoningTokens > 0 ? { reasoningTokens } : {}),
     };
 
     let finishReason: ModelResponse["finishReason"] = "stop";
@@ -309,7 +325,7 @@ export class OpenAIProvider implements ModelProvider {
     else if (choice.finish_reason === "content_filter")
       finishReason = "content_filter";
 
-    return {
+    const result: ModelResponse & { thinking?: string } = {
       message: {
         role: "assistant",
         content: msg.content ?? null,
@@ -319,5 +335,11 @@ export class OpenAIProvider implements ModelProvider {
       finishReason,
       raw: response,
     };
+
+    if (msg.reasoning_content) {
+      result.thinking = msg.reasoning_content;
+    }
+
+    return result;
   }
 }

package/src/models/providers/vertex.ts

@@ -108,6 +108,12 @@ export class VertexAIProvider implements ModelProvider {
       }
     }
 
+    if (options?.reasoning?.enabled) {
+      config.thinkingConfig = {
+        thinkingBudget: options.reasoning.budgetTokens ?? 10000,
+      };
+    }
+
     const params: Record<string, unknown> = {
       model: this.modelId,
       contents,
@@ -140,6 +146,12 @@ export class VertexAIProvider 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,
@@ -163,7 +175,9 @@ export class VertexAIProvider 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 };
         }
 
@@ -354,16 +368,21 @@ export class VertexAIProvider 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) textContent += part.text;
+      if (part.thought && part.text) {
+        thinkingContent += part.text;
+      } else if (part.text) {
+        textContent += part.text;
+      }
       if (part.functionCall) {
         toolCalls.push({
           id: `vertex_tc_${toolCallCounter++}`,
@@ -373,10 +392,12 @@ export class VertexAIProvider 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";
@@ -386,7 +407,7 @@ export class VertexAIProvider implements ModelProvider {
     else if (candidate?.finishReason === "SAFETY")
       finishReason = "content_filter";
 
-    return {
+    const result: ModelResponse & { thinking?: string } = {
       message: {
         role: "assistant",
         content: textContent || null,
@@ -396,5 +417,11 @@ export class VertexAIProvider implements ModelProvider {
       finishReason,
       raw: response,
     };
+
+    if (thinkingContent) {
+      result.thinking = thinkingContent;
+    }
+
+    return result;
   }
 }

package/src/models/types.ts

@@ -64,6 +64,7 @@ export interface TokenUsage {
   promptTokens: number;
   completionTokens: number;
   totalTokens: number;
+  reasoningTokens?: number;
 }
 
 // ── Model response ────────────────────────────────────────────────────────
@@ -77,6 +78,7 @@ export interface ModelResponse {
 
 export type StreamChunk =
   | { type: "text"; text: string }
+  | { type: "thinking"; text: string }
   | { type: "tool_call_start"; toolCall: { id: string; name: string } }
   | { type: "tool_call_delta"; toolCallId: string; argumentsDelta: string }
   | { type: "tool_call_end"; toolCallId: string }
@@ -84,6 +86,14 @@ export type StreamChunk =
 
 // ── Model config ──────────────────────────────────────────────────────────
 
+export interface ReasoningConfig {
+  enabled: boolean;
+  /** Reasoning effort for OpenAI o-series models. */
+  effort?: "low" | "medium" | "high";
+  /** Token budget for thinking (Anthropic / Gemini). */
+  budgetTokens?: number;
+}
+
 export interface ModelConfig {
   temperature?: number;
   maxTokens?: number;
@@ -92,6 +102,8 @@ export interface ModelConfig {
   responseFormat?: "text" | "json" | { type: "json_schema"; schema: Record<string, unknown>; name?: string };
   /** Per-request API key override. When provided, the provider uses this key instead of the one set at construction. */
   apiKey?: string;
+  /** Enable extended thinking / reasoning. */
+  reasoning?: ReasoningConfig;
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────────

package/src/tools/define-tool.ts

@@ -1,6 +1,6 @@
 import type { z } from "zod";
 import type { RunContext } from "../agent/run-context.js";
-import type { ToolDef, ToolResult } from "./types.js";
+import type { ToolDef, ToolResult, ToolCacheConfig } from "./types.js";
 
 export function defineTool<T extends z.ZodObject<any>>(config: {
   name: string;
@@ -10,11 +10,13 @@ export function defineTool<T extends z.ZodObject<any>>(config: {
     args: z.infer<T>,
     ctx: RunContext
   ) => Promise<string | ToolResult>;
+  cache?: ToolCacheConfig;
 }): ToolDef {
   return {
     name: config.name,
     description: config.description,
     parameters: config.parameters,
     execute: config.execute as ToolDef["execute"],
+    cache: config.cache,
   };
 }

package/src/tools/tool-executor.ts

@@ -1,19 +1,61 @@
 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>();
 
   constructor(tools: ToolDef[], concurrency: number = 5) {
     this.tools = new Map(tools.map((t) => [t.name, t]));
     this.concurrency = concurrency;
   }
 
+  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(
     toolCalls: ToolCall[],
     ctx: RunContext
@@ -66,6 +108,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 +149,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,

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 {