@sixb/core 0.1.6 → 0.1.7

package/dist/{chunk-t624af60.js → chunk-6ed5bwnd.js}

@@ -1,4 +1,27 @@
 // @bun
+import {
+  SyncRunError,
+  assertSyncRunExecution
+} from "./chunk-4nxeacx7.js";
+import {
+  WebhookRunError,
+  assertWebhookRunExecution
+} from "./chunk-agsvg9ar.js";
+import {
+  WorkflowRunError,
+  assertWorkflowAgentNodeRunExecution,
+  assertWorkflowRunExecution
+} from "./chunk-qjzp9xyb.js";
+import {
+  CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
+  ConnectorConnectionStorageError
+} from "./chunk-5gd7tpv6.js";
+import {
+  ExecutionStorageError,
+  cloneExecutionRecord,
+  normalizeExecutionRecord,
+  validateExecutionRecordReferences
+} from "./chunk-gbrpsx4m.js";
 import {
   ProviderMaterializationTransactionLifecycle,
   appendScopeSnapshot,
@@ -27,7 +50,7 @@ import {
   startScopeAccumulator,
   uniqueSorted,
   workUniquenessKey
-} from "./chunk-72q2y8hn.js";
+} from "./chunk-8tsf6dmc.js";
 import {
   createAgentOperationScope,
   createAuthOperationScope,
@@ -39,7 +62,7 @@ import {
 import {
   PipelineRunError,
   assertPipelineRunExecution
-} from "./chunk-cy0n5dms.js";
+} from "./chunk-5jcdmjam.js";
 import {
   ProjectionRunError,
   advanceProjectionTelemetry,
@@ -66,27 +89,14 @@ import {
   publicProjectionRunRecord,
   requireTelemetryProjectionRun,
   staleProjectionRunExecution
-} from "./chunk-dysw7nsm.js";
-import {
-  SyncRunError,
-  assertSyncRunExecution
-} from "./chunk-62c7t4jc.js";
-import {
-  WebhookRunError,
-  assertWebhookRunExecution
-} from "./chunk-ezake7g1.js";
-import {
-  WorkflowRunError,
-  assertWorkflowAgentNodeRunExecution,
-  assertWorkflowRunExecution
-} from "./chunk-fe5ev6mr.js";
+} from "./chunk-xdpwpkha.js";
 import {
   parseActionRunFailure
-} from "./chunk-htq0qh7z.js";
+} from "./chunk-ka3a2ft3.js";
 import {
   ActionRunError,
   assertActionRunExecution
-} from "./chunk-xkthy56g.js";
+} from "./chunk-1kamz6j0.js";
 import {
   AgentStorageError,
   agentContextCheckpointMatchesCreateInput,
@@ -94,25 +104,45 @@ import {
   assertAgentContextCheckpointAuthority,
   assertAgentContextCheckpointReplayState,
   assertAgentRunExecution,
-  assertCreateAgentContextCheckpointInput
-} from "./chunk-1g8negke.js";
+  assertConversationAgentRunSpec,
+  assertCreateAgentContextCheckpointInput,
+  assertCreateSubagentRunInput,
+  assertSubagentRunResult,
+  subagentRunMatchesCreateInput
+} from "./chunk-08twe8m6.js";
 import {
   InMemoryAiUsageStorage,
   aiModelCallCostMatchesUsage,
   buildAiAccountingOverview,
   buildAiModelCallAccountingList,
+  buildAiModelCallGroups,
   normalizeAiModelCallCostRecord
-} from "./chunk-drjqm1aa.js";
-import {
-  CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
-  ConnectorConnectionStorageError
-} from "./chunk-5gd7tpv6.js";
+} from "./chunk-p03r0h5s.js";
 import {
-  ExecutionStorageError,
-  cloneExecutionRecord,
-  normalizeExecutionRecord,
-  validateExecutionRecordReferences
-} from "./chunk-h9kxd41f.js";
+  AiLimitOperationLock,
+  AiLimitStorageError,
+  aiLimitAccountingEntryAppliesToSubject,
+  aiLimitAmountKey,
+  aiLimitCalendarMonth,
+  aiLimitPolicyDimensionKey,
+  aiLimitQuantityFromAmount,
+  aiLimitReservationBuckets,
+  aiLimitReservationRequestKey,
+  aiLimitReservationRequestMatches,
+  aiLimitSubjectKey,
+  aiLimitSubjectsFromAccountingEntry,
+  aiModelCallReservationKey,
+  assertAiLimitAccountingMatchesReservation,
+  assertNonBlank,
+  cloneAiLimitPolicy,
+  cloneValidDate,
+  normalizeAiLimitAmount,
+  normalizeAiModelCallReservationIdentity,
+  normalizeCreateAiLimitPolicy,
+  normalizeReserveAiModelCall,
+  normalizeUpdateAiLimitPolicy,
+  resolveAiLimitActual
+} from "./chunk-jecn6t54.js";
 import {
   assertPinnedDatasetWatermark
 } from "./chunk-9dzba0f2.js";
@@ -126,22 +156,22 @@ import {
   projectionEntityKey,
   telemetryPointKey,
   telemetryPointSortKey
-} from "./chunk-vybf6pkp.js";
+} from "./chunk-dbc80ad7.js";
 import {
   MaterializationConflictError,
   MaterializationValidationError
 } from "./chunk-ry24jbr1.js";
 import {
   AGENT_RUN_FAILURE_CODES
-} from "./chunk-t0jjkep3.js";
+} from "./chunk-d8qkxt2v.js";
 import {
   InMemoryAuthStorage,
   paginate,
   principalsEqual
-} from "./chunk-1e8m6yn3.js";
+} from "./chunk-rre42skh.js";
 import {
   normalizeRequesterGroupIds
-} from "./chunk-rhrbz7d4.js";
+} from "./chunk-4a849fr1.js";
 import {
   compareDecimalValues
 } from "./chunk-04b07a9q.js";
@@ -149,11 +179,11 @@ import {
   createSixbError,
   parseSixbFailure,
   toSixbFailure
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 import {
   cloneJsonValue,
   stableJsonStringify
-} from "./chunk-t8t39h7v.js";
+} from "./chunk-n6jxh8sw.js";
 // src/storage/action-runs/idempotency.ts
 function actionSubjectsEqual(left, right) {
   if (left.kind !== right.kind)
@@ -191,7 +221,7 @@ var runDirectly = async (run) => run();
 function actionRunKey(projectId, id) {
   return JSON.stringify([projectId, id]);
 }
-function assertNonBlank(value, fieldName) {
+function assertNonBlank2(value, fieldName) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new ActionRunError(`[Sixb] Action materialization ${fieldName} must be nonblank.`);
   }
@@ -451,9 +481,9 @@ class InMemoryActionRunStorage {
     });
   }
   requireMaterializationRun(input) {
-    assertNonBlank(input.projectId, "projectId");
-    assertNonBlank(input.runId, "runId");
-    assertNonBlank(input.actionId, "actionId");
+    assertNonBlank2(input.projectId, "projectId");
+    assertNonBlank2(input.runId, "runId");
+    assertNonBlank2(input.actionId, "actionId");
     const existing = this.rows.get(actionRunKey(input.projectId, input.runId));
     if (!existing) {
       throw new ActionRunError(`[Sixb] Action run '${input.runId}' not found for project '${input.projectId}'.`);
@@ -468,7 +498,7 @@ class InMemoryActionRunStorage {
   }
 }
 // src/agents/message.ts
-var AGENT_MESSAGE_CONTENT_VERSION = 1;
+var AGENT_MESSAGE_CONTENT_VERSION = 2;
 
 // src/storage/agents/in-memory.ts
 function normalizeFailure(failure) {
@@ -511,7 +541,6 @@ class InMemoryAgentThreadStore {
     const record = {
       id: input.id,
       projectId: input.projectId,
-      agentId: input.agentId,
       ownerPrincipal: clone(input.ownerPrincipal),
       ...input.title === undefined ? {} : { title: input.title },
       status: input.status ?? "active",
@@ -530,8 +559,7 @@ class InMemoryAgentThreadStore {
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
-    const agentIds = input.agentIds ? new Set(input.agentIds) : null;
-    const filtered = [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => input.agentId ? thread.agentId === input.agentId : true).filter((thread) => agentIds ? agentIds.has(thread.agentId) : true).filter((thread) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual(thread.ownerPrincipal, input.ownerPrincipal) : true).sort((a, b) => compareByDate(a.lastMessageAt ?? a.createdAt, b.lastMessageAt ?? b.createdAt, a.id, b.id, order));
+    const filtered = [...this.state.threads.values()].filter((thread) => thread.projectId === input.projectId).filter((thread) => statuses ? statuses.has(thread.status) : true).filter((thread) => input.ownerPrincipal ? principalsEqual(thread.ownerPrincipal, input.ownerPrincipal) : true).sort((a, b) => compareByDate(a.lastMessageAt ?? a.createdAt, b.lastMessageAt ?? b.createdAt, a.id, b.id, order));
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { threads: page.map(clone), hasMore, total };
   }
@@ -545,12 +573,12 @@ class InMemoryAgentRunStore {
     this.executions = executions;
   }
   async create(input) {
+    assertConversationAgentRunSpec(input.spec);
     await assertAgentRunExecution({
       executions: this.executions,
       projectId: input.projectId,
       executionId: input.executionId,
-      runId: input.id,
-      agentId: input.agentId
+      runId: input.id
     });
     const threadKey = key(input.projectId, input.threadId);
     const thread = this.state.threads.get(threadKey);
@@ -569,12 +597,13 @@ class InMemoryAgentRunStore {
     }
     const createdAt = new Date(input.createdAt ?? new Date);
     const run = {
+      kind: "conversation",
       id: input.id,
       projectId: input.projectId,
       executionId: input.executionId,
       threadId: input.threadId,
-      agentId: input.agentId,
       triggerMessageId: input.triggerMessageId,
+      spec: clone(input.spec),
       requesterGroupIds: normalizeRequesterGroupIds(input.requesterGroupIds),
       status: "queued",
       attempt: 0,
@@ -589,6 +618,57 @@ class InMemoryAgentRunStore {
     this.state.threads.set(threadKey, clone(updatedThread));
     return clone(run);
   }
+  async createSubagent(input) {
+    assertCreateSubagentRunInput(input);
+    const execution = await assertAgentRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id
+    });
+    const runKey = key(input.projectId, input.id);
+    const existing = this.state.runs.get(runKey);
+    if (existing) {
+      if (subagentRunMatchesCreateInput(existing, input))
+        return clone(existing);
+      throw new AgentStorageError("duplicate_id", `[Sixb] Subagent run '${input.id}' already exists with different immutable inputs.`);
+    }
+    const parent = this.state.runs.get(key(input.projectId, input.parentRunId));
+    if (!parent || parent.kind !== "conversation") {
+      throw new AgentStorageError("run_not_found", `[Sixb] Parent Agent run '${input.parentRunId}' was not found.`);
+    }
+    if (parent.status !== "running") {
+      throw new AgentStorageError("invalid_state", `[Sixb] Parent Agent run '${parent.id}' is not running (status '${parent.status}').`);
+    }
+    if (execution.source.type !== "execution" || execution.source.executionId !== parent.executionId) {
+      throw new AgentStorageError("invalid_input", `[Sixb] Subagent execution '${execution.id}' is not a child of parent execution '${parent.executionId}'.`);
+    }
+    if (parent.execution?.token !== input.parentExecutionToken) {
+      throw new AgentStorageError("execution_lost", `[Sixb] Parent Agent run '${parent.id}' is no longer owned by this execution.`);
+    }
+    const activeChildren = [...this.state.runs.values()].filter((run2) => run2.kind === "subagent" && run2.projectId === input.projectId && run2.parentRunId === parent.id && (run2.status === "queued" || run2.status === "running")).length;
+    if (activeChildren >= input.maxActiveChildren) {
+      throw new AgentStorageError("active_child_limit", `[Sixb] Agent run '${parent.id}' already has ${activeChildren} active subagents.`);
+    }
+    if ([...this.state.runs.values()].some((run2) => run2.projectId === input.projectId && run2.executionId === input.executionId)) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Execution '${input.executionId}' already belongs to another Agent run.`);
+    }
+    const run = {
+      kind: "subagent",
+      id: input.id,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      parentRunId: input.parentRunId,
+      spawnKey: input.spawnKey,
+      spec: clone(input.spec),
+      requesterGroupIds: clone(parent.requesterGroupIds),
+      status: "queued",
+      attempt: 0,
+      createdAt: new Date(input.createdAt ?? new Date)
+    };
+    this.state.runs.set(runKey, clone(run));
+    return clone(run);
+  }
   async start(input) {
     const run = this.requireStatus(input.projectId, input.id, "queued");
     const startedAt = new Date(input.startedAt ?? new Date);
@@ -646,6 +726,12 @@ class InMemoryAgentRunStore {
     if (!run.execution || run.execution.token !== input.executionToken) {
       throw new AgentStorageError("execution_lost", `[Sixb] Execution token is no longer current on agent run '${input.id}'.`);
     }
+    if (input.status === "succeeded" && run.kind === "subagent") {
+      assertSubagentRunResult(input.result, run.id);
+    }
+    if (input.status === "succeeded" && run.kind === "conversation" && input.result !== undefined) {
+      throw new AgentStorageError("invalid_input", `[Sixb] Conversational Agent run '${run.id}' cannot persist a subagent result.`);
+    }
     const completedAt = new Date(input.completedAt ?? new Date);
     const next = {
       ...run,
@@ -653,6 +739,7 @@ class InMemoryAgentRunStore {
       ...input.modelId === undefined ? {} : { modelId: input.modelId },
       ...input.finishReason === undefined ? {} : { finishReason: input.finishReason },
       ...input.diagnostics === undefined ? {} : { diagnostics: clone(input.diagnostics) },
+      ...input.status === "succeeded" && input.result !== undefined ? { result: clone(input.result) } : {},
       ...input.status === "succeeded" || input.error === undefined ? {} : { error: normalizeFailure(input.error) },
       execution: undefined,
       completedAt
@@ -671,7 +758,8 @@ class InMemoryAgentRunStore {
   async list(input) {
     const order = input.order ?? "desc";
     const statuses = input.statuses ? new Set(input.statuses) : null;
-    const filtered = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.threadId ? run.threadId === input.threadId : true).filter((run) => input.agentId ? run.agentId === input.agentId : true).filter((run) => statuses ? statuses.has(run.status) : true).filter((run) => input.startedAfter ? (run.startedAt ?? run.createdAt) >= input.startedAfter : true).filter((run) => input.startedBefore ? (run.startedAt ?? run.createdAt) <= input.startedBefore : true).sort((a, b) => compareByDate(a.startedAt ?? a.createdAt, b.startedAt ?? b.createdAt, a.id, b.id, order));
+    const kinds = input.kinds ? new Set(input.kinds) : null;
+    const filtered = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => kinds ? kinds.has(run.kind) : true).filter((run) => input.threadId ? run.kind === "conversation" && run.threadId === input.threadId : true).filter((run) => input.parentRunId ? run.kind === "subagent" && run.parentRunId === input.parentRunId : true).filter((run) => statuses ? statuses.has(run.status) : true).filter((run) => input.startedAfter ? (run.startedAt ?? run.createdAt) >= input.startedAfter : true).filter((run) => input.startedBefore ? (run.startedAt ?? run.createdAt) <= input.startedBefore : true).sort((a, b) => compareByDate(a.startedAt ?? a.createdAt, b.startedAt ?? b.createdAt, a.id, b.id, order));
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { runs: page.map(clone), hasMore, total };
   }
@@ -689,6 +777,8 @@ class InMemoryAgentRunStore {
     return run;
   }
   releaseThread(run, completedAt) {
+    if (run.kind !== "conversation")
+      return;
     const threadKey = key(run.projectId, run.threadId);
     const thread = this.state.threads.get(threadKey);
     if (thread && thread.activeRunId === run.id) {
@@ -926,9 +1016,9 @@ class InMemoryAiCostStorage {
       this.recordsByUsage.set(key2, structuredClone(record));
   }
   async summarizeExecutions(input) {
-    assertNonBlank2(input.projectId, "cost summary projectId");
+    assertNonBlank3(input.projectId, "cost summary projectId");
     for (const id of input.executionIds)
-      assertNonBlank2(id, "cost summary executionId");
+      assertNonBlank3(id, "cost summary executionId");
     const requested = new Set(input.executionIds);
     const usageByExecution = new Map(input.executionIds.map((id) => [id, []]));
     for (const usage of this.usage.snapshot().records.values()) {
@@ -947,9 +1037,32 @@ class InMemoryAiCostStorage {
   snapshot() {
     return structuredClone({ recordsByUsage: this.recordsByUsage });
   }
+  async listModelCallGroups(input) {
+    const items = await this.accountingItems();
+    const roots = new Map;
+    return buildAiModelCallGroups(input, await Promise.all(items.map(async (item) => {
+      const key2 = usageRecordKey(item.usage.projectId, item.usage.executionId);
+      let root = roots.get(key2);
+      if (!root) {
+        root = this.attribution?.resolveGroup?.({
+          projectId: item.usage.projectId,
+          executionId: item.usage.executionId
+        }) ?? Promise.resolve({
+          executionId: item.usage.executionId,
+          attribution: item.attribution
+        });
+        roots.set(key2, root);
+      }
+      return { ...item, root: await root };
+    })));
+  }
   restore(snapshot) {
     replaceMap(this.recordsByUsage, snapshot.recordsByUsage);
   }
+  getRecord(projectId, usageRecordId) {
+    const record = this.recordsByUsage.get(usageRecordKey(projectId, usageRecordId));
+    return record ? structuredClone(record) : null;
+  }
   usageRecord(projectId, id) {
     return [...this.usage.snapshot().records.values()].find((record) => record.projectId === projectId && record.id === id);
   }
@@ -1000,7 +1113,7 @@ function addMoney(amounts, money) {
 function usageRecordKey(projectId, id) {
   return JSON.stringify([projectId, id]);
 }
-function assertNonBlank2(value, field) {
+function assertNonBlank3(value, field) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
   }
@@ -1010,6 +1123,429 @@ function replaceMap(target, source) {
   for (const [key2, value] of structuredClone(source))
     target.set(key2, value);
 }
+// src/storage/ai-limits/in-memory.ts
+class InMemoryAiLimitStorage {
+  options;
+  policies = new Map;
+  policyIdsByDimension = new Map;
+  periodStates = new Map;
+  reservations = new Map;
+  operations = new AiLimitOperationLock;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  settleOperations() {
+    return this.operations.settle();
+  }
+  async createPolicy(input) {
+    return this.operations.run(async () => {
+      const policy = normalizeCreateAiLimitPolicy(input);
+      const key2 = policyKey(policy.projectId, policy.id);
+      const dimensionKey = aiLimitPolicyDimensionKey(policy);
+      if (this.policies.has(key2) || this.policyIdsByDimension.has(dimensionKey)) {
+        throw new AiLimitStorageError("duplicate_policy", `[Sixb] An AI limit policy already exists for '${aiLimitSubjectKey(policy.subject)}' and '${aiLimitAmountKey(normalizeAiLimitAmount(policy.limit))}'.`);
+      }
+      this.policies.set(key2, structuredClone(policy));
+      this.policyIdsByDimension.set(dimensionKey, key2);
+      return cloneAiLimitPolicy(policy);
+    });
+  }
+  async updatePolicy(input) {
+    return this.operations.run(async () => {
+      const update = normalizeUpdateAiLimitPolicy(input);
+      const key2 = policyKey(update.projectId, update.id);
+      const existing = this.policies.get(key2);
+      if (!existing)
+        throw missingPolicy(update.projectId, update.id);
+      if (update.limit !== undefined) {
+        const previous = normalizeAiLimitAmount(existing.limit);
+        const next = normalizeAiLimitAmount(update.limit);
+        if (aiLimitAmountKey(previous) !== aiLimitAmountKey(next)) {
+          throw new TypeError("[Sixb] AI limit policy meter and cost currency are immutable.");
+        }
+      }
+      const policy = {
+        ...existing,
+        ...update.limit === undefined ? {} : { limit: update.limit },
+        ...update.enabled === undefined ? {} : { enabled: update.enabled },
+        updatedAt: update.updatedAt
+      };
+      this.policies.set(key2, structuredClone(policy));
+      return cloneAiLimitPolicy(policy);
+    });
+  }
+  async deletePolicy(input) {
+    return this.operations.run(async () => {
+      validatePolicyIdentity(input);
+      const key2 = policyKey(input.projectId, input.id);
+      const existing = this.policies.get(key2);
+      if (!existing)
+        return false;
+      this.policies.delete(key2);
+      this.policyIdsByDimension.delete(aiLimitPolicyDimensionKey(existing));
+      return true;
+    });
+  }
+  async getPolicy(input) {
+    validatePolicyIdentity(input);
+    const policy = this.policies.get(policyKey(input.projectId, input.id));
+    return policy ? cloneAiLimitPolicy(policy) : null;
+  }
+  async listPolicies(input) {
+    assertNonBlank(input.projectId, "projectId");
+    return [...this.policies.values()].filter((policy) => policy.projectId === input.projectId && (input.includeDisabled || policy.enabled)).sort((left, right) => left.id.localeCompare(right.id)).map(cloneAiLimitPolicy);
+  }
+  async listPolicyStatuses(input) {
+    return this.operations.run(async () => {
+      assertNonBlank(input.projectId, "projectId");
+      const period = aiLimitCalendarMonth(input.at ?? new Date);
+      const existingGroups = input.existingGroupIds === undefined ? undefined : new Set(input.existingGroupIds);
+      const policies = await this.listPolicies({
+        projectId: input.projectId,
+        includeDisabled: input.includeDisabled
+      });
+      return Promise.all(policies.map((policy) => this.policyStatus(policy, period, existingGroups)));
+    });
+  }
+  async reserveModelCall(input) {
+    return this.operations.run(async () => {
+      const request = normalizeReserveAiModelCall(input);
+      const reservationKey = aiModelCallReservationKey(request.identity);
+      const existing = this.reservations.get(reservationKey);
+      if (existing) {
+        if (!aiLimitReservationRequestMatches(existing, request)) {
+          throw new AiLimitStorageError("reservation_conflict", `[Sixb] AI model-call reservation '${input.callId}' was replayed with different subjects, estimates, or period.`);
+        }
+        if (existing.state !== "active") {
+          return { status: "terminal", reservation: structuredClone(existing), created: false };
+        }
+        return { status: "reserved", reservation: structuredClone(existing), created: false };
+      }
+      await this.assertExecutionExists(request.identity.projectId, request.identity.executionId);
+      const enabledPolicies = [...this.policies.values()].filter((policy) => policy.projectId === request.identity.projectId && policy.enabled);
+      const subjectKeys = new Set(request.subjects.map(aiLimitSubjectKey));
+      const estimates = new Map(request.estimates.map((quantity) => {
+        const amount = normalizeAiLimitAmount(quantity);
+        return [aiLimitAmountKey(amount), amount];
+      }));
+      const exhaustedPolicies = [];
+      const unavailablePolicies = [];
+      const unavailableReasons = new Set;
+      for (const policy of enabledPolicies) {
+        if (!subjectKeys.has(aiLimitSubjectKey(policy.subject)))
+          continue;
+        const limit = normalizeAiLimitAmount(policy.limit);
+        const estimate = estimates.get(aiLimitAmountKey(limit));
+        const status = await this.policyStatus(policy, request.period);
+        if (!estimate || status.accountingStatus === "unavailable") {
+          unavailablePolicies.push(status);
+          if (!estimate)
+            unavailableReasons.add("missingEstimate");
+          if (status.accountingStatus === "unavailable") {
+            unavailableReasons.add("incompleteAccounting");
+          }
+          continue;
+        }
+        const actual = normalizeAiLimitAmount(status.consumption.actual).amount;
+        const reserved = normalizeAiLimitAmount(status.consumption.reserved).amount;
+        const unknown = normalizeAiLimitAmount(status.consumption.unknown).amount;
+        if (actual + reserved + unknown + estimate.amount > limit.amount) {
+          exhaustedPolicies.push(status);
+        }
+      }
+      if (unavailablePolicies.length > 0) {
+        unavailablePolicies.sort((left, right) => left.policy.id.localeCompare(right.policy.id));
+        return {
+          status: "unavailable",
+          unavailablePolicies,
+          reasons: [...unavailableReasons].sort()
+        };
+      }
+      if (exhaustedPolicies.length > 0) {
+        exhaustedPolicies.sort((left, right) => left.policy.id.localeCompare(right.policy.id));
+        return {
+          status: "denied",
+          exhaustedPolicies,
+          resetAt: new Date(Math.min(...exhaustedPolicies.map((status) => status.period.resetAt.getTime())))
+        };
+      }
+      const buckets = aiLimitReservationBuckets(enabledPolicies, request.subjects, request.estimates);
+      if (buckets.length === 0)
+        return { status: "notRequired" };
+      for (const bucket of buckets) {
+        const amount = normalizeAiLimitAmount(bucket.estimate);
+        const state = this.requirePeriodState(request.identity.projectId, bucket.subject, amount, request.period);
+        state.reserved += amount.amount;
+        state.updatedAt = new Date(request.reservedAt);
+      }
+      const reservation = {
+        ...request.identity,
+        buckets,
+        requestKey: aiLimitReservationRequestKey(request),
+        period: request.period,
+        state: "active",
+        reservedAt: request.reservedAt,
+        updatedAt: new Date(request.reservedAt)
+      };
+      this.reservations.set(reservationKey, structuredClone(reservation));
+      return { status: "reserved", reservation: structuredClone(reservation), created: true };
+    });
+  }
+  async recordModelCallActuals(input) {
+    return this.operations.run(async () => {
+      assertNonBlank(input.projectId, "projectId");
+      assertNonBlank(input.usageRecordId, "usageRecordId");
+      const recordedAt = cloneValidDate(input.recordedAt ?? new Date, "recordedAt");
+      const entry = await this.requireAccountingEntry(input.projectId, input.usageRecordId);
+      const period = aiLimitCalendarMonth(entry.occurredAt);
+      const subjectKeys = new Set(aiLimitSubjectsFromAccountingEntry(entry).map(aiLimitSubjectKey));
+      for (const state of this.periodStates.values()) {
+        if (state.projectId !== input.projectId || state.period.start.getTime() !== period.start.getTime() || !subjectKeys.has(aiLimitSubjectKey(state.subject))) {
+          continue;
+        }
+        const actual = resolveAiLimitActual([entry], state);
+        state.actual += actual.amount;
+        if (actual.accountingStatus === "unavailable")
+          state.accountingStatus = "unavailable";
+        state.updatedAt = new Date(recordedAt);
+      }
+    });
+  }
+  async reconcileModelCall(input) {
+    return this.operations.run(async () => {
+      const identity = normalizeAiModelCallReservationIdentity(input);
+      assertNonBlank(input.usageRecordId, "usageRecordId");
+      const reconciledAt = cloneValidDate(input.reconciledAt ?? new Date, "reconciledAt");
+      const key2 = aiModelCallReservationKey(identity);
+      const reservation = this.reservations.get(key2);
+      if (!reservation)
+        throw missingReservation(identity);
+      if (reservation.state === "reconciled") {
+        if (reservation.usageRecordId === input.usageRecordId) {
+          return structuredClone(reservation);
+        }
+        throw new AiLimitStorageError("reconciliation_conflict", `[Sixb] AI model-call reservation '${identity.callId}' was reconciled with a different usage record.`);
+      }
+      const accounting = await this.requireAccountingEntry(identity.projectId, input.usageRecordId);
+      assertAiLimitAccountingMatchesReservation(reservation, accounting);
+      this.reconcileEstimateCounters(reservation, accounting, reconciledAt);
+      const reconciled = {
+        ...reservation,
+        state: "reconciled",
+        usageRecordId: input.usageRecordId,
+        updatedAt: reconciledAt
+      };
+      this.reservations.set(key2, structuredClone(reconciled));
+      return structuredClone(reconciled);
+    });
+  }
+  async markReservationUnknown(input) {
+    return this.operations.run(async () => {
+      const identity = normalizeAiModelCallReservationIdentity(input);
+      const markedAt = cloneValidDate(input.markedAt ?? new Date, "markedAt");
+      const key2 = aiModelCallReservationKey(identity);
+      const reservation = this.reservations.get(key2);
+      if (!reservation)
+        throw missingReservation(identity);
+      if (reservation.state === "unknown")
+        return structuredClone(reservation);
+      if (reservation.state !== "active")
+        throw invalidState(reservation, "mark unknown");
+      this.moveEstimateCounter(reservation, "reserved", -1n, markedAt);
+      this.moveEstimateCounter(reservation, "unknown", 1n, markedAt);
+      const unknown = {
+        ...reservation,
+        state: "unknown",
+        updatedAt: markedAt
+      };
+      this.reservations.set(key2, structuredClone(unknown));
+      return structuredClone(unknown);
+    });
+  }
+  snapshot() {
+    return structuredClone({
+      policies: this.policies,
+      policyIdsByDimension: this.policyIdsByDimension,
+      periodStates: this.periodStates,
+      reservations: this.reservations
+    });
+  }
+  restore(snapshot) {
+    replaceMap2(this.policies, snapshot.policies);
+    replaceMap2(this.policyIdsByDimension, snapshot.policyIdsByDimension);
+    replaceMap2(this.periodStates, snapshot.periodStates);
+    replaceMap2(this.reservations, snapshot.reservations);
+  }
+  async policyStatus(policy, period, existingGroups) {
+    const limit = normalizeAiLimitAmount(policy.limit);
+    const state = await this.ensurePeriodState(policy, period);
+    const reserved = state.reserved;
+    const unknown = state.unknown;
+    const consumed = state.actual + reserved + unknown;
+    const remaining = limit.amount > consumed ? limit.amount - consumed : 0n;
+    const quantity = (amount) => aiLimitQuantityFromAmount({ ...limit, amount });
+    return {
+      policy: cloneAiLimitPolicy(policy),
+      period: structuredClone(period),
+      consumption: {
+        actual: quantity(state.actual),
+        reserved: quantity(reserved),
+        unknown: quantity(unknown),
+        remaining: quantity(remaining)
+      },
+      accountingStatus: state.accountingStatus,
+      exhausted: consumed >= limit.amount,
+      orphaned: policy.subject.type === "group" && existingGroups !== undefined && !existingGroups.has(policy.subject.id)
+    };
+  }
+  async ensurePeriodState(policy, period) {
+    const amount = normalizeAiLimitAmount(policy.limit);
+    const key2 = periodStateKey(policy.projectId, policy.subject, amount, period);
+    const existing = this.periodStates.get(key2);
+    if (existing?.accountingStatus === "complete")
+      return existing;
+    const actual = await this.resolvePolicyActual(policy, period, amount);
+    if (existing) {
+      existing.actual = actual.amount;
+      existing.accountingStatus = actual.accountingStatus;
+      existing.updatedAt = new Date;
+      return existing;
+    }
+    const state = {
+      projectId: policy.projectId,
+      subject: structuredClone(policy.subject),
+      meter: amount.meter,
+      currency: amount.currency,
+      period: structuredClone(period),
+      actual: actual.amount,
+      reserved: 0n,
+      unknown: 0n,
+      accountingStatus: actual.accountingStatus,
+      updatedAt: new Date
+    };
+    this.periodStates.set(key2, state);
+    return state;
+  }
+  moveEstimateCounter(reservation, counter, direction, updatedAt) {
+    for (const bucket of reservation.buckets) {
+      const amount = normalizeAiLimitAmount(bucket.estimate);
+      const state = this.requirePeriodState(reservation.projectId, bucket.subject, amount, reservation.period);
+      state[counter] += direction * amount.amount;
+      if (state[counter] < 0n) {
+        throw new Error(`[Sixb] In-memory AI limit ${counter} counter became negative.`);
+      }
+      state.updatedAt = new Date(updatedAt);
+    }
+  }
+  reconcileEstimateCounters(reservation, entry, updatedAt) {
+    for (const bucket of reservation.buckets) {
+      const amount = normalizeAiLimitAmount(bucket.estimate);
+      const state = this.requirePeriodState(reservation.projectId, bucket.subject, amount, reservation.period);
+      const counter = reservation.state === "active" ? "reserved" : "unknown";
+      const actual = resolveAiLimitActual([entry], amount);
+      if (actual.accountingStatus === "complete") {
+        state[counter] -= amount.amount;
+      } else if (reservation.state === "active") {
+        state.reserved -= amount.amount;
+        state.unknown += amount.amount;
+      }
+      if (state.reserved < 0n || state.unknown < 0n) {
+        throw new Error("[Sixb] In-memory AI limit reservation counter became negative.");
+      }
+      state.updatedAt = new Date(updatedAt);
+    }
+  }
+  requirePeriodState(projectId, subject, amount, period) {
+    const state = this.periodStates.get(periodStateKey(projectId, subject, amount, period));
+    if (!state)
+      throw new Error("[Sixb] In-memory AI limit period state is inconsistent.");
+    return state;
+  }
+  async assertExecutionExists(projectId, executionId) {
+    if (this.options.resolveExecution) {
+      if (await this.options.resolveExecution({ projectId, executionId }))
+        return;
+      throw new AiLimitStorageError("missing_execution", `[Sixb] AI limit execution '${executionId}' does not exist in project '${projectId}'.`);
+    }
+    if (this.options.executionExists && await this.options.executionExists({ projectId, executionId })) {
+      return;
+    }
+    throw new AiLimitStorageError("missing_execution", `[Sixb] AI limit execution '${executionId}' does not exist in project '${projectId}'.`);
+  }
+  async resolvePolicyActual(policy, period, dimension) {
+    if (!this.options.listUsageRecords || (policy.subject.type === "user" || policy.subject.type === "serviceAccount") && !this.options.resolveExecution) {
+      return { amount: 0n, accountingStatus: "unavailable" };
+    }
+    const records = await this.options.listUsageRecords({ projectId: policy.projectId });
+    const entries = await Promise.all(records.filter((record) => record.occurredAt.getTime() >= period.start.getTime() && record.occurredAt.getTime() < period.end.getTime()).map((record) => this.accountingEntry(record)));
+    return resolveAiLimitActual(entries.filter((entry) => aiLimitAccountingEntryAppliesToSubject(entry, policy.subject)), dimension);
+  }
+  async requireAccountingEntry(projectId, usageRecordId) {
+    if (!this.options.resolveUsageRecord) {
+      throw new AiLimitStorageError("unavailable_actuals", "[Sixb] In-memory AI limit storage has no immutable accounting source.");
+    }
+    const record = await this.options.resolveUsageRecord({ projectId, usageRecordId });
+    if (!record) {
+      throw new AiLimitStorageError("missing_usage_record", `[Sixb] AI usage record '${usageRecordId}' does not exist in project '${projectId}'.`);
+    }
+    return this.accountingEntry(record);
+  }
+  async accountingEntry(record) {
+    const [execution, cost] = await Promise.all([
+      this.options.resolveExecution?.({
+        projectId: record.projectId,
+        executionId: record.executionId
+      }),
+      this.options.resolveCostRecord?.({
+        projectId: record.projectId,
+        usageRecordId: record.id
+      })
+    ]);
+    const requester = execution?.requestedBy;
+    return {
+      projectId: record.projectId,
+      usageRecordId: record.id,
+      executionId: record.executionId,
+      attempt: record.attempt,
+      callId: record.callId,
+      occurredAt: new Date(record.occurredAt),
+      ...record.usage.totalTokens === undefined ? {} : { totalTokens: record.usage.totalTokens },
+      requesterGroupIds: [...record.requesterGroupIds],
+      ...requester?.type === "user" || requester?.type === "serviceAccount" ? { requester: { type: requester.type, id: requester.id } } : {},
+      ...cost?.status === "rated" ? { valuation: { status: "rated", money: structuredClone(cost.money) } } : cost ? { valuation: { status: "unavailable" } } : {}
+    };
+  }
+}
+function policyKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
+}
+function periodStateKey(projectId, subject, amount, period) {
+  return JSON.stringify([
+    projectId,
+    aiLimitSubjectKey(subject),
+    amount.meter,
+    amount.currency,
+    period.start.toISOString()
+  ]);
+}
+function validatePolicyIdentity(input) {
+  assertNonBlank(input.projectId, "projectId");
+  assertNonBlank(input.id, "policy id");
+}
+function missingPolicy(projectId, id) {
+  return new AiLimitStorageError("missing_policy", `[Sixb] AI limit policy '${id}' does not exist in project '${projectId}'.`);
+}
+function missingReservation(identity) {
+  return new AiLimitStorageError("missing_reservation", `[Sixb] AI model-call reservation '${identity.callId}' does not exist for execution '${identity.executionId}' attempt ${identity.attempt}.`);
+}
+function invalidState(reservation, operation) {
+  return new AiLimitStorageError("invalid_reservation_state", `[Sixb] Cannot ${operation} AI model-call reservation '${reservation.callId}' in state '${reservation.state}'.`);
+}
+function replaceMap2(target, source) {
+  target.clear();
+  for (const [key2, value] of structuredClone(source))
+    target.set(key2, value);
+}
 // src/storage/connector-connections/in-memory.ts
 import { timingSafeEqual } from "crypto";
 function connectionRunBase(record, updatedAt) {
@@ -1699,10 +2235,10 @@ class InMemoryConnectorConnectionStorage {
     };
   }
   restore(snapshot) {
-    replaceMap2(this.attempts, snapshot.attempts);
-    replaceMap2(this.connectionRuns, snapshot.connectionRuns);
-    replaceMap2(this.authorizations, snapshot.authorizations);
-    replaceMap2(this.connections, snapshot.connections);
+    replaceMap3(this.attempts, snapshot.attempts);
+    replaceMap3(this.connectionRuns, snapshot.connectionRuns);
+    replaceMap3(this.authorizations, snapshot.authorizations);
+    replaceMap3(this.connections, snapshot.connections);
   }
   now() {
     return new Date(this.options.now?.() ?? new Date);
@@ -1803,7 +2339,7 @@ function safeEqual(left, right) {
 function invalidRun() {
   return new ConnectorConnectionStorageError("run_invalid", "[Sixb] Connector connection run is invalid, expired, or already used.");
 }
-function replaceMap2(target, source) {
+function replaceMap3(target, source) {
   target.clear();
   for (const [key2, value] of structuredClone(source))
     target.set(key2, value);
@@ -6261,7 +6797,9 @@ function compareRequestedAt(left, right, order) {
 var WORKFLOW_RUN_FAILURE_CODES = [
   "internal.unexpected",
   "runtime.cancelled",
-  "workflow.node_failed"
+  "workflow.node_failed",
+  "ai.usage_limit_exceeded",
+  "ai.usage_limit_unavailable"
 ];
 
 // src/storage/workflow-runs/in-memory.ts
@@ -6670,7 +7208,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
       projectId: input.projectId,
       executionId: input.executionId,
       nodeRunId: input.nodeRunId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       workflowExecutionId: workflowRun.executionId
     });
     if (node.status !== "running") {
@@ -6687,7 +7225,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
       projectId: input.projectId,
       nodeRunId: input.nodeRunId,
       executionId: input.executionId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       status: "queued",
       prompt: input.prompt,
       attempt: 0,
@@ -6756,7 +7294,7 @@ class InMemoryWorkflowAgentNodeRunStorage {
   async list(input) {
     const statuses = input.statuses ? new Set(input.statuses) : null;
     const order = input.order ?? "desc";
-    const filtered = [...this.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.agentId ? run.agentId === input.agentId : true).filter((run) => statuses ? statuses.has(run.status) : true).sort((a, b) => order === "asc" ? a.createdAt.getTime() - b.createdAt.getTime() : b.createdAt.getTime() - a.createdAt.getTime());
+    const filtered = [...this.runs.values()].filter((run) => run.projectId === input.projectId).filter((run) => input.actorId ? run.actorId === input.actorId : true).filter((run) => statuses ? statuses.has(run.status) : true).sort((a, b) => order === "asc" ? a.createdAt.getTime() - b.createdAt.getTime() : b.createdAt.getTime() - a.createdAt.getTime());
     const { page, total, hasMore } = paginate(filtered, input);
     return { runs: page.map(cloneRecord), total, hasMore };
   }
@@ -6807,7 +7345,31 @@ class InMemoryStorage {
   agentStorage = new InMemoryAgentStorage(this.executionStorage);
   aiUsageStorage = new InMemoryAiUsageStorage(this.executionStorage);
   aiCostStorage = new InMemoryAiCostStorage(this.aiUsageStorage, {
-    resolve: (input) => this.resolveAiAccountingAttribution(input)
+    resolve: (input) => this.resolveAiAccountingAttribution(input),
+    resolveGroup: async (input) => {
+      const attribution = await this.resolveAiAccountingAttribution(input);
+      if (attribution?.kind !== "subagent")
+        return { executionId: input.executionId, attribution };
+      const parent = await this.agentStorage.runs.getById({
+        projectId: input.projectId,
+        id: attribution.parentRunId
+      });
+      if (!parent)
+        throw new Error("[Sixb] Subagent accounting parent is missing.");
+      return {
+        executionId: parent.executionId,
+        attribution: await this.resolveAiAccountingAttribution({
+          ...input,
+          executionId: parent.executionId
+        })
+      };
+    }
+  });
+  aiLimitStorage = new InMemoryAiLimitStorage({
+    resolveExecution: ({ projectId, executionId }) => this.executionStorage.getById({ projectId, id: executionId }),
+    resolveUsageRecord: ({ projectId, usageRecordId }) => this.aiUsageStorage.getRecord(projectId, usageRecordId),
+    resolveCostRecord: ({ projectId, usageRecordId }) => this.aiCostStorage.getRecord(projectId, usageRecordId),
+    listUsageRecords: ({ projectId }) => this.aiUsageStorage.listRecords(projectId)
   });
   actionRunStorage = new InMemoryActionRunStorage(this.executionStorage);
   syncRunStorage = new InMemorySyncRunStorage(this.executionStorage);
@@ -6826,6 +7388,7 @@ class InMemoryStorage {
   agents;
   aiUsage;
   aiCosts;
+  aiLimits;
   actionRuns;
   syncRuns;
   pipelineRuns;
@@ -6846,6 +7409,7 @@ class InMemoryStorage {
     this.agents = createAgentOperationScope(this.agentStorage, scope);
     this.aiUsage = createOperationScopedFacade(this.aiUsageStorage, scope);
     this.aiCosts = createOperationScopedFacade(this.aiCostStorage, scope);
+    this.aiLimits = createOperationScopedFacade(this.aiLimitStorage, scope);
     this.actionRuns = createOperationScopedFacade(this.actionRunStorage, scope);
     this.syncRuns = createOperationScopedFacade(this.syncRunStorage, scope);
     this.pipelineRuns = createOperationScopedFacade(this.pipelineRunStorage, scope);
@@ -6878,14 +7442,20 @@ class InMemoryStorage {
       projectId: input.projectId,
       id: execution.executor.runId
     });
-    if (directRun) {
+    if (directRun?.kind === "conversation") {
       return {
         kind: "agent",
-        agentId: directRun.agentId,
         agentRunId: directRun.id,
         threadId: directRun.threadId
       };
     }
+    if (directRun?.kind === "subagent") {
+      return {
+        kind: "subagent",
+        subagentRunId: directRun.id,
+        parentRunId: directRun.parentRunId
+      };
+    }
     const agentRun = await this.workflowRunStorage.agentNodes.getByNodeRunId({
       projectId: input.projectId,
       nodeRunId: execution.executor.runId
@@ -6900,7 +7470,7 @@ class InMemoryStorage {
       return;
     return {
       kind: "workflowAgent",
-      agentId: agentRun.agentId,
+      agentStepId: node.nodeId,
       nodeRunId: agentRun.nodeRunId,
       workflowId: node.workflowId,
       workflowRunId: node.workflowRunId
@@ -6929,7 +7499,13 @@ class InMemoryStorage {
       this.activeTransactionTokens.add(transactionToken);
       this.materializationLifecycles.set(transactionToken, materializationLifecycle);
       try {
-        const result = await this.transactionScope.run(transactionToken, async () => run(tx));
+        const result = await this.transactionScope.run(transactionToken, async () => {
+          try {
+            return await run(tx);
+          } finally {
+            await this.aiLimitStorage.settleOperations();
+          }
+        });
         materializationLifecycle.assertCommittable();
         return result;
       } catch (error) {
@@ -6987,6 +7563,7 @@ class InMemoryStorage {
       agents: this.agentStorage,
       aiUsage: this.aiUsageStorage,
       aiCosts: this.aiCostStorage,
+      aiLimits: this.aiLimitStorage,
       actionRuns: this.actionRunStorage,
       syncRuns: this.syncRunStorage,
       pipelineRuns: this.pipelineRunStorage,
@@ -7015,6 +7592,7 @@ class InMemoryStorage {
       agents: this.agentStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
       aiCosts: this.aiCostStorage.snapshot(),
+      aiLimits: this.aiLimitStorage.snapshot(),
       actionRuns: this.actionRunStorage.snapshot(),
       syncRuns: this.syncRunStorage.snapshot(),
       pipelineRuns: this.pipelineRunStorage.snapshot(),
@@ -7036,6 +7614,7 @@ class InMemoryStorage {
     this.agentStorage.restore(snapshot.agents);
     this.aiUsageStorage.restore(snapshot.aiUsage);
     this.aiCostStorage.restore(snapshot.aiCosts);
+    this.aiLimitStorage.restore(snapshot.aiLimits);
     this.actionRunStorage.restore(snapshot.actionRuns);
     this.syncRunStorage.restore(snapshot.syncRuns);
     this.pipelineRunStorage.restore(snapshot.pipelineRuns);
@@ -7257,6 +7836,6 @@ function assertAppliedPrefix(migrations, rows) {
   }
   return [...rows].sort((a, b) => a.version - b.version);
 }
-export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiCostStorageError, InMemoryAiCostStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, compareQueryScalarValues, queryScalarValuesEqual, objectBatchKey, linkBatchKey, objectLinkCursor, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
+export { actionSubjectsEqual, actionRunParamsEqual, actionRunPhaseRecordsEqual, finishActionRunPhase, canRequeueActionRunAfterEnqueueFailure, isTerminalActionRun, InMemoryActionRunStorage, AGENT_MESSAGE_CONTENT_VERSION, InMemoryAgentStorage, AiCostStorageError, InMemoryAiCostStorage, InMemoryAiLimitStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, compareQueryScalarValues, queryScalarValuesEqual, objectBatchKey, linkBatchKey, objectLinkCursor, canRequeuePipelineRunAfterEnqueueFailure, PIPELINE_RUN_FAILURE_CODES, InMemoryPipelineRunStorage, InMemoryProjectionRunStorage, InMemoryRulesStorage, canRequeueSyncRunAfterEnqueueFailure, SYNC_RUN_FAILURE_CODES, InMemorySyncRunStorage, createTransactionStorageProxy, assertTransactionActive, throwNestedStorageTransaction, WEBHOOK_RUN_FAILURE_CODES, canRetryWebhookRun, InMemoryWebhookRunStorage, WorkflowInterventionError, InMemoryWorkflowInterventionStorage, WORKFLOW_RUN_FAILURE_CODES, InMemoryWorkflowRunStorage, InMemoryWorkflowNodeRunStorage, InMemoryWorkflowAgentNodeRunStorage, InMemoryStorage, isMigrationCapableStorage, migrateStorage, checkStorageSchema, step, defineMigrations, runMigrationSet, describeMigrationHistory };
 
-//# debugId=9ED097CBB9250C8464756E2164756E21
+//# debugId=472382EF0F10AB3864756E2164756E21