@lota-sdk/core 0.3.0 → 0.3.2

package/infrastructure/schema/00_thread.surql

@@ -1,75 +1,73 @@
-DEFINE TABLE thread SCHEMAFULL;
+DEFINE TABLE IF NOT EXISTS thread SCHEMAFULL;
 
-DEFINE FIELD organizationId ON thread TYPE record<organization>;
-DEFINE FIELD userId         ON thread TYPE record<user>;
-DEFINE FIELD type           ON thread TYPE string
+DEFINE FIELD IF NOT EXISTS organizationId ON thread TYPE record<organization>;
+DEFINE FIELD IF NOT EXISTS userId         ON thread TYPE record<user>;
+DEFINE FIELD IF NOT EXISTS type           ON thread TYPE string
   ASSERT $value IN ['default', 'topic', 'thread', 'group']
   DEFAULT 'group';
-DEFINE FIELD agentId        ON thread TYPE option<string>;
-DEFINE FIELD threadType ON thread TYPE option<string>;
-DEFINE FIELD members        ON thread TYPE option<array<string>> DEFAULT [];
-DEFINE FIELD title          ON thread TYPE option<string>;
-DEFINE FIELD nameGenerated  ON thread TYPE bool DEFAULT false;
-DEFINE FIELD status         ON thread TYPE string
+DEFINE FIELD IF NOT EXISTS agentId        ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS threadType ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS members        ON thread TYPE option<array<string>> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS title          ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS nameGenerated  ON thread TYPE bool DEFAULT false;
+DEFINE FIELD IF NOT EXISTS status         ON thread TYPE string
   ASSERT $value IN ['active', 'archived']
   DEFAULT 'active';
-DEFINE FIELD activeRunId           ON thread TYPE option<string>;
-DEFINE FIELD activeStreamId        ON thread TYPE option<string>;
-DEFINE FIELD memoryBlock           ON thread TYPE option<string>;
-DEFINE FIELD memoryBlockSummary    ON thread TYPE option<string>;
-DEFINE FIELD compactionSummary     ON thread TYPE option<string>;
-DEFINE FIELD lastCompactedMessageId ON thread TYPE option<string>;
-DEFINE FIELD isCompacting          ON thread TYPE bool DEFAULT false;
-DEFINE FIELD turnCount             ON thread TYPE int DEFAULT 0;
-DEFINE FIELD createdAt ON thread TYPE datetime DEFAULT time::now();
-DEFINE FIELD updatedAt ON thread TYPE datetime DEFAULT time::now() VALUE time::now();
+DEFINE FIELD IF NOT EXISTS activeRunId            ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS activeStreamId         ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS memoryBlock            ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS memoryBlockSummary     ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS compactionSummary      ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS lastCompactedMessageId ON thread TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS isCompacting           ON thread TYPE bool DEFAULT false;
+DEFINE FIELD IF NOT EXISTS turnCount              ON thread TYPE int DEFAULT 0;
+DEFINE FIELD IF NOT EXISTS createdAt ON thread TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON thread TYPE datetime DEFAULT time::now() VALUE time::now();
 
-DEFINE INDEX threadDefaultUniqueIdx ON thread
-  FIELDS userId, organizationId, agentId
-  WHERE type = 'default' UNIQUE;
+DEFINE INDEX IF NOT EXISTS threadDefaultLookupIdx ON thread
+  FIELDS type, userId, organizationId, agentId UNIQUE;
 
-DEFINE INDEX threadThreadUniqueIdx ON thread
-  FIELDS userId, organizationId, threadType
-  WHERE type = 'thread' UNIQUE;
+DEFINE INDEX IF NOT EXISTS threadThreadLookupIdx ON thread
+  FIELDS type, userId, organizationId, threadType UNIQUE;
 
-DEFINE INDEX threadOrgIdx ON thread FIELDS organizationId;
-DEFINE INDEX threadUserIdx ON thread FIELDS userId;
-DEFINE INDEX threadUserOrgTypeUpdatedIdx ON thread
+DEFINE INDEX IF NOT EXISTS threadOrgIdx ON thread FIELDS organizationId;
+DEFINE INDEX IF NOT EXISTS threadUserIdx ON thread FIELDS userId;
+DEFINE INDEX IF NOT EXISTS threadUserOrgTypeUpdatedIdx ON thread
   FIELDS userId, organizationId, type, updatedAt;
-DEFINE INDEX threadUserOrgStatusTypeUpdatedIdx ON thread
+DEFINE INDEX IF NOT EXISTS threadUserOrgStatusTypeUpdatedIdx ON thread
   FIELDS userId, organizationId, status, type, updatedAt;
 
 # Thread Message table (AI SDK UIMessage persistence).
 # parts uses OVERWRITE on the wildcard to override the implicit non-FLEXIBLE
 # definition that array<object> creates — this is the only way to allow
 # arbitrary nested object shapes inside the array on SCHEMAFULL tables.
-DEFINE TABLE threadMessage SCHEMAFULL;
-DEFINE FIELD threadId ON TABLE threadMessage TYPE record<thread> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD messageId ON TABLE threadMessage TYPE string;
-DEFINE FIELD role ON TABLE threadMessage TYPE string;
-DEFINE FIELD parts ON TABLE threadMessage TYPE array<object> FLEXIBLE;
+DEFINE TABLE IF NOT EXISTS threadMessage SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS threadId ON TABLE threadMessage TYPE record<thread> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS messageId ON TABLE threadMessage TYPE string;
+DEFINE FIELD IF NOT EXISTS role ON TABLE threadMessage TYPE string;
+DEFINE FIELD IF NOT EXISTS parts ON TABLE threadMessage TYPE array<object> FLEXIBLE;
 DEFINE FIELD OVERWRITE parts.* ON TABLE threadMessage TYPE object FLEXIBLE;
-DEFINE FIELD metadata ON TABLE threadMessage TYPE option<object> FLEXIBLE;
-DEFINE FIELD createdAt ON TABLE threadMessage TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD updatedAt ON TABLE threadMessage TYPE datetime VALUE time::now();
+DEFINE FIELD IF NOT EXISTS metadata ON TABLE threadMessage TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE threadMessage TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE threadMessage TYPE datetime VALUE time::now();
 
-DEFINE INDEX threadMessageThreadIdx ON TABLE threadMessage COLUMNS threadId;
-DEFINE INDEX threadMessageThreadCreatedIdx ON TABLE threadMessage COLUMNS threadId, createdAt;
-DEFINE INDEX threadMessageThreadMessageUniqueIdx ON TABLE threadMessage COLUMNS threadId, messageId UNIQUE;
+DEFINE INDEX IF NOT EXISTS threadMessageThreadIdx ON TABLE threadMessage COLUMNS threadId;
+DEFINE INDEX IF NOT EXISTS threadMessageThreadCreatedIdx ON TABLE threadMessage COLUMNS threadId, createdAt;
+DEFINE INDEX IF NOT EXISTS threadMessageThreadMessageUniqueIdx ON TABLE threadMessage COLUMNS threadId, messageId UNIQUE;
 
 # Thread attachments.
-DEFINE TABLE threadAttachment SCHEMAFULL;
-DEFINE FIELD threadId ON TABLE threadAttachment TYPE record<thread> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD messageId ON TABLE threadAttachment TYPE record<threadMessage> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD attachmentType ON TABLE threadAttachment TYPE string;
-DEFINE FIELD name ON TABLE threadAttachment TYPE string;
-DEFINE FIELD contentType ON TABLE threadAttachment TYPE string;
-DEFINE FIELD storageKey ON TABLE threadAttachment TYPE option<string>;
-DEFINE FIELD sizeBytes ON TABLE threadAttachment TYPE option<int>;
-DEFINE FIELD url ON TABLE threadAttachment TYPE option<string>;
-DEFINE FIELD createdAt ON TABLE threadAttachment TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD updatedAt ON TABLE threadAttachment TYPE datetime VALUE time::now();
+DEFINE TABLE IF NOT EXISTS threadAttachment SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS threadId ON TABLE threadAttachment TYPE record<thread> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS messageId ON TABLE threadAttachment TYPE record<threadMessage> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS attachmentType ON TABLE threadAttachment TYPE string;
+DEFINE FIELD IF NOT EXISTS name ON TABLE threadAttachment TYPE string;
+DEFINE FIELD IF NOT EXISTS contentType ON TABLE threadAttachment TYPE string;
+DEFINE FIELD IF NOT EXISTS storageKey ON TABLE threadAttachment TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS sizeBytes ON TABLE threadAttachment TYPE option<int>;
+DEFINE FIELD IF NOT EXISTS url ON TABLE threadAttachment TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE threadAttachment TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE threadAttachment TYPE datetime VALUE time::now();
 
-DEFINE INDEX threadAttachmentThreadIdx ON TABLE threadAttachment COLUMNS threadId;
-DEFINE INDEX threadAttachmentMessageIdx ON TABLE threadAttachment COLUMNS messageId;
-DEFINE INDEX threadAttachmentThreadMessageIdx ON TABLE threadAttachment COLUMNS threadId, messageId;
+DEFINE INDEX IF NOT EXISTS threadAttachmentThreadIdx ON TABLE threadAttachment COLUMNS threadId;
+DEFINE INDEX IF NOT EXISTS threadAttachmentMessageIdx ON TABLE threadAttachment COLUMNS messageId;
+DEFINE INDEX IF NOT EXISTS threadAttachmentThreadMessageIdx ON TABLE threadAttachment COLUMNS threadId, messageId;

package/infrastructure/schema/04_runtime_bootstrap.surql

@@ -2,6 +2,7 @@
 DEFINE TABLE IF NOT EXISTS runtimeBootstrap SCHEMAFULL;
 DEFINE FIELD IF NOT EXISTS key ON TABLE runtimeBootstrap TYPE string;
 DEFINE FIELD IF NOT EXISTS schemaFingerprint ON TABLE runtimeBootstrap TYPE string;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE runtimeBootstrap TYPE datetime DEFAULT time::now() READONLY;
 DEFINE FIELD IF NOT EXISTS readyAt ON TABLE runtimeBootstrap TYPE datetime;
 DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE runtimeBootstrap TYPE datetime VALUE time::now();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,7 +32,7 @@
     "@chat-adapter/slack": "^4.23.0",
     "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.3.0",
+    "@lota-sdk/shared": "0.3.2",
     "@mendable/firecrawl-js": "^4.18.1",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.145",

package/src/create-runtime.ts

@@ -90,7 +90,7 @@ type ArchiveSdkThread = (
 
 type UnarchiveSdkThread = (
   threadId: Parameters<typeof threadServiceSingleton.updateStatus>[0],
-  status?: 'regular',
+  status?: 'active',
 ) => ReturnType<typeof threadServiceSingleton.updateStatus>
 
 let activeRuntimeToken: symbol | null = null
@@ -317,7 +317,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         get: threadServiceSingleton.getThread.bind(threadServiceSingleton),
         update: threadServiceSingleton.updateTitle.bind(threadServiceSingleton),
         archive: async (threadId, status = 'archived') => await threadServiceSingleton.updateStatus(threadId, status),
-        unarchive: async (threadId, status = 'regular') => await threadServiceSingleton.updateStatus(threadId, status),
+        unarchive: async (threadId, status = 'active') => await threadServiceSingleton.updateStatus(threadId, status),
         delete: threadServiceSingleton.deleteThread.bind(threadServiceSingleton),
         stop: threadServiceSingleton.stopActiveRun.bind(threadServiceSingleton),
         listMessages: threadMessageServiceSingleton.listMessageHistoryPage.bind(threadMessageServiceSingleton),

package/src/db/record-id.ts

@@ -8,13 +8,18 @@ export interface RecordIdShape {
   id: RecordIdValue
 }
 
-export interface StringableRecordId {
+export type RecordIdInput = string | RecordId | StringRecordId | RecordIdShape
+export type RecordIdRef = RecordIdInput
+
+const SURREAL_RECORD_ID_CLASS_NAMES = new Set(['RecordId', 'StringRecordId'])
+
+interface SurrealRecordIdLike {
   toString(): string
 }
 
-export type RecordIdInput = string | RecordId | StringRecordId | RecordIdShape | StringableRecordId
-
-export type RecordIdRef = RecordIdInput
+interface NamedConstructor {
+  name?: unknown
+}
 
 class InvalidRecordIdError extends BadRequestError {
   constructor(message: string) {
@@ -23,18 +28,18 @@ class InvalidRecordIdError extends BadRequestError {
   }
 }
 
-export function readCustomStringValue(value: object): string | null {
-  const toStringValue: unknown = Reflect.get(value, 'toString')
-  if (typeof toStringValue !== 'function' || toStringValue === Object.prototype.toString) {
-    return null
+export function isSurrealRecordIdValue(value: unknown): boolean {
+  if (!value || typeof value !== 'object') {
+    return false
   }
 
-  const stringValue = Reflect.apply(toStringValue as (this: object) => unknown, value, [])
-  if (typeof stringValue !== 'string' || stringValue.length === 0) {
-    return null
+  const constructor = (value as { constructor?: unknown }).constructor
+  if (typeof constructor !== 'function') {
+    return false
   }
 
-  return stringValue
+  const constructorName = (constructor as NamedConstructor).name
+  return typeof constructorName === 'string' && SURREAL_RECORD_ID_CLASS_NAMES.has(constructorName)
 }
 
 export function ensureRecordId(value: RecordIdInput, fallbackTable?: string): RecordId {
@@ -42,8 +47,8 @@ export function ensureRecordId(value: RecordIdInput, fallbackTable?: string): Re
     return value
   }
 
-  if (value instanceof StringRecordId) {
-    return ensureRecordId(value.toString(), fallbackTable)
+  if (value instanceof StringRecordId || isSurrealRecordIdValue(value)) {
+    return ensureRecordId((value as SurrealRecordIdLike).toString(), fallbackTable)
   }
 
   if (typeof value === 'string') {
@@ -58,16 +63,11 @@ export function ensureRecordId(value: RecordIdInput, fallbackTable?: string): Re
     return new RecordId(fallbackTable, value)
   }
 
-  if (typeof value === 'object') {
+  if (typeof value === 'object' && Object.keys(value).length === 2) {
     const record = value as { tb?: string; id?: RecordIdValue }
-    if (record.tb && record.id !== undefined) {
+    if (typeof record.tb === 'string' && record.id !== undefined) {
       return new RecordId(record.tb, record.id)
     }
-
-    const stringValue = readCustomStringValue(value)
-    if (stringValue && stringValue !== '[object Object]') {
-      return ensureRecordId(stringValue, fallbackTable)
-    }
   }
 
   throw new InvalidRecordIdError('Invalid record id value')

package/src/db/service.ts

@@ -16,7 +16,7 @@ import { serverLogger } from '../config/logger'
 import { withTimeout } from '../utils/async'
 import { isRecord } from '../utils/string'
 import type { RecordIdInput } from './record-id'
-import { ensureRecordId, readCustomStringValue } from './record-id'
+import { ensureRecordId, isSurrealRecordIdValue } from './record-id'
 import type { DatabaseTable } from './tables'
 
 export class SurrealDBError extends Error {
@@ -103,19 +103,6 @@ function isBoundQueryLike(value: unknown): value is BoundQueryLike {
   return value.bindings === undefined || isRecord(value.bindings)
 }
 
-function toStringLikeValue(value: unknown): string | null {
-  if (!value || typeof value !== 'object') {
-    return null
-  }
-
-  const stringValue = readCustomStringValue(value)
-  if (typeof stringValue !== 'string' || stringValue.length === 0 || stringValue === '[object Object]') {
-    return null
-  }
-
-  return stringValue
-}
-
 const CONNECT_MAX_ATTEMPTS = 5
 const CONNECT_RETRY_BASE_DELAY_MS = 100
 const CONNECT_RETRY_JITTER_MS = 50
@@ -353,6 +340,10 @@ export class SurrealDBService {
       return value.map((entry) => this.normalizeParseValue(entry))
     }
 
+    if (isSurrealRecordIdValue(value)) {
+      return ensureRecordId(value as RecordIdInput)
+    }
+
     if (!isRecord(value)) {
       return value
     }
@@ -413,10 +404,6 @@ export class SurrealDBService {
     return new BoundQuery(query.query, this.normalizeBindings(query.bindings))
   }
 
-  private isSerializedRecordId(value: string): boolean {
-    return /^[a-zA-Z][a-zA-Z0-9_]*:(?:⟨.+⟩|.+)$/.test(value)
-  }
-
   private normalizeRuntimeValue(value: unknown): unknown {
     if (value === null || value === undefined) {
       return value
@@ -435,17 +422,16 @@ export class SurrealDBService {
       return value.map((entry) => this.normalizeRuntimeValue(entry))
     }
 
+    if (isSurrealRecordIdValue(value)) {
+      return ensureRecordId(value as RecordIdInput)
+    }
+
     if (!isRecord(value)) {
       return value
     }
 
     if ('tb' in value && 'id' in value && Object.keys(value).length === 2) {
-      return ensureRecordId(value as RecordIdInput)
-    }
-
-    const stringValue = toStringLikeValue(value)
-    if (stringValue && this.isSerializedRecordId(stringValue)) {
-      return ensureRecordId(stringValue)
+      return ensureRecordId(value as unknown as RecordIdInput)
     }
 
     const entries = Object.entries(value)
@@ -467,17 +453,23 @@ export class SurrealDBService {
   }
 
   private normalizeMutationFieldValue(value: unknown): unknown {
-    if (value === null || value === undefined) {
+    if (value === undefined) {
       return undefined
     }
 
+    if (value === null) {
+      return null
+    }
+
     return this.normalizeRuntimeValue(value)
   }
 
   // Cast is safe: normalizeRuntimeValue preserves Record shape when input is a Record
   private normalizeMutationData(data: Record<string, unknown>): Record<string, unknown> {
     return Object.fromEntries(
-      Object.entries(data).map(([key, value]) => [key, this.normalizeMutationFieldValue(value)]),
+      Object.entries(data)
+        .map(([key, value]) => [key, this.normalizeMutationFieldValue(value)] as const)
+        .filter((entry): entry is readonly [string, unknown] => entry[1] !== undefined),
     ) as Record<string, unknown>
   }
 
@@ -490,11 +482,6 @@ export class SurrealDBService {
       return new Table(value)
     }
 
-    const stringValue = toStringLikeValue(value)
-    if (stringValue) {
-      return new Table(stringValue)
-    }
-
     throw new SurrealDBError('Invalid table value')
   }
 
@@ -503,20 +490,17 @@ export class SurrealDBService {
       return true
     }
 
+    if (isSurrealRecordIdValue(value)) {
+      return true
+    }
+
     if (typeof value === 'string') {
       return /^[a-zA-Z][a-zA-Z0-9_]*:/.test(value)
     }
 
     if (value && typeof value === 'object') {
       const record = value as { tb?: unknown; id?: unknown }
-      if (typeof record.tb === 'string' && record.id !== undefined && Object.keys(value).length === 2) {
-        return true
-      }
-
-      const stringValue = toStringLikeValue(value)
-      if (stringValue) {
-        return /^[a-zA-Z][a-zA-Z0-9_]*:/.test(stringValue)
-      }
+      return typeof record.tb === 'string' && record.id !== undefined && Object.keys(value).length === 2
     }
 
     return false
@@ -689,7 +673,11 @@ export class SurrealDBService {
       for (const key of filterKeys) {
         this.assertValidIdentifier(key, 'filter field')
       }
-      const orderDir = options?.orderDir ?? 'ASC'
+      const rawOrderDir: unknown = options?.orderDir
+      if (rawOrderDir !== undefined && rawOrderDir !== 'ASC' && rawOrderDir !== 'DESC') {
+        throw new SurrealDBError(`Invalid orderDir value: ${this.describeInvalidValue(rawOrderDir)}`)
+      }
+      const orderDir = rawOrderDir ?? 'ASC'
       const limit = options?.limit
       const offset = options?.offset
       const vars: Record<string, unknown> = this.normalizeMutationData(filter)
@@ -730,6 +718,22 @@ export class SurrealDBService {
     }
   }
 
+  private describeInvalidValue(value: unknown): string {
+    if (typeof value === 'string') {
+      return value
+    }
+
+    try {
+      const serialized = JSON.stringify(value)
+      if (typeof serialized === 'string') {
+        return serialized
+      }
+      return Object.prototype.toString.call(value)
+    } catch {
+      return Object.prototype.toString.call(value)
+    }
+  }
+
   async create<T extends z.ZodTypeAny>(
     table: DatabaseTable,
     data: Record<string, unknown>,

package/src/runtime/runtime-config.ts

@@ -151,17 +151,20 @@ const threadBootstrapWelcomeConfigSchema = z.object({
   }),
 })
 
-const threadConfigSchema = z.object({
-  bootstrap: z
-    .object({
-      onboardingDirectAgents: z.array(z.string().trim().min(1)).optional(),
-      completedDirectAgents: z.array(z.string().trim().min(1)).optional(),
-      coreTypesAfterOnboarding: z.array(z.string().trim().min(1)).optional(),
-      ensureDefaultGroupOnCompleted: z.boolean().optional(),
-      onboardingWelcome: threadBootstrapWelcomeConfigSchema.optional(),
-    })
-    .optional(),
-})
+const threadConfigSchema = z
+  .object({
+    bootstrap: z
+      .object({
+        onboardingDefaultAgents: z.array(z.string().trim().min(1)).optional(),
+        completedDefaultAgents: z.array(z.string().trim().min(1)).optional(),
+        threadTypesAfterOnboarding: z.array(z.string().trim().min(1)).optional(),
+        ensureDefaultGroupOnCompleted: z.boolean().optional(),
+        onboardingWelcome: threadBootstrapWelcomeConfigSchema.optional(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict()
 
 const agentsConfigSchema = z
   .object({

package/src/services/plan-executor.service.ts

@@ -21,7 +21,7 @@ import {
   STRUCTURAL_NODE_TYPES as STRUCTURAL_NODE_TYPE_VALUES,
   PlanValidationIssueSchema,
 } from '@lota-sdk/shared'
-import { RecordId } from 'surrealdb'
+import { RecordId, StringRecordId } from 'surrealdb'
 
 import { aiLogger } from '../config/logger'
 import type { RecordIdInput } from '../db/record-id'
@@ -1865,7 +1865,14 @@ class PlanExecutorService {
     run: PlanRunRecord,
     checkpoint: RecordIdInput | { id: RecordIdInput },
   ) {
-    const checkpointId = checkpoint && typeof checkpoint === 'object' && 'id' in checkpoint ? checkpoint.id : checkpoint
+    const checkpointId =
+      checkpoint &&
+      typeof checkpoint === 'object' &&
+      !(checkpoint instanceof RecordId) &&
+      !(checkpoint instanceof StringRecordId) &&
+      'id' in checkpoint
+        ? (checkpoint as { id: RecordIdInput }).id
+        : checkpoint
 
     await tx
       .update(ensureRecordId(run.id, TABLES.PLAN_RUN))

package/src/services/thread-turn-preparation.service.ts

@@ -122,12 +122,13 @@ function writeMultiAgentEvent(
 ): void {
   if (!writer) return
 
-  writer.write({
+  const chunk: ChatStreamChunk = {
     type: 'data-multi-agent-event',
     id: `multi-agent-${Bun.randomUUIDv7()}`,
     data: event,
     transient: true,
-  } as unknown as ChatStreamChunk)
+  }
+  writer.write(chunk)
 }
 
 function applyPlanTurnToolPolicy(tools: ToolSet, nodeSpec: PlanNodeSpecRecord): ToolSet {
@@ -342,32 +343,20 @@ async function streamAgentResponse(
   const agentAbortSignal = streamParams.abortSignal ?? ctx.runAbortSignal
   agentTimer.step('agent-construction')
 
-  const MAX_STREAM_RETRIES = 3
   let result: unknown
-  for (let attempt = 0; ; attempt++) {
-    try {
-      result = await streamParams.observer.run(() =>
-        agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
-      )
-      agentTimer.step('agent.stream()-resolved')
-      break
-    } catch (error) {
-      if (agentAbortSignal.aborted) {
-        streamParams.observer.recordAbort(error)
-        throw error
-      }
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      const isTransient =
-        errorMessage.includes('client disconnected') ||
-        errorMessage.includes('ECONNRESET') ||
-        errorMessage.includes('socket hang up') ||
-        errorMessage.includes('fetch failed')
-      if (!isTransient || attempt >= MAX_STREAM_RETRIES - 1) {
-        streamParams.observer.recordError(error)
-        throw error
-      }
-      aiLogger.warn`Transient stream error (attempt ${attempt + 1}/${MAX_STREAM_RETRIES}): ${errorMessage} — retrying`
+  try {
+    result = await streamParams.observer.run(() =>
+      agent.stream({ messages: modelMessages, abortSignal: agentAbortSignal }),
+    )
+    agentTimer.step('agent.stream()-resolved')
+  } catch (error) {
+    if (agentAbortSignal.aborted) {
+      streamParams.observer.recordAbort(error)
+      throw error
     }
+
+    streamParams.observer.recordError(error)
+    throw error
   }
   if (!hasUIMessageStream(result)) {
     throw new Error(`Agent run for ${resolvedAgentId} did not expose a UI message stream.`)
@@ -982,7 +971,7 @@ export async function prepareThreadRunCore(params: ThreadRunCoreParams): Promise
                     phase: 'waiting-for-agent',
                     agentId: checkResult.agentId,
                     agentName: resolveRuntimeAgentDisplayName(agentIdentityOverrides, checkResult.agentId),
-                    note: checkResult.routingContext,
+                    note: checkResult.routingContext ?? undefined,
                   })
 
                   // Insert hidden bridge message between agent turns
@@ -1003,7 +992,7 @@ export async function prepareThreadRunCore(params: ThreadRunCoreParams): Promise
                   throwIfRunAborted()
 
                   lastResponse = await runGroupAgent(checkResult.agentId, {
-                    routingContext: checkResult.routingContext,
+                    routingContext: checkResult.routingContext ?? undefined,
                   })
                   respondedAgents.push(checkResult.agentId)
                   throwIfRunAborted()

package/src/services/thread.service.ts

@@ -29,6 +29,12 @@ import type { NormalizedThread, PublicThread, ThreadRecord } from './thread.type
 const THREAD_ACTIVE_RUN_LOCK_TTL_MS = 90_000
 const THREAD_ACTIVE_RUN_LOCK_MAX_WAIT_MS = 750
 const THREAD_ACTIVE_RUN_LOCK_RETRY_DELAY_MS = 75
+const THREAD_BOOTSTRAP_LOCK_TTL_MS = 15_000
+const THREAD_BOOTSTRAP_LOCK_REFRESH_INTERVAL_MS = 5_000
+const THREAD_BOOTSTRAP_LOCK_MAX_WAIT_MS = 5_000
+const THREAD_BOOTSTRAP_LOCK_RETRY_DELAY_MS = 100
+const THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS = 20
+const THREAD_UNIQUE_LOOKUP_RETRY_DELAY_MS = 100
 
 function isRecordIdInput(value: unknown): value is RecordIdInput {
   if (typeof value === 'string' || value instanceof RecordId || value instanceof StringRecordId) {
@@ -51,6 +57,10 @@ function buildActiveRunLockKey(threadId: RecordIdRef): string {
   return `thread-active-run:${recordIdToString(ensureRecordId(threadId, TABLES.THREAD), TABLES.THREAD)}`
 }
 
+function buildBootstrapThreadsLockKey(userId: RecordIdRef, orgId: RecordIdRef): string {
+  return `thread-bootstrap:${recordIdToString(ensureRecordId(userId, TABLES.USER), TABLES.USER)}:${recordIdToString(ensureRecordId(orgId, TABLES.ORGANIZATION), TABLES.ORGANIZATION)}`
+}
+
 function buildListThreadsQuery(options: {
   includeArchived: boolean
   paginate: boolean
@@ -94,6 +104,35 @@ function isUniqueConstraintError(error: unknown): boolean {
   return error.message.includes('already contains')
 }
 
+function requireExistingThread(
+  record: ThreadRecord | null,
+  params: {
+    type: 'default' | 'thread'
+    organizationId: RecordIdRef
+    userId: RecordIdRef
+    agentId?: string
+    threadType?: string
+  },
+): ThreadRecord {
+  if (record) {
+    return record
+  }
+
+  const scope = {
+    organizationId: recordIdToString(params.organizationId, TABLES.ORGANIZATION),
+    userId: recordIdToString(params.userId, TABLES.USER),
+    ...(params.agentId ? { agentId: params.agentId } : {}),
+    ...(params.threadType ? { threadType: params.threadType } : {}),
+  }
+  throw new Error(`Thread lookup failed after duplicate ${params.type} thread create: ${JSON.stringify(scope)}`)
+}
+
+type UniqueThreadLookupParams = Parameters<typeof requireExistingThread>[1]
+
+function haveSameMembers(left: string[], right: string[]): boolean {
+  return left.length === right.length && left.every((value, index) => value === right[index])
+}
+
 export class ActiveThreadRunConflictError extends Error {
   constructor() {
     super('A chat run is already active.')
@@ -135,6 +174,30 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
     }
 
     const title = input.title ?? THREAD.DEFAULT_TITLE
+    const nameGenerated = input.title !== undefined && input.title !== THREAD.DEFAULT_TITLE
+
+    if (input.type === 'default') {
+      const agentId = input.agentId
+      if (!agentId) {
+        throw new Error('Default threads require agentId')
+      }
+      const { record } = await this.getOrCreateDefault(input.organizationId, input.userId, agentId)
+      return await this.toNormalizedThread(record)
+    }
+
+    if (input.type === 'thread') {
+      const threadType = input.threadType
+      if (!threadType) {
+        throw new Error('Thread threads require threadType')
+      }
+      const { record } = await this.getOrCreateThread(input.organizationId, input.userId, threadType, {
+        members: input.members ?? [...agentRoster],
+        title,
+        nameGenerated,
+      })
+      return await this.toNormalizedThread(record)
+    }
+
     const thread = await this.create({
       userId: input.userId,
       organizationId: input.organizationId,
@@ -144,7 +207,7 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
       members: input.members ?? [...agentRoster],
       title,
       status: 'active',
-      nameGenerated: input.title !== undefined && input.title !== THREAD.DEFAULT_TITLE,
+      nameGenerated,
       isCompacting: false,
       turnCount: 0,
     })
@@ -156,13 +219,13 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
     orgId: RecordIdRef,
     userId: RecordIdRef,
     agentId: string,
+    config?: { title?: string; nameGenerated?: boolean },
   ): Promise<{ record: ThreadRecord; created: boolean }> {
-    const existing = await this.databaseService.findOne(
-      this.table,
-      { type: 'default', organizationId: orgId, userId, agentId },
-      ThreadSchema,
-    )
-    if (existing) return { record: existing, created: false }
+    const lookup = { type: 'default' as const, organizationId: orgId, userId, agentId }
+    const existing = await this.findThreadByUniqueLookup(lookup)
+    if (existing) {
+      return { record: await this.syncThreadConfig(existing, config), created: false }
+    }
 
     try {
       const record = await this.create({
@@ -171,21 +234,16 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
         userId,
         agentId,
         members: [agentId],
-        title: getAgentDisplayName(agentId),
+        title: config?.title ?? getAgentDisplayName(agentId),
         status: 'active',
-        nameGenerated: false,
+        nameGenerated: config?.nameGenerated ?? false,
         isCompacting: false,
         turnCount: 0,
       })
       return { record, created: true }
     } catch (e) {
       if (isUniqueConstraintError(e)) {
-        const retried = await this.databaseService.findOne(
-          this.table,
-          { type: 'default', organizationId: orgId, userId, agentId },
-          ThreadSchema,
-        )
-        return { record: retried!, created: false }
+        return { record: await this.syncThreadConfig(await this.waitForExistingThread(lookup), config), created: false }
       }
       throw e
     }
@@ -195,14 +253,13 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
     orgId: RecordIdRef,
     userId: RecordIdRef,
     threadType: string,
-    config: { members: string[]; title: string },
+    config: { members: string[]; title: string; nameGenerated?: boolean },
   ): Promise<{ record: ThreadRecord; created: boolean }> {
-    const existing = await this.databaseService.findOne(
-      this.table,
-      { type: 'thread', organizationId: orgId, userId, threadType },
-      ThreadSchema,
-    )
-    if (existing) return { record: existing, created: false }
+    const lookup = { type: 'thread' as const, organizationId: orgId, userId, threadType }
+    const existing = await this.findThreadByUniqueLookup(lookup)
+    if (existing) {
+      return { record: await this.syncThreadConfig(existing, config), created: false }
+    }
 
     try {
       const record = await this.create({
@@ -213,104 +270,193 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
         members: config.members,
         title: config.title,
         status: 'active',
-        nameGenerated: false,
+        nameGenerated: config.nameGenerated ?? false,
         isCompacting: false,
         turnCount: 0,
       })
       return { record, created: true }
     } catch (e) {
       if (isUniqueConstraintError(e)) {
-        const retried = await this.databaseService.findOne(
-          this.table,
-          { type: 'thread', organizationId: orgId, userId, threadType },
-          ThreadSchema,
-        )
-        return { record: retried!, created: false }
+        return { record: await this.syncThreadConfig(await this.waitForExistingThread(lookup), config), created: false }
       }
       throw e
     }
   }
 
-  async ensureBootstrapThreads(
-    userId: RecordIdRef,
-    orgId: RecordIdRef,
-    options?: { onboardStatus?: string; userName?: string | null },
-  ): Promise<void> {
-    const onboardStatus = options?.onboardStatus ?? 'completed'
-    const onboardingCompleted = onboardStatus === 'completed'
-    const bootstrapConfig = getThreadBootstrapConfig()
-
-    const existingThreads = await databaseService.findMany(
-      TABLES.THREAD,
-      { userId, organizationId: orgId },
-      ThreadSchema,
-    )
-
-    const hasGroupThread = existingThreads.some((t) => t.type === 'group')
-    const defaultThreadsByAgent = new Map<string, ThreadRecord>()
-    const threadThreadsByType = new Map<string, ThreadRecord>()
-
-    for (const thread of existingThreads) {
-      if (thread.type === 'default' && thread.agentId) {
-        defaultThreadsByAgent.set(thread.agentId, thread)
-      }
-      if (thread.type === 'thread' && typeof thread.threadType === 'string') {
-        threadThreadsByType.set(thread.threadType, thread)
-      }
+  private async syncThreadConfig(
+    record: ThreadRecord,
+    config?: { title?: string; nameGenerated?: boolean; members?: string[] },
+  ): Promise<ThreadRecord> {
+    if (!config) {
+      return record
     }
 
-    const requiredDefaultAgents = onboardingCompleted
-      ? bootstrapConfig.completedDefaultAgents
-      : bootstrapConfig.onboardingDefaultAgents
-
-    const creations: Promise<{ record: ThreadRecord; created: boolean }>[] = []
+    const updates: Partial<ThreadRecord> = {}
 
-    for (const agentId of requiredDefaultAgents) {
-      if (defaultThreadsByAgent.has(agentId)) continue
-      creations.push(this.getOrCreateDefault(orgId, userId, agentId))
+    if (config.title !== undefined && record.title !== config.title) {
+      updates.title = config.title
     }
-
-    if (onboardingCompleted && bootstrapConfig.ensureDefaultGroupOnCompleted && !hasGroupThread) {
-      creations.push(
-        this.createThread({ userId, organizationId: orgId, type: 'group', title: THREAD.DEFAULT_TITLE }).then(
-          (normalized) => ({ record: normalized as unknown as ThreadRecord, created: true }),
-        ),
-      )
+    if (config.nameGenerated !== undefined && record.nameGenerated !== config.nameGenerated) {
+      updates.nameGenerated = config.nameGenerated
     }
-
-    if (onboardingCompleted) {
-      for (const wsType of bootstrapConfig.threadTypesAfterOnboarding) {
-        if (threadThreadsByType.has(wsType)) continue
-        const profile = getCoreThreadProfile(wsType)
-        creations.push(
-          this.getOrCreateThread(orgId, userId, wsType, { members: [...profile.members], title: profile.config.title }),
-        )
-      }
+    if (config.members !== undefined && !haveSameMembers(record.members, config.members)) {
+      updates.members = config.members
     }
 
-    let createdResults: { record: ThreadRecord; created: boolean }[] = []
-    if (creations.length > 0) {
-      createdResults = await Promise.all(creations)
+    if (Object.keys(updates).length === 0) {
+      return record
     }
 
-    const onboardingWelcome = bootstrapConfig.onboardingWelcome
-    if (!onboardingCompleted && onboardingWelcome) {
-      const createdOwnerThread = createdResults.find(
-        (r) => r.created && r.record.type === 'default' && r.record.agentId === onboardingWelcome.defaultAgentId,
-      )
-      const existingOwnerThread = defaultThreadsByAgent.get(onboardingWelcome.defaultAgentId)
+    return await this.update(record.id, updates)
+  }
 
-      const ownerThreadId = createdOwnerThread?.record.id ?? existingOwnerThread?.id
+  private async findThreadByUniqueLookup(params: UniqueThreadLookupParams): Promise<ThreadRecord | null> {
+    return await this.databaseService.findOne(
+      this.table,
+      {
+        type: params.type,
+        organizationId: params.organizationId,
+        userId: params.userId,
+        ...(params.agentId ? { agentId: params.agentId } : {}),
+        ...(params.threadType ? { threadType: params.threadType } : {}),
+      },
+      ThreadSchema,
+    )
+  }
 
-      if (ownerThreadId) {
-        const ownerThreadRef = ensureRecordId(ownerThreadId, TABLES.THREAD)
-        await threadMessageService.ensureBootstrapWelcomeMessage({
-          threadId: ownerThreadRef,
-          agentId: onboardingWelcome.defaultAgentId,
-          text: onboardingWelcome.buildMessageText({ userName: options?.userName }),
-        })
+  private async waitForExistingThread(params: UniqueThreadLookupParams): Promise<ThreadRecord> {
+    for (let attempt = 0; attempt < THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS; attempt += 1) {
+      const record = await this.findThreadByUniqueLookup(params)
+      if (record) {
+        return record
+      }
+      if (attempt < THREAD_UNIQUE_LOOKUP_MAX_ATTEMPTS - 1) {
+        await Bun.sleep(THREAD_UNIQUE_LOOKUP_RETRY_DELAY_MS)
       }
     }
+
+    return requireExistingThread(null, params)
+  }
+
+  async ensureBootstrapThreads(
+    userId: RecordIdRef,
+    orgId: RecordIdRef,
+    options?: { onboardStatus?: string; userName?: string | null },
+  ): Promise<void> {
+    await withRedisLeaseLock(
+      {
+        redis: getRedisConnection(),
+        lockKey: buildBootstrapThreadsLockKey(userId, orgId),
+        lockTtlMs: THREAD_BOOTSTRAP_LOCK_TTL_MS,
+        refreshIntervalMs: THREAD_BOOTSTRAP_LOCK_REFRESH_INTERVAL_MS,
+        retryDelayMs: THREAD_BOOTSTRAP_LOCK_RETRY_DELAY_MS,
+        maxWaitMs: THREAD_BOOTSTRAP_LOCK_MAX_WAIT_MS,
+        label: 'thread bootstrap',
+        logger: serverLogger,
+      },
+      async (signal) => {
+        const throwIfAborted = () => {
+          if (signal.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error('Thread bootstrap lease was aborted.')
+          }
+        }
+
+        throwIfAborted()
+        const onboardStatus = options?.onboardStatus ?? 'completed'
+        const onboardingCompleted = onboardStatus === 'completed'
+        const bootstrapConfig = getThreadBootstrapConfig()
+
+        const existingThreads = await databaseService.findMany(
+          TABLES.THREAD,
+          { userId, organizationId: orgId },
+          ThreadSchema,
+        )
+        throwIfAborted()
+
+        const hasGroupThread = existingThreads.some((t) => t.type === 'group')
+        const defaultThreadsByAgent = new Map<string, ThreadRecord>()
+        const threadThreadsByType = new Map<string, ThreadRecord>()
+
+        for (const thread of existingThreads) {
+          if (thread.type === 'default' && thread.agentId) {
+            defaultThreadsByAgent.set(thread.agentId, thread)
+          }
+          if (thread.type === 'thread' && typeof thread.threadType === 'string') {
+            threadThreadsByType.set(thread.threadType, thread)
+          }
+        }
+
+        const requiredDefaultAgents = onboardingCompleted
+          ? bootstrapConfig.completedDefaultAgents
+          : bootstrapConfig.onboardingDefaultAgents
+
+        const creationTasks: Array<() => Promise<{ record: ThreadRecord; created: boolean }>> = []
+
+        for (const agentId of requiredDefaultAgents) {
+          if (defaultThreadsByAgent.has(agentId)) continue
+          creationTasks.push(async () => await this.getOrCreateDefault(orgId, userId, agentId))
+        }
+
+        if (onboardingCompleted && bootstrapConfig.ensureDefaultGroupOnCompleted && !hasGroupThread) {
+          creationTasks.push(
+            async () =>
+              await this.createThread({
+                userId,
+                organizationId: orgId,
+                type: 'group',
+                title: THREAD.DEFAULT_TITLE,
+              }).then(async (normalized) => ({
+                record: await this.getById(ensureRecordId(normalized.id, TABLES.THREAD)),
+                created: true,
+              })),
+          )
+        }
+
+        if (onboardingCompleted) {
+          for (const wsType of bootstrapConfig.threadTypesAfterOnboarding) {
+            if (threadThreadsByType.has(wsType)) continue
+            const profile = getCoreThreadProfile(wsType)
+            creationTasks.push(
+              async () =>
+                await this.getOrCreateThread(orgId, userId, wsType, {
+                  members: [...profile.members],
+                  title: profile.config.title,
+                }),
+            )
+          }
+        }
+
+        let createdResults: { record: ThreadRecord; created: boolean }[] = []
+        if (creationTasks.length > 0) {
+          for (const runCreation of creationTasks) {
+            throwIfAborted()
+            createdResults.push(await runCreation())
+            throwIfAborted()
+          }
+        }
+
+        const onboardingWelcome = bootstrapConfig.onboardingWelcome
+        if (!onboardingCompleted && onboardingWelcome) {
+          const createdOwnerThread = createdResults.find(
+            (r) => r.created && r.record.type === 'default' && r.record.agentId === onboardingWelcome.defaultAgentId,
+          )
+          const existingOwnerThread = defaultThreadsByAgent.get(onboardingWelcome.defaultAgentId)
+
+          const ownerThreadId = createdOwnerThread?.record.id ?? existingOwnerThread?.id
+
+          if (ownerThreadId) {
+            throwIfAborted()
+            const ownerThreadRef = ensureRecordId(ownerThreadId, TABLES.THREAD)
+            await threadMessageService.ensureBootstrapWelcomeMessage({
+              threadId: ownerThreadRef,
+              agentId: onboardingWelcome.defaultAgentId,
+              text: onboardingWelcome.buildMessageText({ userName: options?.userName }),
+            })
+            throwIfAborted()
+          }
+        }
+      },
+    )
   }
 
   async listThreads(
@@ -675,7 +821,7 @@ class ThreadService extends BaseService<typeof ThreadSchema> {
       title: thread.title ?? this.getDefaultTitle(thread),
       status,
       memoryBlock: this.formatMemoryBlockForPrompt(thread),
-      members: thread.members ?? [],
+      members: thread.members,
       createdAt: toIsoDateTimeString(thread.createdAt),
       updatedAt: toIsoDateTimeString(thread.updatedAt),
     })

package/src/system-agents/thread-router.agent.ts

@@ -1,30 +1,23 @@
-import { ToolLoopAgent } from 'ai'
+import { generateObject } from 'ai'
 import { z } from 'zod'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import { agentDescriptions, agentDisplayNames, agentShortDisplayNames, routerModelId } from '../config/agent-defaults'
-
-// ---------------------------------------------------------------------------
-// Schemas
-// ---------------------------------------------------------------------------
+import { chatLogger } from '../config/logger'
+import { withTimeout } from '../utils/async'
 
 const TriageResultSchema = z.object({ agentId: z.string(), routingContext: z.string() })
 
-const CheckResultSchema = z.object({
+const CheckResultObjectSchema = z.object({
   done: z.boolean(),
-  agentId: z.string().optional(),
-  routingContext: z.string().optional(),
+  agentId: z.string().nullable(),
+  routingContext: z.string().nullable(),
 })
-
-const ROUTER_OUTPUT_PREVIEW_CHARS = 300
+type RouterCheckContinueResult = { done: false; agentId: string; routingContext: string | null }
 
 export type RouterTriageResult = z.infer<typeof TriageResultSchema>
-export type RouterCheckResult = z.infer<typeof CheckResultSchema>
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+export type RouterCheckResult = { done: true } | RouterCheckContinueResult
 
 interface RouterDisplayOptions {
   displayNamesById?: Partial<Record<string, string>>
@@ -136,56 +129,13 @@ function extractExplicitAgentTargets(
     })
 }
 
-function extractJson(text: string): unknown {
-  const match = text.match(/\{[\s\S]*\}/)
-  if (!match) return null
-  try {
-    return JSON.parse(match[0])
-  } catch {
-    return null
-  }
-}
-
-/** Extract usable text from agent result — reasoning-only models put output in reasoning tokens */
-function extractResultText(result: { text?: string; reasoning?: unknown }): string {
-  const text = typeof result.text === 'string' ? result.text : ''
-  if (text.trim()) return text
-  // Reasoning can be a string or an array of { type, text } objects
-  const reasoning = result.reasoning
-  if (typeof reasoning === 'string') return reasoning
-  if (Array.isArray(reasoning)) {
-    return reasoning
-      .map((r) => {
-        if (typeof r === 'string') return r
-        if (typeof r !== 'object' || r === null || !('text' in r)) return ''
-
-        const text = (r as { text?: unknown }).text
-        return typeof text === 'string' ? text : ''
-      })
-      .join('')
-  }
-  return ''
-}
-
-function logRouterRaw(label: 'triage' | 'check', text: string): void {
-  const preview = text.trim().slice(0, ROUTER_OUTPUT_PREVIEW_CHARS)
-  if (!preview) return
-  console.log(`[thread-router] ${label} raw:`, preview)
-}
-
-// ---------------------------------------------------------------------------
-// Prompts
-// ---------------------------------------------------------------------------
-
 const TRIAGE_SYSTEM_PROMPT = `You are a thread message router. Decide which team member should respond FIRST to the user message.
 
 Rules:
 - Pick the single best-fit agent from the members list based on domain expertise.
 - If the user explicitly addresses an agent by name or role (e.g. "CTO: ..." or "CMO: ..."), route to that agent.
 - If no specialist clearly matches (general chat, greetings, coordination), respond with agentId "".
-- Be decisive. Reply with ONLY a JSON object, no other text.
-
-Format: {"agentId":"<id>","routingContext":"<1-sentence instruction>"}`
+- Be decisive.`
 
 const CHECK_SYSTEM_PROMPT = `You decide if another team member should ALSO respond after the previous agent's response.
 
@@ -199,25 +149,37 @@ Rules:
 - If the user explicitly addressed multiple agents (e.g. "CTO: ... CMO: ...") and one hasn't responded yet, they MUST respond. Return done:false.
 - If the last agent's response explicitly defers to or recommends another specialist, that specialist SHOULD respond. Return done:false.
 - If there is a clearly separate dimension of the user's question not yet covered by any responded agent, add the best-fit remaining agent.
-- Do NOT add agents just for agreement, acknowledgement, or minor additions.
-- Reply with ONLY a JSON object, no other text.
+- Do NOT add agents just for agreement, acknowledgement, or minor additions.`
 
-Format: {"done":true} or {"done":false,"agentId":"<id>","routingContext":"<1-sentence>"}`
+const THREAD_ROUTER_TIMEOUT_MS = 30_000
 
-// ---------------------------------------------------------------------------
-// Agent functions
-// ---------------------------------------------------------------------------
-
-function createRouterAgent(systemPrompt: string) {
+async function generateRouterObject<TSchema extends z.ZodTypeAny>(params: {
+  schema: TSchema
+  system: string
+  prompt: string
+  label: 'triage' | 'check'
+}): Promise<z.infer<TSchema> | null> {
   const modelId = routerModelId ?? 'openai/gpt-5.4-nano'
-  return new ToolLoopAgent({
-    id: 'thread-router',
-    model: aiGatewayChatModel(modelId),
-    headers: buildAiGatewayDirectCacheHeaders('thread-router'),
-    providerOptions: { openai: { reasoningEffort: 'low' } },
-    instructions: systemPrompt,
-    maxOutputTokens: 256,
-  })
+
+  try {
+    const { object } = await withTimeout(
+      generateObject({
+        model: aiGatewayChatModel(modelId),
+        headers: buildAiGatewayDirectCacheHeaders('thread-router'),
+        providerOptions: { openai: { reasoningEffort: 'low' } },
+        schema: params.schema,
+        system: params.system,
+        prompt: params.prompt,
+        maxOutputTokens: 256,
+      }),
+      THREAD_ROUTER_TIMEOUT_MS,
+      `thread-router ${params.label}`,
+    )
+    return params.schema.parse(object)
+  } catch (error) {
+    chatLogger.error`[thread-router] ${params.label} failed: ${error instanceof Error ? error.message : String(error)}`
+    return null
+  }
 }
 
 export async function triageThreadMessage(params: {
@@ -253,40 +215,27 @@ export async function triageThreadMessage(params: {
     .filter(Boolean)
     .join('\n\n')
 
-  const agent = createRouterAgent(TRIAGE_SYSTEM_PROMPT)
-  let result: Awaited<ReturnType<typeof agent.generate>>
-  try {
-    result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
-  } catch (error) {
-    console.error('[thread-router] triage failed:', error instanceof Error ? error.message : error)
-    return null
-  }
+  const parsed = await generateRouterObject({
+    schema: TriageResultSchema,
+    system: TRIAGE_SYSTEM_PROMPT,
+    prompt,
+    label: 'triage',
+  })
 
-  const effectiveText = extractResultText(result as { text?: string; reasoning?: unknown })
-  logRouterRaw('triage', effectiveText)
-  const json = extractJson(effectiveText)
-  if (json === null) {
-    if (effectiveText.trim()) {
-      console.log('[thread-router] triage ignored non-json output')
-    }
-    return null
-  }
-  const parsed = TriageResultSchema.safeParse(json)
-  if (!parsed.success) {
-    console.log('[thread-router] triage parse failed:', JSON.stringify(parsed.error.issues))
+  if (!parsed) {
     return null
   }
-  if (!parsed.data.agentId) {
-    console.log('[thread-router] triage returned empty agentId — fallback to owner')
+  if (!parsed.agentId) {
+    chatLogger.debug`[thread-router] triage returned empty agentId`
     return null
   }
-  if (!params.members.includes(parsed.data.agentId)) {
-    console.log('[thread-router] triage returned unknown agent:', parsed.data.agentId)
+  if (!params.members.includes(parsed.agentId)) {
+    chatLogger.warn`[thread-router] triage returned unknown agent: ${parsed.agentId}`
     return null
   }
 
-  console.log('[thread-router] triage routed to:', parsed.data.agentId)
-  return parsed.data
+  chatLogger.debug`[thread-router] triage routed to ${parsed.agentId}`
+  return parsed
 }
 
 export async function checkForNextAgent(params: {
@@ -328,38 +277,22 @@ export async function checkForNextAgent(params: {
     `Last agent response:\n"${params.lastResponseSummary}"`,
   ].join('\n\n')
 
-  const agent = createRouterAgent(CHECK_SYSTEM_PROMPT)
-  let result: Awaited<ReturnType<typeof agent.generate>>
-  try {
-    result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
-  } catch (error) {
-    console.error('[thread-router] check failed:', error instanceof Error ? error.message : error)
-    return { done: true }
-  }
+  const parsed = await generateRouterObject({
+    schema: CheckResultObjectSchema,
+    system: CHECK_SYSTEM_PROMPT,
+    prompt,
+    label: 'check',
+  })
 
-  const effectiveText = extractResultText(result as { text?: string; reasoning?: unknown })
-  logRouterRaw('check', effectiveText)
-  const json = extractJson(effectiveText)
-  if (json === null) {
-    if (effectiveText.trim()) {
-      console.log('[thread-router] check ignored non-json output')
-    }
-    return { done: true }
-  }
-  const parsed = CheckResultSchema.safeParse(json)
-  if (!parsed.success) {
-    console.log('[thread-router] check parse failed:', JSON.stringify(parsed.error.issues))
-    return { done: true }
-  }
-  if (parsed.data.done) {
-    console.log('[thread-router] check: done, no more agents needed')
+  if (!parsed || parsed.done) {
+    chatLogger.debug`[thread-router] check finished without another agent`
     return { done: true }
   }
-  if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) {
-    console.log('[thread-router] check: invalid agentId:', parsed.data.agentId)
+  if (!parsed.agentId || !remainingMembers.includes(parsed.agentId)) {
+    chatLogger.warn`[thread-router] check returned invalid agent: ${parsed.agentId ?? 'missing'}`
     return { done: true }
   }
 
-  console.log('[thread-router] check: next agent:', parsed.data.agentId)
-  return parsed.data
+  chatLogger.debug`[thread-router] check selected ${parsed.agentId}`
+  return { done: false, agentId: parsed.agentId, routingContext: parsed.routingContext ?? null }
 }

package/src/utils/async.ts

@@ -9,22 +9,21 @@ class TimeoutError extends Error {
 }
 
 export async function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => {
-    controller.abort()
-  }, ms)
+  let timeoutId: ReturnType<typeof setTimeout> | undefined
 
   try {
     return await Promise.race([
       promise,
       new Promise<never>((_, reject) => {
-        controller.signal.addEventListener('abort', () => {
+        timeoutId = setTimeout(() => {
           reject(new TimeoutError(operation, ms))
-        })
+        }, ms)
       }),
     ])
   } finally {
-    clearTimeout(timeoutId)
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+    }
   }
 }