@lupaflow/agent 0.1.0

package/package.json

@@ -0,0 +1,35 @@
+{
+    "name":  "@lupaflow/agent",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/core":  "workspace:*",
+                         "@lupaflow/types":  "workspace:*",
+                         "@lupaflow/providers":  "workspace:*",
+                         "@lupaflow/tools":  "workspace:*",
+                         "@lupaflow/memory":  "workspace:*",
+                         "@lupaflow/plugins": "workspace:*"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/agent.ts

@@ -0,0 +1,84 @@
+import type { AgentConfig, Tool, Personality, Goal, Constraint } from "@lupaflow/types"
+import { MemoryStore } from "@lupaflow/memory"
+import { AgentRunner, AgentRunOptions, AgentRunResult, AgentStreamChunk } from "./runner"
+import { validateAgentConfig } from "./config"
+import { generateId } from "@lupaflow/core"
+import { toolRegistry } from "@lupaflow/tools"
+
+export class Agent {
+  public config: AgentConfig
+  private memoryStore?: MemoryStore
+
+  constructor(config: AgentConfig) {
+    validateAgentConfig(config)
+    this.config = {
+      ...config,
+      id: config.id || generateId(),
+    }
+  }
+
+  tool(t: Tool): this {
+    this.config.tools = this.config.tools || []
+    this.config.tools.push(t)
+    return this
+  }
+
+  useTool(name: string): this {
+    try {
+      const tool = toolRegistry.get(name)
+      this.config.tools = this.config.tools || []
+      this.config.tools.push(tool)
+    } catch {
+      throw new Error(`Tool "${name}" not found in registry`)
+    }
+    return this
+  }
+
+  memory(memory: MemoryStore): this {
+    this.memoryStore = memory
+    return this
+  }
+
+  personality(p: Personality): this {
+    this.config.personality = p
+    return this
+  }
+
+  goal(g: Goal): this {
+    this.config.goals = this.config.goals || []
+    this.config.goals.push(g)
+    return this
+  }
+
+  constraint(c: Constraint): this {
+    this.config.constraints = this.config.constraints || []
+    this.config.constraints.push(c)
+    return this
+  }
+
+  temperature(t: number): this {
+    this.config.temperature = t
+    return this
+  }
+
+  model(m: string): this {
+    this.config.model = m
+    return this
+  }
+
+  async run(input: string, options?: Partial<AgentRunOptions>): Promise<AgentRunResult> {
+    const runner = new AgentRunner(this.config, this.memoryStore)
+    return runner.run({
+      input,
+      ...options,
+    })
+  }
+
+  async *streamRun(input: string, options?: Partial<AgentRunOptions>): AsyncIterableIterator<AgentStreamChunk> {
+    const runner = new AgentRunner(this.config, this.memoryStore)
+    yield* runner.streamRun({
+      input,
+      ...options,
+    })
+  }
+}

package/src/config.ts

@@ -0,0 +1,51 @@
+import type { AgentConfig } from "@lupaflow/types"
+import { ConfigError } from "@lupaflow/core"
+
+export function validateAgentConfig(config: AgentConfig): void {
+  if (!config.name) throw new ConfigError("Agent name is required")
+  if (!config.provider) throw new ConfigError("Provider is required for agent")
+
+  if (config.temperature !== undefined && (config.temperature < 0 || config.temperature > 2)) {
+    throw new ConfigError("Temperature must be between 0 and 2")
+  }
+
+  if (config.maxRetries !== undefined && config.maxRetries < 0) {
+    throw new ConfigError("maxRetries must be >= 0")
+  }
+}
+
+export function buildSystemPrompt(config: AgentConfig): string {
+  const parts: string[] = []
+
+  parts.push(config.systemPrompt || `You are ${config.name}, an AI assistant.`)
+
+  if (config.personality) {
+    const p = config.personality
+    parts.push("")
+    parts.push("--- Personality ---")
+    if (p.name) parts.push(`Name: ${p.name}`)
+    if (p.tone) parts.push(`Tone: ${p.tone}`)
+    if (p.style) parts.push(`Style: ${p.style}`)
+    if (p.traits?.length) parts.push(`Traits: ${p.traits.join(", ")}`)
+  }
+
+  if (config.goals?.length) {
+    parts.push("")
+    parts.push("--- Goals ---")
+    config.goals.forEach((g, i) => parts.push(`${i + 1}. ${g.description}`))
+  }
+
+  if (config.constraints?.length) {
+    parts.push("")
+    parts.push("--- Constraints ---")
+    config.constraints.forEach((c) => parts.push(`- ${c.description}`))
+  }
+
+  if (config.tools?.length) {
+    parts.push("")
+    parts.push(`You have access to these tools: ${config.tools.map((t) => t.definition.name).join(", ")}`)
+    parts.push("Use them when appropriate to fulfill the user's request.")
+  }
+
+  return parts.join("\n")
+}

package/src/context.ts

@@ -0,0 +1,63 @@
+import type { Message } from "@lupaflow/types"
+import { estimateTokens } from "@lupaflow/core"
+
+export interface ContextConfig {
+  maxMessages?: number
+  maxTokens?: number
+  preserveSystem?: boolean
+}
+
+export class ContextManager {
+  private messages: Message[] = []
+  private config: ContextConfig
+
+  constructor(config: ContextConfig = {}) {
+    this.config = {
+      maxMessages: config.maxMessages || 50,
+      maxTokens: config.maxTokens || 4000,
+      preserveSystem: config.preserveSystem ?? true,
+    }
+  }
+
+  add(message: Message): void {
+    this.messages.push(message)
+    this.trim()
+  }
+
+  getMessages(): Message[] {
+    return [...this.messages]
+  }
+
+  getTotalTokens(): number {
+    return this.messages.reduce((sum, m) => sum + estimateTokens(m.content || ""), 0)
+  }
+
+  trim(): void {
+    if (this.messages.length <= this.config.maxMessages! && this.getTotalTokens() <= this.config.maxTokens!) {
+      return
+    }
+
+    while (
+      this.messages.length > 2 &&
+      (this.messages.length > this.config.maxMessages! || this.getTotalTokens() > this.config.maxTokens!)
+    ) {
+      const startIdx = this.config.preserveSystem && this.messages[0]?.role === "system" ? 1 : 0
+      if (startIdx < this.messages.length) {
+        this.messages.splice(startIdx, 1)
+      } else {
+        break
+      }
+    }
+  }
+
+  clear(): void {
+    const systemMsg = this.config.preserveSystem
+      ? this.messages.find((m) => m.role === "system")
+      : undefined
+    this.messages = systemMsg ? [systemMsg] : []
+  }
+
+  toJSON(): Message[] {
+    return this.getMessages()
+  }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { Agent } from "./agent"
+export { AgentRunner } from "./runner"
+export type { AgentRunOptions, AgentRunResult, AgentStreamChunk } from "./runner"
+export { ContextManager } from "./context"
+export { withRetry } from "./retry"
+export { buildSystemPrompt, validateAgentConfig } from "./config"

package/src/retry.ts

@@ -0,0 +1,47 @@
+import { delay } from "@lupaflow/core"
+import { RetryError } from "@lupaflow/core"
+import { globalEventBus } from "@lupaflow/core"
+
+export interface RetryConfig {
+  maxRetries: number
+  baseDelay: number
+  maxDelay: number
+  backoffFactor: number
+}
+
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  config: Partial<RetryConfig> = {},
+  context?: string
+): Promise<T> {
+  const cfg: RetryConfig = {
+    maxRetries: config.maxRetries ?? 3,
+    baseDelay: config.baseDelay ?? 1000,
+    maxDelay: config.maxDelay ?? 30000,
+    backoffFactor: config.backoffFactor ?? 2,
+  }
+
+  let lastError: Error | null = null
+
+  for (let attempt = 0; attempt <= cfg.maxRetries; attempt++) {
+    try {
+      return await fn()
+    } catch (err: any) {
+      lastError = err
+      if (attempt < cfg.maxRetries) {
+        const waitTime = Math.min(cfg.baseDelay * Math.pow(cfg.backoffFactor, attempt), cfg.maxDelay)
+        await globalEventBus.emit("agent:error", {
+          error: err.message,
+          retryAttempt: attempt + 1,
+        } as any)
+        await delay(waitTime)
+      }
+    }
+  }
+
+  throw new RetryError(
+    `${context ? `[${context}] ` : ""}Failed after ${cfg.maxRetries + 1} attempts`,
+    cfg.maxRetries + 1,
+    lastError!
+  )
+}

package/src/runner.ts

@@ -0,0 +1,528 @@
+import type { Message, CompletionResponse, AgentConfig, MemoryEntry, ToolCall } from "@lupaflow/types"
+import { providerRegistry } from "@lupaflow/providers"
+import { ContextManager } from "./context"
+import { MemoryStore } from "@lupaflow/memory"
+import { withRetry } from "./retry"
+import { buildSystemPrompt } from "./config"
+import { generateId } from "@lupaflow/core"
+import { globalEventBus } from "@lupaflow/core"
+import { ToolError } from "@lupaflow/core"
+import {
+  runBeforeAgentRunHooks,
+  runAfterAgentRunHooks,
+  runBeforeToolCallHooks,
+  runAfterToolCallHooks,
+  runBeforeProviderCallHooks,
+  runAfterProviderCallHooks,
+} from "@lupaflow/plugins"
+
+export interface AgentRunOptions {
+  input: string
+  sessionId?: string
+  onThinking?: (message: string) => void
+  onToolCall?: (tool: string, args: Record<string, unknown>) => void
+  onToolResult?: (tool: string, result: unknown) => void
+}
+
+export interface AgentRunResult {
+  id: string
+  output: string
+  messages: Message[]
+  usage: {
+    totalTokens: number
+    promptTokens: number
+    completionTokens: number
+  }
+  latencyMs: number
+  toolCalls: number
+  finishReason: string
+}
+
+export type AgentStreamChunk =
+  | { type: "text"; text: string }
+  | { type: "tool_call"; toolCall: ToolCall }
+  | { type: "tool_result"; toolCall: ToolCall; result: unknown }
+  | { type: "error"; error: string }
+  | {
+      type: "finish"
+      output: string
+      finishReason: string
+      usage: { totalTokens: number; promptTokens: number; completionTokens: number }
+      toolCalls: number
+      latencyMs: number
+    }
+
+export class AgentRunner {
+  private config: AgentConfig
+  private context: ContextManager
+  private memory?: MemoryStore
+  private toolCallCount = 0
+  private totalPromptTokens = 0
+  private totalCompletionTokens = 0
+
+  constructor(config: AgentConfig, memory?: MemoryStore) {
+    this.config = config
+    this.context = new ContextManager({
+      maxMessages: config.maxContextMessages || 50,
+    })
+    this.memory = memory
+  }
+
+  async run(options: AgentRunOptions): Promise<AgentRunResult> {
+    const runId = generateId()
+    const startTime = Date.now()
+    this.toolCallCount = 0
+    this.totalPromptTokens = 0
+    this.totalCompletionTokens = 0
+
+    const provider = providerRegistry.get(this.config.provider, {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      topP: this.config.topP,
+    })
+
+    const systemPrompt = buildSystemPrompt(this.config)
+
+    runBeforeAgentRunHooks({
+      input: options.input,
+      ...this.config,
+    } as any)
+
+    this.context.add({ role: "system", content: systemPrompt })
+    this.context.add({ role: "user", content: options.input })
+
+    await globalEventBus.emit("agent:start", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      config: this.config as any,
+    } as any)
+
+    await globalEventBus.emit("agent:thinking", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      message: options.input,
+    } as any)
+
+    let finalContent = ""
+    let finishReason = "stop"
+    let iterationCount = 0
+    const maxIterations = 20
+
+    while (iterationCount < maxIterations) {
+      iterationCount++
+
+      const request = runBeforeProviderCallHooks(this.config.provider, {
+        model: this.config.model,
+        messages: this.context.getMessages(),
+        tools: this.config.tools,
+        systemPrompt: undefined,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        topP: this.config.topP,
+      } as any)
+
+      const response: CompletionResponse = await withRetry(
+        () =>
+          provider.complete({
+            messages: request.messages as Message[] || this.context.getMessages(),
+            tools: this.config.tools,
+            systemPrompt: undefined,
+            temperature: this.config.temperature,
+            maxTokens: this.config.maxTokens,
+            topP: this.config.topP,
+            model: this.config.model,
+          }),
+        {
+          maxRetries: this.config.maxRetries ?? 3,
+          baseDelay: this.config.retryDelay ?? 1000,
+        },
+        this.config.name
+      )
+
+      runAfterProviderCallHooks(response as any)
+
+      this.totalPromptTokens += response.usage.promptTokens
+      this.totalCompletionTokens += response.usage.completionTokens
+
+      if (response.toolCalls.length > 0) {
+        this.context.add({
+          role: "assistant",
+          content: response.content || null,
+          toolCalls: response.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function" as const,
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+          })),
+        })
+      } else if (response.content) {
+        this.context.add({ role: "assistant", content: response.content })
+      }
+
+      if (response.toolCalls.length === 0) {
+        finalContent = response.content || ""
+        finishReason = response.finishReason
+        break
+      }
+
+      for (const tc of response.toolCalls) {
+        this.toolCallCount++
+        await globalEventBus.emit("tool:start", {
+          agentId: this.config.id || this.config.name,
+          runId,
+          tool: tc.name,
+          args: tc.args,
+        } as any)
+
+        options.onToolCall?.(tc.name, tc.args)
+
+        try {
+          const tool = this.config.tools?.find((t) => t.definition.name === tc.name)
+          if (!tool) throw new ToolError(tc.name, `Tool "${tc.name}" not found on agent`)
+
+          const hookArgs = runBeforeToolCallHooks(tc.name, tc.args as Record<string, unknown>)
+          const result = await tool.execute(hookArgs)
+          const hookResult = runAfterToolCallHooks(result)
+          const resultStr = typeof hookResult === "string" ? hookResult : JSON.stringify(hookResult, null, 2)
+
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: resultStr,
+          })
+
+          await globalEventBus.emit("tool:finish", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            result: hookResult,
+            durationMs: Date.now() - startTime,
+          } as any)
+
+          options.onToolResult?.(tc.name, hookResult)
+        } catch (err: any) {
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: `Error: ${err.message}`,
+          })
+
+          await globalEventBus.emit("tool:error", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            error: err.message,
+          } as any)
+        }
+      }
+    }
+
+    const totalLatency = Date.now() - startTime
+
+    if (this.memory) {
+      await this.memory.store({
+        id: generateId(),
+        type: "short-term",
+        key: `agent:${this.config.name}:input:${generateId()}`,
+        content: options.input,
+        metadata: { runId, agentName: this.config.name },
+        timestamp: Date.now(),
+      } as MemoryEntry)
+
+      if (finalContent) {
+        await this.memory.store({
+          id: generateId(),
+          type: "short-term",
+          key: `agent:${this.config.name}:output:${generateId()}`,
+          content: finalContent,
+          metadata: { runId, agentName: this.config.name },
+          timestamp: Date.now(),
+        } as MemoryEntry)
+      }
+    }
+
+    await globalEventBus.emit("agent:response", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      content: finalContent,
+      tokens: this.totalCompletionTokens,
+      latencyMs: totalLatency,
+    } as any)
+
+    runAfterAgentRunHooks({
+      id: runId,
+      output: finalContent,
+      messages: this.context.getMessages(),
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens,
+      },
+      latencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+      finishReason,
+    })
+
+    await globalEventBus.emit("agent:complete", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+      totalLatencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+    } as any)
+
+    return {
+      id: runId,
+      output: finalContent,
+      messages: this.context.getMessages(),
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens,
+      },
+      latencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+      finishReason,
+    }
+  }
+
+  async *streamRun(options: AgentRunOptions): AsyncIterableIterator<AgentStreamChunk> {
+    const runId = generateId()
+    const startTime = Date.now()
+    this.toolCallCount = 0
+    this.totalPromptTokens = 0
+    this.totalCompletionTokens = 0
+
+    const provider = providerRegistry.get(this.config.provider, {
+      model: this.config.model,
+      temperature: this.config.temperature,
+      maxTokens: this.config.maxTokens,
+      topP: this.config.topP,
+    })
+
+    const systemPrompt = buildSystemPrompt(this.config)
+
+    runBeforeAgentRunHooks({
+      input: options.input,
+      ...this.config,
+    } as any)
+
+    this.context.add({ role: "system", content: systemPrompt })
+    this.context.add({ role: "user", content: options.input })
+
+    await globalEventBus.emit("agent:start", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      config: this.config as any,
+    } as any)
+
+    await globalEventBus.emit("agent:thinking", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      message: options.input,
+    } as any)
+
+    let finalContent = ""
+    let finishReason = "stop"
+    let iterationCount = 0
+    const maxIterations = 20
+
+    while (iterationCount < maxIterations) {
+      iterationCount++
+
+      const request = runBeforeProviderCallHooks(this.config.provider, {
+        model: this.config.model,
+        messages: this.context.getMessages(),
+        tools: this.config.tools,
+        systemPrompt: undefined,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        topP: this.config.topP,
+      } as any)
+
+      const messages = (request.messages as Message[]) || this.context.getMessages()
+
+      // stream from the provider
+      const stream = provider.streamComplete({
+        messages,
+        tools: this.config.tools,
+        systemPrompt: undefined,
+        temperature: this.config.temperature,
+        maxTokens: this.config.maxTokens,
+        topP: this.config.topP,
+        model: this.config.model,
+      })
+
+      let roundContent = ""
+      let roundToolCalls: ToolCall[] = []
+
+      for await (const chunk of stream) {
+        if (chunk.type === "text") {
+          roundContent += chunk.text
+          yield { type: "text", text: chunk.text }
+        } else if (chunk.type === "tool_call") {
+          roundToolCalls.push(chunk.toolCall)
+        } else if (chunk.type === "finish") {
+          roundContent = chunk.content
+          roundToolCalls = chunk.toolCalls
+          this.totalPromptTokens += chunk.usage.promptTokens
+          this.totalCompletionTokens += chunk.usage.completionTokens
+          finishReason = chunk.finishReason
+        }
+      }
+
+      runAfterProviderCallHooks({
+        content: roundContent,
+        toolCalls: roundToolCalls,
+      } as any)
+
+      // add assistant message to context
+      if (roundToolCalls.length > 0) {
+        this.context.add({
+          role: "assistant",
+          content: roundContent || null,
+          toolCalls: roundToolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function" as const,
+            function: { name: tc.name, arguments: JSON.stringify(tc.args) },
+          })),
+        })
+      } else if (roundContent) {
+        this.context.add({ role: "assistant", content: roundContent })
+      }
+
+      if (roundToolCalls.length === 0) {
+        finalContent = roundContent
+        finishReason = finishReason || "stop"
+        break
+      }
+
+      // execute tool calls
+      for (const tc of roundToolCalls) {
+        this.toolCallCount++
+        await globalEventBus.emit("tool:start", {
+          agentId: this.config.id || this.config.name,
+          runId,
+          tool: tc.name,
+          args: tc.args,
+        } as any)
+
+        options.onToolCall?.(tc.name, tc.args)
+        yield { type: "tool_call", toolCall: tc }
+
+        try {
+          const tool = this.config.tools?.find((t) => t.definition.name === tc.name)
+          if (!tool) throw new ToolError(tc.name, `Tool "${tc.name}" not found on agent`)
+
+          const hookArgs = runBeforeToolCallHooks(tc.name, tc.args as Record<string, unknown>)
+          const result = await tool.execute(hookArgs)
+          const hookResult = runAfterToolCallHooks(result)
+          const resultStr = typeof hookResult === "string" ? hookResult : JSON.stringify(hookResult, null, 2)
+
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: resultStr,
+          })
+
+          await globalEventBus.emit("tool:finish", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            result: hookResult,
+            durationMs: Date.now() - startTime,
+          } as any)
+
+          options.onToolResult?.(tc.name, hookResult)
+          yield { type: "tool_result", toolCall: tc, result: hookResult }
+        } catch (err: any) {
+          this.context.add({
+            role: "tool",
+            toolCallId: tc.id,
+            name: tc.name,
+            content: `Error: ${err.message}`,
+          })
+
+          await globalEventBus.emit("tool:error", {
+            agentId: this.config.id || this.config.name,
+            runId,
+            tool: tc.name,
+            error: err.message,
+          } as any)
+
+          yield { type: "error", error: err.message }
+        }
+      }
+    }
+
+    const totalLatency = Date.now() - startTime
+
+    if (this.memory) {
+      await this.memory.store({
+        id: generateId(),
+        type: "short-term",
+        key: `agent:${this.config.name}:input:${generateId()}`,
+        content: options.input,
+        metadata: { runId, agentName: this.config.name },
+        timestamp: Date.now(),
+      } as MemoryEntry)
+
+      if (finalContent) {
+        await this.memory.store({
+          id: generateId(),
+          type: "short-term",
+          key: `agent:${this.config.name}:output:${generateId()}`,
+          content: finalContent,
+          metadata: { runId, agentName: this.config.name },
+          timestamp: Date.now(),
+        } as MemoryEntry)
+      }
+    }
+
+    await globalEventBus.emit("agent:response", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      content: finalContent,
+      tokens: this.totalCompletionTokens,
+      latencyMs: totalLatency,
+    } as any)
+
+    runAfterAgentRunHooks({
+      id: runId,
+      output: finalContent,
+      messages: this.context.getMessages(),
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens,
+      },
+      latencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+      finishReason,
+    })
+
+    await globalEventBus.emit("agent:complete", {
+      agentId: this.config.id || this.config.name,
+      runId,
+      totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+      totalLatencyMs: totalLatency,
+      toolCalls: this.toolCallCount,
+    } as any)
+
+    yield {
+      type: "finish",
+      output: finalContent,
+      finishReason,
+      usage: {
+        totalTokens: this.totalPromptTokens + this.totalCompletionTokens,
+        promptTokens: this.totalPromptTokens,
+        completionTokens: this.totalCompletionTokens,
+      },
+      toolCalls: this.toolCallCount,
+      latencyMs: totalLatency,
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})