@open-mercato/ai-assistant 0.5.1-develop.3036.f02c281f23 → 0.5.1-develop.3045.b4b3320cc2

package/src/modules/ai_assistant/lib/__tests__/agent-runtime.test.ts

@@ -0,0 +1,291 @@
+import type { AiAgentDefinition, AiAgentPageContextInput } from '../ai-agent-definition'
+import type { AiToolDefinition } from '../types'
+
+const streamTextMock = jest.fn()
+const stepCountIsMock = jest.fn((count: number) => ({ __stopWhen: 'stepCount', count }))
+const convertToModelMessagesMock = jest.fn((messages: unknown) => messages)
+
+jest.mock('ai', () => {
+  const actual = jest.requireActual('ai')
+  return {
+    ...actual,
+    streamText: (...args: unknown[]) => streamTextMock(...args),
+    stepCountIs: (...args: unknown[]) => stepCountIsMock(...(args as [number])),
+    convertToModelMessages: (...args: unknown[]) => convertToModelMessagesMock(...args),
+  }
+})
+
+const createModelMock = jest.fn(
+  (options: { modelId: string; apiKey: string }) => ({ id: options.modelId, apiKey: options.apiKey }),
+)
+const resolveApiKeyMock = jest.fn(() => 'test-api-key')
+
+jest.mock('@open-mercato/shared/lib/ai/llm-provider-registry', () => ({
+  llmProviderRegistry: {
+    resolveFirstConfigured: () => ({
+      id: 'test-provider',
+      defaultModel: 'provider-default-model',
+      resolveApiKey: resolveApiKeyMock,
+      createModel: createModelMock,
+    }),
+  },
+}))
+
+import { z } from 'zod'
+import {
+  resetAgentRegistryForTests,
+  seedAgentRegistryForTests,
+} from '../agent-registry'
+import { toolRegistry, registerMcpTool } from '../tool-registry'
+import { runAiAgentText, composeSystemPrompt } from '../agent-runtime'
+
+function makeAgent(
+  overrides: Partial<AiAgentDefinition> & Pick<AiAgentDefinition, 'id' | 'moduleId'>,
+): AiAgentDefinition {
+  return {
+    label: `${overrides.id} label`,
+    description: `${overrides.id} description`,
+    systemPrompt: 'System prompt base.',
+    allowedTools: [],
+    ...overrides,
+  }
+}
+
+function makeTool(
+  overrides: Partial<AiToolDefinition> & Pick<AiToolDefinition, 'name'>,
+): AiToolDefinition {
+  return {
+    description: `${overrides.name} description`,
+    inputSchema: z.object({}),
+    handler: async () => ({ ok: true }),
+    ...overrides,
+  }
+}
+
+const baseAuth = {
+  tenantId: 'tenant-1',
+  organizationId: 'org-1',
+  userId: 'user-1',
+  features: ['*'],
+  isSuperAdmin: true,
+}
+
+const baseMessages = [{ role: 'user' as const, id: 'm1', parts: [{ type: 'text' as const, text: 'hi' }] }]
+
+function fakeStreamResult(): {
+  toTextStreamResponse: jest.Mock
+  toUIMessageStreamResponse: jest.Mock
+} {
+  const toTextStreamResponse = jest.fn(
+    () =>
+      new Response('streamed', {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' },
+      }),
+  )
+  const toUIMessageStreamResponse = jest.fn(
+    () =>
+      new Response('streamed', {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream' },
+      }),
+  )
+  return { toTextStreamResponse, toUIMessageStreamResponse }
+}
+
+describe('runAiAgentText', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+    streamTextMock.mockImplementation(() => fakeStreamResult())
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+  })
+
+  it('invokes streamText with the composed system prompt and tools map', async () => {
+    registerMcpTool(makeTool({ name: 'customers.list_people' }), { moduleId: 'customers' })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        allowedTools: ['customers.list_people'],
+      }),
+    ])
+
+    const response = await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+    })
+
+    expect(response).toBeInstanceOf(Response)
+    expect(streamTextMock).toHaveBeenCalledTimes(1)
+    const callArg = streamTextMock.mock.calls[0][0] as {
+      system: string
+      tools: Record<string, unknown>
+      messages: unknown
+      model: { id: string }
+      stopWhen?: unknown
+    }
+    expect(callArg.system).toBe('System prompt base.')
+    expect(Object.keys(callArg.tools)).toEqual(['customers__list_people'])
+    // PR #1593 applies a default stopWhen of stepCountIs(10) when maxSteps
+    // is undefined so tool-calls actually execute (agent-runtime.ts).
+    expect(callArg.stopWhen).toBeDefined()
+    expect(callArg.model.id).toBe('provider-default-model')
+    expect(convertToModelMessagesMock).toHaveBeenCalledWith(baseMessages)
+  })
+
+  it('propagates maxSteps as stopWhen: stepCountIs(n)', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        maxSteps: 5,
+      }),
+    ])
+
+    await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+    })
+
+    expect(stepCountIsMock).toHaveBeenCalledWith(5)
+    const callArg = streamTextMock.mock.calls[0][0] as { stopWhen: unknown }
+    expect(callArg.stopWhen).toEqual({ __stopWhen: 'stepCount', count: 5 })
+  })
+
+  it('lets modelOverride win over agent.defaultModel', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        defaultModel: 'agent-default',
+      }),
+    ])
+
+    await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+      modelOverride: 'override-model',
+    })
+
+    expect(createModelMock).toHaveBeenCalledWith(
+      expect.objectContaining({ modelId: 'override-model' }),
+    )
+  })
+
+  it('falls back to agent.defaultModel when no override is given', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        defaultModel: 'agent-default',
+      }),
+    ])
+
+    await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+    })
+
+    expect(createModelMock).toHaveBeenCalledWith(
+      expect.objectContaining({ modelId: 'agent-default' }),
+    )
+  })
+
+  it('appends resolvePageContext output to the system prompt when entityType+recordId are present', async () => {
+    const resolvePageContext = jest.fn(async (_input: AiAgentPageContextInput) => 'Hydrated record context.')
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        resolvePageContext,
+      }),
+    ])
+
+    await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+      pageContext: { entityType: 'customers:person', recordId: 'abc' },
+      container: {} as never,
+    })
+
+    expect(resolvePageContext).toHaveBeenCalledTimes(1)
+    const callArg = streamTextMock.mock.calls[0][0] as { system: string }
+    expect(callArg.system).toBe('System prompt base.\n\nHydrated record context.')
+  })
+
+  it('skips resolvePageContext silently when entityType or recordId are missing', async () => {
+    const resolvePageContext = jest.fn(async () => 'should-not-append')
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        resolvePageContext,
+      }),
+    ])
+
+    await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+      pageContext: { pageId: 'customers.people' },
+      container: {} as never,
+    })
+
+    expect(resolvePageContext).not.toHaveBeenCalled()
+    const callArg = streamTextMock.mock.calls[0][0] as { system: string }
+    expect(callArg.system).toBe('System prompt base.')
+  })
+
+  it('does not fail the request if resolvePageContext throws', async () => {
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+    const resolvePageContext = jest.fn(async () => {
+      throw new Error('boom')
+    })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        resolvePageContext,
+      }),
+    ])
+
+    const response = await runAiAgentText({
+      agentId: 'customers.assistant',
+      messages: baseMessages as never,
+      authContext: baseAuth,
+      pageContext: { entityType: 'customers:person', recordId: 'abc' },
+      container: {} as never,
+    })
+
+    expect(response).toBeInstanceOf(Response)
+    const callArg = streamTextMock.mock.calls[0][0] as { system: string }
+    expect(callArg.system).toBe('System prompt base.')
+    errorSpy.mockRestore()
+  })
+})
+
+describe('composeSystemPrompt', () => {
+  it('returns base prompt when resolvePageContext is not declared', async () => {
+    const agent: AiAgentDefinition = {
+      id: 'x.y',
+      moduleId: 'x',
+      label: 'x',
+      description: 'x',
+      systemPrompt: 'base',
+      allowedTools: [],
+    }
+    const result = await composeSystemPrompt(agent, undefined, undefined, null, null)
+    expect(result).toBe('base')
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/agent-tools.test.ts

@@ -0,0 +1,172 @@
+import { z } from 'zod'
+import type { AiAgentDefinition } from '../ai-agent-definition'
+import type { AiToolDefinition } from '../types'
+import { resolveAiAgentTools, AgentPolicyError } from '../agent-tools'
+import {
+  resetAgentRegistryForTests,
+  seedAgentRegistryForTests,
+} from '../agent-registry'
+import { toolRegistry, registerMcpTool } from '../tool-registry'
+
+function makeAgent(
+  overrides: Partial<AiAgentDefinition> & Pick<AiAgentDefinition, 'id' | 'moduleId'>,
+): AiAgentDefinition {
+  return {
+    label: `${overrides.id} label`,
+    description: `${overrides.id} description`,
+    systemPrompt: 'You are a test agent.',
+    allowedTools: [],
+    ...overrides,
+  }
+}
+
+function makeTool(
+  overrides: Partial<AiToolDefinition> & Pick<AiToolDefinition, 'name'>,
+): AiToolDefinition {
+  return {
+    description: `${overrides.name} description`,
+    inputSchema: z.object({ query: z.string().optional() }),
+    handler: async () => ({ ok: true }),
+    ...overrides,
+  }
+}
+
+const baseAuth = {
+  tenantId: 'tenant-1',
+  organizationId: 'org-1',
+  userId: 'user-1',
+  features: ['*'],
+  isSuperAdmin: true,
+}
+
+describe('resolveAiAgentTools', () => {
+  let warnSpy: jest.SpyInstance
+
+  beforeEach(() => {
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+    warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    warnSpy.mockRestore()
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+  })
+
+  it('throws AgentPolicyError with structured deny code when the agent is unknown', async () => {
+    await expect(
+      resolveAiAgentTools({
+        agentId: 'missing.agent',
+        authContext: baseAuth,
+      }),
+    ).rejects.toMatchObject({
+      name: 'AgentPolicyError',
+      code: 'agent_unknown',
+    })
+  })
+
+  it('throws AgentPolicyError when the agent requires features the caller lacks', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        requiredFeatures: ['customers.assistant.use'],
+      }),
+    ])
+
+    await expect(
+      resolveAiAgentTools({
+        agentId: 'customers.assistant',
+        authContext: { ...baseAuth, features: [], isSuperAdmin: false },
+      }),
+    ).rejects.toBeInstanceOf(AgentPolicyError)
+  })
+
+  it('returns whitelisted tools adapted to the AI SDK shape', async () => {
+    registerMcpTool(makeTool({ name: 'customers.list_people' }), { moduleId: 'customers' })
+    registerMcpTool(makeTool({ name: 'customers.get_person' }), { moduleId: 'customers' })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        allowedTools: ['customers.list_people', 'customers.get_person'],
+      }),
+    ])
+
+    const result = await resolveAiAgentTools({
+      agentId: 'customers.assistant',
+      authContext: baseAuth,
+    })
+
+    expect(result.agent.id).toBe('customers.assistant')
+    expect(Object.keys(result.tools).sort()).toEqual([
+      'customers__get_person',
+      'customers__list_people',
+    ])
+    for (const [, tool] of Object.entries(result.tools)) {
+      expect(tool).toBeDefined()
+      expect(typeof (tool as { execute?: unknown }).execute).toBe('function')
+    }
+  })
+
+  it('skips tools the caller lacks features for and still returns the rest', async () => {
+    registerMcpTool(
+      makeTool({
+        name: 'customers.list_people',
+        requiredFeatures: ['customers.people.view'],
+      }),
+      { moduleId: 'customers' },
+    )
+    registerMcpTool(
+      makeTool({
+        name: 'catalog.list_products',
+        requiredFeatures: ['catalog.products.view'],
+      }),
+      { moduleId: 'catalog' },
+    )
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        allowedTools: ['customers.list_people', 'catalog.list_products'],
+      }),
+    ])
+
+    const result = await resolveAiAgentTools({
+      agentId: 'customers.assistant',
+      authContext: {
+        ...baseAuth,
+        features: ['customers.people.view'],
+        isSuperAdmin: false,
+      },
+    })
+
+    expect(Object.keys(result.tools)).toEqual(['customers__list_people'])
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('catalog.list_products'),
+    )
+  })
+
+  it('skips a whitelisted tool that vanished from the registry between checks', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        allowedTools: ['customers.list_people'],
+      }),
+    ])
+
+    const result = await resolveAiAgentTools({
+      agentId: 'customers.assistant',
+      authContext: baseAuth,
+    })
+
+    // Tool never registered -> policy gate returns tool_unknown -> warn + skip.
+    expect(result.tools).toEqual({})
+    expect(warnSpy).toHaveBeenCalled()
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/agent-transport.test.ts

@@ -0,0 +1,41 @@
+import { createAiAgentTransport } from '../agent-transport'
+
+describe('createAiAgentTransport', () => {
+  it('points at the default ai_assistant dispatcher with the agent query param', () => {
+    const transport = createAiAgentTransport({ agentId: 'customers.assistant' })
+    // ChatTransport keeps the api URL as a protected field — access it for test assertions.
+    const apiUrl = (transport as unknown as { api: string }).api
+    expect(apiUrl).toBe('/api/ai_assistant/ai/chat?agent=customers.assistant')
+  })
+
+  it('honors a custom endpoint override', () => {
+    const transport = createAiAgentTransport({
+      agentId: 'catalog.merchandising_assistant',
+      endpoint: '/custom/chat',
+    })
+    const apiUrl = (transport as unknown as { api: string }).api
+    expect(apiUrl).toBe('/custom/chat?agent=catalog.merchandising_assistant')
+  })
+
+  it('merges extra body fields and surfaces the debug flag when provided', () => {
+    const transport = createAiAgentTransport({
+      agentId: 'customers.assistant',
+      body: { pageContext: { pageId: 'customers.people' } },
+      debug: true,
+    })
+    const body = (transport as unknown as { body: Record<string, unknown> }).body
+    expect(body).toEqual({
+      pageContext: { pageId: 'customers.people' },
+      debug: true,
+    })
+  })
+
+  it('preserves the agent query when the endpoint already contains a query string', () => {
+    const transport = createAiAgentTransport({
+      agentId: 'customers.assistant',
+      endpoint: '/api/ai/chat?trace=1',
+    })
+    const apiUrl = (transport as unknown as { api: string }).api
+    expect(apiUrl).toBe('/api/ai/chat?trace=1&agent=customers.assistant')
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/ai-agent-definition.test.ts

@@ -0,0 +1,183 @@
+import { z } from 'zod'
+import {
+  defineAiAgent,
+  defineAiAgentExtension,
+  type AiAgentDefinition,
+} from '../ai-agent-definition'
+import { defineAiTool } from '../ai-tool-definition'
+import type { AiToolDefinition, McpToolDefinition } from '../types'
+
+describe('defineAiTool', () => {
+  it('returns the tool definition unchanged (identity builder)', () => {
+    const tool = defineAiTool({
+      name: 'catalog.search_products',
+      description: 'Search the product catalog',
+      inputSchema: z.object({ query: z.string() }),
+      handler: async (input) => ({ matches: [input.query] }),
+    })
+    expect(tool.name).toBe('catalog.search_products')
+    expect(tool.description).toBe('Search the product catalog')
+    expect(typeof tool.handler).toBe('function')
+  })
+
+  it('preserves additive focused-agent metadata on AiToolDefinition', () => {
+    const tool = defineAiTool({
+      name: 'catalog.update_product',
+      description: 'Update a product',
+      inputSchema: z.object({ id: z.string() }),
+      requiredFeatures: ['catalog.products.update'],
+      handler: async (input) => ({ ok: true, id: input.id }),
+      displayName: 'Update product',
+      tags: ['write', 'catalog'],
+      isMutation: true,
+      maxCallsPerTurn: 1,
+      supportsAttachments: true,
+    })
+    expect(tool.displayName).toBe('Update product')
+    expect(tool.tags).toEqual(['write', 'catalog'])
+    expect(tool.isMutation).toBe(true)
+    expect(tool.maxCallsPerTurn).toBe(1)
+    expect(tool.supportsAttachments).toBe(true)
+  })
+
+  it('returns an object assignable to AiToolDefinition and McpToolDefinition (BC)', () => {
+    const built = defineAiTool({
+      name: 'meta.ping',
+      description: 'Ping',
+      inputSchema: z.object({}),
+      handler: async () => ({ pong: true }),
+    })
+    const asAi: AiToolDefinition = built
+    const asMcp: McpToolDefinition = built
+    expect(asAi.name).toBe('meta.ping')
+    expect(asMcp.name).toBe('meta.ping')
+  })
+
+  it('plain-object AiToolDefinition authored without defineAiTool() still type-checks', () => {
+    const plain: AiToolDefinition<{ id: string }, { ok: boolean }> = {
+      name: 'customers.get',
+      description: 'Fetch a customer',
+      inputSchema: z.object({ id: z.string() }),
+      handler: async () => ({ ok: true }),
+    }
+    expect(plain.name).toBe('customers.get')
+  })
+})
+
+describe('defineAiAgentExtension', () => {
+  it('returns the extension definition unchanged (identity builder)', () => {
+    const extension = defineAiAgentExtension({
+      targetAgentId: 'catalog.catalog_assistant',
+      replaceAllowedTools: ['catalog.list_products'],
+      deleteAllowedTools: ['catalog.old_tool'],
+      appendAllowedTools: ['example.catalog_stats'],
+      replaceSystemPrompt: 'Replacement prompt.',
+      appendSystemPrompt: 'Use example.catalog_stats for app-level catalog metrics.',
+      replaceSuggestions: [
+        { label: 'Start fresh', prompt: 'Start fresh' },
+      ],
+      deleteSuggestions: ['Old prompt'],
+      appendSuggestions: [
+        { label: 'Show catalog stats', prompt: 'Show catalog stats' },
+      ],
+    })
+
+    expect(extension.targetAgentId).toBe('catalog.catalog_assistant')
+    expect(extension.replaceAllowedTools).toEqual(['catalog.list_products'])
+    expect(extension.deleteAllowedTools).toEqual(['catalog.old_tool'])
+    expect(extension.appendAllowedTools).toEqual(['example.catalog_stats'])
+    expect(extension.replaceSystemPrompt).toBe('Replacement prompt.')
+    expect(extension.deleteSuggestions).toEqual(['Old prompt'])
+    expect(extension.appendSuggestions).toEqual([
+      { label: 'Show catalog stats', prompt: 'Show catalog stats' },
+    ])
+  })
+})
+
+describe('defineAiAgent', () => {
+  it('returns the agent definition unchanged (identity builder)', () => {
+    const agent = defineAiAgent({
+      id: 'catalog.merchandising_assistant',
+      moduleId: 'catalog',
+      label: 'Merchandising assistant',
+      description: 'Draft product descriptions and extract attributes',
+      systemPrompt: 'You are a merchandising assistant.',
+      allowedTools: ['catalog.search_products', 'catalog.get_product'],
+    })
+    expect(agent.id).toBe('catalog.merchandising_assistant')
+    expect(agent.moduleId).toBe('catalog')
+    expect(agent.allowedTools).toHaveLength(2)
+  })
+
+  it('accepts every optional spec field', () => {
+    const resolvePageContext = jest.fn<
+      Promise<string | null>,
+      [
+        Parameters<NonNullable<AiAgentDefinition['resolvePageContext']>>[0],
+      ]
+    >(async () => 'context string')
+
+    const agent = defineAiAgent({
+      id: 'catalog.demo',
+      moduleId: 'catalog',
+      label: 'Demo',
+      description: 'Demo agent with all optional fields set',
+      systemPrompt: 'prompt',
+      allowedTools: ['catalog.search_products'],
+      executionMode: 'chat',
+      defaultModel: 'gpt-4o',
+      acceptedMediaTypes: ['image', 'pdf', 'file'],
+      requiredFeatures: ['catalog.products.view'],
+      uiParts: ['mutation-preview-card'],
+      readOnly: true,
+      mutationPolicy: 'read-only',
+      maxSteps: 12,
+      output: {
+        schemaName: 'ProductBrief',
+        schema: z.object({ name: z.string() }),
+        mode: 'generate',
+      },
+      resolvePageContext,
+      keywords: ['catalog', 'merchandising'],
+      suggestions: [
+        { label: 'Show catalog stats', prompt: 'Show catalog stats' },
+      ],
+      domain: 'catalog',
+      dataCapabilities: {
+        entities: ['catalog.product'],
+        operations: ['read', 'search'],
+        searchableFields: ['name', 'sku'],
+      },
+    })
+
+    expect(agent.executionMode).toBe('chat')
+    expect(agent.mutationPolicy).toBe('read-only')
+    expect(agent.maxSteps).toBe(12)
+    expect(agent.output?.schemaName).toBe('ProductBrief')
+    expect(agent.output?.mode).toBe('generate')
+    expect(agent.dataCapabilities?.operations).toEqual(['read', 'search'])
+    expect(agent.keywords).toEqual(['catalog', 'merchandising'])
+    expect(agent.suggestions).toEqual([
+      { label: 'Show catalog stats', prompt: 'Show catalog stats' },
+    ])
+    expect(agent.domain).toBe('catalog')
+    expect(agent.acceptedMediaTypes).toEqual(['image', 'pdf', 'file'])
+    expect(agent.requiredFeatures).toEqual(['catalog.products.view'])
+    expect(agent.uiParts).toEqual(['mutation-preview-card'])
+    expect(agent.readOnly).toBe(true)
+    expect(agent.defaultModel).toBe('gpt-4o')
+    expect(resolvePageContext).not.toHaveBeenCalled()
+  })
+
+  it('enforces the structural shape at the type level (compile-time contract)', () => {
+    const minimal: AiAgentDefinition = {
+      id: 'mod.agent',
+      moduleId: 'mod',
+      label: 'l',
+      description: 'd',
+      systemPrompt: 'p',
+      allowedTools: [],
+    }
+    expect(minimal.allowedTools).toEqual([])
+  })
+})