@lota-sdk/core 0.1.9 → 0.1.12

package/infrastructure/schema/00_workstream.surql

@@ -13,6 +13,7 @@ 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 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;

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.9",
+  "version": "0.1.12",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -13,91 +13,6 @@
       "bun": "./src/index.ts",
       "import": "./src/index.ts",
       "types": "./src/index.ts"
-    },
-    "./ai/*": {
-      "bun": "./src/ai/*.ts",
-      "import": "./src/ai/*.ts",
-      "types": "./src/ai/*.ts"
-    },
-    "./bifrost": {
-      "bun": "./src/bifrost/bifrost.ts",
-      "import": "./src/bifrost/bifrost.ts",
-      "types": "./src/bifrost/bifrost.ts"
-    },
-    "./bifrost/*": {
-      "bun": "./src/bifrost/*.ts",
-      "import": "./src/bifrost/*.ts",
-      "types": "./src/bifrost/*.ts"
-    },
-    "./runtime/*": {
-      "bun": "./src/runtime/*.ts",
-      "import": "./src/runtime/*.ts",
-      "types": "./src/runtime/*.ts"
-    },
-    "./tools/*": {
-      "bun": "./src/tools/*.ts",
-      "import": "./src/tools/*.ts",
-      "types": "./src/tools/*.ts"
-    },
-    "./storage/*": {
-      "bun": "./src/storage/*.ts",
-      "import": "./src/storage/*.ts",
-      "types": "./src/storage/*.ts"
-    },
-    "./document/*": {
-      "bun": "./src/document/*.ts",
-      "import": "./src/document/*.ts",
-      "types": "./src/document/*.ts"
-    },
-    "./system-agents/*": {
-      "bun": "./src/system-agents/*.ts",
-      "import": "./src/system-agents/*.ts",
-      "types": "./src/system-agents/*.ts"
-    },
-    "./db/*": {
-      "bun": "./src/db/*.ts",
-      "import": "./src/db/*.ts",
-      "types": "./src/db/*.ts"
-    },
-    "./redis": {
-      "bun": "./src/redis/index.ts",
-      "import": "./src/redis/index.ts",
-      "types": "./src/redis/index.ts"
-    },
-    "./redis/*": {
-      "bun": "./src/redis/*.ts",
-      "import": "./src/redis/*.ts",
-      "types": "./src/redis/*.ts"
-    },
-    "./services/*": {
-      "bun": "./src/services/*.ts",
-      "import": "./src/services/*.ts",
-      "types": "./src/services/*.ts"
-    },
-    "./config/*": {
-      "bun": "./src/config/*.ts",
-      "import": "./src/config/*.ts",
-      "types": "./src/config/*.ts"
-    },
-    "./utils/*": {
-      "bun": "./src/utils/*.ts",
-      "import": "./src/utils/*.ts",
-      "types": "./src/utils/*.ts"
-    },
-    "./queues/*": {
-      "bun": "./src/queues/*.ts",
-      "import": "./src/queues/*.ts",
-      "types": "./src/queues/*.ts"
-    },
-    "./workers/*": {
-      "bun": "./src/workers/*.ts",
-      "import": "./src/workers/*.ts",
-      "types": "./src/workers/*.ts"
-    },
-    "./embeddings": {
-      "bun": "./src/embeddings/provider.ts",
-      "import": "./src/embeddings/provider.ts",
-      "types": "./src/embeddings/provider.ts"
     }
   },
   "scripts": {
@@ -112,9 +27,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.11",
     "@mendable/firecrawl-js": "^4.16.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.116",
@@ -123,6 +39,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/ai/index.ts

@@ -0,0 +1,3 @@
+export * from './definitions'
+export * from './embedding-cache'
+export * from '../embeddings/provider'

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/bifrost/index.ts

@@ -0,0 +1 @@
+export * from './bifrost'