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

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

@@ -0,0 +1,217 @@
+import type { AiAgentDefinition } from '../ai-agent-definition'
+import {
+  applyAgentExtensionEntriesForTests,
+  getAgent,
+  listAgents,
+  listAgentsByModule,
+  loadAgentRegistry,
+  resetAgentRegistryForTests,
+  seedAgentRegistryForTests,
+} from '../agent-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,
+  }
+}
+
+describe('agent-registry', () => {
+  beforeEach(() => {
+    resetAgentRegistryForTests()
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+  })
+
+  it('loads generated agents when present and otherwise falls back to an empty registry', async () => {
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await loadAgentRegistry()
+
+    const agents = listAgents()
+    if (errorSpy.mock.calls.length > 0) {
+      expect(agents).toEqual([])
+      expect(errorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[AI Agents] Could not load ai-agents.generated.ts'),
+        expect.any(Object),
+      )
+    } else {
+      expect(agents.every((agent) => getAgent(agent.id) === agent)).toBe(true)
+    }
+    errorSpy.mockRestore()
+  })
+
+  it('populates the registry from a fixture `allAiAgents` array and returns entries via getAgent', () => {
+    const catalogAgent = makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog' })
+    const customersAgent = makeAgent({ id: 'customers.assistant', moduleId: 'customers' })
+
+    seedAgentRegistryForTests([catalogAgent, customersAgent])
+
+    expect(getAgent('catalog.merchandiser')).toBe(catalogAgent)
+    expect(getAgent('customers.assistant')).toBe(customersAgent)
+    expect(getAgent('unknown.agent')).toBeUndefined()
+  })
+
+  it('listAgents() returns all entries stable-sorted by id', () => {
+    seedAgentRegistryForTests([
+      makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+      makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog' }),
+      makeAgent({ id: 'catalog.pricing', moduleId: 'catalog' }),
+    ])
+
+    expect(listAgents().map((agent) => agent.id)).toEqual([
+      'catalog.merchandiser',
+      'catalog.pricing',
+      'customers.assistant',
+    ])
+  })
+
+  it('listAgentsByModule filters on moduleId', () => {
+    seedAgentRegistryForTests([
+      makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog' }),
+      makeAgent({ id: 'catalog.pricing', moduleId: 'catalog' }),
+      makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+    ])
+
+    expect(listAgentsByModule('catalog').map((agent) => agent.id)).toEqual([
+      'catalog.merchandiser',
+      'catalog.pricing',
+    ])
+    expect(listAgentsByModule('customers').map((agent) => agent.id)).toEqual([
+      'customers.assistant',
+    ])
+    expect(listAgentsByModule('unknown')).toEqual([])
+  })
+
+  it('throws with both module ids when two entries share the same id', () => {
+    const first = makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog' })
+    const conflict = makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog_demo' })
+
+    expect(() => seedAgentRegistryForTests([first, conflict])).toThrow(
+      /Duplicate agent id "catalog\.merchandiser".*module "catalog".*module "catalog_demo"/
+    )
+  })
+
+  it('skips malformed entries with a warning, valid entries still load', () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const valid = makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog' })
+    const malformed = {
+      id: 'catalog.broken',
+      moduleId: 'catalog',
+      label: 'broken',
+      description: 'broken',
+      allowedTools: [],
+    } as unknown
+
+    seedAgentRegistryForTests([malformed, valid])
+
+    expect(getAgent('catalog.broken')).toBeUndefined()
+    expect(getAgent('catalog.merchandiser')).toBe(valid)
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[AI Agents] Skipping malformed agent entry')
+    )
+    warnSpy.mockRestore()
+  })
+
+  it('applies append, delete, and replace extensions to an existing agent', () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.catalog_assistant',
+        moduleId: 'catalog',
+        systemPrompt: 'Base prompt.',
+        allowedTools: ['catalog.list_products', 'catalog.get_product', 'catalog.old_tool'],
+        suggestions: [
+          { label: 'Find products', prompt: 'Find products' },
+          { label: 'Old prompt', prompt: 'Old prompt' },
+        ],
+      }),
+    ])
+
+    applyAgentExtensionEntriesForTests([
+      {
+        targetAgentId: 'catalog.catalog_assistant',
+        deleteAllowedTools: ['catalog.old_tool'],
+        appendAllowedTools: ['example.catalog_stats', 'catalog.list_products'],
+        replaceSystemPrompt: 'Replacement prompt.',
+        appendSystemPrompt: 'Use example.catalog_stats for tenant-specific catalog metrics.',
+        deleteSuggestions: ['Old prompt'],
+        appendSuggestions: [
+          { label: 'Show catalog stats', prompt: 'Show catalog stats' },
+        ],
+      },
+    ])
+
+    expect(getAgent('catalog.catalog_assistant')).toMatchObject({
+      allowedTools: ['catalog.list_products', 'catalog.get_product', 'example.catalog_stats'],
+      suggestions: [
+        { label: 'Find products', prompt: 'Find products' },
+        { label: 'Show catalog stats', prompt: 'Show catalog stats' },
+      ],
+    })
+    expect(getAgent('catalog.catalog_assistant')?.systemPrompt).toBe(
+      'Replacement prompt.\n\nUse example.catalog_stats for tenant-specific catalog metrics.',
+    )
+  })
+
+  it('supports full tool and suggestion replacement in an extension', () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.catalog_assistant',
+        moduleId: 'catalog',
+        allowedTools: ['catalog.list_products'],
+        suggestions: [{ label: 'Find products', prompt: 'Find products' }],
+      }),
+    ])
+
+    applyAgentExtensionEntriesForTests([
+      {
+        targetAgentId: 'catalog.catalog_assistant',
+        replaceAllowedTools: ['example.catalog_stats'],
+        replaceSuggestions: [
+          { label: 'Show categories', prompt: 'Show categories' },
+        ],
+      },
+    ])
+
+    expect(getAgent('catalog.catalog_assistant')).toMatchObject({
+      allowedTools: ['example.catalog_stats'],
+      suggestions: [
+        { label: 'Show categories', prompt: 'Show categories' },
+      ],
+    })
+  })
+
+  it('resetAgentRegistryForTests clears the cache so a subsequent seed sees fresh fixtures', () => {
+    seedAgentRegistryForTests([
+      makeAgent({ id: 'catalog.merchandiser', moduleId: 'catalog' }),
+    ])
+    expect(listAgents()).toHaveLength(1)
+
+    resetAgentRegistryForTests()
+    expect(listAgents()).toEqual([])
+
+    seedAgentRegistryForTests([
+      makeAgent({ id: 'customers.assistant', moduleId: 'customers' }),
+    ])
+    expect(listAgents().map((agent) => agent.id)).toEqual(['customers.assistant'])
+  })
+
+  it('loadAgentRegistry is idempotent — repeat calls do not duplicate entries', async () => {
+    const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {})
+
+    await loadAgentRegistry()
+    const firstIds = listAgents().map((agent) => agent.id)
+    await loadAgentRegistry()
+    await loadAgentRegistry()
+
+    expect(listAgents().map((agent) => agent.id)).toEqual(firstIds)
+    expect(errorSpy).toHaveBeenCalledTimes(firstIds.length === 0 ? 1 : 0)
+    errorSpy.mockRestore()
+  })
+})

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

@@ -0,0 +1,329 @@
+import type { AiAgentDefinition, AiAgentPageContextInput } from '../ai-agent-definition'
+
+const generateObjectMock = jest.fn()
+const streamObjectMock = jest.fn()
+const stepCountIsMock = jest.fn((count: number) => ({ __stopWhen: 'stepCount', count }))
+const convertToModelMessagesMock = jest.fn((messages: unknown) => messages)
+const streamTextMock = jest.fn()
+
+jest.mock('ai', () => {
+  const actual = jest.requireActual('ai')
+  return {
+    ...actual,
+    generateObject: (...args: unknown[]) => generateObjectMock(...args),
+    streamObject: (...args: unknown[]) => streamObjectMock(...args),
+    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 } from '../tool-registry'
+import { runAiAgentObject } from '../agent-runtime'
+import { AgentPolicyError } from '../agent-tools'
+
+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,
+  }
+}
+
+const baseAuth = {
+  tenantId: 'tenant-1',
+  organizationId: 'org-1',
+  userId: 'user-1',
+  features: ['*'],
+  isSuperAdmin: true,
+}
+
+describe('runAiAgentObject — generate mode', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+    generateObjectMock.mockImplementation(async () => ({
+      object: { name: 'X' },
+      finishReason: 'stop',
+      usage: { inputTokens: 10, outputTokens: 5 },
+    }))
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+  })
+
+  it('returns the parsed object when the agent declares output + executionMode=object', async () => {
+    const schema = z.object({ name: z.string() })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+        mutationPolicy: 'read-only',
+        output: { schemaName: 'ExtractedAttributes', schema },
+      }),
+    ])
+
+    const result = await runAiAgentObject({
+      agentId: 'catalog.extractor',
+      input: 'extract please',
+      authContext: baseAuth,
+    })
+
+    expect(result.mode).toBe('generate')
+    if (result.mode !== 'generate') throw new Error('unreachable')
+    expect(result.object).toEqual({ name: 'X' })
+    expect(result.finishReason).toBe('stop')
+    expect(result.usage).toEqual({ inputTokens: 10, outputTokens: 5 })
+    expect(generateObjectMock).toHaveBeenCalledTimes(1)
+    const callArg = generateObjectMock.mock.calls[0][0] as {
+      system: string
+      schemaName: string
+      schema: unknown
+      messages: unknown
+      model: { id: string }
+    }
+    expect(callArg.system).toBe('System prompt base.')
+    expect(callArg.schemaName).toBe('ExtractedAttributes')
+    expect(callArg.schema).toBe(schema)
+    expect(callArg.model.id).toBe('provider-default-model')
+  })
+
+  it('runtime output override wins over agent-level output', async () => {
+    const agentSchema = z.object({ a: z.string() })
+    const overrideSchema = z.object({ b: z.number() })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+        output: { schemaName: 'AgentSchema', schema: agentSchema },
+      }),
+    ])
+
+    await runAiAgentObject({
+      agentId: 'catalog.extractor',
+      input: 'go',
+      authContext: baseAuth,
+      output: { schemaName: 'RuntimeSchema', schema: overrideSchema },
+    })
+
+    const callArg = generateObjectMock.mock.calls[0][0] as {
+      schemaName: string
+      schema: unknown
+    }
+    expect(callArg.schemaName).toBe('RuntimeSchema')
+    expect(callArg.schema).toBe(overrideSchema)
+  })
+
+  it('throws AgentPolicyError(execution_mode_not_supported) when neither the agent nor the caller declare a schema', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+      }),
+    ])
+
+    await expect(
+      runAiAgentObject({
+        agentId: 'catalog.extractor',
+        input: 'go',
+        authContext: baseAuth,
+      }),
+    ).rejects.toMatchObject({
+      name: 'AgentPolicyError',
+      code: 'execution_mode_not_supported',
+    })
+    expect(generateObjectMock).not.toHaveBeenCalled()
+  })
+
+  it('rejects chat-mode agents called via runAiAgentObject', async () => {
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'customers.assistant',
+        moduleId: 'customers',
+        executionMode: 'chat',
+      }),
+    ])
+
+    await expect(
+      runAiAgentObject({
+        agentId: 'customers.assistant',
+        input: 'go',
+        authContext: baseAuth,
+      }),
+    ).rejects.toBeInstanceOf(AgentPolicyError)
+    await expect(
+      runAiAgentObject({
+        agentId: 'customers.assistant',
+        input: 'go',
+        authContext: baseAuth,
+      }),
+    ).rejects.toMatchObject({ code: 'execution_mode_not_supported' })
+    expect(generateObjectMock).not.toHaveBeenCalled()
+  })
+
+  it('rejects when the caller lacks the agent.requiredFeatures', async () => {
+    const schema = z.object({ name: z.string() })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+        requiredFeatures: ['catalog.extract'],
+        output: { schemaName: 'Out', schema },
+      }),
+    ])
+
+    await expect(
+      runAiAgentObject({
+        agentId: 'catalog.extractor',
+        input: 'go',
+        authContext: {
+          ...baseAuth,
+          features: ['unrelated.feature'],
+          isSuperAdmin: false,
+        },
+      }),
+    ).rejects.toMatchObject({
+      name: 'AgentPolicyError',
+      code: 'agent_features_denied',
+    })
+  })
+
+  it('applies modelOverride when supplied', async () => {
+    const schema = z.object({ name: z.string() })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+        defaultModel: 'agent-default',
+        output: { schemaName: 'Out', schema },
+      }),
+    ])
+
+    await runAiAgentObject({
+      agentId: 'catalog.extractor',
+      input: 'go',
+      authContext: baseAuth,
+      modelOverride: 'override-model',
+    })
+
+    expect(createModelMock).toHaveBeenCalledWith(
+      expect.objectContaining({ modelId: 'override-model' }),
+    )
+  })
+
+  it('invokes resolvePageContext and appends hydration output when entityType+recordId are provided', async () => {
+    const schema = z.object({ name: z.string() })
+    const resolvePageContext = jest.fn(async (_input: AiAgentPageContextInput) => 'Hydrated record context.')
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+        output: { schemaName: 'Out', schema },
+        resolvePageContext,
+      }),
+    ])
+
+    await runAiAgentObject({
+      agentId: 'catalog.extractor',
+      input: 'go',
+      authContext: baseAuth,
+      pageContext: { entityType: 'catalog:product', recordId: 'p-1' },
+      container: {} as never,
+    })
+
+    expect(resolvePageContext).toHaveBeenCalledTimes(1)
+    const callArg = generateObjectMock.mock.calls[0][0] as { system: string }
+    expect(callArg.system).toBe('System prompt base.\n\nHydrated record context.')
+  })
+})
+
+describe('runAiAgentObject — stream mode', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+    streamObjectMock.mockImplementation(() => ({
+      object: Promise.resolve({ name: 'final' }),
+      partialObjectStream: (async function* () {
+        yield { name: 'fi' } as Partial<{ name: string }>
+        yield { name: 'final' } as Partial<{ name: string }>
+      })(),
+      textStream: (async function* () {
+        yield '{"name":"fi'
+        yield 'nal"}'
+      })(),
+      finishReason: Promise.resolve('stop' as string | undefined),
+      usage: Promise.resolve({ inputTokens: 1, outputTokens: 1 }),
+    }))
+  })
+
+  afterAll(() => {
+    resetAgentRegistryForTests()
+    toolRegistry.clear()
+  })
+
+  it('mode=stream calls streamObject and returns a stream handle', async () => {
+    const schema = z.object({ name: z.string() })
+    seedAgentRegistryForTests([
+      makeAgent({
+        id: 'catalog.extractor',
+        moduleId: 'catalog',
+        executionMode: 'object',
+        output: { schemaName: 'Out', schema, mode: 'stream' },
+      }),
+    ])
+
+    const result = await runAiAgentObject<{ name: string }>({
+      agentId: 'catalog.extractor',
+      input: 'go',
+      authContext: baseAuth,
+    })
+
+    expect(streamObjectMock).toHaveBeenCalledTimes(1)
+    expect(result.mode).toBe('stream')
+    if (result.mode !== 'stream') throw new Error('unreachable')
+    await expect(result.object).resolves.toEqual({ name: 'final' })
+
+    const partials: Array<Partial<{ name: string }>> = []
+    for await (const part of result.partialObjectStream) partials.push(part)
+    expect(partials.length).toBeGreaterThan(0)
+
+    const chunks: string[] = []
+    for await (const chunk of result.textStream) chunks.push(chunk)
+    expect(chunks.join('')).toContain('"name"')
+  })
+})