@lota-sdk/core 0.1.8 → 0.1.11

package/infrastructure/schema/00_workstream.surql

@@ -13,7 +13,8 @@ DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE workstream TYPE datetime VALUE tim
 DEFINE FIELD IF NOT EXISTS memoryBlock ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS memoryBlockSummary ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS activeRunId ON TABLE workstream TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS chatSummary ON TABLE workstream TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS activeStreamId ON TABLE workstream TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS compactionSummary ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS lastCompactedMessageId ON TABLE workstream TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS nameGenerated ON TABLE workstream TYPE bool DEFAULT false;
 DEFINE FIELD IF NOT EXISTS isCompacting ON TABLE workstream TYPE bool DEFAULT false;

package/infrastructure/schema/02_execution_plan.surql

@@ -1,53 +1,204 @@
-# Execution plan runtime.
-DEFINE TABLE IF NOT EXISTS plan SCHEMAFULL;
-DEFINE FIELD IF NOT EXISTS organizationId ON TABLE plan TYPE record<organization>;
-DEFINE FIELD IF NOT EXISTS workstreamId ON TABLE plan TYPE record<workstream> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD IF NOT EXISTS title ON TABLE plan TYPE string;
-DEFINE FIELD IF NOT EXISTS objective ON TABLE plan TYPE string;
-DEFINE FIELD IF NOT EXISTS status ON TABLE plan TYPE string;
-DEFINE FIELD IF NOT EXISTS leadAgentId ON TABLE plan TYPE string;
-DEFINE FIELD IF NOT EXISTS currentTaskId ON TABLE plan TYPE option<record<planTask>>;
-DEFINE FIELD IF NOT EXISTS restartFromTaskId ON TABLE plan TYPE option<record<planTask>>;
-DEFINE FIELD IF NOT EXISTS replacedPlanId ON TABLE plan TYPE option<record<plan>>;
-DEFINE FIELD IF NOT EXISTS failureCount ON TABLE plan TYPE int DEFAULT 0;
-DEFINE FIELD IF NOT EXISTS createdAt ON TABLE plan TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE plan TYPE datetime VALUE time::now();
-DEFINE FIELD IF NOT EXISTS startedAt ON TABLE plan TYPE option<datetime>;
-DEFINE FIELD IF NOT EXISTS completedAt ON TABLE plan TYPE option<datetime>;
-
-DEFINE INDEX IF NOT EXISTS planWorkstreamIdx ON TABLE plan COLUMNS workstreamId;
-DEFINE INDEX IF NOT EXISTS planWorkstreamStatusIdx ON TABLE plan COLUMNS workstreamId, status;
-
-DEFINE TABLE IF NOT EXISTS planTask SCHEMAFULL;
-DEFINE FIELD IF NOT EXISTS planId ON TABLE planTask TYPE record<plan> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD IF NOT EXISTS organizationId ON TABLE planTask TYPE record<organization>;
-DEFINE FIELD IF NOT EXISTS workstreamId ON TABLE planTask TYPE record<workstream>;
-DEFINE FIELD IF NOT EXISTS position ON TABLE planTask TYPE int;
-DEFINE FIELD IF NOT EXISTS title ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS rationale ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS kind ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS ownerType ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS ownerRef ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS status ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS resultStatus ON TABLE planTask TYPE string DEFAULT 'not-started';
-DEFINE FIELD IF NOT EXISTS input ON TABLE planTask TYPE option<object | string> FLEXIBLE;
-DEFINE FIELD IF NOT EXISTS outputSummary ON TABLE planTask TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS blockedReason ON TABLE planTask TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS externalRef ON TABLE planTask TYPE option<string>;
-DEFINE FIELD IF NOT EXISTS retryCount ON TABLE planTask TYPE int DEFAULT 0;
-DEFINE FIELD IF NOT EXISTS idempotencyKey ON TABLE planTask TYPE string;
-DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planTask TYPE datetime DEFAULT time::now() READONLY;
-DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE planTask TYPE datetime VALUE time::now();
-DEFINE FIELD IF NOT EXISTS startedAt ON TABLE planTask TYPE option<datetime>;
-DEFINE FIELD IF NOT EXISTS completedAt ON TABLE planTask TYPE option<datetime>;
-
-DEFINE INDEX IF NOT EXISTS planTaskPlanPositionIdx ON TABLE planTask COLUMNS planId, position;
-DEFINE INDEX IF NOT EXISTS planTaskPlanStatusIdx ON TABLE planTask COLUMNS planId, status;
-DEFINE INDEX IF NOT EXISTS planTaskIdempotencyIdx ON TABLE planTask COLUMNS idempotencyKey UNIQUE;
+# Execution plan runtime v2.
+
+DEFINE TABLE IF NOT EXISTS planSpec SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS organizationId ON TABLE planSpec TYPE record<organization>;
+DEFINE FIELD IF NOT EXISTS workstreamId ON TABLE planSpec TYPE record<workstream> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS title ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS objective ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS version ON TABLE planSpec TYPE int;
+DEFINE FIELD IF NOT EXISTS status ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS leadAgentId ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS schemaRegistry ON TABLE planSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS edges ON TABLE planSpec TYPE array<object> FLEXIBLE DEFAULT [];
+DEFINE FIELD IF NOT EXISTS edges.* ON TABLE planSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS edges.*.id ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS edges.*.source ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS edges.*.target ON TABLE planSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS edges.*.when ON TABLE planSpec TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS edges.*.map ON TABLE planSpec TYPE object FLEXIBLE DEFAULT {};
+DEFINE FIELD IF NOT EXISTS entryNodeIds ON TABLE planSpec TYPE array<string>;
+DEFINE FIELD IF NOT EXISTS replacedSpecId ON TABLE planSpec TYPE option<record<planSpec>>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planSpec TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE planSpec TYPE datetime VALUE time::now();
+DEFINE FIELD IF NOT EXISTS compiledAt ON TABLE planSpec TYPE option<datetime>;
+
+DEFINE INDEX IF NOT EXISTS planSpecWorkstreamIdx ON TABLE planSpec COLUMNS workstreamId;
+DEFINE INDEX IF NOT EXISTS planSpecWorkstreamStatusIdx ON TABLE planSpec COLUMNS workstreamId, status;
+
+DEFINE TABLE IF NOT EXISTS planNodeSpec SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planNodeSpec TYPE record<planSpec> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS position ON TABLE planNodeSpec TYPE int;
+DEFINE FIELD IF NOT EXISTS type ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS label ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS owner ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS objective ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS instructions ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS inputSchemaRef ON TABLE planNodeSpec TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS outputSchemaRef ON TABLE planNodeSpec TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS deliverables ON TABLE planNodeSpec TYPE array<object> FLEXIBLE DEFAULT [];
+DEFINE FIELD IF NOT EXISTS deliverables.* ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS deliverables.*.name ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS deliverables.*.kind ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS deliverables.*.required ON TABLE planNodeSpec TYPE bool DEFAULT true;
+DEFINE FIELD IF NOT EXISTS deliverables.*.schemaRef ON TABLE planNodeSpec TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS deliverables.*.description ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS successCriteria ON TABLE planNodeSpec TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS completionChecks ON TABLE planNodeSpec TYPE array<object> FLEXIBLE DEFAULT [];
+DEFINE FIELD IF NOT EXISTS completionChecks.* ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS completionChecks.*.type ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS completionChecks.*.config ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS completionChecks.*.blocking ON TABLE planNodeSpec TYPE bool DEFAULT true;
+DEFINE FIELD IF NOT EXISTS completionChecks.*.description ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS retryPolicy ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS failurePolicy ON TABLE planNodeSpec TYPE array<object> FLEXIBLE DEFAULT [];
+DEFINE FIELD IF NOT EXISTS failurePolicy.* ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS failurePolicy.*.on ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS failurePolicy.*.action ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS failurePolicy.*.note ON TABLE planNodeSpec TYPE string;
+DEFINE FIELD IF NOT EXISTS timeoutMs ON TABLE planNodeSpec TYPE option<int>;
+DEFINE FIELD IF NOT EXISTS toolPolicy ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS contextPolicy ON TABLE planNodeSpec TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS upstreamNodeIds ON TABLE planNodeSpec TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS downstreamNodeIds ON TABLE planNodeSpec TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planNodeSpec TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE planNodeSpec TYPE datetime VALUE time::now();
+
+DEFINE INDEX IF NOT EXISTS planNodeSpecPlanIdx ON TABLE planNodeSpec COLUMNS planSpecId;
+DEFINE INDEX IF NOT EXISTS planNodeSpecPlanNodeIdx ON TABLE planNodeSpec COLUMNS planSpecId, nodeId UNIQUE;
+DEFINE INDEX IF NOT EXISTS planNodeSpecPlanPositionIdx ON TABLE planNodeSpec COLUMNS planSpecId, position;
+
+DEFINE TABLE IF NOT EXISTS planRun SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planRun TYPE record<planSpec> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS organizationId ON TABLE planRun TYPE record<organization>;
+DEFINE FIELD IF NOT EXISTS workstreamId ON TABLE planRun TYPE record<workstream> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS leadAgentId ON TABLE planRun TYPE string;
+DEFINE FIELD IF NOT EXISTS status ON TABLE planRun TYPE string;
+DEFINE FIELD IF NOT EXISTS currentNodeId ON TABLE planRun TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS waitingNodeId ON TABLE planRun TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS readyNodeIds ON TABLE planRun TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS failureCount ON TABLE planRun TYPE int DEFAULT 0;
+DEFINE FIELD IF NOT EXISTS replacedRunId ON TABLE planRun TYPE option<record<planRun>>;
+DEFINE FIELD IF NOT EXISTS lastCheckpointId ON TABLE planRun TYPE option<record<planCheckpoint>>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planRun TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE planRun TYPE datetime VALUE time::now();
+DEFINE FIELD IF NOT EXISTS startedAt ON TABLE planRun TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS completedAt ON TABLE planRun TYPE option<datetime>;
+
+DEFINE INDEX IF NOT EXISTS planRunWorkstreamIdx ON TABLE planRun COLUMNS workstreamId;
+DEFINE INDEX IF NOT EXISTS planRunWorkstreamStatusIdx ON TABLE planRun COLUMNS workstreamId, status;
+DEFINE INDEX IF NOT EXISTS planRunSpecIdx ON TABLE planRun COLUMNS planSpecId;
+
+DEFINE TABLE IF NOT EXISTS planNodeRun SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planNodeRun TYPE record<planRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planNodeRun TYPE record<planSpec> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planNodeRun TYPE string;
+DEFINE FIELD IF NOT EXISTS status ON TABLE planNodeRun TYPE string;
+DEFINE FIELD IF NOT EXISTS attemptCount ON TABLE planNodeRun TYPE int DEFAULT 0;
+DEFINE FIELD IF NOT EXISTS retryCount ON TABLE planNodeRun TYPE int DEFAULT 0;
+DEFINE FIELD IF NOT EXISTS resolvedInput ON TABLE planNodeRun TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS latestStructuredOutput ON TABLE planNodeRun TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS latestNotes ON TABLE planNodeRun TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS latestAttemptId ON TABLE planNodeRun TYPE option<record<planNodeAttempt>>;
+DEFINE FIELD IF NOT EXISTS blockedReason ON TABLE planNodeRun TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS failureClass ON TABLE planNodeRun TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS readyAt ON TABLE planNodeRun TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS startedAt ON TABLE planNodeRun TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS completedAt ON TABLE planNodeRun TYPE option<datetime>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planNodeRun TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE planNodeRun TYPE datetime VALUE time::now();
+
+DEFINE INDEX IF NOT EXISTS planNodeRunRunIdx ON TABLE planNodeRun COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planNodeRunRunNodeIdx ON TABLE planNodeRun COLUMNS runId, nodeId UNIQUE;
+DEFINE INDEX IF NOT EXISTS planNodeRunRunStatusIdx ON TABLE planNodeRun COLUMNS runId, status;
+
+DEFINE TABLE IF NOT EXISTS planNodeAttempt SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planNodeAttempt TYPE record<planRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeRunId ON TABLE planNodeAttempt TYPE record<planNodeRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planNodeAttempt TYPE string;
+DEFINE FIELD IF NOT EXISTS emittedBy ON TABLE planNodeAttempt TYPE string;
+DEFINE FIELD IF NOT EXISTS status ON TABLE planNodeAttempt TYPE string;
+DEFINE FIELD IF NOT EXISTS structuredOutput ON TABLE planNodeAttempt TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS notes ON TABLE planNodeAttempt TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS validationIssueIds ON TABLE planNodeAttempt TYPE array<record<planValidationIssue>> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS failureClass ON TABLE planNodeAttempt TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planNodeAttempt TYPE datetime DEFAULT time::now() READONLY;
+
+DEFINE INDEX IF NOT EXISTS planNodeAttemptRunIdx ON TABLE planNodeAttempt COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planNodeAttemptNodeRunIdx ON TABLE planNodeAttempt COLUMNS nodeRunId;
+DEFINE INDEX IF NOT EXISTS planNodeAttemptRunNodeIdx ON TABLE planNodeAttempt COLUMNS runId, nodeId;
+
+DEFINE TABLE IF NOT EXISTS planArtifact SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planArtifact TYPE record<planRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planArtifact TYPE string;
+DEFINE FIELD IF NOT EXISTS attemptId ON TABLE planArtifact TYPE record<planNodeAttempt> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS name ON TABLE planArtifact TYPE string;
+DEFINE FIELD IF NOT EXISTS kind ON TABLE planArtifact TYPE string;
+DEFINE FIELD IF NOT EXISTS pointer ON TABLE planArtifact TYPE string;
+DEFINE FIELD IF NOT EXISTS schemaRef ON TABLE planArtifact TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS description ON TABLE planArtifact TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS payload ON TABLE planArtifact TYPE option<object | array> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planArtifact TYPE datetime DEFAULT time::now() READONLY;
+
+DEFINE INDEX IF NOT EXISTS planArtifactRunIdx ON TABLE planArtifact COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planArtifactAttemptIdx ON TABLE planArtifact COLUMNS attemptId;
+DEFINE INDEX IF NOT EXISTS planArtifactRunNodeNameIdx ON TABLE planArtifact COLUMNS runId, nodeId, name;
+
+DEFINE TABLE IF NOT EXISTS planValidationIssue SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planValidationIssue TYPE option<record<planSpec>>;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planValidationIssue TYPE option<record<planRun>>;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planValidationIssue TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS attemptId ON TABLE planValidationIssue TYPE option<record<planNodeAttempt>>;
+DEFINE FIELD IF NOT EXISTS severity ON TABLE planValidationIssue TYPE string;
+DEFINE FIELD IF NOT EXISTS code ON TABLE planValidationIssue TYPE string;
+DEFINE FIELD IF NOT EXISTS message ON TABLE planValidationIssue TYPE string;
+DEFINE FIELD IF NOT EXISTS detail ON TABLE planValidationIssue TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planValidationIssue TYPE datetime DEFAULT time::now() READONLY;
+
+DEFINE INDEX IF NOT EXISTS planValidationIssueSpecIdx ON TABLE planValidationIssue COLUMNS planSpecId;
+DEFINE INDEX IF NOT EXISTS planValidationIssueRunIdx ON TABLE planValidationIssue COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planValidationIssueAttemptIdx ON TABLE planValidationIssue COLUMNS attemptId;
+
+DEFINE TABLE IF NOT EXISTS planCheckpoint SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planCheckpoint TYPE record<planRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS sequence ON TABLE planCheckpoint TYPE int;
+DEFINE FIELD IF NOT EXISTS runStatus ON TABLE planCheckpoint TYPE string;
+DEFINE FIELD IF NOT EXISTS readyNodeIds ON TABLE planCheckpoint TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS activeNodeIds ON TABLE planCheckpoint TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS artifactIds ON TABLE planCheckpoint TYPE array<record<planArtifact>> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS lastCompletedNodeIds ON TABLE planCheckpoint TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS snapshot ON TABLE planCheckpoint TYPE object FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planCheckpoint TYPE datetime DEFAULT time::now() READONLY;
+
+DEFINE INDEX IF NOT EXISTS planCheckpointRunIdx ON TABLE planCheckpoint COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planCheckpointRunSequenceIdx ON TABLE planCheckpoint COLUMNS runId, sequence UNIQUE;
+
+DEFINE TABLE IF NOT EXISTS planApproval SCHEMAFULL;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planApproval TYPE record<planRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planApproval TYPE string;
+DEFINE FIELD IF NOT EXISTS nodeRunId ON TABLE planApproval TYPE record<planNodeRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS status ON TABLE planApproval TYPE string;
+DEFINE FIELD IF NOT EXISTS presented ON TABLE planApproval TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS response ON TABLE planApproval TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS requestedBy ON TABLE planApproval TYPE string;
+DEFINE FIELD IF NOT EXISTS respondedBy ON TABLE planApproval TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS approvalMessageId ON TABLE planApproval TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS comments ON TABLE planApproval TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS requiredEdits ON TABLE planApproval TYPE array<string> DEFAULT [];
+DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planApproval TYPE datetime DEFAULT time::now() READONLY;
+DEFINE FIELD IF NOT EXISTS updatedAt ON TABLE planApproval TYPE datetime VALUE time::now();
+DEFINE FIELD IF NOT EXISTS respondedAt ON TABLE planApproval TYPE option<datetime>;
+
+DEFINE INDEX IF NOT EXISTS planApprovalRunIdx ON TABLE planApproval COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planApprovalNodeRunIdx ON TABLE planApproval COLUMNS nodeRunId;
+DEFINE INDEX IF NOT EXISTS planApprovalRunStatusIdx ON TABLE planApproval COLUMNS runId, status;
 
 DEFINE TABLE IF NOT EXISTS planEvent SCHEMAFULL;
-DEFINE FIELD IF NOT EXISTS planId ON TABLE planEvent TYPE record<plan> REFERENCE ON DELETE CASCADE;
-DEFINE FIELD IF NOT EXISTS taskId ON TABLE planEvent TYPE option<record<planTask>>;
+DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planEvent TYPE record<planSpec> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS runId ON TABLE planEvent TYPE record<planRun> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS nodeId ON TABLE planEvent TYPE option<string>;
+DEFINE FIELD IF NOT EXISTS attemptId ON TABLE planEvent TYPE option<record<planNodeAttempt>>;
+DEFINE FIELD IF NOT EXISTS approvalId ON TABLE planEvent TYPE option<record<planApproval>>;
 DEFINE FIELD IF NOT EXISTS eventType ON TABLE planEvent TYPE string;
 DEFINE FIELD IF NOT EXISTS fromStatus ON TABLE planEvent TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS toStatus ON TABLE planEvent TYPE option<string>;
@@ -56,7 +207,6 @@ DEFINE FIELD IF NOT EXISTS detail ON TABLE planEvent TYPE option<object> FLEXIBL
 DEFINE FIELD IF NOT EXISTS emittedBy ON TABLE planEvent TYPE string;
 DEFINE FIELD IF NOT EXISTS createdAt ON TABLE planEvent TYPE datetime DEFAULT time::now() READONLY;
 
-DEFINE INDEX IF NOT EXISTS planEventPlanIdx ON TABLE planEvent COLUMNS planId;
-DEFINE INDEX IF NOT EXISTS planEventTaskIdx ON TABLE planEvent COLUMNS taskId;
-DEFINE INDEX IF NOT EXISTS planEventTypeIdx ON TABLE planEvent COLUMNS planId, eventType;
-DEFINE INDEX IF NOT EXISTS planEventTimeIdx ON TABLE planEvent COLUMNS planId, createdAt;
+DEFINE INDEX IF NOT EXISTS planEventRunIdx ON TABLE planEvent COLUMNS runId;
+DEFINE INDEX IF NOT EXISTS planEventRunNodeIdx ON TABLE planEvent COLUMNS runId, nodeId;
+DEFINE INDEX IF NOT EXISTS planEventRunTimeIdx ON TABLE planEvent COLUMNS runId, createdAt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -112,9 +112,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
+    "@ai-sdk/devtools": "^0.0.15",
     "@ai-sdk/openai": "^3.0.41",
     "@logtape/logtape": "^2.0.4",
-    "@lota-sdk/shared": "0.1.7",
+    "@lota-sdk/shared": "0.1.9",
     "@mendable/firecrawl-js": "^4.16.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.116",
@@ -123,6 +124,7 @@
     "ioredis": "5.9.3",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",
+    "resumable-stream": "^2.2.12",
     "surrealdb": "^2.0.2",
     "zod": "^4.3.6"
   }

package/src/bifrost/bifrost.ts

@@ -1,3 +1,4 @@
+import { devToolsMiddleware } from '@ai-sdk/devtools'
 import { createOpenAI } from '@ai-sdk/openai'
 import { wrapLanguageModel } from 'ai'
 import type { LanguageModelMiddleware } from 'ai'
@@ -36,6 +37,10 @@ function readReasoningDetailsText(value: unknown): string | null {
   return textParts.join('\n\n')
 }
 
+function readReasoningDeltaText(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
 function readBifrostChatReasoningText(message: Record<string, unknown>): string | null {
   return (
     readString(message.reasoning) ??
@@ -63,13 +68,29 @@ export function extractBifrostChatReasoningDeltaText(rawChunk: unknown): string
   for (const choice of rawChunk.choices) {
     if (!isRecord(choice) || !isRecord(choice.delta)) continue
 
-    const reasoningText = readBifrostChatReasoningText(choice.delta)
+    const reasoningText =
+      readReasoningDeltaText(choice.delta.reasoning) ??
+      readReasoningDeltaText(choice.delta.reasoning_content) ??
+      readReasoningDetailsText(choice.delta.reasoning_details)
     if (reasoningText) return reasoningText
   }
 
   return null
 }
 
+type BifrostResponsesReasoningDelta = { id: string; delta: string; itemId: string }
+
+export function extractBifrostResponsesReasoningDelta(rawChunk: unknown): BifrostResponsesReasoningDelta | null {
+  if (!isRecord(rawChunk) || rawChunk.type !== 'response.reasoning_summary_text.delta') return null
+  if ('summary_index' in rawChunk) return null
+
+  const itemId = readString(rawChunk.item_id)
+  const delta = readReasoningDeltaText(rawChunk.delta)
+  if (!itemId || !delta) return null
+
+  return { id: `${itemId}:0`, delta, itemId }
+}
+
 export function injectBifrostChatReasoningContent(
   content: readonly BifrostGeneratedContent[],
   response?: BifrostChatResponse,
@@ -143,6 +164,30 @@ export function injectBifrostChatReasoningStream(
   )
 }
 
+export function injectBifrostResponsesReasoningStream(
+  stream: ReadableStream<BifrostStreamPart>,
+): ReadableStream<BifrostStreamPart> {
+  return stream.pipeThrough(
+    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
+      transform(chunk, controller) {
+        controller.enqueue(chunk)
+
+        if (chunk.type !== 'raw') return
+
+        const reasoningDelta = extractBifrostResponsesReasoningDelta(chunk.rawValue)
+        if (!reasoningDelta) return
+
+        controller.enqueue({
+          type: 'reasoning-delta',
+          id: reasoningDelta.id,
+          delta: reasoningDelta.delta,
+          providerMetadata: { openai: { itemId: reasoningDelta.itemId } },
+        } as BifrostStreamPart)
+      },
+    }),
+  )
+}
+
 function addBifrostReasoningRawChunks(
   params: BifrostCallOptions,
   type: BifrostTransformParamsOptions['type'],
@@ -197,6 +242,14 @@ function createBifrostProvider(extraParams?: BifrostExtraParams) {
   })
 }
 
+function withBifrostDevTools<TModel>(model: TModel): TModel {
+  if (process.env.NODE_ENV === 'production') {
+    return model
+  }
+
+  return wrapLanguageModel({ model: model as never, middleware: devToolsMiddleware() }) as unknown as TModel
+}
+
 let provider: ReturnType<typeof createOpenAI> | null = null
 let openRouterResponseHealingProvider: ReturnType<typeof createOpenAI> | null = null
 
@@ -217,38 +270,54 @@ export function getBifrostOpenRouterResponseHealingProvider() {
 }
 
 export function bifrostModel(modelId: string) {
-  return getBifrostProvider()(modelId)
+  return withBifrostDevTools(
+    wrapLanguageModel({
+      model: getBifrostProvider()(modelId),
+      middleware: {
+        specificationVersion: 'v3',
+        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
+        wrapStream: async ({ doStream, params }) => {
+          const result = await doStream()
+          if (!isReasoningEnabled(params)) return result
+
+          return { ...result, stream: injectBifrostResponsesReasoningStream(result.stream) }
+        },
+      },
+    }),
+  )
 }
 
 export function bifrostOpenRouterResponseHealingModel(modelId: string) {
-  return getBifrostOpenRouterResponseHealingProvider()(modelId)
+  return withBifrostDevTools(getBifrostOpenRouterResponseHealingProvider()(modelId))
 }
 
 export function bifrostChatModel(modelId: string) {
-  return wrapLanguageModel({
-    model: getBifrostProvider().chat(modelId),
-    middleware: {
-      specificationVersion: 'v3',
-      transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
-      wrapGenerate: async ({ doGenerate }) => {
-        const result = await doGenerate()
-
-        return {
-          ...result,
-          content: injectBifrostChatReasoningContent(
-            result.content,
-            result.response as BifrostChatResponse | undefined,
-          ),
-        }
-      },
-      wrapStream: async ({ doStream, params }) => {
-        const result = await doStream()
-        if (!isReasoningEnabled(params)) return result
+  return withBifrostDevTools(
+    wrapLanguageModel({
+      model: getBifrostProvider().chat(modelId),
+      middleware: {
+        specificationVersion: 'v3',
+        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
+        wrapGenerate: async ({ doGenerate }) => {
+          const result = await doGenerate()
+
+          return {
+            ...result,
+            content: injectBifrostChatReasoningContent(
+              result.content,
+              result.response as BifrostChatResponse | undefined,
+            ),
+          }
+        },
+        wrapStream: async ({ doStream, params }) => {
+          const result = await doStream()
+          if (!isReasoningEnabled(params)) return result
 
-        return { ...result, stream: injectBifrostChatReasoningStream(result.stream) }
+          return { ...result, stream: injectBifrostChatReasoningStream(result.stream) }
+        },
       },
-    },
-  })
+    }),
+  )
 }
 
 export function bifrostEmbeddingModel(modelId: string) {

package/src/config/model-constants.ts

@@ -10,26 +10,28 @@ export const OPENROUTER_CODE_ANALYSIS_MODEL_ID = 'openrouter/xiaomi/mimo-v2-flas
 export const OPENROUTER_FAST_REASONING_MODEL_ID = 'openrouter/openai/gpt-oss-120b:nitro' as const
 export const OPENROUTER_STRUCTURED_REASONING_MODEL_ID = 'openrouter/openai/gpt-oss-120b:exacto' as const
 
+export const BIFROST_REASONING_SUMMARY_LEVEL = 'detailed' as const
+
 export const OPENAI_HIGH_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: 'auto' },
+  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
 } as const
 
 export const OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: 'auto' },
+  openai: { forceReasoning: true, reasoningEffort: 'high', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
 } as const
 
 export const OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'xhigh', reasoningSummary: 'auto' },
+  openai: { forceReasoning: true, reasoningEffort: 'xhigh', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
 } as const
 
 export const OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'medium', reasoningSummary: 'auto' },
+  openai: { forceReasoning: true, reasoningEffort: 'medium', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
 } as const
 
 export const OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'low', reasoningSummary: 'auto' },
+  openai: { forceReasoning: true, reasoningEffort: 'low', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
 } as const
 
 export const OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS = {
-  openai: { forceReasoning: true, reasoningEffort: 'minimal', reasoningSummary: 'auto' },
+  openai: { forceReasoning: true, reasoningEffort: 'minimal', reasoningSummary: BIFROST_REASONING_SUMMARY_LEVEL },
 } as const

package/src/db/memory-store.ts

@@ -1,10 +1,8 @@
 import { BoundQuery, eq, inside } from 'surrealdb'
 
-import { getEmbeddingCache } from '../ai/embedding-cache'
-import { env } from '../config/env-shapes'
 import { aiLogger } from '../config/logger'
 import { DEFAULT_MEMORY_SEARCH_LIMIT } from '../config/search'
-import { createDefaultEmbeddings } from '../embeddings/provider'
+import { getDefaultEmbeddings } from '../embeddings/provider'
 import { memoryQueryBuilder } from './memory-query-builder'
 import type { RelationCounts } from './memory-store.helpers'
 import { hashContent, mapRowToMemoryRecord, processGraphAwareRows } from './memory-store.helpers'
@@ -25,8 +23,6 @@ import { TABLES } from './tables'
 const MEMORY_TABLE = TABLES.MEMORY
 const MEMORY_HISTORY_TABLE = TABLES.MEMORY_HISTORY
 const MEMORY_RELATION_TABLE = TABLES.MEMORY_RELATION
-const EMBEDDING_CACHE_TTL_MS = 5 * 60 * 1000
-const EMBEDDING_CACHE_MAX_ENTRIES = 64
 const MIN_RELEVANCE_SCORE = 0.25
 const TOUCH_MEMORIES_MAX_ATTEMPTS = 4
 const TOUCH_MEMORIES_RETRY_BASE_DELAY_MS = 25
@@ -37,9 +33,6 @@ interface EmbeddingClient {
 }
 
 export class SurrealMemoryStore {
-  private embeddingCache = new Map<string, { embedding: number[]; ts: number }>()
-  private embeddingInFlight = new Map<string, Promise<number[]>>()
-
   constructor(private embeddings: EmbeddingClient) {}
 
   private toMetadataFieldPath(key: string): string {
@@ -183,72 +176,11 @@ export class SurrealMemoryStore {
       }))
   }
 
-  private getEmbeddingCacheKey(content: string): string {
-    return content.trim().toLowerCase()
-  }
-
-  private pruneEmbeddingCache(now: number): void {
-    for (const [cacheKey, entry] of this.embeddingCache.entries()) {
-      if (now - entry.ts > EMBEDDING_CACHE_TTL_MS) {
-        this.embeddingCache.delete(cacheKey)
-      }
-    }
-
-    while (this.embeddingCache.size > EMBEDDING_CACHE_MAX_ENTRIES) {
-      const oldest = this.embeddingCache.keys().next().value
-      if (!oldest) break
-      this.embeddingCache.delete(oldest)
-    }
-  }
-
   private async generateEmbedding(content: string): Promise<number[]> {
     const normalized = content.trim()
     if (!normalized) return []
 
-    const cacheKey = this.getEmbeddingCacheKey(normalized)
-    const now = Date.now()
-    this.pruneEmbeddingCache(now)
-
-    // L1: in-memory cache
-    const cached = this.embeddingCache.get(cacheKey)
-    if (cached && now - cached.ts <= EMBEDDING_CACHE_TTL_MS) {
-      return cached.embedding
-    }
-
-    const inFlight = this.embeddingInFlight.get(cacheKey)
-    if (inFlight) {
-      return await inFlight
-    }
-
-    const request = (async () => {
-      // L2: Redis cache
-      const redisCache = getEmbeddingCache()
-      if (redisCache) {
-        const model = env.AI_EMBEDDING_MODEL
-        const redisCached = await redisCache.get(model, normalized)
-        if (redisCached) {
-          this.embeddingCache.set(cacheKey, { embedding: redisCached, ts: Date.now() })
-          return redisCached
-        }
-      }
-
-      // L3: API call
-      const embedding = await this.embeddings.embedQuery(normalized)
-      this.embeddingCache.set(cacheKey, { embedding, ts: Date.now() })
-      this.pruneEmbeddingCache(Date.now())
-
-      // Backfill Redis
-      if (redisCache) {
-        void redisCache.set(env.AI_EMBEDDING_MODEL, normalized, embedding)
-      }
-
-      return embedding
-    })().finally(() => {
-      this.embeddingInFlight.delete(cacheKey)
-    })
-
-    this.embeddingInFlight.set(cacheKey, request)
-    return await request
+    return await this.embeddings.embedQuery(normalized)
   }
 
   async warmEmbedding(content: string): Promise<void> {
@@ -1059,7 +991,7 @@ let defaultMemoryStore: SurrealMemoryStore | null = null
 
 export function getDefaultMemoryStore(): SurrealMemoryStore {
   if (!defaultMemoryStore) {
-    defaultMemoryStore = new SurrealMemoryStore(createDefaultEmbeddings())
+    defaultMemoryStore = new SurrealMemoryStore(getDefaultEmbeddings())
   }
   return defaultMemoryStore
 }