@objectstack/service-ai 4.0.3 → 4.0.5

package/src/__tests__/vercel-stream-encoder.test.ts

@@ -1,310 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { describe, it, expect } from 'vitest';
-import type { TextStreamPart, ToolSet } from '@objectstack/spec/contracts';
-import { encodeStreamPart, encodeVercelDataStream } from '../stream/vercel-stream-encoder.js';
-
-// Helper to parse SSE frame payload
-function parseSSE(frame: string): Record<string, unknown> | null {
-  if (!frame.startsWith('data: ') || !frame.endsWith('\n\n')) return null;
-  const json = frame.slice(6, -2);
-  if (json === '[DONE]') return null;
-  return JSON.parse(json);
-}
-
-// ─────────────────────────────────────────────────────────────────
-// encodeStreamPart — individual frame encoding (v6 SSE format)
-// ─────────────────────────────────────────────────────────────────
-
-describe('encodeStreamPart', () => {
-  it('should encode text-delta as SSE frame', () => {
-    const part = { type: 'text-delta', text: 'Hello world' } as TextStreamPart<ToolSet>;
-    const frame = encodeStreamPart(part);
-    const payload = parseSSE(frame);
-    expect(payload).toEqual({ type: 'text-delta', id: '0', delta: 'Hello world' });
-  });
-
-  it('should JSON-escape text-delta content', () => {
-    const part = { type: 'text-delta', text: 'say "hi"\nnewline' } as TextStreamPart<ToolSet>;
-    const frame = encodeStreamPart(part);
-    expect(frame.startsWith('data: ')).toBe(true);
-    expect(frame.endsWith('\n\n')).toBe(true);
-
-    // Verify round-trip: decode the frame payload back to the original text
-    const payload = parseSSE(frame);
-    expect(payload).not.toBeNull();
-    expect((payload as Record<string, unknown>).delta).toBe('say "hi"\nnewline');
-  });
-
-  it('should encode tool-call as tool-input-available SSE frame', () => {
-    const part = {
-      type: 'tool-call',
-      toolCallId: 'call_1',
-      toolName: 'get_weather',
-      input: { location: 'San Francisco' },
-    } as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    const payload = parseSSE(frame);
-    expect(payload).toEqual({
-      type: 'tool-input-available',
-      toolCallId: 'call_1',
-      toolName: 'get_weather',
-      input: { location: 'San Francisco' },
-    });
-  });
-
-  it('should encode tool-input-start as SSE frame', () => {
-    const part = {
-      type: 'tool-input-start',
-      id: 'call_2',
-      toolName: 'search',
-    } as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    const payload = parseSSE(frame);
-    expect(payload).toEqual({
-      type: 'tool-input-start',
-      toolCallId: 'call_2',
-      toolName: 'search',
-    });
-  });
-
-  it('should encode tool-input-delta as SSE frame', () => {
-    const part = {
-      type: 'tool-input-delta',
-      id: 'call_2',
-      delta: '{"query":',
-    } as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    const payload = parseSSE(frame);
-    expect(payload).toEqual({
-      type: 'tool-input-delta',
-      toolCallId: 'call_2',
-      inputTextDelta: '{"query":',
-    });
-  });
-
-  it('should encode tool-result as tool-output-available SSE frame', () => {
-    const part = {
-      type: 'tool-result',
-      toolCallId: 'call_1',
-      toolName: 'get_weather',
-      output: { temperature: 72 },
-    } as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    const payload = parseSSE(frame);
-    expect(payload).toEqual({
-      type: 'tool-output-available',
-      toolCallId: 'call_1',
-      output: { temperature: 72 },
-    });
-  });
-
-  it('should return empty string for finish (handled by generator)', () => {
-    const part = {
-      type: 'finish',
-      finishReason: 'stop',
-      totalUsage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
-      rawFinishReason: 'stop',
-    } as unknown as TextStreamPart<ToolSet>;
-
-    expect(encodeStreamPart(part)).toBe('');
-  });
-
-  it('should return empty string for finish-step (handled by generator)', () => {
-    const part = {
-      type: 'finish-step',
-      finishReason: 'tool-calls',
-      usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
-    } as unknown as TextStreamPart<ToolSet>;
-
-    expect(encodeStreamPart(part)).toBe('');
-  });
-
-  it('should return empty string for unknown event types', () => {
-    const part = { type: 'unknown-internal' } as unknown as TextStreamPart<ToolSet>;
-    expect(encodeStreamPart(part)).toBe('');
-  });
-
-  it('should encode reasoning-start part with g: prefix', () => {
-    const part = {
-      type: 'reasoning-start',
-      id: 'r1',
-    } as unknown as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    expect(frame).toBe('g:{"text":""}\n');
-  });
-
-  it('should encode reasoning-delta part with g: prefix', () => {
-    const part = {
-      type: 'reasoning-delta',
-      id: 'r1',
-      text: 'Let me think through this step by step...',
-    } as unknown as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    expect(frame).toBe('g:{"text":"Let me think through this step by step..."}\n');
-  });
-
-  it('should encode reasoning-end part as empty (no specific end marker)', () => {
-    const part = {
-      type: 'reasoning-end',
-      id: 'r1',
-    } as unknown as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    expect(frame).toBe('');
-  });
-
-  it('should pass through custom step events', () => {
-    const part = {
-      type: 'step-start',
-      stepId: 'step_1',
-      stepName: 'Query database',
-    } as unknown as TextStreamPart<ToolSet>;
-
-    const frame = encodeStreamPart(part);
-    const payload = parseSSE(frame);
-    expect(payload).toEqual({
-      type: 'step-start',
-      stepId: 'step_1',
-      stepName: 'Query database',
-    });
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────
-// encodeVercelDataStream — async iterable transformation (v6 SSE)
-//
-// Lifecycle: start → start-step → text-start → ...events... → text-end → finish-step → finish → [DONE]
-// ─────────────────────────────────────────────────────────────────
-
-describe('encodeVercelDataStream', () => {
-  it('should transform stream events into v6 UI Message Stream frames', async () => {
-    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
-      yield { type: 'text-delta', text: 'Hello' } as TextStreamPart<ToolSet>;
-      yield { type: 'text-delta', text: ' world' } as TextStreamPart<ToolSet>;
-      yield {
-        type: 'finish',
-        finishReason: 'stop',
-        totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        rawFinishReason: 'stop',
-      } as unknown as TextStreamPart<ToolSet>;
-    }
-
-    const frames: string[] = [];
-    for await (const frame of encodeVercelDataStream(source())) {
-      frames.push(frame);
-    }
-
-    // Preamble: start, start-step, text-start
-    // Content: 2 text-deltas
-    // Postamble: text-end, finish-step, finish, [DONE]
-    expect(frames).toHaveLength(9);
-
-    // Preamble
-    expect(parseSSE(frames[0])).toEqual({ type: 'start' });
-    expect(parseSSE(frames[1])).toEqual({ type: 'start-step' });
-    expect(parseSSE(frames[2])).toEqual({ type: 'text-start', id: '0' });
-
-    // Content
-    expect(parseSSE(frames[3])).toMatchObject({ type: 'text-delta', delta: 'Hello' });
-    expect(parseSSE(frames[4])).toMatchObject({ type: 'text-delta', delta: ' world' });
-
-    // Postamble
-    expect(parseSSE(frames[5])).toEqual({ type: 'text-end', id: '0' });
-    expect(parseSSE(frames[6])).toEqual({ type: 'finish-step' });
-    expect(parseSSE(frames[7])).toMatchObject({ type: 'finish', finishReason: 'stop' });
-    expect(frames[8]).toBe('data: [DONE]\n\n');
-  });
-
-  it('should skip events with no wire format mapping', async () => {
-    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
-      yield { type: 'text-delta', text: 'Hi' } as TextStreamPart<ToolSet>;
-      yield { type: 'unknown-internal' } as unknown as TextStreamPart<ToolSet>;
-      yield {
-        type: 'finish',
-        finishReason: 'stop',
-        totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        rawFinishReason: 'stop',
-      } as unknown as TextStreamPart<ToolSet>;
-    }
-
-    const frames: string[] = [];
-    for await (const frame of encodeVercelDataStream(source())) {
-      frames.push(frame);
-    }
-
-    // Preamble(3) + 1 text-delta + Postamble(4) = 8 ('unknown-internal' dropped)
-    expect(frames).toHaveLength(8);
-    expect(parseSSE(frames[3])).toMatchObject({ type: 'text-delta', delta: 'Hi' });
-  });
-
-  it('should handle empty stream', async () => {
-    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
-      // empty
-    }
-
-    const frames: string[] = [];
-    for await (const frame of encodeVercelDataStream(source())) {
-      frames.push(frame);
-    }
-
-    // Preamble(3) + text-end + finish-step + finish + [DONE] = 7
-    expect(frames).toHaveLength(7);
-    expect(parseSSE(frames[0])).toEqual({ type: 'start' });
-    expect(parseSSE(frames[3])).toEqual({ type: 'text-end', id: '0' });
-    expect(frames[6]).toBe('data: [DONE]\n\n');
-  });
-
-  it('should handle tool-call events in stream', async () => {
-    async function* source(): AsyncIterable<TextStreamPart<ToolSet>> {
-      yield {
-        type: 'tool-call',
-        toolCallId: 'call_1',
-        toolName: 'search',
-        input: { query: 'test' },
-      } as TextStreamPart<ToolSet>;
-      yield {
-        type: 'tool-result',
-        toolCallId: 'call_1',
-        toolName: 'search',
-        output: { hits: 42 },
-      } as TextStreamPart<ToolSet>;
-      yield {
-        type: 'finish',
-        finishReason: 'tool-calls',
-        totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-        rawFinishReason: 'tool_calls',
-      } as unknown as TextStreamPart<ToolSet>;
-    }
-
-    const frames: string[] = [];
-    for await (const frame of encodeVercelDataStream(source())) {
-      frames.push(frame);
-    }
-
-    // Preamble(3) + tool-input-available + tool-output-available + Postamble(4) = 9
-    expect(frames).toHaveLength(9);
-
-    // Verify tool-call frame content
-    const toolCallPayload = parseSSE(frames[3]);
-    expect(toolCallPayload).toMatchObject({
-      type: 'tool-input-available',
-      toolCallId: 'call_1',
-      toolName: 'search',
-      input: { query: 'test' },
-    });
-
-    const toolResultPayload = parseSSE(frames[4]);
-    expect(toolResultPayload).toMatchObject({
-      type: 'tool-output-available',
-      toolCallId: 'call_1',
-      output: { hits: 42 },
-    });
-  });
-});

package/src/adapters/index.ts

@@ -1,6 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-export type { LLMAdapter } from '@objectstack/spec/contracts';
-export { MemoryLLMAdapter } from './memory-adapter.js';
-export { VercelLLMAdapter } from './vercel-adapter.js';
-export type { VercelLLMAdapterConfig } from './vercel-adapter.js';

package/src/adapters/memory-adapter.ts

@@ -1,72 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type {
-  ModelMessage,
-  AIRequestOptions,
-  AIResult,
-  TextStreamPart,
-  ToolSet,
-} from '@objectstack/spec/contracts';
-import type { LLMAdapter } from '@objectstack/spec/contracts';
-
-/**
- * MemoryLLMAdapter — deterministic in-memory adapter for testing & development.
- *
- * Always echoes back the last user message prefixed with "[memory] ".
- * Useful for unit tests, CI pipelines, and local dev without an LLM key.
- */
-export class MemoryLLMAdapter implements LLMAdapter {
-  readonly name = 'memory';
-
-  async chat(messages: ModelMessage[], options?: AIRequestOptions): Promise<AIResult> {
-    const lastUserMessage = [...messages].reverse().find(m => m.role === 'user');
-    const userContent = lastUserMessage?.content;
-    const text = typeof userContent === 'string' ? userContent : '(complex content)';
-    const content = lastUserMessage
-      ? `[memory] ${text}`
-      : '[memory] (no user message)';
-
-    return {
-      content,
-      model: options?.model ?? 'memory',
-      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-    };
-  }
-
-  async complete(prompt: string, options?: AIRequestOptions): Promise<AIResult> {
-    return {
-      content: `[memory] ${prompt}`,
-      model: options?.model ?? 'memory',
-      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-    };
-  }
-
-  async *streamChat(
-    messages: ModelMessage[],
-    _options?: AIRequestOptions,
-  ): AsyncIterable<TextStreamPart<ToolSet>> {
-    const result = await this.chat(messages);
-    // Emit word-by-word deltas for realistic streaming simulation
-    const words = result.content.split(' ');
-    for (let i = 0; i < words.length; i++) {
-      const wordText = i === 0 ? words[i] : ` ${words[i]}`;
-      yield { type: 'text-delta', id: `delta_${i}`, text: wordText } as TextStreamPart<ToolSet>;
-    }
-    yield {
-      type: 'finish',
-      finishReason: 'stop' as const,
-      totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-      rawFinishReason: 'stop',
-    } as unknown as TextStreamPart<ToolSet>;
-  }
-
-  async embed(input: string | string[]): Promise<number[][]> {
-    const texts = Array.isArray(input) ? input : [input];
-    // Return deterministic zero vectors of dimension 3
-    return texts.map(() => [0, 0, 0]);
-  }
-
-  async listModels(): Promise<string[]> {
-    return ['memory'];
-  }
-}

package/src/adapters/types.ts

@@ -1,3 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-export type { LLMAdapter } from '@objectstack/spec/contracts';

package/src/adapters/vercel-adapter.ts

@@ -1,148 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type {
-  ModelMessage,
-  AIRequestOptions,
-  AIResult,
-  TextStreamPart,
-  ToolSet,
-} from '@objectstack/spec/contracts';
-import type { LLMAdapter } from '@objectstack/spec/contracts';
-import type { AIToolDefinition } from '@objectstack/spec/contracts';
-import type { LanguageModelV2 } from '@ai-sdk/provider';
-import { generateText, streamText, tool as vercelTool, jsonSchema } from 'ai';
-
-/**
- * Convert ObjectStack `AIRequestOptions` into the subset of Vercel AI SDK
- * options supported by `generateText` / `streamText`.
- *
- * Forwards: temperature, maxTokens, stop (→ stopSequences), tools, toolChoice.
- */
-function buildVercelOptions(options?: AIRequestOptions): Record<string, unknown> {
-  if (!options) return {};
-
-  const opts: Record<string, unknown> = {};
-
-  if (options.temperature != null) opts.temperature = options.temperature;
-  if (options.maxTokens != null) opts.maxTokens = options.maxTokens;
-  if (options.stop?.length) opts.stopSequences = options.stop;
-
-  if (options.tools?.length) {
-    const tools: Record<string, unknown> = {};
-    for (const t of options.tools as AIToolDefinition[]) {
-      tools[t.name] = vercelTool({
-        description: t.description,
-        inputSchema: jsonSchema(t.parameters as any),
-      });
-    }
-    opts.tools = tools;
-  }
-
-  if (options.toolChoice != null) {
-    opts.toolChoice = options.toolChoice;
-  }
-
-  return opts;
-}
-
-/**
- * VercelLLMAdapter — Production LLM adapter powered by the Vercel AI SDK.
- *
- * Wraps `generateText` / `streamText` from the `ai` package, delegating to
- * any Vercel AI SDK–compatible model provider (OpenAI, Anthropic, Google,
- * Ollama, etc.).
- *
- * @example
- * ```typescript
- * import { openai } from '@ai-sdk/openai';
- * import { VercelLLMAdapter } from '@objectstack/service-ai';
- *
- * const adapter = new VercelLLMAdapter({ model: openai('gpt-4o') });
- * ```
- */
-export class VercelLLMAdapter implements LLMAdapter {
-  readonly name = 'vercel';
-
-  private readonly model: LanguageModelV2;
-
-  constructor(config: VercelLLMAdapterConfig) {
-    this.model = config.model;
-  }
-
-  async chat(messages: ModelMessage[], options?: AIRequestOptions): Promise<AIResult> {
-    const result = await generateText({
-      model: this.model,
-      messages,
-      ...buildVercelOptions(options),
-    });
-
-    return {
-      content: result.text,
-      model: result.response?.modelId,
-      toolCalls: result.toolCalls?.length ? result.toolCalls : undefined,
-      usage: result.usage ? {
-        promptTokens: result.usage.inputTokens ?? 0,
-        completionTokens: result.usage.outputTokens ?? 0,
-        totalTokens: result.usage.totalTokens ?? 0,
-      } : undefined,
-    };
-  }
-
-  async complete(prompt: string, options?: AIRequestOptions): Promise<AIResult> {
-    const result = await generateText({
-      model: this.model,
-      prompt,
-      ...buildVercelOptions(options),
-    });
-
-    return {
-      content: result.text,
-      model: result.response?.modelId,
-      usage: result.usage ? {
-        promptTokens: result.usage.inputTokens ?? 0,
-        completionTokens: result.usage.outputTokens ?? 0,
-        totalTokens: result.usage.totalTokens ?? 0,
-      } : undefined,
-    };
-  }
-
-  async *streamChat(
-    messages: ModelMessage[],
-    options?: AIRequestOptions,
-  ): AsyncIterable<TextStreamPart<ToolSet>> {
-    const result = streamText({
-      model: this.model,
-      messages,
-      ...buildVercelOptions(options),
-    });
-
-    for await (const part of result.fullStream) {
-      yield part as TextStreamPart<ToolSet>;
-    }
-  }
-
-  async embed(_input: string | string[]): Promise<number[][]> {
-    // Vercel AI SDK uses a separate EmbeddingModel — not supported via this adapter.
-    throw new Error(
-      '[VercelLLMAdapter] Embeddings require a dedicated EmbeddingModel. ' +
-      'Configure an embedding adapter instead.',
-    );
-  }
-
-  async listModels(): Promise<string[]> {
-    // Model listing is provider-specific and not available through the base SDK.
-    return [];
-  }
-}
-
-/**
- * Configuration for the Vercel LLM adapter.
- */
-export interface VercelLLMAdapterConfig {
-  /**
-   * A Vercel AI SDK–compatible language model instance.
-   *
-   * @example `openai('gpt-4o')` or `anthropic('claude-sonnet-4-20250514')`
-   */
-  model: LanguageModelV2;
-}

package/src/agent-runtime.ts

@@ -1,154 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import type {
-  ModelMessage,
-  AIRequestOptions,
-  AIToolDefinition,
-  IMetadataService,
-} from '@objectstack/spec/contracts';
-import type { Agent } from '@objectstack/spec';
-import { AgentSchema } from '@objectstack/spec/ai';
-
-/**
- * Context passed alongside a user message when chatting with an agent.
- *
- * UI clients set these fields to tell the agent which object, record,
- * or view the user is currently looking at so it can provide contextual
- * answers without additional tool calls.
- */
-export interface AgentChatContext {
-  /** Current object the user is viewing (e.g. "account") */
-  objectName?: string;
-  /** Currently selected record ID */
-  recordId?: string;
-  /** Current view name */
-  viewName?: string;
-}
-
-/**
- * AgentRuntime — Resolves an agent definition into runnable chat parameters.
- *
- * Responsibilities:
- * 1. Load & validate agent metadata from the metadata service.
- * 2. Build the system prompt from agent `instructions` + UI context.
- * 3. Derive {@link AIRequestOptions} from agent `model` and `tools`.
- * 4. Map agent tool references to concrete {@link AIToolDefinition}s
- *    registered in the {@link ToolRegistry}.
- */
-export class AgentRuntime {
-  constructor(private readonly metadataService: IMetadataService) {}
-
-  // ── Public API ────────────────────────────────────────────────
-
-  /**
-   * List all active agents registered in the metadata service.
-   *
-   * Returns a summary for each agent (name, label, role) suitable
-   * for populating an agent selector dropdown in the UI.
-   */
-  async listAgents(): Promise<Array<{ name: string; label: string; role: string }>> {
-    const rawItems = await this.metadataService.list('agent');
-    const agents: Array<{ name: string; label: string; role: string }> = [];
-
-    for (const raw of rawItems) {
-      const result = AgentSchema.safeParse(raw);
-      if (result.success && result.data.active) {
-        agents.push({
-          name: result.data.name,
-          label: result.data.label,
-          role: result.data.role,
-        });
-      }
-    }
-
-    return agents;
-  }
-
-  /**
-   * Load and validate an agent definition by name.
-   *
-   * The raw metadata is validated through {@link AgentSchema} to ensure
-   * required fields (`instructions`, `name`, `role`, etc.) are present
-   * and well-typed.  Returns `undefined` when the agent does not exist
-   * or validation fails.
-   */
-  async loadAgent(agentName: string): Promise<Agent | undefined> {
-    const raw = await this.metadataService.get('agent', agentName);
-    if (!raw) return undefined;
-
-    const result = AgentSchema.safeParse(raw);
-    if (!result.success) {
-      return undefined;
-    }
-    return result.data;
-  }
-
-  /**
-   * Build the system message(s) that should be prepended to the
-   * conversation when chatting with the given agent.
-   */
-  buildSystemMessages(agent: Agent, context?: AgentChatContext): ModelMessage[] {
-    const parts: string[] = [];
-
-    // Base instructions
-    parts.push(agent.instructions);
-
-    // Contextual hints from the user's current UI state
-    if (context) {
-      const ctx: string[] = [];
-      if (context.objectName) ctx.push(`Current object: ${context.objectName}`);
-      if (context.recordId) ctx.push(`Selected record ID: ${context.recordId}`);
-      if (context.viewName) ctx.push(`Current view: ${context.viewName}`);
-      if (ctx.length > 0) {
-        parts.push('\n--- Current Context ---\n' + ctx.join('\n'));
-      }
-    }
-
-    return [{ role: 'system' as const, content: parts.join('\n') }];
-  }
-
-  /**
-   * Derive {@link AIRequestOptions} from an agent definition.
-   *
-   * Tool references declared in `agent.tools` are resolved by name against
-   * `availableTools` (i.e. the full set of ToolRegistry definitions).
-   * Any unresolved references (tools the agent declares but that are not
-   * registered) are silently skipped — this is intentional so that agents
-   * can be defined before all tools are available.
-   *
-   * @param agent          - The agent definition to derive options from
-   * @param availableTools - All tool definitions currently registered in the ToolRegistry
-   * @returns Request options with model config and resolved tool definitions
-   */
-  buildRequestOptions(
-    agent: Agent,
-    availableTools: AIToolDefinition[],
-  ): AIRequestOptions {
-    const options: AIRequestOptions = {};
-
-    // Model config
-    if (agent.model) {
-      options.model = agent.model.model;
-      options.temperature = agent.model.temperature;
-      options.maxTokens = agent.model.maxTokens;
-    }
-
-    // Resolve agent tool references → concrete tool definitions
-    if (agent.tools && agent.tools.length > 0) {
-      const toolMap = new Map(availableTools.map(t => [t.name, t]));
-      const resolved: AIToolDefinition[] = [];
-      for (const ref of agent.tools) {
-        const def = toolMap.get(ref.name);
-        if (def) {
-          resolved.push(def);
-        }
-      }
-      if (resolved.length > 0) {
-        options.tools = resolved;
-        options.toolChoice = 'auto';
-      }
-    }
-
-    return options;
-  }
-}