@radaros/core 0.3.5 → 0.3.7

package/src/agent/agent.ts

@@ -1,417 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import { EventBus } from "../events/event-bus.js";
-import { InMemoryStorage } from "../storage/in-memory.js";
-import { SessionManager } from "../session/session-manager.js";
-import { ToolExecutor } from "../tools/tool-executor.js";
-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,
-  RunOutput,
-} from "./types.js";
-
-export class Agent {
-  readonly name: string;
-  readonly eventBus: EventBus;
-  readonly instructions?: string | ((ctx: RunContext) => string);
-
-  private config: AgentConfig;
-  private sessionManager: SessionManager;
-  private llmLoop: LLMLoop;
-  private logger: Logger;
-  private storageInitPromise: Promise<void> | null = null;
-
-  get tools() {
-    return this.config.tools ?? [];
-  }
-
-  get modelId(): string {
-    return this.config.model.modelId;
-  }
-
-  get providerId(): string {
-    return this.config.model.providerId;
-  }
-
-  get hasStructuredOutput(): boolean {
-    return !!this.config.structuredOutput;
-  }
-
-  get structuredOutputSchema(): import("zod").ZodSchema | undefined {
-    return this.config.structuredOutput;
-  }
-
-  constructor(config: AgentConfig) {
-    this.config = config;
-    this.name = config.name;
-    this.instructions = config.instructions;
-    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({
-      level: config.logLevel ?? "silent",
-      prefix: config.name,
-    });
-
-    const toolExecutor =
-      config.tools && config.tools.length > 0
-        ? new ToolExecutor(config.tools)
-        : null;
-
-    this.llmLoop = new LLMLoop(config.model, toolExecutor, {
-      maxToolRoundtrips: config.maxToolRoundtrips ?? 10,
-      temperature: config.temperature,
-      structuredOutput: config.structuredOutput,
-      logger: this.logger,
-      reasoning: config.reasoning,
-      retry: config.retry,
-    });
-  }
-
-  async run(input: MessageContent, opts?: RunOpts): Promise<RunOutput> {
-    const startTime = Date.now();
-    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv4();
-    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({
-      sessionId,
-      userId,
-      metadata: opts?.metadata ?? {},
-      eventBus: this.eventBus,
-      sessionState: { ...session.state },
-    });
-
-    this.logger.agentStart(this.name, inputText);
-
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: this.name,
-      input: inputText,
-    });
-
-    try {
-      if (this.config.hooks?.beforeRun) {
-        await this.config.hooks.beforeRun(ctx);
-      }
-
-      if (this.config.guardrails?.input) {
-        for (const guardrail of this.config.guardrails.input) {
-          const result = await guardrail.validate(input, ctx);
-          if (!result.pass) {
-            throw new Error(
-              `Input guardrail "${guardrail.name}" blocked: ${result.reason}`
-            );
-          }
-        }
-      }
-
-      const messages = await this.buildMessages(input, session, ctx);
-      const output = await this.llmLoop.run(messages, ctx, opts?.apiKey);
-
-      output.durationMs = Date.now() - startTime;
-
-      if (this.config.guardrails?.output) {
-        for (const guardrail of this.config.guardrails.output) {
-          const result = await guardrail.validate(output, ctx);
-          if (!result.pass) {
-            throw new Error(
-              `Output guardrail "${guardrail.name}" blocked: ${result.reason}`
-            );
-          }
-        }
-      }
-
-      await this.sessionManager.appendMessages(sessionId, [
-        { role: "user", content: inputText },
-        { role: "assistant", content: output.text },
-      ]);
-      await this.sessionManager.updateState(sessionId, ctx.sessionState);
-
-      if (this.config.memory) {
-        await this.config.memory.addMessages(sessionId, [
-          { role: "user", content: inputText },
-          { role: "assistant", content: output.text },
-        ]);
-      }
-
-      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", {
-        runId: ctx.runId,
-        output,
-      });
-
-      return output;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-
-      this.logger.error(`Run failed: ${err.message}`);
-
-      if (this.config.hooks?.onError) {
-        await this.config.hooks.onError(ctx, err);
-      }
-
-      this.eventBus.emit("run.error", {
-        runId: ctx.runId,
-        error: err,
-      });
-
-      throw err;
-    }
-  }
-
-  async *stream(
-    input: MessageContent,
-    opts?: RunOpts
-  ): AsyncGenerator<StreamChunk> {
-    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv4();
-    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({
-      sessionId,
-      userId,
-      metadata: opts?.metadata ?? {},
-      eventBus: this.eventBus,
-      sessionState: { ...session.state },
-    });
-
-    this.eventBus.emit("run.start", {
-      runId: ctx.runId,
-      agentName: this.name,
-      input: inputText,
-    });
-
-    let fullText = "";
-    let streamOk = false;
-    let streamUsage: import("../models/types.js").TokenUsage = {
-      promptTokens: 0,
-      completionTokens: 0,
-      totalTokens: 0,
-    };
-
-    try {
-      if (this.config.hooks?.beforeRun) {
-        await this.config.hooks.beforeRun(ctx);
-      }
-
-      if (this.config.guardrails?.input) {
-        for (const guardrail of this.config.guardrails.input) {
-          const result = await guardrail.validate(input, ctx);
-          if (!result.pass) {
-            throw new Error(
-              `Input guardrail "${guardrail.name}" blocked: ${result.reason}`
-            );
-          }
-        }
-      }
-
-      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;
-      }
-
-      streamOk = true;
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-
-      if (this.config.hooks?.onError) {
-        await this.config.hooks.onError(ctx, err);
-      }
-
-      this.eventBus.emit("run.error", {
-        runId: ctx.runId,
-        error: err,
-      });
-
-      throw err;
-    } finally {
-      if (streamOk) {
-        await this.sessionManager.appendMessages(sessionId, [
-          { role: "user", content: inputText },
-          { role: "assistant", content: fullText },
-        ]);
-        await this.sessionManager.updateState(sessionId, ctx.sessionState);
-
-        if (this.config.memory) {
-          await this.config.memory.addMessages(sessionId, [
-            { role: "user", content: inputText },
-            { role: "assistant", content: fullText },
-          ]);
-        }
-
-        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: streamUsage,
-          },
-        });
-      }
-    }
-  }
-
-  private async buildMessages(
-    input: MessageContent,
-    session: Session,
-    ctx: RunContext
-  ): Promise<ChatMessage[]> {
-    const messages: ChatMessage[] = [];
-
-    let systemContent = "";
-    if (this.config.instructions) {
-      systemContent =
-        typeof this.config.instructions === "function"
-          ? this.config.instructions(ctx)
-          : this.config.instructions;
-    }
-
-    if (this.config.memory) {
-      const memoryContext = await this.config.memory.getContextString(
-        session.sessionId
-      );
-      if (memoryContext) {
-        systemContent = systemContent
-          ? `${systemContent}\n\n${memoryContext}`
-          : memoryContext;
-      }
-    }
-
-    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 });
-    }
-
-    if (this.config.addHistoryToMessages !== false) {
-      const limit = this.config.numHistoryRuns
-        ? this.config.numHistoryRuns * 2
-        : 20;
-      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 ${session.sessionId}`);
-      }
-      messages.push(...history);
-    }
-
-    messages.push({ role: "user", content: input });
-
-    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

@@ -1,290 +0,0 @@
-import { createRequire } from "node:module";
-import type { z } from "zod";
-import type { ModelProvider } from "../models/provider.js";
-import {
-  getTextContent,
-  type ChatMessage,
-  type ModelConfig,
-  type ReasoningConfig,
-  type StreamChunk,
-  type ToolDefinition,
-} from "../models/types.js";
-import type { ToolExecutor } from "../tools/tool-executor.js";
-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);
-
-export class LLMLoop {
-  private provider: ModelProvider;
-  private toolExecutor: ToolExecutor | null;
-  private maxToolRoundtrips: number;
-  private temperature?: number;
-  private maxTokens?: number;
-  private structuredOutput?: z.ZodSchema;
-  private logger?: Logger;
-  private reasoning?: ReasoningConfig;
-  private retry?: Partial<RetryConfig>;
-
-  constructor(
-    provider: ModelProvider,
-    toolExecutor: ToolExecutor | null,
-    options: {
-      maxToolRoundtrips: number;
-      temperature?: number;
-      maxTokens?: number;
-      structuredOutput?: z.ZodSchema;
-      logger?: Logger;
-      reasoning?: ReasoningConfig;
-      retry?: Partial<RetryConfig>;
-    }
-  ) {
-    this.provider = provider;
-    this.toolExecutor = toolExecutor;
-    this.maxToolRoundtrips = options.maxToolRoundtrips;
-    this.temperature = options.temperature;
-    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() ?? [];
-
-    for (let roundtrip = 0; roundtrip <= this.maxToolRoundtrips; roundtrip++) {
-      const modelConfig: ModelConfig & { tools?: ToolDefinition[] } = {};
-      if (apiKey) modelConfig.apiKey = apiKey;
-      if (this.temperature !== undefined)
-        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 = {
-          type: "json_schema",
-          schema: this.zodToJsonSchema(this.structuredOutput),
-          name: "structured_response",
-        };
-      }
-
-      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);
-
-      if (
-        response.finishReason !== "tool_calls" ||
-        !response.message.toolCalls?.length ||
-        !this.toolExecutor
-      ) {
-        const text = getTextContent(response.message.content);
-
-        const output: RunOutput = {
-          text,
-          toolCalls: allToolCalls,
-          usage: {
-            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);
-            const parsed = JSON.parse(jsonStr);
-            output.structured = this.structuredOutput.parse(parsed);
-          } catch {
-            // structured parsing failed, raw text is still available
-          }
-        }
-
-        return output;
-      }
-
-      const toolResults = await this.toolExecutor.executeAll(
-        response.message.toolCalls,
-        ctx
-      );
-
-      allToolCalls.push(...toolResults);
-
-      for (const result of toolResults) {
-        const content =
-          typeof result.result === "string"
-            ? result.result
-            : result.result.content;
-
-        this.logger?.toolCall(result.toolName, {});
-        this.logger?.toolResult(result.toolName, typeof content === "string" ? content : JSON.stringify(content));
-
-        currentMessages.push({
-          role: "tool",
-          content,
-          toolCallId: result.toolCallId,
-          name: result.toolName,
-        });
-      }
-    }
-
-    const lastAssistantMsg = currentMessages
-      .reverse()
-      .find((m) => m.role === "assistant");
-
-    const text = getTextContent(lastAssistantMsg?.content ?? null);
-
-    return {
-      text,
-      toolCalls: allToolCalls,
-      usage: {
-        promptTokens: totalPromptTokens,
-        completionTokens: totalCompletionTokens,
-        totalTokens: totalPromptTokens + totalCompletionTokens,
-        ...(totalReasoningTokens > 0 ? { reasoningTokens: totalReasoningTokens } : {}),
-      },
-      ...(thinkingContent ? { thinking: thinkingContent } : {}),
-    };
-  }
-
-  async *stream(
-    messages: ChatMessage[],
-    ctx: RunContext,
-    apiKey?: string
-  ): AsyncGenerator<StreamChunk> {
-    const currentMessages = [...messages];
-    const toolDefs = this.toolExecutor?.getToolDefinitions() ?? [];
-
-    for (let roundtrip = 0; roundtrip <= this.maxToolRoundtrips; roundtrip++) {
-      const modelConfig: ModelConfig & { tools?: ToolDefinition[] } = {};
-      if (apiKey) modelConfig.apiKey = apiKey;
-      if (this.temperature !== undefined)
-        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<{
-        id: string;
-        name: string;
-        args: string;
-      }> = [];
-      let finishReason = "stop";
-
-      const streamGen = this.provider.stream(currentMessages, modelConfig);
-
-      for await (const chunk of streamGen) {
-        yield chunk;
-
-        if (chunk.type === "text") {
-          fullText += chunk.text;
-          ctx.eventBus.emit("run.stream.chunk", {
-            runId: ctx.runId,
-            chunk: chunk.text,
-          });
-        } else if (chunk.type === "tool_call_start") {
-          pendingToolCalls.push({
-            id: chunk.toolCall.id,
-            name: chunk.toolCall.name,
-            args: "",
-          });
-        } else if (chunk.type === "tool_call_delta") {
-          const tc = pendingToolCalls.find(
-            (t) => t.id === chunk.toolCallId
-          );
-          if (tc) {
-            tc.args += chunk.argumentsDelta;
-          }
-        } else if (chunk.type === "finish") {
-          finishReason = chunk.finishReason;
-        }
-      }
-
-      if (finishReason !== "tool_calls" || pendingToolCalls.length === 0 || !this.toolExecutor) {
-        return;
-      }
-
-      const assistantMsg: ChatMessage = {
-        role: "assistant",
-        content: fullText || null,
-        toolCalls: pendingToolCalls.map((tc) => ({
-          id: tc.id,
-          name: tc.name,
-          arguments: JSON.parse(tc.args || "{}"),
-        })),
-      };
-      currentMessages.push(assistantMsg);
-
-      const toolResults = await this.toolExecutor.executeAll(
-        assistantMsg.toolCalls!,
-        ctx
-      );
-
-      for (const result of toolResults) {
-        const content =
-          typeof result.result === "string"
-            ? result.result
-            : result.result.content;
-
-        currentMessages.push({
-          role: "tool",
-          content,
-          toolCallId: result.toolCallId,
-          name: result.toolName,
-        });
-      }
-    }
-  }
-
-  private extractJson(text: string): string {
-    const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
-    if (fenceMatch) return fenceMatch[1].trim();
-
-    const braceStart = text.indexOf("{");
-    const braceEnd = text.lastIndexOf("}");
-    if (braceStart !== -1 && braceEnd > braceStart) {
-      return text.slice(braceStart, braceEnd + 1);
-    }
-
-    return text.trim();
-  }
-
-  private zodToJsonSchema(schema: z.ZodSchema): Record<string, unknown> {
-    try {
-      const { zodToJsonSchema } = _require("zod-to-json-schema");
-      const result = zodToJsonSchema(schema, {
-        target: "jsonSchema7",
-        $refStrategy: "none",
-      }) as Record<string, unknown>;
-      delete result["$schema"];
-      return result;
-    } catch {
-      return {};
-    }
-  }
-}