@lota-sdk/core 0.1.8 → 0.1.11

package/src/db/service.ts

@@ -66,6 +66,8 @@ export type CreateMutationBuilder = {
 export interface DatabaseTransaction {
   query: (query: unknown) => Promise<unknown>
   create: (target: unknown) => CreateMutationBuilder
+  update: (target: unknown) => MutationBuilder
+  delete: (target: unknown) => Promise<unknown>
   relate: (from: unknown, edgeTable: unknown, to: unknown, data?: Values<Record<string, unknown>>) => Promise<unknown>
   commit: () => Promise<void>
   cancel: () => Promise<void>
@@ -458,6 +460,38 @@ export class SurrealDBService {
     throw new SurrealDBError('Invalid table value')
   }
 
+  private isRecordIdLike(value: unknown): boolean {
+    if (value instanceof RecordId || value instanceof StringRecordId) {
+      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) {
+        return true
+      }
+
+      const stringValue = toStringLikeValue(value)
+      if (stringValue) {
+        return /^[a-zA-Z][a-zA-Z0-9_]*:/.test(stringValue)
+      }
+    }
+
+    return false
+  }
+
+  private normalizeCreateTarget(value: unknown): Table | RecordId {
+    if (this.isRecordIdLike(value)) {
+      return ensureRecordId(value as RecordIdInput)
+    }
+
+    return this.normalizeTableValue(value)
+  }
+
   private wrapMutationBuilder(builder: MutationBuilder): MutationBuilder {
     return {
       content: (data) => this.wrapMutationBuilder(builder.content(this.normalizeMutationData(data))),
@@ -478,8 +512,14 @@ export class SurrealDBService {
   private wrapTransaction(tx: SurrealTransaction): DatabaseTransaction {
     return {
       query: (query: unknown) => tx.query(this.normalizeBoundQuery(query as BoundQuery | BoundQueryLike)),
-      create: (target: unknown) =>
-        this.wrapCreateBuilder(tx.create(this.normalizeTableValue(target)) as unknown as CreateMutationBuilder),
+      create: (target: unknown) => {
+        const normalizedTarget = this.normalizeCreateTarget(target)
+        const builder = normalizedTarget instanceof Table ? tx.create(normalizedTarget) : tx.create(normalizedTarget)
+        return this.wrapCreateBuilder(builder as unknown as CreateMutationBuilder)
+      },
+      update: (target: unknown) =>
+        this.wrapMutationBuilder(tx.update(ensureRecordId(target as RecordIdInput)) as unknown as MutationBuilder),
+      delete: (target: unknown) => tx.delete(ensureRecordId(target as RecordIdInput)),
       relate: (from: unknown, edgeTable: unknown, to: unknown, data?: Values<Record<string, unknown>>) =>
         tx.relate(
           ensureRecordId(from as RecordIdInput),

package/src/db/tables.ts

@@ -7,8 +7,15 @@ export const TABLES = {
   MEMORY_RELATION: 'memoryRelation',
   MEMORY_HISTORY: 'memoryHistory',
   LEARNED_SKILL: 'learnedSkill',
-  PLAN: 'plan',
-  PLAN_TASK: 'planTask',
+  PLAN_SPEC: 'planSpec',
+  PLAN_NODE_SPEC: 'planNodeSpec',
+  PLAN_RUN: 'planRun',
+  PLAN_NODE_RUN: 'planNodeRun',
+  PLAN_NODE_ATTEMPT: 'planNodeAttempt',
+  PLAN_ARTIFACT: 'planArtifact',
+  PLAN_APPROVAL: 'planApproval',
+  PLAN_CHECKPOINT: 'planCheckpoint',
+  PLAN_VALIDATION_ISSUE: 'planValidationIssue',
   PLAN_EVENT: 'planEvent',
   ORGANIZATION: 'organization',
   ORGANIZATION_MEMBER: 'organizationMember',

package/src/embeddings/provider.ts

@@ -1,10 +1,23 @@
 import { embed, embedMany } from 'ai'
 
+import { getEmbeddingCache } from '../ai/embedding-cache'
 import { bifrostEmbeddingModel } from '../bifrost/bifrost'
 import { env } from '../config/env-shapes'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
 
+type SharedEmbeddingCache = {
+  get(model: string, text: string): Promise<number[] | null>
+  set(model: string, text: string, embedding: number[]): Promise<void>
+}
+
+type ProviderEmbeddingsOptions = {
+  embedFn?: typeof embed
+  embedManyFn?: typeof embedMany
+  getCache?: () => SharedEmbeddingCache | null
+  modelId?: string
+}
+
 function resolveEmbeddingModel(modelId: string) {
   const normalized = modelId.trim()
   if (!normalized) {
@@ -20,23 +33,54 @@ function resolveEmbeddingModel(modelId: string) {
   return bifrostEmbeddingModel(normalized)
 }
 
-class ProviderEmbeddings {
+function normalizeEmbedding(embedding: readonly number[]): number[] {
+  return embedding.map((value) => Number(value))
+}
+
+export class ProviderEmbeddings {
+  private readonly embedFn: typeof embed
+  private readonly embedManyFn: typeof embedMany
+  private readonly getCache: () => SharedEmbeddingCache | null
+  private readonly modelId: string
   private _model: ReturnType<typeof resolveEmbeddingModel> | null = null
 
+  constructor(options: ProviderEmbeddingsOptions = {}) {
+    this.embedFn = options.embedFn ?? embed
+    this.embedManyFn = options.embedManyFn ?? embedMany
+    this.getCache = options.getCache ?? getEmbeddingCache
+    this.modelId = options.modelId ?? env.AI_EMBEDDING_MODEL
+  }
+
   private getModel() {
     if (!this._model) {
-      this._model = resolveEmbeddingModel(env.AI_EMBEDDING_MODEL)
+      this._model = resolveEmbeddingModel(this.modelId)
     }
     return this._model
   }
 
+  private async loadCachedEmbedding(text: string): Promise<number[] | null> {
+    const redisCache = this.getCache()
+    if (!redisCache) return null
+
+    return await redisCache.get(this.modelId, text)
+  }
+
   async embedQuery(text: string): Promise<number[]> {
     const input = text.trim()
     if (!input) return []
 
-    const result = await embed({ model: this.getModel(), value: input, maxRetries: 2 })
+    const cached = await this.loadCachedEmbedding(input)
+    if (cached) return cached
+
+    const result = await this.embedFn({ model: this.getModel(), value: input, maxRetries: 2 })
+    const embedding = normalizeEmbedding(result.embedding)
+
+    const redisCache = this.getCache()
+    if (redisCache) {
+      void redisCache.set(this.modelId, input, embedding)
+    }
 
-    return result.embedding.map((value) => Number(value))
+    return embedding
   }
 
   async embedDocuments(values: string[]): Promise<number[][]> {
@@ -51,26 +95,53 @@ class ProviderEmbeddings {
       return normalized.map(() => [])
     }
 
-    const result = await embedMany({
-      model: this.getModel(),
-      values: nonEmptyEntries.map((entry) => entry.value),
-      maxRetries: 2,
-    })
-
-    const embeddingsByIndex = new Map<number, number[]>()
-    result.embeddings.forEach((embedding, index) => {
-      const entry = nonEmptyEntries.at(index)
-      if (!entry) return
-      embeddingsByIndex.set(
-        entry.index,
-        embedding.map((value) => Number(value)),
+    const uniqueTexts = [...new Set(nonEmptyEntries.map((entry) => entry.value))]
+    const embeddingsByText = new Map<string, number[]>()
+    let missingTexts = [...uniqueTexts]
+
+    const redisCache = this.getCache()
+    if (redisCache && missingTexts.length > 0) {
+      const redisResults = await Promise.all(
+        missingTexts.map(async (text) => ({ text, embedding: await redisCache.get(this.modelId, text) })),
       )
-    })
 
-    return normalized.map((_, index) => embeddingsByIndex.get(index) ?? [])
+      missingTexts = []
+      for (const result of redisResults) {
+        if (!result.embedding) {
+          missingTexts.push(result.text)
+          continue
+        }
+
+        embeddingsByText.set(result.text, result.embedding)
+      }
+    }
+
+    if (missingTexts.length > 0) {
+      const result = await this.embedManyFn({ model: this.getModel(), values: missingTexts, maxRetries: 2 })
+
+      missingTexts.forEach((text, index) => {
+        const embedding = normalizeEmbedding(result.embeddings[index] ?? [])
+        embeddingsByText.set(text, embedding)
+        if (redisCache) {
+          void redisCache.set(this.modelId, text, embedding)
+        }
+      })
+    }
+
+    return normalized.map((text) => (text ? (embeddingsByText.get(text) ?? []) : []))
+  }
+}
+
+let defaultEmbeddings: ProviderEmbeddings | null = null
+
+export function getDefaultEmbeddings(): ProviderEmbeddings {
+  if (!defaultEmbeddings) {
+    defaultEmbeddings = new ProviderEmbeddings()
   }
+
+  return defaultEmbeddings
 }
 
-export function createDefaultEmbeddings(): ProviderEmbeddings {
-  return new ProviderEmbeddings()
+export function resetDefaultEmbeddingsForTests(): void {
+  defaultEmbeddings = null
 }

package/src/index.ts

@@ -32,6 +32,7 @@ import type { workstreamMessageService } from './services/workstream-message.ser
 import type { workstreamTitleService } from './services/workstream-title.service'
 import type {
   createWorkstreamApprovalContinuationStream,
+  createWorkstreamNativeToolApprovalStream,
   createWorkstreamTurnStream,
   runWorkstreamTurnInBackground,
 } from './services/workstream-turn'
@@ -124,6 +125,7 @@ export interface LotaRuntime {
     workstreamService: typeof workstreamService
     workstreamTitleService: typeof workstreamTitleService
     createWorkstreamApprovalContinuationStream: typeof createWorkstreamApprovalContinuationStream
+    createWorkstreamNativeToolApprovalStream: typeof createWorkstreamNativeToolApprovalStream
     createWorkstreamTurnStream: typeof createWorkstreamTurnStream
     isApprovalContinuationRequest: typeof isApprovalContinuationRequest
     runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
@@ -291,6 +293,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
   const { workstreamTitleService } = await import('./services/workstream-title.service')
   const {
     createWorkstreamApprovalContinuationStream,
+    createWorkstreamNativeToolApprovalStream,
     createWorkstreamTurnStream,
     isApprovalContinuationRequest,
     runWorkstreamTurnInBackground,
@@ -431,6 +434,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       workstreamService,
       workstreamTitleService,
       createWorkstreamApprovalContinuationStream,
+      createWorkstreamNativeToolApprovalStream,
       createWorkstreamTurnStream,
       isApprovalContinuationRequest,
       runWorkstreamTurnInBackground,
@@ -495,5 +499,7 @@ function createPluginDatabaseConnector(pluginRuntime: Record<string, LotaPlugin>
 export type { CoreWorkstreamProfile } from './config/agent-defaults'
 export type { SurrealDBService } from './db/service'
 export type { RedisConnectionManager } from './redis/connection'
+export { createWorkstreamResumableContext } from './redis/stream-context'
 export type { LotaPlugin, LotaPluginContributions } from './runtime/plugin-types'
 export type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime/runtime-extensions'
+export { createLogHelloWorldTool } from './tools/log-hello-world.tool'

package/src/redis/stream-context.ts

@@ -0,0 +1,44 @@
+import type { Redis } from 'ioredis'
+import type { Publisher, Subscriber } from 'resumable-stream/ioredis'
+import { createResumableStreamContext } from 'resumable-stream/ioredis'
+
+import { getRedisConnection } from './index'
+
+function toSubscriber(client: Redis): Subscriber {
+  const handlers = new Map<string, (message: string) => void>()
+  const messageListener = (channel: string, message: string) => {
+    handlers.get(channel)?.(message)
+  }
+  return {
+    connect: () => Promise.resolve(),
+    subscribe: async (channel, callback) => {
+      if (handlers.size === 0) client.on('message', messageListener)
+      handlers.set(channel, callback)
+      await client.subscribe(channel)
+    },
+    unsubscribe: async (channel) => {
+      handlers.delete(channel)
+      if (handlers.size === 0) client.removeListener('message', messageListener)
+      return client.unsubscribe(channel)
+    },
+  }
+}
+
+function toPublisher(client: Redis): Publisher {
+  return {
+    connect: () => Promise.resolve(),
+    publish: (channel, message) => client.publish(channel, message),
+    set: (key, value, options) => (options?.EX ? client.set(key, value, 'EX', options.EX) : client.set(key, value)),
+    get: (key) => client.get(key),
+    incr: (key) => client.incr(key),
+  }
+}
+
+export function createWorkstreamResumableContext() {
+  const redis = getRedisConnection()
+  return createResumableStreamContext({
+    waitUntil: null,
+    subscriber: toSubscriber(redis.duplicate()),
+    publisher: toPublisher(redis),
+  })
+}

package/src/runtime/approval-continuation.ts

@@ -4,6 +4,44 @@ export function hasApprovalRespondedParts(message: ChatMessage): boolean {
   return message.parts.some((part) => 'state' in part && (part as { state: string }).state === 'approval-responded')
 }
 
+export interface ApprovalContinuationResponse {
+  approvalId: string
+  approved: boolean
+  comments?: string
+  requiredEdits: string[]
+}
+
+export function readApprovalContinuationResponse(message: ChatMessage): ApprovalContinuationResponse | null {
+  for (const part of message.parts) {
+    if (!('state' in part) || (part as { state: string }).state !== 'approval-responded') continue
+    const approval = (part as { approval?: unknown }).approval
+    if (!approval || typeof approval !== 'object') continue
+
+    const record = approval as {
+      id?: unknown
+      approved?: unknown
+      reason?: unknown
+      comments?: unknown
+      requiredEdits?: unknown
+    }
+    if (typeof record.id !== 'string' || typeof record.approved !== 'boolean') continue
+
+    const requiredEdits = Array.isArray(record.requiredEdits)
+      ? record.requiredEdits.filter((item): item is string => typeof item === 'string' && item.trim().length > 0)
+      : []
+    const comments =
+      typeof record.comments === 'string' && record.comments.trim().length > 0
+        ? record.comments.trim()
+        : typeof record.reason === 'string' && record.reason.trim().length > 0
+          ? record.reason.trim()
+          : undefined
+
+    return { approvalId: record.id, approved: record.approved, comments, requiredEdits }
+  }
+
+  return null
+}
+
 export function isApprovalContinuationRequest(messages: ChatMessage[]): boolean {
   const lastAssistant = [...messages].reverse().find((message) => message.role === 'assistant')
   if (!lastAssistant) return false
@@ -14,3 +52,24 @@ export function isApprovalContinuationRequest(messages: ChatMessage[]): boolean
 
   return hasApprovalRespondedParts(lastAssistant)
 }
+
+const PLAN_TOOL_NAMES = new Set([
+  'createExecutionPlan',
+  'replaceExecutionPlan',
+  'submitExecutionNodeResult',
+  'getActiveExecutionPlan',
+  'resumeExecutionPlanRun',
+])
+
+export function isNativeToolApprovalRequest(messages: ChatMessage[]): boolean {
+  const lastAssistant = [...messages].reverse().find((m) => m.role === 'assistant')
+  if (!lastAssistant) return false
+
+  return lastAssistant.parts.some((part) => {
+    if (!('state' in part) || (part as { state: string }).state !== 'approval-responded') return false
+    const type = (part as { type?: string }).type
+    if (typeof type !== 'string' || !type.startsWith('tool-')) return false
+    const toolName = type.slice(5)
+    return !PLAN_TOOL_NAMES.has(toolName)
+  })
+}

package/src/runtime/chat-request-routing.ts

@@ -1,14 +1,18 @@
 import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
 
-import { isApprovalContinuationRequest } from './approval-continuation'
+import { isApprovalContinuationRequest, isNativeToolApprovalRequest } from './approval-continuation'
 
 export type RoutedChatRequest =
   | { kind: 'approval-continuation'; approvalMessages: ChatMessage[] }
+  | { kind: 'native-tool-approval'; messages: ChatMessage[] }
   | { kind: 'turn'; inputMessage: ChatMessage }
   | { kind: 'invalid'; message: string }
 
 export function routeWorkstreamChatMessages(messages: ChatMessage[]): RoutedChatRequest {
   if (isApprovalContinuationRequest(messages)) {
+    if (isNativeToolApprovalRequest(messages)) {
+      return { kind: 'native-tool-approval', messages }
+    }
     return { kind: 'approval-continuation', approvalMessages: messages }
   }
 

package/src/runtime/execution-plan.ts

@@ -1,14 +1,13 @@
 import type { SerializableExecutionPlan } from '@lota-sdk/shared/schemas/execution-plan'
 
 export const EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT = `<execution-plan-protocol>
-- Before doing multi-step work, create an execution plan instead of tracking steps only in prose.
-- Keep plans short and operational. Prefer 2 to 7 tasks unless the work truly needs more.
-- Use execution-plan tools to create, replace, update, inspect, and restart the plan.
-- Only one execution-plan task may be active at a time.
-- Every task should have a concrete rationale and a concise output summary when work happens.
-- Treat prior task output summaries and carried tasks in <execution-plan-state> as observed facts.
-- If the ordered steps materially change, replace the plan instead of silently rewriting it in prose.
-- If the active plan is blocked, do not continue blindly. Replan, restart a task, ask for user input, or abort.
+- Before doing multi-step work, create a contract-driven execution plan instead of tracking steps only in prose.
+- Plans are graph-capable workflow contracts. Every execution node must define objective, instructions, deliverables, success criteria, completion checks, retry policy, failure policy, and tool/context policy.
+- The runtime executor owns lifecycle truth. Do not claim that a node is complete until submitExecutionNodeResult succeeds.
+- Use execution-plan tools to create, replace, inspect, submit node results, and resume runs.
+- Treat the active execution run in <execution-plan-state> as authoritative. Do not mutate run or node status in prose.
+- Work only on nodes that are active or explicitly ready for your executor. If a node is awaiting human input or approval, stop and let the runtime resume it.
+- If the graph, contracts, or success criteria materially change, replace the plan instead of silently drifting.
 </execution-plan-protocol>`
 
 export function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | null | undefined): string | undefined {
@@ -16,11 +15,11 @@ export function formatExecutionPlanForPrompt(plan: SerializableExecutionPlan | n
 
   const payload = {
     policy: {
-      activePlanIsAuthoritative: true,
-      priorOutputSummariesAreObservedFacts: true,
-      singleActiveTask: true,
-      explicitReplanRequired: true,
-      failureBudget: 2,
+      executorOwnsLifecycleTruth: true,
+      contractDrivenExecution: true,
+      humanGatesAreDurable: true,
+      artifactsAreFirstClassOutputs: true,
+      checkpointRecoveryEnabled: true,
     },
     plan,
   }
@@ -43,16 +42,24 @@ export function createExecutionPlanInstructionSectionCache(params: {
   disabled?: boolean
   loadPlan: () => Promise<SerializableExecutionPlan | null | undefined>
 }) {
+  let planPromise: Promise<SerializableExecutionPlan | null | undefined> | null = null
   let sectionsPromise: Promise<string[] | undefined> | null = null
 
   return {
     invalidate() {
+      planPromise = null
       sectionsPromise = null
     },
+    async getPlan(): Promise<SerializableExecutionPlan | null | undefined> {
+      if (params.disabled) return undefined
+
+      planPromise ??= params.loadPlan()
+      return await planPromise
+    },
     async getSections(): Promise<string[] | undefined> {
       if (params.disabled) return undefined
 
-      sectionsPromise ??= params.loadPlan().then((plan) => buildExecutionPlanInstructionSections(plan))
+      sectionsPromise ??= this.getPlan().then((plan) => buildExecutionPlanInstructionSections(plan))
       return await sectionsPromise
     },
   }

package/src/runtime/turn-lifecycle.ts

@@ -2,27 +2,35 @@ import type { ChatMessage } from '@lota-sdk/shared/schemas/chat-message'
 
 export async function finalizeTurnRun(params: {
   serverRunId: string
-  getEntity: () => Promise<{ lastCompactedMessageId?: string | null; chatSummary?: string | null }>
+  getEntity: () => Promise<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
   getUncompactedMessages: (cursor?: string) => Promise<ChatMessage[]>
   assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
   enqueueCompaction: () => Promise<void>
   unregisterRun: (runId: string) => void
   clearActiveRunId: (runId: string) => Promise<void>
   disposeAbort: () => void
+  activeStreamId?: string
+  clearActiveStreamId?: (streamId: string) => Promise<void>
 }): Promise<void> {
+  // Clear the active run immediately so new messages are not blocked
+  params.unregisterRun(params.serverRunId)
+  await params.clearActiveRunId(params.serverRunId)
+  if (params.activeStreamId && params.clearActiveStreamId) {
+    await params.clearActiveStreamId(params.activeStreamId)
+  }
+  params.disposeAbort()
+
   try {
     const entity = await params.getEntity()
     const cursor = typeof entity.lastCompactedMessageId === 'string' ? entity.lastCompactedMessageId : undefined
     const uncompactedMessages = await params.getUncompactedMessages(cursor)
-    const summaryText = typeof entity.chatSummary === 'string' ? entity.chatSummary : ''
+    const summaryText = typeof entity.compactionSummary === 'string' ? entity.compactionSummary : ''
     const { shouldCompact } = params.assessCompaction(summaryText, uncompactedMessages)
 
     if (shouldCompact) {
       await params.enqueueCompaction()
     }
-  } finally {
-    params.unregisterRun(params.serverRunId)
-    await params.clearActiveRunId(params.serverRunId)
-    params.disposeAbort()
+  } catch {
+    // compaction assessment errors should not surface to callers
   }
 }

package/src/runtime/workstream-chat-helpers.ts

@@ -121,14 +121,14 @@ export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{
     .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
 }
 
-export function appendCompactionContextToHistoryMessages(
+export function appendPersistedWorkstreamContextToHistoryMessages(
   historyMessages: WorkstreamHistoryMessage[],
-  params: { chatSummary?: string | null; persistedState?: unknown },
+  params: { compactionSummary?: string | null; persistedState?: unknown },
 ): WorkstreamHistoryMessage[] {
   const nextHistoryMessages = [...historyMessages]
-  const chatSummary = typeof params.chatSummary === 'string' ? params.chatSummary.trim() : ''
-  if (chatSummary) {
-    nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${chatSummary}` })
+  const compactionSummary = typeof params.compactionSummary === 'string' ? params.compactionSummary.trim() : ''
+  if (compactionSummary) {
+    nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${compactionSummary}` })
   }
 
   if (params.persistedState !== undefined && params.persistedState !== null) {

package/src/services/context-compaction.service.ts

@@ -61,7 +61,7 @@ class ContextCompactionService {
     )
 
     const result = await contextCompactionRuntime.compactHistory({
-      summaryText: typeof workstream.chatSummary === 'string' ? workstream.chatSummary : '',
+      summaryText: typeof workstream.compactionSummary === 'string' ? workstream.compactionSummary : '',
       liveMessages,
       tailMessageCount: WORKSTREAM_RAW_TAIL_MESSAGES,
       contextSize: params.contextSize,
@@ -82,7 +82,11 @@ class ContextCompactionService {
     await databaseService.update(
       TABLES.WORKSTREAM,
       params.workstreamId,
-      { chatSummary: result.summaryText, lastCompactedMessageId: result.lastCompactedMessageId, state: result.state },
+      {
+        compactionSummary: result.summaryText,
+        lastCompactedMessageId: result.lastCompactedMessageId,
+        state: result.state,
+      },
       WorkstreamSchema,
     )
 

package/src/services/document-chunk.service.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto'
 
 import { chunkMarkdownDocument, chunkPagedDocument, chunkPlainTextDocument } from '../document/org-document-chunking'
 import type { ParsedDocumentChunk } from '../document/org-document-chunking'
-import { createDefaultEmbeddings } from '../embeddings/provider'
+import { getDefaultEmbeddings } from '../embeddings/provider'
 
 type DocumentChunkEmbeddings = {
   embedDocuments(documents: string[]): Promise<number[][]>
@@ -10,7 +10,7 @@ type DocumentChunkEmbeddings = {
 }
 
 function createDocumentChunkEmbeddings(): DocumentChunkEmbeddings {
-  const embeddings = createDefaultEmbeddings()
+  const embeddings = getDefaultEmbeddings()
 
   return {
     embedDocuments: async (documents) => await embeddings.embedDocuments(documents),