fix(webhooks): complete all 8 webhook event dispatches and fix test coverage

- Add cdn.build_complete dispatch to CDN trigger endpoint
- Add 5 webhook dispatches to conversation engine (content.saved,
  content.deleted, model.saved, branch.merged, branch.rejected)
- Move webhook emission from chat.post.ts into conversation-engine.ts
  to cover both Studio chat and Conversation API paths
- Add 7 missing ConversationKeysPanel UI strings to dictionary
- Fix conversation_keys.description accuracy (remove plan requirement)
- Add emitWebhookEvent stubs to branch, content, and CDN tests
- Add conversation engine webhook dispatch assertions

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Contentrain

.contentrain/content/system/ui-strings/en.json

@@ -244,18 +244,25 @@
   "content.vocabulary_empty_description": "Ask the chat agent to add terms — e.g. \"Add vocabulary term 'CTA' meaning 'Call to Action'.\" Terms keep translations consistent across locales.",
   "content.vocabulary_empty_title": "No vocabulary terms",
   "conversation_keys.copy": "Copy API Key",
+  "conversation_keys.copy_warning": "Copy this key now — it will not be shown again.",
   "conversation_keys.create": "Create API Key",
+  "conversation_keys.create_error": "Failed to create API key. Please try again.",
   "conversation_keys.created": "API key created — copy it now, it won't be shown again.",
+  "conversation_keys.creating": "Creating...",
   "conversation_keys.custom_instructions": "Custom Instructions",
   "conversation_keys.delete_confirm": "Revoke this API key? External services using it will lose access.",
-  "conversation_keys.description": "API keys for external services to access the conversation engine. Business plan required.",
+  "conversation_keys.description": "API keys for external services to access the conversation engine.",
+  "conversation_keys.last_used": "Last used",
   "conversation_keys.model": "AI Model",
   "conversation_keys.monthly_limit": "Monthly Limit",
   "conversation_keys.name": "Key Name",
+  "conversation_keys.name_placeholder": "e.g. Production API, Staging Bot",
+  "conversation_keys.never_used": "Never used",
   "conversation_keys.no_keys": "No API keys",
   "conversation_keys.no_keys_description": "Create an API key to enable external services to chat with your content.",
   "conversation_keys.rate_limit": "Rate Limit (per minute)",
   "conversation_keys.revoke": "Revoke Key",
+  "conversation_keys.revoke_error": "Failed to revoke API key. Please try again.",
   "conversation_keys.revoked": "Key revoked",
   "conversation_keys.role": "Role",
   "conversation_keys.title": "Conversation API",

server/api/workspaces/[workspaceId]/projects/[projectId]/cdn/builds/trigger.post.ts

@@ -86,6 +86,15 @@ export default defineEventHandler(async (event) => {
         completed_at: new Date().toISOString(),
       })
 
+      // Emit webhook event (fire-and-forget)
+      emitWebhookEvent(projectId, workspaceId, 'cdn.build_complete', {
+        buildId: build.id,
+        status: result.error ? 'failed' : 'success',
+        filesUploaded: result.filesUploaded,
+        durationMs: result.durationMs,
+        error: result.error ?? null,
+      }).catch(() => {})
+
       await eventStream.push(JSON.stringify({
         phase: 'complete',
         message: result.error ? `Build failed: ${result.error}` : `Build complete — ${result.filesUploaded} files in ${result.durationMs}ms`,

server/api/workspaces/[workspaceId]/projects/[projectId]/chat.post.ts

@@ -202,7 +202,6 @@ export default defineEventHandler(async (event) => {
     let totalInputTokens = 0
     let totalOutputTokens = 0
     let lastAssistantContent: AIContentBlock[] = []
-    let lastAffected: Record<string, unknown> = {}
 
     try {
       for await (const evt of runConversationLoop(
@@ -218,7 +217,6 @@ export default defineEventHandler(async (event) => {
           totalInputTokens = (evt.usage as { inputTokens: number })?.inputTokens ?? 0
           totalOutputTokens = (evt.usage as { outputTokens: number })?.outputTokens ?? 0
           lastAssistantContent = (evt.lastContent as AIContentBlock[]) ?? []
-          lastAffected = (evt.affected as Record<string, unknown>) ?? {}
 
           // Forward the done event without lastContent (not needed by client)
           await eventStream.push(JSON.stringify({
@@ -244,14 +242,7 @@ export default defineEventHandler(async (event) => {
         workspaceId, session.user.id, usageSource, usageMonth,
       )
 
-      // Emit webhook events for content changes (fire-and-forget)
-      if (lastAffected.snapshotChanged) {
-        emitWebhookEvent(projectId, workspaceId, 'content.saved', {
-          models: (lastAffected.models as string[]) ?? [],
-          source: 'studio',
-          conversationId,
-        }).catch(() => {})
-      }
+      // Webhook events are now emitted from conversation-engine.ts per tool execution
     }
     catch (e: unknown) {
       const msg = e instanceof Error ? e.message : 'Chat error'

server/utils/conversation-engine.ts

@@ -313,6 +313,13 @@ export async function executeToolWithAutoMerge(
         else {
           result = { ...summarizeWriteResult(writeResult), merged: false, workflow }
         }
+
+        // Emit webhook event (fire-and-forget)
+        emitWebhookEvent(projectId, workspaceId, 'content.saved', {
+          models: [modelId],
+          locale,
+          source: 'conversation',
+        }).catch(() => {})
         break
       }
 
@@ -340,6 +347,14 @@ export async function executeToolWithAutoMerge(
         else {
           result = { ...summarizeWriteResult(writeResult), merged: false, reviewBranch: writeResult.branch }
         }
+
+        // Emit webhook event (fire-and-forget)
+        emitWebhookEvent(projectId, workspaceId, 'content.deleted', {
+          models: [modelId],
+          locale,
+          entryIds: params.entryIds as string[],
+          source: 'conversation',
+        }).catch(() => {})
         break
       }
 
@@ -356,6 +371,12 @@ export async function executeToolWithAutoMerge(
         else {
           result = { ...summarizeWriteResult(writeResult), merged: false, reviewBranch: writeResult.branch }
         }
+
+        // Emit webhook event (fire-and-forget)
+        emitWebhookEvent(projectId, workspaceId, 'model.saved', {
+          modelId: (params as Record<string, unknown>).id as string,
+          source: 'conversation',
+        }).catch(() => {})
         break
       }
 
@@ -444,6 +465,12 @@ export async function executeToolWithAutoMerge(
         affected.snapshotChanged = true
         affected.branchesChanged = true
         result = mergeResult
+
+        // Emit webhook event (fire-and-forget)
+        emitWebhookEvent(projectId, workspaceId, 'branch.merged', {
+          branch: branchToMerge,
+          source: 'conversation',
+        }).catch(() => {})
         break
       }
 
@@ -460,6 +487,12 @@ export async function executeToolWithAutoMerge(
         await engine.rejectBranch(branchToReject)
         affected.branchesChanged = true
         result = { rejected: true }
+
+        // Emit webhook event (fire-and-forget)
+        emitWebhookEvent(projectId, workspaceId, 'branch.rejected', {
+          branch: branchToReject,
+          source: 'conversation',
+        }).catch(() => {})
         break
       }
 

tests/integration/cdn-routes.integration.test.ts

@@ -303,6 +303,7 @@ describe('CDN route integration', () => {
       contentRoot: '.',
     }))
     vi.stubGlobal('useCDNProvider', vi.fn().mockReturnValue({}))
+    vi.stubGlobal('emitWebhookEvent', vi.fn().mockResolvedValue(undefined))
     vi.stubGlobal('executeCDNBuild', vi.fn().mockImplementation(async ({ onProgress }) => {
       onProgress?.({ phase: 'upload', message: 'Uploading files', current: 1, total: 2 })
       return {
@@ -337,6 +338,13 @@ describe('CDN route integration', () => {
     expect(eventStreamState.stream.push).toHaveBeenCalledWith(expect.stringContaining('"phase":"complete"'))
     expect(eventStreamState.stream.close).toHaveBeenCalledOnce()
     expect(eventStreamState.stream.onClosed).toHaveBeenCalledOnce()
+
+    const emitMock = vi.mocked(globalThis.emitWebhookEvent as ReturnType<typeof vi.fn>)
+    expect(emitMock).toHaveBeenCalledWith('project-1', 'workspace-1', 'cdn.build_complete', expect.objectContaining({
+      buildId: 'build-1',
+      status: 'success',
+      filesUploaded: 2,
+    }))
   })
 
   it('returns 404 for CDN build history requested through the wrong workspace path', async () => {

tests/integration/content-routes.integration.test.ts

@@ -52,6 +52,7 @@ describe('content route integration', () => {
     vi.stubGlobal('invalidateBrainCache', vi.fn())
     vi.stubGlobal('createContentEngine', vi.fn().mockReturnValue({ saveContent, mergeBranch }))
     vi.stubGlobal('useMediaProvider', vi.fn().mockReturnValue({ listAssets }))
+    vi.stubGlobal('emitWebhookEvent', vi.fn().mockResolvedValue(undefined))
     vi.stubGlobal('useDatabaseProvider', vi.fn().mockReturnValue({
       trackMediaUsage,
     }))

tests/unit/branch-moderation-routes.test.ts

@@ -17,6 +17,7 @@ function stubRouteGlobals(branch: string) {
     if (key === 'branch') return branch
     return undefined
   }))
+  vi.stubGlobal('emitWebhookEvent', vi.fn().mockResolvedValue(undefined))
   vi.stubGlobal('useDatabaseProvider', vi.fn(() => ({
     getUserClient: vi.fn((accessToken: string) => {
       const userClient = (globalThis as typeof globalThis & {

tests/unit/conversation-engine-regression.test.ts

@@ -16,6 +16,95 @@ describe('conversation engine regression', () => {
     vi.unstubAllGlobals()
   })
 
+  it('emits webhook events for content-mutating tools', async () => {
+    const { emptyAffected } = await import('../../server/utils/agent-types')
+    const git = {} as GitProvider
+    const permissions: AgentPermissions = {
+      workspaceRole: 'owner',
+      projectRole: null,
+      specificModels: false,
+      allowedModels: [],
+      allowedLocales: [],
+      availableTools: ['save_content', 'delete_content', 'save_model', 'merge_branch', 'reject_branch'],
+    }
+    const uiContext: ChatUIContext = {
+      activeModelId: null,
+      activeLocale: 'en',
+      activeEntryId: null,
+      panelState: 'overview',
+      activeBranch: null,
+    }
+
+    vi.stubGlobal('emptyAffected', emptyAffected)
+    vi.stubGlobal('hasFeature', vi.fn().mockReturnValue(true))
+
+    const mockEmit = vi.fn().mockResolvedValue(undefined)
+    vi.stubGlobal('emitWebhookEvent', mockEmit)
+    vi.stubGlobal('invalidateBrainCache', vi.fn())
+    vi.stubGlobal('getOrBuildBrainCache', vi.fn().mockResolvedValue({
+      models: new Map([['posts', { id: 'posts', kind: 'collection' }]]),
+    }))
+
+    const writeResult = {
+      branch: 'cr/content-posts-en',
+      commit: { sha: 'abc123' },
+      diff: [],
+      validation: { valid: true, errors: [] },
+    }
+    const mockEngine = {
+      saveContent: vi.fn().mockResolvedValue(writeResult),
+      deleteContent: vi.fn().mockResolvedValue(writeResult),
+      saveModel: vi.fn().mockResolvedValue(writeResult),
+      mergeBranch: vi.fn().mockResolvedValue({ merged: true }),
+      rejectBranch: vi.fn().mockResolvedValue(undefined),
+    }
+
+    const { executeToolWithAutoMerge } = await loadConversationEngineModule()
+
+    // Test save_content emits content.saved
+    await executeToolWithAutoMerge(
+      'save_content', { model: 'posts', locale: 'en', data: { e1: { title: 'Hello' } } },
+      mockEngine as never, git, 'user@test.com', 'user-1', 'content', 'auto-merge',
+      permissions, 'pro', 'project-1', 'workspace-1', uiContext,
+    )
+    expect(mockEmit).toHaveBeenCalledWith('project-1', 'workspace-1', 'content.saved', expect.objectContaining({
+      models: ['posts'], source: 'conversation',
+    }))
+
+    // Test delete_content emits content.deleted
+    mockEmit.mockClear()
+    await executeToolWithAutoMerge(
+      'delete_content', { model: 'posts', locale: 'en', entryIds: ['e1'] },
+      mockEngine as never, git, 'user@test.com', 'user-1', 'content', 'auto-merge',
+      permissions, 'pro', 'project-1', 'workspace-1', uiContext,
+    )
+    expect(mockEmit).toHaveBeenCalledWith('project-1', 'workspace-1', 'content.deleted', expect.objectContaining({
+      models: ['posts'], entryIds: ['e1'], source: 'conversation',
+    }))
+
+    // Test merge_branch emits branch.merged
+    mockEmit.mockClear()
+    await executeToolWithAutoMerge(
+      'merge_branch', { branch: 'cr/test' },
+      mockEngine as never, git, 'user@test.com', 'user-1', 'content', 'auto-merge',
+      permissions, 'pro', 'project-1', 'workspace-1', uiContext,
+    )
+    expect(mockEmit).toHaveBeenCalledWith('project-1', 'workspace-1', 'branch.merged', expect.objectContaining({
+      branch: 'cr/test', source: 'conversation',
+    }))
+
+    // Test reject_branch emits branch.rejected
+    mockEmit.mockClear()
+    await executeToolWithAutoMerge(
+      'reject_branch', { branch: 'cr/test' },
+      mockEngine as never, git, 'user@test.com', 'user-1', 'content', 'auto-merge',
+      permissions, 'pro', 'project-1', 'workspace-1', uiContext,
+    )
+    expect(mockEmit).toHaveBeenCalledWith('project-1', 'workspace-1', 'branch.rejected', expect.objectContaining({
+      branch: 'cr/test', source: 'conversation',
+    }))
+  })
+
   it('returns unavailable schema validation instead of a fake 100 score', async () => {
     const { emptyAffected } = await import('../../server/utils/agent-types')
     const git = {} as GitProvider