@open-mercato/ai-assistant 0.8.1-develop.7296.1.2111d779db → 0.9.0

package/src/modules/ai_assistant/lib/__tests__/ai-api-operation-runner.test.ts

@@ -1,6 +1,12 @@
 import { z } from 'zod'
 import { createAiApiOperationRunner, normalizePath, type AiToolExecutionContext } from '../ai-api-operation-runner'
 import type { ApiRouteManifestEntry } from '@open-mercato/shared/modules/registry'
+import { registerApiInterceptors } from '@open-mercato/shared/lib/crud/interceptor-registry'
+import {
+  runApiInterceptorsAfter,
+  runApiInterceptorsBefore,
+} from '@open-mercato/shared/lib/crud/interceptor-runner'
+import { resolveApiInterceptorRoutePath } from '@open-mercato/shared/lib/modules/api-route-identity'
 import {
   TRUSTED_AUTH_CONTEXT_SYMBOL,
   resolveAuthFromRequestDetailed,
@@ -52,6 +58,7 @@ describe('createAiApiOperationRunner', () => {
   let fetchSpy: jest.SpyInstance | null = null
 
   beforeEach(() => {
+    registerApiInterceptors([])
     if (typeof globalThis.fetch === 'function') {
       fetchSpy = jest.spyOn(globalThis, 'fetch').mockImplementation(() => {
         throw new Error('fetch must not be called by the in-process runner')
@@ -66,6 +73,7 @@ describe('createAiApiOperationRunner', () => {
   })
 
   afterEach(() => {
+    registerApiInterceptors([])
     fetchSpy?.mockRestore?.()
     fetchSpy = null
   })
@@ -350,6 +358,152 @@ describe('createAiApiOperationRunner', () => {
     expect(captured!.params.itemId).toBe('abc-123')
   })
 
+  it.each([
+    ['mixed-case', '/CUSTOMERS/PEOPLE'],
+    ['percent-encoded', '/customers/%70eople'],
+  ])('binds the authored manifest identity for a %s synthetic request', async (_label, path) => {
+    registerApiInterceptors([{
+      moduleId: 'test',
+      interceptors: [
+        {
+          id: 'test.ai-exact-policy',
+          targetRoute: 'customers/people',
+          methods: ['GET', 'POST'],
+          priority: 10,
+          async before(request) {
+            if (request.method === 'POST') {
+              return { ok: false, statusCode: 451, message: 'Denied by canonical policy' }
+            }
+            return { ok: true }
+          },
+          async after() {
+            return { merge: { exactPolicyApplied: true } }
+          },
+        },
+        {
+          id: 'test.ai-prefix-policy',
+          targetRoute: 'customers/*',
+          methods: ['GET', 'POST'],
+          priority: 20,
+          async before() {
+            return { ok: true }
+          },
+          async after() {
+            return { merge: { prefixPolicyApplied: true } }
+          },
+        },
+      ],
+    }])
+    const handler = jest.fn(async (request: Request) => {
+      const routePath = resolveApiInterceptorRoutePath(request)
+      if (routePath === null) return new Response('{}', { status: 400 })
+      const method = request.method === 'POST' ? 'POST' : 'GET'
+      const requestPayload = {
+        method,
+        url: request.url,
+        body: {},
+        query: {},
+        headers: {},
+      }
+      const context = {
+        userId: 'user-1',
+        tenantId: 'tenant-1',
+        organizationId: 'org-1',
+        em: {} as never,
+        container: {} as never,
+        userFeatures: ['*'],
+      }
+      const before = await runApiInterceptorsBefore({
+        routePath,
+        method,
+        request: requestPayload,
+        context,
+      })
+      if (!before.ok) {
+        return new Response(JSON.stringify(before.body), {
+          status: before.statusCode,
+          headers: { 'content-type': 'application/json' },
+        })
+      }
+      const after = await runApiInterceptorsAfter({
+        routePath,
+        method,
+        request: before.request,
+        response: { statusCode: 200, body: { routePath }, headers: {} },
+        context,
+        metadataByInterceptor: before.metadataByInterceptor,
+      })
+      return new Response(JSON.stringify(after.body), {
+        status: after.statusCode,
+        headers: { 'content-type': 'application/json' },
+      })
+    })
+    const apiRoutes: ApiRouteManifestEntry[] = [
+      makeManifestEntry({
+        path: '/customers/people',
+        methods: ['GET', 'POST'],
+        load: async () => ({
+          POST: handler,
+          GET: handler,
+          openApi: { tag: 'Customers', methods: { GET: {}, POST: {} } },
+          metadata: {
+            GET: { requireAuth: true, requireFeatures: ['customers.people.manage'] },
+            POST: { requireAuth: true, requireFeatures: ['customers.people.manage'] },
+          },
+        }),
+      }),
+    ]
+    const tool = makeTool({
+      name: 'customers.create_person',
+      requiredFeatures: ['customers.people.manage'],
+      isMutation: true,
+    })
+    const runner = createAiApiOperationRunner(makeCtx(tool), { apiRoutes })
+
+    const result = await runner.run({ method: 'POST', path, body: { name: 'Taylor' } })
+    const allowed = await runner.run({ method: 'GET', path })
+
+    expect(result).toMatchObject({
+      success: false,
+      statusCode: 451,
+      error: 'Denied by canonical policy',
+    })
+    expect(allowed).toEqual({
+      success: true,
+      statusCode: 200,
+      data: {
+        routePath: 'customers/people',
+        exactPolicyApplied: true,
+        prefixPolicyApplied: true,
+      },
+    })
+    expect(handler).toHaveBeenCalledTimes(2)
+  })
+
+  it('fails malformed synthetic request encoding before dispatch', async () => {
+    const handler = jest.fn(async () => new Response('{}', {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    }))
+    const apiRoutes: ApiRouteManifestEntry[] = [
+      makeManifestEntry({
+        path: '/customers/[id]',
+        methods: ['GET'],
+        load: async () => ({
+          GET: handler,
+          openApi: { tag: 'Customers', methods: { GET: {} } },
+        }),
+      }),
+    ]
+    const runner = createAiApiOperationRunner(makeCtx(makeTool({ name: 'customers.get' })), { apiRoutes })
+
+    const result = await runner.run({ method: 'GET', path: '/customers/%ZZ' })
+
+    expect(result.success).toBe(false)
+    expect(result.statusCode).toBe(400)
+    expect(handler).not.toHaveBeenCalled()
+  })
+
   it('falls back to default export for legacy route entries', async () => {
     const legacyHandler = jest.fn(async () => new Response(
       JSON.stringify({ ok: true }),

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

@@ -10,6 +10,8 @@ import {
   findGeneratedFile,
   compileAndImportGenerated,
   ensureApiRouteManifestsRegistered,
+  resolveAppAliasPath,
+  createAppAliasPlugin,
 } from '../generated-registry-loader'
 
 function makeTempDir(): string {
@@ -95,6 +97,19 @@ describe('rewriteGeneratedAliasImports', () => {
     expect(out).toBe(`import x from ${safeJsLiteral(expectedUrl)}`)
   })
 
+  // Regression for #6575: apps whose tsconfig maps `@/*` to `./src/*` must
+  // resolve `@/...` against src/ first, not the app root.
+  it('resolves a `@/...` import to the app src/ directory when the target lives there', () => {
+    const appRoot = makeTempDir()
+    fs.mkdirSync(path.join(appRoot, 'src', 'lib'), { recursive: true })
+    fs.writeFileSync(path.join(appRoot, 'src', 'lib', 'helpers.ts'), 'export const a = 1\n')
+
+    const out = rewriteGeneratedAliasImports(`import { a } from '@/lib/helpers'`, appRoot)
+
+    const expectedUrl = pathToFileURL(path.join(appRoot, 'src', 'lib', 'helpers.ts')).href
+    expect(out).toBe(`import { a } from ${safeJsLiteral(expectedUrl)}`)
+  })
+
   it('leaves non-alias imports untouched', () => {
     const source = [
       `import { z } from 'zod'`,
@@ -169,6 +184,98 @@ describe('rewriteGeneratedAliasImports', () => {
   })
 })
 
+describe('resolveAppAliasPath', () => {
+  it('prefers src/ over the app root for ordinary alias paths', () => {
+    const appRoot = makeTempDir()
+    fs.mkdirSync(path.join(appRoot, 'src', 'lib'), { recursive: true })
+    fs.mkdirSync(path.join(appRoot, 'lib'), { recursive: true })
+    fs.writeFileSync(path.join(appRoot, 'src', 'lib', 'x.ts'), '')
+    fs.writeFileSync(path.join(appRoot, 'lib', 'x.ts'), '')
+
+    expect(resolveAppAliasPath(appRoot, 'lib/x')).toBe(path.join(appRoot, 'src', 'lib', 'x.ts'))
+  })
+
+  it('falls back to the app root for apps that keep their sources there', () => {
+    const appRoot = makeTempDir()
+    fs.mkdirSync(path.join(appRoot, 'modules', 'demo'), { recursive: true })
+    fs.writeFileSync(path.join(appRoot, 'modules', 'demo', 'index.ts'), '')
+
+    expect(resolveAppAliasPath(appRoot, 'modules/demo')).toBe(
+      path.join(appRoot, 'modules', 'demo', 'index.ts'),
+    )
+  })
+
+  it('maps `.mercato/*` to the app root only', () => {
+    const appRoot = makeTempDir()
+    fs.mkdirSync(path.join(appRoot, 'src', '.mercato', 'generated'), { recursive: true })
+    fs.writeFileSync(path.join(appRoot, 'src', '.mercato', 'generated', 'entities.ts'), '')
+
+    expect(resolveAppAliasPath(appRoot, '.mercato/generated/entities')).toBeNull()
+
+    fs.mkdirSync(path.join(appRoot, '.mercato', 'generated'), { recursive: true })
+    fs.writeFileSync(path.join(appRoot, '.mercato', 'generated', 'entities.ts'), '')
+    expect(resolveAppAliasPath(appRoot, '.mercato/generated/entities')).toBe(
+      path.join(appRoot, '.mercato', 'generated', 'entities.ts'),
+    )
+  })
+
+  it('returns null when nothing matches', () => {
+    expect(resolveAppAliasPath(makeTempDir(), 'lib/missing')).toBeNull()
+  })
+})
+
+describe('createAppAliasPlugin', () => {
+  // Regression for #6575: `bundleLocalModules` bundled @app module sources with
+  // `alias: { '@': appRoot }`, so every `@/lib/...` / `@/modules/...` import in
+  // an app with `@/*` -> `./src/*` failed with esbuild "Could not resolve".
+  it('bundles an @app module whose sources import through `@/` into src/', async () => {
+    const appRoot = makeTempAppRoot()
+    const generatedDir = path.join(appRoot, '.mercato', 'generated')
+    const moduleDir = path.join(appRoot, 'src', 'modules', 'example')
+    fs.mkdirSync(generatedDir, { recursive: true })
+    fs.mkdirSync(moduleDir, { recursive: true })
+    fs.mkdirSync(path.join(appRoot, 'src', 'lib'), { recursive: true })
+    fs.writeFileSync(path.join(appRoot, 'src', 'lib', 'toolName.ts'), 'export const TOOL_NAME = "example.from_src_lib"\n')
+    fs.writeFileSync(
+      path.join(moduleDir, 'ai-tools.ts'),
+      [`import { TOOL_NAME } from '@/lib/toolName'`, 'export const aiTools = [{ name: TOOL_NAME }]'].join('\n'),
+    )
+    const generatedPath = path.join(generatedDir, 'ai-tools.generated.ts')
+    fs.writeFileSync(
+      generatedPath,
+      [
+        'import * as ExampleTools from "../../src/modules/example/ai-tools"',
+        'export const aiToolConfigEntries = ExampleTools.aiTools',
+      ].join('\n'),
+    )
+
+    const esbuild = await import('esbuild')
+    const result = await esbuild.build({
+      entryPoints: [generatedPath],
+      bundle: true,
+      packages: 'external',
+      format: 'esm',
+      platform: 'node',
+      write: false,
+      logLevel: 'silent',
+      plugins: [createAppAliasPlugin(appRoot)],
+    })
+
+    expect(result.errors).toEqual([])
+    expect(result.outputFiles[0].text).toContain('example.from_src_lib')
+  })
+
+  it('wires the alias plugin into the bundling compile path', () => {
+    const loaderSource = fs.readFileSync(
+      path.join(__dirname, '..', 'generated-registry-loader.ts'),
+      'utf8',
+    )
+
+    expect(loaderSource).toContain('plugins: [createAppAliasPlugin(appRoot)]')
+    expect(loaderSource).not.toMatch(/alias:\s*\{\s*'@'/)
+  })
+})
+
 describe('collectAppLocalSpecifiers', () => {
   it('collects static and dynamic @app specifiers once each, and nothing else', () => {
     const source = [

package/src/modules/ai_assistant/lib/__tests__/llm-adapters-openai.test.ts

@@ -367,3 +367,76 @@ describe('OpenAIAdapter — safety identifier + moderation capability', () => {
     expect(provider.supportsInputModeration).toBe(false)
   })
 })
+
+describe('OpenAIAdapter wire protocol (apiMode)', () => {
+  type ModelWithProvider = { provider: string }
+
+  function modelProvider(preset: OpenAICompatiblePreset): string {
+    const model = createOpenAICompatibleProvider(preset).createModel({
+      apiKey: 'test-key',
+      modelId: preset.defaultModel || 'local-model',
+    }) as ModelWithProvider
+    return model.provider
+  }
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  it('builds a Chat Completions model when the preset omits apiMode', () => {
+    expect(modelProvider(DEEPINFRA_PRESET)).toBe('openai.chat')
+  })
+
+  it('builds a Responses API model when the preset opts into apiMode "responses"', () => {
+    expect(modelProvider({ ...DEEPINFRA_PRESET, apiMode: 'responses' })).toBe('openai.responses')
+  })
+
+  it('keeps the native OpenAI preset on the Responses API and every compatible preset on Chat Completions', () => {
+    for (const preset of OPENAI_COMPATIBLE_PRESETS) {
+      const expected = preset.id === 'openai' ? 'openai.responses' : 'openai.chat'
+      expect({ id: preset.id, provider: modelProvider(preset) }).toEqual({
+        id: preset.id,
+        provider: expected,
+      })
+    }
+  })
+
+  it('posts DeepInfra turns to /chat/completions instead of /responses', async () => {
+    const fetchSpy = jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new Response(
+        JSON.stringify({
+          id: 'chatcmpl-1',
+          object: 'chat.completion',
+          created: 0,
+          model: 'zai-org/GLM-5.1',
+          choices: [
+            {
+              index: 0,
+              message: { role: 'assistant', content: 'ok' },
+              finish_reason: 'stop',
+            },
+          ],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
+        }),
+        { status: 200, headers: { 'content-type': 'application/json' } },
+      ),
+    )
+    const model = createOpenAICompatibleProvider(DEEPINFRA_PRESET).createModel({
+      apiKey: 'test-key',
+      modelId: 'zai-org/GLM-5.1',
+    }) as {
+      doGenerate: (options: {
+        prompt: Array<{ role: 'user'; content: Array<{ type: 'text'; text: string }> }>
+      }) => Promise<unknown>
+    }
+
+    await model.doGenerate({
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+    })
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1)
+    expect(String(fetchSpy.mock.calls[0][0])).toBe(
+      'https://api.deepinfra.com/v1/openai/chat/completions',
+    )
+  })
+})

package/src/modules/ai_assistant/lib/ai-api-operation-runner.ts

@@ -100,6 +100,14 @@ function buildUrl(path: string, query?: AiApiOperationRequest['query']): URL {
   return url
 }
 
+function decodePathForManifestMatch(path: string): string | null {
+  try {
+    return path.split('/').map((segment) => decodeURIComponent(segment)).join('/')
+  } catch {
+    return null
+  }
+}
+
 function buildAuthEnvelope(ctx: AiToolExecutionContext): TrustedAuthContextEnvelope {
   const userId = ctx.userId
   if (!userId) {
@@ -231,6 +239,19 @@ export function createAiApiOperationRunner(
         return failure(400, message) as AiApiOperationResponse<T>
       }
       const path = normalizePath(request.path)
+      const manifestPath = decodePathForManifestMatch(path)
+      if (manifestPath === null) {
+        return failure(400, `Invalid path encoding for ${method} ${path}`) as AiApiOperationResponse<T>
+      }
+
+      const url = buildUrl(path, request.query)
+      const headers = new Headers()
+      const requestInit: RequestInit = { method, headers }
+      if (request.body !== undefined && method !== 'GET') {
+        headers.set('content-type', 'application/json')
+        requestInit.body = JSON.stringify(request.body)
+      }
+      const syntheticRequest = new Request(url, requestInit)
 
       let routes: ApiRouteManifestEntry[]
       try {
@@ -240,7 +261,7 @@ export function createAiApiOperationRunner(
         return failure(500, `Operation runner manifest unavailable: ${message}`) as AiApiOperationResponse<T>
       }
 
-      const match = findApiRouteManifestMatch(routes, method, path)
+      const match = findApiRouteManifestMatch(routes, method, manifestPath, syntheticRequest)
       if (!match) {
         return failure(
           404,
@@ -291,15 +312,6 @@ export function createAiApiOperationRunner(
         ) as AiApiOperationResponse<T>
       }
 
-      const url = buildUrl(path, request.query)
-      const headers = new Headers()
-      const requestInit: RequestInit = { method, headers }
-      if (request.body !== undefined && method !== 'GET') {
-        headers.set('content-type', 'application/json')
-        requestInit.body = JSON.stringify(request.body)
-      }
-
-      const syntheticRequest = new Request(url, requestInit)
       attachTrustedAuthContext(syntheticRequest, buildAuthEnvelope(ctx))
 
       let response: Response
@@ -339,4 +351,3 @@ async function defaultLoadApiRoutes(): Promise<ApiRouteManifestEntry[]> {
   }
   return registered
 }
-

package/src/modules/ai_assistant/lib/generated-registry-loader.ts

@@ -140,7 +140,7 @@ export async function compileAndImportGenerated(
         sourcemap: false,
         write: false,
         logLevel: 'silent',
-        alias: { '@': appRoot },
+        plugins: [createAppAliasPlugin(appRoot)],
       })
       fs.writeFileSync(jsPath, result.outputFiles[0].text)
     } else {
@@ -171,6 +171,46 @@ export async function compileAndImportGenerated(
   )) as Record<string, unknown>
 }
 
+const APP_ALIAS_SUFFIXES = ['.ts', '.tsx', '/index.ts', '/index.tsx']
+
+/**
+ * Resolve an `@/<rest>` specifier the way the app's tsconfig maps it:
+ * `@/.mercato/*` to the app root, every other `@/*` to `src/` first with the
+ * app root as a fallback (apps that keep their sources at the root). Mirrors
+ * the alias resolver in `createCliBundlePlugins`
+ * (`@open-mercato/shared/lib/bootstrap/dynamicLoader`), which this module can
+ * only load lazily. Returns `null` when no file matches. Exported for unit testing.
+ */
+export function resolveAppAliasPath(appRoot: string, rest: string): string | null {
+  const bases = rest.startsWith('.mercato/')
+    ? [path.join(appRoot, rest)]
+    : [path.join(appRoot, 'src', rest), path.join(appRoot, rest)]
+  for (const base of bases) {
+    if (fs.existsSync(base) && fs.statSync(base).isFile()) return base
+    for (const suffix of APP_ALIAS_SUFFIXES) {
+      if (fs.existsSync(base + suffix)) return base + suffix
+    }
+  }
+  return null
+}
+
+/**
+ * esbuild plugin resolving `@/` through `resolveAppAliasPath`. An unmatched
+ * specifier falls back to the literal app-root mapping so esbuild reports the
+ * missing file against the path the app author wrote. Exported for unit testing.
+ */
+export function createAppAliasPlugin(appRoot: string): import('esbuild').Plugin {
+  return {
+    name: 'app-alias',
+    setup(build) {
+      build.onResolve({ filter: /^@\// }, (args) => {
+        const rest = args.path.slice('@/'.length)
+        return { path: resolveAppAliasPath(appRoot, rest) ?? path.join(appRoot, rest) }
+      })
+    },
+  }
+}
+
 function isJestRuntime(): boolean {
   return typeof process.env.JEST_WORKER_ID === 'string'
 }
@@ -286,7 +326,8 @@ function toSafeJsStringLiteral(value: string): string {
  *   1. `@/...` path-alias imports (both `from "@/x"` and dynamic `import("@/x")`).
  *      The `@/` alias is a Next.js bundler convention; outside the bundler Node
  *      treats `@/...` as a bare package specifier and throws
- *      `ERR_MODULE_NOT_FOUND`. Resolved against `appRoot`.
+ *      `ERR_MODULE_NOT_FOUND`. Resolved like the app tsconfig maps the alias
+ *      (see `resolveAppAliasPath`), falling back to `appRoot`.
  *   2. `../../src/...` relative imports the generator emits for `@app` local
  *      modules (e.g. `from "../../src/modules/<id>/ai-tools"`). esbuild's
  *      transform (transpile-only) leaves these untouched, so the compiled
@@ -332,8 +373,11 @@ function rewriteGeneratedAliasImportsForRuntime(
         : target
     return toRuntimeLiteral(candidate)
   }
-  const resolveAlias = (relativePath: string): string =>
-    toResolvedLiteral(path.join(appRoot, relativePath))
+  const resolveAlias = (relativePath: string): string => {
+    const resolved = resolveAppAliasPath(appRoot, relativePath)
+    if (resolved !== null) return toRuntimeLiteral(resolved)
+    return toResolvedLiteral(path.join(appRoot, relativePath))
+  }
   const resolveRelative = (specifier: string): string => {
     const artifact = appLocalArtifacts.get(specifier)
     if (artifact !== undefined) return toRuntimeLiteral(artifact)

package/src/modules/ai_assistant/lib/llm-adapters/openai.ts

@@ -10,7 +10,9 @@
  *
  * The factory {@link createOpenAICompatibleProvider} takes a preset and
  * returns a fully-configured `LlmProvider` that internally calls
- * `createOpenAI({ apiKey, baseURL })` from `@ai-sdk/openai`.
+ * `createOpenAI({ apiKey, baseURL })` from `@ai-sdk/openai` and builds a
+ * Chat Completions model, or a Responses API model for presets that set
+ * `apiMode: 'responses'` (only the native `openai` preset).
  *
  * @see packages/shared/src/lib/ai/llm-provider.ts
  * @see ./openai-compatible-presets.ts
@@ -87,8 +89,20 @@ export interface OpenAICompatiblePreset {
    * deepinfra, groq, …).
    */
   usesVendorPrefixedModelIds?: boolean
+  /**
+   * Wire protocol used for model calls. `'chat'` (the default) targets
+   * `POST {baseURL}/chat/completions`, which every OpenAI-compatible backend
+   * (DeepInfra, Groq, Together, Fireworks, LiteLLM, Ollama, …) implements.
+   * `'responses'` targets OpenAI's Responses API (`POST {baseURL}/responses`),
+   * which only the native `openai` preset opts into — compatible backends do
+   * not implement it and answer `404 Not Found`.
+   */
+  apiMode?: OpenAICompatibleApiMode
 }
 
+/** Wire protocol an {@link OpenAICompatiblePreset} speaks. */
+export type OpenAICompatibleApiMode = 'chat' | 'responses'
+
 function readFirstNonEmpty(
   env: EnvLookup,
   keys: readonly string[],
@@ -120,6 +134,8 @@ export function createOpenAICompatibleProvider(
     )
   }
 
+  const apiMode: OpenAICompatibleApiMode = preset.apiMode ?? 'chat'
+
   function resolveApiKey(env?: EnvLookup): string | null {
     return readFirstNonEmpty(env ?? process.env, preset.envKeys)
   }
@@ -166,7 +182,9 @@ export function createOpenAICompatibleProvider(
         apiKey: options.apiKey,
         ...(baseURL ? { baseURL } : {}),
       })
-      return openai(options.modelId)
+      return apiMode === 'responses'
+        ? openai.responses(options.modelId)
+        : openai.chat(options.modelId)
     },
   }
 

package/src/modules/ai_assistant/lib/openai-compatible-presets.ts

@@ -26,6 +26,7 @@ const OPENAI_PRESET: OpenAICompatiblePreset = {
   baseURL: undefined,
   baseURLEnvKeys: ['OPENAI_BASE_URL'],
   envKeys: ['OPENAI_API_KEY', 'OPENCODE_OPENAI_API_KEY'],
+  apiMode: 'responses',
   supportsInputModeration: true,
   supportsEndUserSafetyIdentifier: true,
   defaultModel: 'gpt-5-mini',

package/src/modules/ai_assistant/widgets/notifications/ConversationSharedRenderer.tsx

@@ -26,7 +26,7 @@ export function ConversationSharedRenderer({
   const handleView = async () => {
     setExecuting(true)
     try {
-      if (viewAction) {
+      if (viewAction && notification.status !== 'actioned') {
         await onAction(viewAction.id)
       }
       if (notification.linkHref) router.push(notification.linkHref)
@@ -82,7 +82,7 @@ export function ConversationSharedRenderer({
               e.stopPropagation()
               handleView()
             }}
-            disabled={executing || (!viewAction && !notification.linkHref)}
+            disabled={executing || (!viewAction && !notification.linkHref) || (notification.status === 'actioned' && !notification.linkHref)}
           >
             <ExternalLink className="size-3.5" aria-hidden="true" />
             {t('ai_assistant.notifications.conversation_shared.view_button', 'View Conversation')}