fix(chat): resolve a caller-supplied conversation id through its owner

The v2 chat route used the caller-supplied conversationId verbatim, with no
existence, owner, or workspace check, against a store keyed by bare text with
no owner column. A caller who knew another user's conversation id reached that
conversation. Ids now resolve through the same owner-scoped loader the web chat
path uses, and anything unresolvable answers one uniform 404 before any
lifecycle work runs. Omitting the id mints a server-issued conversation.

The contract also accepted any 1-128 character string for a column typed uuid,
so a malformed id raised a driver error and rendered 500 while an unknown but
well-formed id rendered 404 - a shape oracle, and a 500 on ordinary input.

The ownership predicate had no coverage anywhere: the route test mocked the
module and the lifecycle test drove a chain mock that ignores its where clause,
so deleting the owner condition left both suites green. It is now asserted by
composition and by condition count, which is what catches a dropped condition.

Also renames the reply's model identifier away from a term the project's own
copy rules forbid on a user-facing surface.

Author: waleedlatif1

apps/sim/app/api/v2/chat/route.test.ts

@@ -16,6 +16,7 @@ const {
   mockGenerateId,
   mockRequestExplicitStreamAbort,
   mockResolveBillingAttribution,
+  mockResolveOrCreateChat,
   mockRunHeadlessCopilotLifecycle,
 } = vi.hoisted(() => ({
   MockV2ApiKeyUnauthenticatedError: class MockV2ApiKeyUnauthenticatedError extends Error {},
@@ -35,6 +36,7 @@ const {
   mockCheckPreAuthRate: vi.fn(),
   mockGenerateId: vi.fn(),
   mockResolveBillingAttribution: vi.fn(),
+  mockResolveOrCreateChat: vi.fn(),
   mockRequestExplicitStreamAbort: vi.fn().mockResolvedValue(undefined),
   mockRunHeadlessCopilotLifecycle: vi.fn(),
 }))
@@ -78,6 +80,10 @@ vi.mock('@/lib/copilot/chat/workspace-context', () => ({
   generateWorkspaceContext: vi.fn().mockResolvedValue('workspace context'),
 }))
 
+vi.mock('@/lib/copilot/chat/lifecycle', () => ({
+  resolveOrCreateChat: mockResolveOrCreateChat,
+}))
+
 vi.mock('@/lib/copilot/chat/payload', () => ({
   buildIntegrationToolSchemas: vi.fn().mockResolvedValue([{ name: 'run_workflow' }]),
 }))
@@ -111,6 +117,17 @@ const personalAuth = {
   keyType: 'personal',
 }
 
+/**
+ * The route never echoes the caller's string back as the conversation id: it
+ * reports whatever the owner-scoped resolver returns.
+ */
+const SERVER_ISSUED_CHAT_ID = 'chat-server-1'
+const OWNED_CONVERSATION_ID = '11111111-1111-4111-8111-111111111111'
+
+function chatRow(id: string) {
+  return { id, userId: 'user-1', workspaceId: 'workspace-1', workflowId: null, type: 'mothership' }
+}
+
 const successResult = {
   success: true,
   content: 'Hello there',
@@ -144,6 +161,12 @@ describe('POST /api/v2/chat', () => {
     mockResolveBillingAttribution.mockResolvedValue(billingAttributionSnapshot)
     mockRequestExplicitStreamAbort.mockResolvedValue(undefined)
     mockRunHeadlessCopilotLifecycle.mockResolvedValue(successResult)
+    mockResolveOrCreateChat.mockResolvedValue({
+      chatId: SERVER_ISSUED_CHAT_ID,
+      chat: chatRow(SERVER_ISSUED_CHAT_ID),
+      conversationHistory: [],
+      isNew: true,
+    })
   })
 
   it('rejects a missing or invalid API key', async () => {
@@ -187,15 +210,15 @@ describe('POST /api/v2/chat', () => {
     expect(mockRunHeadlessCopilotLifecycle).not.toHaveBeenCalled()
   })
 
-  it('runs one turn and answers the reply with a generated conversation id', async () => {
+  it('runs one turn and answers the reply with a server-issued conversation id', async () => {
     const response = await callChat({ workspaceId: 'workspace-1', message: 'hi' })
 
     expect(response.status).toBe(200)
     const body = await response.json()
     expect(body.data).toEqual({
       content: 'Hello there',
-      model: 'mothership',
-      conversationId: 'generated-1',
+      model: 'sim',
+      conversationId: SERVER_ISSUED_CHAT_ID,
       tokens: { prompt: 10, completion: 5, total: 15 },
       cost: { total: 0.01 },
       toolCalls: [{ name: 'run_workflow' }],
@@ -206,7 +229,7 @@ describe('POST /api/v2/chat', () => {
       messages: [{ role: 'user', content: 'hi' }],
       userId: 'user-1',
       workspaceId: 'workspace-1',
-      chatId: 'generated-1',
+      chatId: SERVER_ISSUED_CHAT_ID,
       mode: 'agent',
       isHosted: true,
       workspaceContext: 'workspace context',
@@ -216,7 +239,7 @@ describe('POST /api/v2/chat', () => {
     expect(options).toMatchObject({
       userId: 'user-1',
       workspaceId: 'workspace-1',
-      chatId: 'generated-1',
+      chatId: SERVER_ISSUED_CHAT_ID,
       goRoute: '/api/mothership/execute',
       autoExecuteTools: true,
       interactive: false,
@@ -230,17 +253,88 @@ describe('POST /api/v2/chat', () => {
     })
   })
 
-  it('continues the conversation the caller names', async () => {
+  it('mints a server-issued conversation when the caller names none', async () => {
+    const response = await callChat({ workspaceId: 'workspace-1', message: 'hi' })
+
+    expect(response.status).toBe(200)
+    const body = await response.json()
+    expect(body.data.conversationId).toBe(SERVER_ISSUED_CHAT_ID)
+    const resolverInput = mockResolveOrCreateChat.mock.calls[0][0] as Record<string, unknown>
+    expect(Object.hasOwn(resolverInput, 'chatId')).toBe(false)
+    expect(resolverInput).toMatchObject({
+      userId: 'user-1',
+      workspaceId: 'workspace-1',
+      type: 'mothership',
+    })
+  })
+
+  it('resolves a named conversation against the calling user and workspace before continuing it', async () => {
+    mockResolveOrCreateChat.mockResolvedValue({
+      chatId: OWNED_CONVERSATION_ID,
+      chat: chatRow(OWNED_CONVERSATION_ID),
+      conversationHistory: [],
+      isNew: false,
+    })
+
     const response = await callChat({
       workspaceId: 'workspace-1',
       message: 'and then?',
-      conversationId: 'conv-9',
+      conversationId: OWNED_CONVERSATION_ID,
     })
 
     expect(response.status).toBe(200)
+    expect(mockResolveOrCreateChat).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: OWNED_CONVERSATION_ID,
+        userId: 'user-1',
+        workspaceId: 'workspace-1',
+      })
+    )
+    const body = await response.json()
+    expect(body.data.conversationId).toBe(OWNED_CONVERSATION_ID)
+    expect(mockRunHeadlessCopilotLifecycle.mock.calls[0][0]).toMatchObject({
+      chatId: OWNED_CONVERSATION_ID,
+    })
+  })
+
+  it('answers 404 and runs nothing when the resolver refuses the named conversation', async () => {
+    mockResolveOrCreateChat.mockResolvedValue({
+      chatId: OWNED_CONVERSATION_ID,
+      chat: null,
+      conversationHistory: [],
+      isNew: false,
+    })
+
+    const response = await callChat({
+      workspaceId: 'workspace-1',
+      message: 'and then?',
+      conversationId: OWNED_CONVERSATION_ID,
+    })
+
+    expect(response.status).toBe(404)
     const body = await response.json()
-    expect(body.data.conversationId).toBe('conv-9')
-    expect(mockRunHeadlessCopilotLifecycle.mock.calls[0][0]).toMatchObject({ chatId: 'conv-9' })
+    expect(body.error.code).toBe('NOT_FOUND')
+    expect(mockResolveOrCreateChat).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: OWNED_CONVERSATION_ID,
+        userId: 'user-1',
+        workspaceId: 'workspace-1',
+      })
+    )
+    // No tokens may be billed against an id the caller could not be given.
+    expect(mockRunHeadlessCopilotLifecycle).not.toHaveBeenCalled()
+  })
+
+  it('rejects a malformed conversation id before resolving anything', async () => {
+    const response = await callChat({
+      workspaceId: 'workspace-1',
+      message: 'and then?',
+      conversationId: 'not-a-conversation-id',
+    })
+
+    expect(response.status).toBe(400)
+    expect(mockResolveOrCreateChat).not.toHaveBeenCalled()
+    expect(mockRunHeadlessCopilotLifecycle).not.toHaveBeenCalled()
   })
 
   it('answers a failed run as a 500 with the run error', async () => {
@@ -282,7 +376,10 @@ describe('POST /api/v2/chat', () => {
     expect(chunks.map((chunk) => chunk.content)).toEqual(['Hello', ' there'])
     const final = events.at(-1) as { type: string; data: Record<string, unknown> }
     expect(final.type).toBe('final')
-    expect(final.data).toMatchObject({ content: 'Hello there', conversationId: 'generated-1' })
+    expect(final.data).toMatchObject({
+      content: 'Hello there',
+      conversationId: SERVER_ISSUED_CHAT_ID,
+    })
   })
 
   it('ends the NDJSON stream with an error event when the run fails', async () => {

apps/sim/app/api/v2/chat/route.ts

@@ -13,6 +13,7 @@ import {
 } from '@/lib/api/server/routes'
 import { resolveBillingAttribution } from '@/lib/billing/core/billing-attribution'
 import { chatOperations } from '@/lib/copilot/application/operations'
+import { resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
 import { buildIntegrationToolSchemas } from '@/lib/copilot/chat/payload'
 import { generateWorkspaceContext } from '@/lib/copilot/chat/workspace-context'
 import { computeWorkspaceEntitlements } from '@/lib/copilot/entitlements'
@@ -48,6 +49,12 @@ const CHAT_STREAM_VALUE = 'ndjson'
 const CHAT_HEARTBEAT_INTERVAL_MS = 15_000
 const ndjsonEncoder = new TextEncoder()
 
+/**
+ * Model recorded on conversations this route creates, matching the model the
+ * web Chat surface stamps on a new mothership conversation.
+ */
+const V2_CHAT_MODEL = 'claude-opus-4-8'
+
 function isAbortError(error: unknown): boolean {
   return error instanceof Error && error.name === 'AbortError'
 }
@@ -80,7 +87,7 @@ function buildChatResultPayload(
 
   return {
     content: result.content ?? '',
-    model: 'mothership',
+    model: 'sim',
     conversationId,
     tokens: result.usage
       ? {
@@ -130,14 +137,35 @@ export const POST = withRouteHandler(
     if (!parsed.success) return parsed.response
     const { workspaceId, message, conversationId } = parsed.data.body
 
-    const chatId = conversationId || generateId()
     const messageId = generateId()
     const requestId = generateId()
-    const reqLogger = logger.withMetadata({ chatId, messageId, requestId })
+    let reqLogger = logger.withMetadata({ messageId, requestId })
 
     try {
       const workspaceAccess = await assertActiveWorkspaceAccess(workspaceId, userId)
       const userPermission = workspaceAccess.permission
+
+      // A caller-supplied conversation id is a claim, not an identity: resolve
+      // it through the same owner- and workspace-scoped loader the web Chat
+      // surface uses, and refuse every id that does not resolve with the same
+      // response so the refusal carries no information about the id. Omitting
+      // the id mints a server-issued conversation instead of trusting one.
+      const resolvedChat = await resolveOrCreateChat({
+        ...(conversationId ? { chatId: conversationId } : {}),
+        userId,
+        workspaceId,
+        model: V2_CHAT_MODEL,
+        type: 'mothership',
+      })
+      if (conversationId && !resolvedChat.chat) {
+        return v2Error('NOT_FOUND', 'Conversation not found')
+      }
+      if (!resolvedChat.chat || !resolvedChat.chatId) {
+        reqLogger.error('Failed to start a chat conversation', { userId, workspaceId })
+        return v2Error('INTERNAL_ERROR', 'Internal server error')
+      }
+      const chatId = resolvedChat.chatId
+      reqLogger = logger.withMetadata({ chatId, messageId, requestId })
       const secretMountPolicy = normalizeSecretMountPolicy(undefined)
 
       let environmentContext: CopilotEnvironmentContext | undefined

apps/sim/lib/api/contracts/v2/chat.ts

@@ -24,8 +24,7 @@ export const v2ChatBodySchema = z.object({
     .describe('The message to send to Sim.'),
   conversationId: z
     .string()
-    .min(1, 'conversationId cannot be empty')
-    .max(128, 'conversationId cannot exceed 128 characters')
+    .uuid('conversationId must be a valid conversation id')
     .optional()
     .describe('Conversation to continue; a new one starts when omitted.'),
 })
@@ -39,7 +38,7 @@ const v2ChatTokensSchema = z.object({
 export const v2ChatResultSchema = z.object({
   content: z.string(),
   conversationId: z.string(),
-  model: z.string(),
+  model: z.string().describe('Identifier of the agent that produced the reply.'),
   tokens: v2ChatTokensSchema.optional(),
   // untyped-response: cost is a billing passthrough whose shape is owned by the copilot backend, not this contract
   cost: z.unknown().optional(),

apps/sim/lib/copilot/chat/lifecycle.test.ts

@@ -1,7 +1,7 @@
 /**
  * @vitest-environment node
  */
-import { dbChainMockFns, resetDbChainMock, workflowAuthzMockFns } from '@sim/testing'
+import { dbChainMockFns, resetDbChainMock, schemaMock, workflowAuthzMockFns } from '@sim/testing'
 import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const {
@@ -135,6 +135,54 @@ describe('lifecycle copilot chat reads (cutover to copilot_messages)', () => {
     expect(result?.messages).toEqual([userMsg])
   })
 
+  it('scopes the chat lookup to the requesting user, not the chat id alone', async () => {
+    dbChainMockFns.limit.mockResolvedValueOnce([chatRow])
+    dbChainMockFns.orderBy.mockResolvedValueOnce([])
+
+    await getAccessibleCopilotChatWithMessages(CHAT_ID, USER_ID)
+
+    const predicate = dbChainMockFns.where.mock.calls[0]?.[0] as {
+      type: string
+      conditions: unknown[]
+    }
+    expect(predicate.type).toBe('and')
+    // Three conditions exactly: dropping one silently widens the lookup, so the
+    // count is asserted alongside the membership checks.
+    expect(predicate.conditions).toHaveLength(3)
+    expect(predicate.conditions).toContainEqual({
+      type: 'eq',
+      left: schemaMock.copilotChats.userId,
+      right: USER_ID,
+    })
+    expect(predicate.conditions).toContainEqual({
+      type: 'eq',
+      left: schemaMock.copilotChats.id,
+      right: CHAT_ID,
+    })
+    expect(predicate.conditions).toContainEqual({
+      type: 'isNull',
+      column: schemaMock.copilotChats.deletedAt,
+    })
+  })
+
+  it('resolveOrCreateChat scopes its existing-chat lookup to the requesting user', async () => {
+    dbChainMockFns.limit.mockResolvedValueOnce([chatRow])
+    dbChainMockFns.orderBy.mockResolvedValueOnce([])
+
+    await resolveOrCreateChat({ chatId: CHAT_ID, userId: USER_ID, model: 'm' })
+
+    const predicate = dbChainMockFns.where.mock.calls[0]?.[0] as {
+      type: string
+      conditions: unknown[]
+    }
+    expect(predicate.conditions).toHaveLength(3)
+    expect(predicate.conditions).toContainEqual({
+      type: 'eq',
+      left: schemaMock.copilotChats.userId,
+      right: USER_ID,
+    })
+  })
+
   it('resolveOrCreateChat returns conversationHistory from the table for an existing chat', async () => {
     dbChainMockFns.limit.mockResolvedValueOnce([chatRow])
     dbChainMockFns.orderBy.mockResolvedValueOnce([{ content: userMsg }, { content: asstMsg }])

packages/sim-cli/src/commands/protocol/chat.test.ts

@@ -102,7 +102,7 @@ function written(spy: WriteSpy): string {
 
 const FINAL = {
   type: 'final',
-  data: { content: 'Hello there', conversationId: 'conv-1', model: 'mothership' },
+  data: { content: 'Hello there', conversationId: 'conv-1', model: 'sim' },
 }
 
 describe('sim chat', () => {