fix: close a credential-misdirection path this branch had opened

Making the endpoint normalizer trim handled whitespace around a value but
not a control character inside one, and the URL parser removes those from
anywhere in its input — so a value that reads as one host could resolve to
another, and the profile's key went with it. The flag and environment paths
never touch the config writer, so its guard did not cover this. The
normalizer now refuses the same character set the writer does, which also
keeps the invariant that nothing it blesses can be refused by the write
that stores it. Comparing the parsed URL back against its input was the
alternative and is wrong: the parser rewrites percent-encoding, case,
internationalized hosts and default ports, so legitimate endpoints would be
refused.

The blank-query guard tested for exactly empty, so a whitespace-only value
still reached the wire — as a real zero on a numeric filter, an explicit
false on a boolean one, and as an encoded space the server then rejected.
It now refuses any value that is blank once trimmed, while a body string
keeps its meaning, an explicit zero still sends, and a value with content
around its whitespace is passed through untouched rather than trimmed.

A graph-id conflict reported 409 on the v2 route and fell through the older
persistence wrapper as an unclassified 500. That wrapper now classifies
orchestration failures through the cause chain, which also fixes a
pre-existing case where a workflow archived between authorization and the
locked read reported 500 rather than 404.

Persisting a chat turn claimed its row by id alone, so a conversation
soft-deleted mid-turn still received the messages and was bumped back up
the list. It now requires a live row. A turn whose caller hung up after the
model had already answered persisted nothing, though the work was done and
billed; it now persists and still reports the connection as closed.

An empty workspace id from the login response was read as no workspace at
all. A published description still promised a language-tag standard the
schema does not enforce.

The test asserting that a turn is stored before the final event drained the
whole response first, so it held whichever order the code used. It now
reads the stream incrementally and fails if the write moves after the
event.

Author: waleedlatif1

apps/docs/openapi-v2-knowledge.json

@@ -6843,7 +6843,7 @@
                 "enum": ["default", "plain", "markdown", "code"]
               },
               "lang": {
-                "description": "Optional document language, as a BCP-47 tag such as `en` or `en-US`.",
+                "description": "Optional document language: hyphen-separated letter and digit subtags such as `en`, `en-US`, or `zh-Hant-TW`. Only that shape is validated, not full BCP-47 conformance.",
                 "type": "string",
                 "maxLength": 35,
                 "pattern": "^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$"

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

@@ -3,6 +3,8 @@
  */
 
 import { createMockRequest } from '@sim/testing'
+import { sleep } from '@sim/utils/helpers'
+import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const {
@@ -130,6 +132,9 @@ const personalAuth = {
 const SERVER_ISSUED_CHAT_ID = 'chat-server-1'
 const OWNED_CONVERSATION_ID = '11111111-1111-4111-8111-111111111111'
 
+/** How long a stream read may stay pending before it counts as "nothing more yet". */
+const IDLE_STREAM_MS = 20
+
 function chatRow(id: string) {
   return { id, userId: 'user-1', workspaceId: 'workspace-1', workflowId: null, type: 'mothership' }
 }
@@ -148,6 +153,79 @@ function callChat(body: Record<string, unknown>, headers: Record<string, string>
   return POST(req, { params: Promise.resolve({}) })
 }
 
+/**
+ * Same call, but over a request whose signal the test controls — the only way
+ * to reproduce a caller that hangs up while the turn is still running.
+ */
+function callChatWithSignal(
+  body: Record<string, unknown>,
+  signal: AbortSignal,
+  headers: Record<string, string> = {}
+) {
+  const req = new NextRequest(new URL('http://localhost:3000/api/v2/chat'), {
+    method: 'POST',
+    headers: new Headers({
+      'Content-Type': 'application/json',
+      'X-API-Key': 'test-key',
+      ...headers,
+    }),
+    body: JSON.stringify(body),
+    signal,
+  })
+  return POST(req, { params: Promise.resolve({}) })
+}
+
+/**
+ * Read an NDJSON response incrementally. `drain()` returns the events that have
+ * already reached the caller and stops as soon as the producer goes quiet;
+ * `rest()` reads to the end. A pending read is held across calls so no chunk is
+ * dropped between the two.
+ */
+function readNdjsonStream(response: Response) {
+  const reader = response.body!.getReader()
+  const decoder = new TextDecoder()
+  let buffered = ''
+  let pending: Promise<ReadableStreamReadResult<Uint8Array>> | null = null
+
+  const parse = (): Array<Record<string, unknown>> => {
+    const lines = buffered.split('\n')
+    buffered = lines.pop() ?? ''
+    return lines.filter((line) => line.trim().length > 0).map((line) => JSON.parse(line))
+  }
+
+  const step = async (): Promise<'idle' | 'done' | 'chunk'> => {
+    pending ??= reader.read()
+    const settled = await Promise.race([
+      pending.then((result) => ({ result })),
+      sleep(IDLE_STREAM_MS).then(() => null),
+    ])
+    if (!settled) return 'idle'
+    pending = null
+    if (settled.result.done) return 'done'
+    buffered += decoder.decode(settled.result.value, { stream: true })
+    return 'chunk'
+  }
+
+  return {
+    async drain() {
+      const events: Array<Record<string, unknown>> = []
+      for (;;) {
+        const state = await step()
+        events.push(...parse())
+        if (state !== 'chunk') return events
+      }
+    },
+    async rest() {
+      const events: Array<Record<string, unknown>> = []
+      for (;;) {
+        const state = await step()
+        events.push(...parse())
+        if (state === 'done') return events
+      }
+    },
+  }
+}
+
 async function readNdjsonEvents(response: Response): Promise<Array<Record<string, unknown>>> {
   const raw = await response.text()
   return raw
@@ -484,16 +562,96 @@ describe('POST /api/v2/chat', () => {
     ])
   })
 
-  it('persists the turn on the NDJSON path too, before the final event', async () => {
+  it('persists the turn on the NDJSON path before the final event reaches the caller', async () => {
+    // Hold the transcript write open and watch the wire: draining the whole
+    // response first would pass just as happily with the write moved after the
+    // final event, so the write is gated and the stream read incrementally.
+    let persistEntered: () => void = () => {}
+    const persistInFlight = new Promise<void>((resolve) => {
+      persistEntered = resolve
+    })
+    let releasePersist: () => void = () => {}
+    mockPersistCopilotChatTurn.mockImplementation(() => {
+      persistEntered()
+      return new Promise<void>((resolve) => {
+        releasePersist = resolve
+      })
+    })
+
     const response = await callChat(
       { workspaceId: 'workspace-1', message: 'hi' },
       { accept: 'application/x-ndjson' }
     )
-    const events = await readNdjsonEvents(response)
+    const stream = readNdjsonStream(response)
+
+    await persistInFlight
+    const beforeRelease = await stream.drain()
+    expect(beforeRelease.map((event) => event.type)).not.toContain('final')
+
+    releasePersist()
+    const afterRelease = await stream.rest()
+    expect(afterRelease.at(-1)?.type).toBe('final')
 
     expect(mockPersistCopilotChatTurn).toHaveBeenCalledTimes(1)
     expect(mockPersistCopilotChatTurn.mock.calls[0][1]).toHaveLength(2)
-    expect(events.at(-1)?.type).toBe('final')
+  })
+
+  it('persists a completed turn whose caller hung up, and still reports it as client-closed', async () => {
+    const controller = new AbortController()
+    mockRunHeadlessCopilotLifecycle.mockImplementation(async () => {
+      controller.abort()
+      return successResult
+    })
+
+    const response = await callChatWithSignal(
+      { workspaceId: 'workspace-1', message: 'hi' },
+      controller.signal
+    )
+
+    // The model already ran and was billed, so the reply is written to the
+    // conversation it belongs to — but the caller is gone, and the status the
+    // route reports says exactly that.
+    expect(response.status).toBe(499)
+    const body = await response.json()
+    expect(body.error.code).toBe('CLIENT_CLOSED_REQUEST')
+    expect(mockPersistCopilotChatTurn).toHaveBeenCalledTimes(1)
+    expect(mockPersistCopilotChatTurn.mock.calls[0][0]).toBe(SERVER_ISSUED_CHAT_ID)
+  })
+
+  it('persists a completed turn whose NDJSON caller hung up, and still ends in an abort event', async () => {
+    const controller = new AbortController()
+    mockRunHeadlessCopilotLifecycle.mockImplementation(async () => {
+      controller.abort()
+      return successResult
+    })
+
+    const response = await callChatWithSignal(
+      { workspaceId: 'workspace-1', message: 'hi' },
+      controller.signal,
+      { accept: 'application/x-ndjson' }
+    )
+    const events = await readNdjsonEvents(response)
+
+    const last = events.at(-1) as { type: string; error?: string }
+    expect(last.type).toBe('error')
+    expect(last.error).toBe('Chat request aborted')
+    expect(mockPersistCopilotChatTurn).toHaveBeenCalledTimes(1)
+  })
+
+  it('persists nothing for a failed run whose caller hung up', async () => {
+    const controller = new AbortController()
+    mockRunHeadlessCopilotLifecycle.mockImplementation(async () => {
+      controller.abort()
+      return { success: false, error: 'model exploded' }
+    })
+
+    const response = await callChatWithSignal(
+      { workspaceId: 'workspace-1', message: 'hi' },
+      controller.signal
+    )
+
+    expect(response.status).toBe(499)
+    expect(mockPersistCopilotChatTurn).not.toHaveBeenCalled()
   })
 
   it('persists nothing when the run fails, so no question is stored without its answer', async () => {

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

@@ -198,11 +198,10 @@ export const POST = withRouteHandler(
        * resolved. Without it a `sim chat` turn leaves a titled conversation
        * that opens to an empty transcript in the web Chat list.
        *
-       * By the time this runs the turn has completed and been billed, and a
-       * streamed reply has already reached the caller, so a write failure is
-       * logged and the successful response still stands. The write is one
-       * transaction, so that failure leaves the transcript empty rather than
-       * showing the question without the answer.
+       * By the time this runs the turn has completed and been billed, so a
+       * write failure is logged and the response the caller gets is unchanged.
+       * The write is one transaction, so that failure leaves the transcript
+       * empty rather than showing the question without the answer.
        */
       const persistTurn = async (result: OrchestratorResult): Promise<void> => {
         try {
@@ -355,6 +354,13 @@ export const POST = withRouteHandler(
                 })
                 allowExplicitAbort = false
 
+                // Persist before the cancellation check: the turn ran and was
+                // billed, so the reply belongs in the transcript even when the
+                // caller stopped listening — that is the only place it survives.
+                if (result.success) {
+                  await persistTurn(result)
+                }
+
                 if (lifecycleAbortController.signal.aborted) {
                   send({ type: 'error', error: 'Chat request aborted' })
                   return
@@ -373,8 +379,6 @@ export const POST = withRouteHandler(
                   return
                 }
 
-                await persistTurn(result)
-
                 send({
                   type: 'final',
                   data: buildChatResultPayload(result, chatId, integrationTools),
@@ -428,6 +432,14 @@ export const POST = withRouteHandler(
         const result = await runLifecycle()
         allowExplicitAbort = false
 
+        // Persist before the cancellation check: the turn ran and was billed,
+        // so the reply belongs in the transcript even when the caller stopped
+        // listening — that is the only place it survives. The cancellation
+        // check still decides the status the caller receives.
+        if (result.success) {
+          await persistTurn(result)
+        }
+
         if (lifecycleAbortController.signal.aborted || req.signal.aborted) {
           reqLogger.info('Chat request aborted after lifecycle completion')
           return v2Error('CLIENT_CLOSED_REQUEST', 'Chat request aborted')
@@ -438,8 +450,6 @@ export const POST = withRouteHandler(
           return v2Error('INTERNAL_ERROR', result.error || 'Chat request failed')
         }
 
-        await persistTurn(result)
-
         return v2Data(buildChatResultPayload(result, chatId, integrationTools))
       } finally {
         allowExplicitAbort = false

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

@@ -490,7 +490,7 @@ const v2KnowledgeDocumentProcessingOptionsSchema =
       lang: knowledgeDocumentUploadMetadataSchema.shape.processingOptions
         .unwrap()
         .shape.lang.describe(
-          'Optional document language, as a BCP-47 tag such as `en` or `en-US`.'
+          'Optional document language: hyphen-separated letter and digit subtags such as `en`, `en-US`, or `zh-Hant-TW`. Only that shape is validated, not full BCP-47 conformance.'
         ),
     })
     .strict()

apps/sim/lib/copilot/chat/messages-store.test.ts

@@ -1,10 +1,11 @@
 /**
  * @vitest-environment node
  */
-import { dbChainMockFns, resetDbChainMock } from '@sim/testing'
+import { dbChainMockFns, resetDbChainMock, schemaMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import {
   appendCopilotChatMessages,
+  persistCopilotChatTurn,
   replaceCopilotChatMessages,
 } from '@/lib/copilot/chat/messages-store'
 import type { PersistedMessage } from '@/lib/copilot/chat/persisted-message'
@@ -231,4 +232,41 @@ describe('messages-store', () => {
       expect(JSON.stringify(lastValuesRows())).not.toContain('huge')
     })
   })
+
+  describe('persistCopilotChatTurn', () => {
+    it('claims the chat row by id AND liveness, so a soft-deleted chat matches nothing', async () => {
+      dbChainMockFns.returning.mockResolvedValueOnce([{ model: 'claude-sonnet-4-5' }])
+
+      await persistCopilotChatTurn('chat-1', [userMsg, assistantMsg])
+
+      // The chain mock ignores predicates, so the predicate itself is the
+      // assertion: without the liveness term the update still matches an
+      // archived row and the turn lands in a conversation the user deleted.
+      expect(dbChainMockFns.where).toHaveBeenCalledWith({
+        type: 'and',
+        conditions: [
+          { type: 'eq', left: schemaMock.copilotChats.id, right: 'chat-1' },
+          { type: 'isNull', column: schemaMock.copilotChats.deletedAt },
+        ],
+      })
+    })
+
+    it('writes the transcript with the chat model when the row is still live', async () => {
+      dbChainMockFns.returning.mockResolvedValueOnce([{ model: 'claude-sonnet-4-5' }])
+
+      await persistCopilotChatTurn('chat-1', [userMsg, assistantMsg])
+
+      const rows = lastValuesRows()
+      expect(rows.map((r) => r.messageId)).toEqual(['msg-user-1', 'msg-asst-1'])
+      expect(rows[0].model).toBe('claude-sonnet-4-5')
+    })
+
+    it('writes nothing when the claim matches no row', async () => {
+      dbChainMockFns.returning.mockResolvedValueOnce([])
+
+      await persistCopilotChatTurn('chat-1', [userMsg, assistantMsg])
+
+      expect(dbChainMockFns.insert).not.toHaveBeenCalled()
+    })
+  })
 })

apps/sim/lib/copilot/chat/messages-store.ts

@@ -1,6 +1,6 @@
 import { db } from '@sim/db'
 import { copilotChats, copilotMessages } from '@sim/db/schema'
-import { and, eq, notInArray, sql } from 'drizzle-orm'
+import { and, eq, isNull, notInArray, sql } from 'drizzle-orm'
 import { type PersistedMessage, stripToolResultOutput } from '@/lib/copilot/chat/persisted-message'
 import type { DbOrTx } from '@/lib/db/types'
 
@@ -87,8 +87,15 @@ export async function appendCopilotChatMessages(
  * turn run without that surface would leave a chat that opens to nothing.
  *
  * Both messages are written in a single transaction, so a failure leaves the
- * transcript untouched rather than showing a question with no answer. Does
- * nothing when the chat no longer exists; throws on a write failure.
+ * transcript untouched rather than showing a question with no answer.
+ *
+ * The chat row is claimed under the same liveness predicate the accessible-chat
+ * loaders use, so a chat soft-deleted while the turn was running receives
+ * nothing: the update matches no row and the transaction returns having written
+ * neither the transcript nor the recency bump. Dropping the turn is right here
+ * because the user deleted the conversation after asking — resurrecting it with
+ * a reply would undo that deletion, and the caller still has its reply in the
+ * response. Throws on a write failure.
  */
 export async function persistCopilotChatTurn(
   chatId: string,
@@ -98,7 +105,7 @@ export async function persistCopilotChatTurn(
     const [updated] = await tx
       .update(copilotChats)
       .set({ updatedAt: new Date() })
-      .where(eq(copilotChats.id, chatId))
+      .where(and(eq(copilotChats.id, chatId), isNull(copilotChats.deletedAt)))
       .returning({ model: copilotChats.model })
     if (!updated) return
     await appendCopilotChatMessages(chatId, messages, { chatModel: updated.model ?? null }, tx)