@sixb/core 0.1.2 → 0.1.3

package/dist/{chunk-ys1nse2v.js → chunk-xmggaxg4.js}

@@ -35,7 +35,7 @@ import {
   createOperationScopedFacade,
   createStorageOperationScope,
   createWorkflowRunOperationScope
-} from "./chunk-57r1cpxx.js";
+} from "./chunk-xc7hq65b.js";
 import {
   PipelineRunError,
   assertPipelineRunExecution
@@ -79,7 +79,7 @@ import {
   WorkflowRunError,
   assertWorkflowAgentNodeRunExecution,
   assertWorkflowRunExecution
-} from "./chunk-4x43bkbp.js";
+} from "./chunk-pxtrxm3p.js";
 import {
   parseActionRunFailure
 } from "./chunk-htq0qh7z.js";
@@ -89,8 +89,20 @@ import {
 } from "./chunk-xkthy56g.js";
 import {
   AgentStorageError,
-  assertAgentRunExecution
-} from "./chunk-vp1vc6ee.js";
+  agentContextCheckpointMatchesCreateInput,
+  assertAgentContextCheckpointAnchors,
+  assertAgentContextCheckpointAuthority,
+  assertAgentContextCheckpointReplayState,
+  assertAgentRunExecution,
+  assertCreateAgentContextCheckpointInput
+} from "./chunk-qer6am8w.js";
+import {
+  InMemoryAiUsageStorage,
+  aiModelCallCostMatchesUsage,
+  buildAiAccountingOverview,
+  buildAiModelCallAccountingList,
+  normalizeAiModelCallCostRecord
+} from "./chunk-kqxgf6kv.js";
 import {
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
   ConnectorConnectionStorageError
@@ -125,22 +137,22 @@ import {
 } from "./chunk-6wetht33.js";
 import {
   AGENT_RUN_FAILURE_CODES
-} from "./chunk-663csy96.js";
+} from "./chunk-t0jjkep3.js";
 import {
   InMemoryAuthStorage,
-  normalizeRequesterGroupIds,
   paginate,
   principalsEqual
-} from "./chunk-jaj13078.js";
+} from "./chunk-d2adj15j.js";
+import {
+  normalizeRequesterGroupIds
+} from "./chunk-rhrbz7d4.js";
 import {
   createSixbError,
   parseSixbFailure,
   toSixbFailure
 } from "./chunk-0172wgm9.js";
 import {
-  assertJsonValue,
   cloneJsonValue,
-  isPlainRecord,
   stableJsonStringify
 } from "./chunk-t8t39h7v.js";
 // src/storage/action-runs/idempotency.ts
@@ -729,6 +741,30 @@ class InMemoryAgentMessageStore {
     }));
     return clone(message);
   }
+  async deleteByRunId(input) {
+    const threadKey = key(input.projectId, input.threadId);
+    const thread = this.state.threads.get(threadKey);
+    if (!thread) {
+      throw new AgentStorageError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+    }
+    const messages = [...this.state.messages.entries()].filter(([, message]) => message.projectId === input.projectId && message.threadId === input.threadId && message.runId === input.runId);
+    if (messages.length === 0) {
+      return 0;
+    }
+    for (const [messageKey] of messages) {
+      this.state.messages.delete(messageKey);
+    }
+    const remainingMessages = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId && message.threadId === input.threadId).sort((left, right) => right.seq - left.seq);
+    const latestMessage = remainingMessages[0];
+    const updatedAt = new Date;
+    this.state.threads.set(threadKey, clone({
+      ...thread,
+      messageCount: remainingMessages.length,
+      lastMessageAt: latestMessage?.createdAt,
+      updatedAt
+    }));
+    return messages.length;
+  }
   async getById(params) {
     const record = this.state.messages.get(key(params.projectId, params.id));
     return record ? clone(record) : null;
@@ -736,7 +772,7 @@ class InMemoryAgentMessageStore {
   async list(input) {
     const order = input.order ?? "asc";
     const roles = input.roles ? new Set(input.roles) : null;
-    const filtered = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId).filter((message) => message.threadId === input.threadId).filter((message) => roles ? roles.has(message.role) : true).sort((a, b) => order === "asc" ? a.seq - b.seq : b.seq - a.seq);
+    const filtered = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId).filter((message) => message.threadId === input.threadId).filter((message) => input.afterSeq === undefined ? true : message.seq > input.afterSeq).filter((message) => roles ? roles.has(message.role) : true).sort((a, b) => order === "asc" ? a.seq - b.seq : b.seq - a.seq);
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit);
     return { messages: page.map(clone), hasMore, total };
   }
@@ -751,31 +787,100 @@ class InMemoryAgentMessageStore {
   }
 }
 
+class InMemoryAgentContextCheckpointStore {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  async create(input) {
+    assertCreateAgentContextCheckpointInput(input);
+    const run = this.state.runs.get(key(input.projectId, input.createdByRunId)) ?? null;
+    const thread = this.state.threads.get(key(input.projectId, input.threadId)) ?? null;
+    assertAgentContextCheckpointAuthority({ create: input, run, thread });
+    const messages = [...this.state.messages.values()].filter((message) => message.projectId === input.projectId && message.threadId === input.threadId);
+    const headSeq = messages.reduce((head, message) => Math.max(head, message.seq), 0);
+    const latest = this.findLatest(input.projectId, input.threadId);
+    const existingForRun = [...this.state.checkpoints.values()].find((checkpoint) => checkpoint.projectId === input.projectId && checkpoint.createdByRunId === input.createdByRunId);
+    if (existingForRun) {
+      if (agentContextCheckpointMatchesCreateInput(existingForRun, input)) {
+        assertAgentContextCheckpointReplayState({
+          create: input,
+          existing: existingForRun,
+          latest,
+          headSeq
+        });
+        return clone(existingForRun);
+      }
+      throw new AgentStorageError("invalid_state", `[Sixb] Agent run '${input.createdByRunId}' already created a different context checkpoint.`);
+    }
+    if (this.state.checkpoints.has(key(input.projectId, input.id))) {
+      throw new AgentStorageError("duplicate_id", `[Sixb] Agent context checkpoint '${input.id}' already exists for project '${input.projectId}'.`);
+    }
+    const firstRetained = messages.filter((message) => message.seq > input.summarizedThroughSeq).sort((left, right) => left.seq - right.seq)[0] ?? null;
+    assertAgentContextCheckpointAnchors({
+      create: input,
+      latest,
+      headSeq,
+      firstRetained
+    });
+    const record = {
+      id: input.id,
+      projectId: input.projectId,
+      threadId: input.threadId,
+      createdByRunId: input.createdByRunId,
+      ...input.expectedPreviousCheckpointId === null ? {} : { previousCheckpointId: input.expectedPreviousCheckpointId },
+      reason: input.reason,
+      summary: input.summary,
+      summaryFormatVersion: input.summaryFormatVersion,
+      summarizedThroughSeq: input.summarizedThroughSeq,
+      observedHeadSeq: input.observedHeadSeq,
+      estimatedInputTokensBefore: input.estimatedInputTokensBefore,
+      estimatedInputTokensAfter: input.estimatedInputTokensAfter,
+      summaryModelId: input.summaryModelId,
+      createdAt: new Date(input.createdAt ?? new Date)
+    };
+    this.state.checkpoints.set(key(input.projectId, input.id), clone(record));
+    return clone(record);
+  }
+  async getLatest(input) {
+    const record = this.findLatest(input.projectId, input.threadId);
+    return record ? clone(record) : null;
+  }
+  findLatest(projectId, threadId) {
+    return [...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === projectId && checkpoint.threadId === threadId).sort((left, right) => right.summarizedThroughSeq - left.summarizedThroughSeq || right.createdAt.getTime() - left.createdAt.getTime() || right.id.localeCompare(left.id))[0] ?? null;
+  }
+}
+
 class InMemoryAgentStorage {
   state = {
     threads: new Map,
     runs: new Map,
-    messages: new Map
+    messages: new Map,
+    checkpoints: new Map
   };
   threads;
   runs;
   messages;
+  checkpoints;
   constructor(executions) {
     this.threads = new InMemoryAgentThreadStore(this.state);
     this.runs = new InMemoryAgentRunStore(this.state, executions);
     this.messages = new InMemoryAgentMessageStore(this.state);
+    this.checkpoints = new InMemoryAgentContextCheckpointStore(this.state);
   }
   snapshot() {
     return {
       threads: structuredClone(this.state.threads),
       runs: structuredClone(this.state.runs),
-      messages: structuredClone(this.state.messages)
+      messages: structuredClone(this.state.messages),
+      checkpoints: structuredClone(this.state.checkpoints)
     };
   }
   restore(snapshot) {
     replace(this.state.threads, snapshot.threads);
     replace(this.state.runs, snapshot.runs);
     replace(this.state.messages, snapshot.messages);
+    replace(this.state.checkpoints, snapshot.checkpoints);
   }
 }
 function replace(target, source) {
@@ -784,248 +889,120 @@ function replace(target, source) {
     target.set(k, value);
   }
 }
-// src/storage/ai-usage/errors.ts
-class AiUsageStorageError extends Error {
+// src/storage/ai-cost/errors.ts
+class AiCostStorageError extends Error {
   code;
-  name = "AiUsageStorageError";
+  name = "AiCostStorageError";
   constructor(code, message) {
     super(message);
     this.code = code;
   }
 }
-// src/storage/ai-usage/usage.ts
-var USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "uncachedInputTokens",
-  "cacheReadInputTokens",
-  "cacheWriteInputTokens",
-  "textOutputTokens",
-  "reasoningOutputTokens"
-];
-function normalizeAiModelCallUsage(input) {
-  for (const field of USAGE_FIELDS) {
-    assertUsageCount(input[field], field);
-  }
-  const totalTokens = input.inputTokens === undefined || input.outputTokens === undefined ? undefined : addUsageCounts(input.inputTokens, input.outputTokens, "totalTokens");
-  const reportingStatus = input.inputTokens !== undefined && input.outputTokens !== undefined ? "complete" : USAGE_FIELDS.some((field) => input[field] !== undefined) ? "partial" : "unavailable";
-  return {
-    ...input.inputTokens === undefined ? {} : { inputTokens: input.inputTokens },
-    ...input.outputTokens === undefined ? {} : { outputTokens: input.outputTokens },
-    ...totalTokens === undefined ? {} : { totalTokens },
-    ...input.uncachedInputTokens === undefined ? {} : { uncachedInputTokens: input.uncachedInputTokens },
-    ...input.cacheReadInputTokens === undefined ? {} : { cacheReadInputTokens: input.cacheReadInputTokens },
-    ...input.cacheWriteInputTokens === undefined ? {} : { cacheWriteInputTokens: input.cacheWriteInputTokens },
-    ...input.textOutputTokens === undefined ? {} : { textOutputTokens: input.textOutputTokens },
-    ...input.reasoningOutputTokens === undefined ? {} : { reasoningOutputTokens: input.reasoningOutputTokens },
-    reportingStatus
-  };
-}
-function aggregateAiModelCallUsage(usages) {
-  const normalized = Array.from(usages, normalizeAiModelCallUsage);
-  const fields = Object.fromEntries(USAGE_FIELDS.map((field) => [field, sumUsageField(normalized, field)]));
-  const aggregate = normalizeAiModelCallUsage(fields);
-  if (aggregate.reportingStatus === "unavailable" && normalized.some((usage) => usage.reportingStatus !== "unavailable")) {
-    return { ...aggregate, reportingStatus: "partial" };
-  }
-  return aggregate;
-}
-function sumUsageField(usages, field) {
-  if (usages.length === 0)
-    return;
-  let total = 0;
-  for (const usage of usages) {
-    const value = usage[field];
-    if (value === undefined)
-      return;
-    total = addUsageCounts(total, value, `aggregate ${field}`);
-  }
-  return total;
-}
-function assertUsageCount(value, field) {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
-    throw new TypeError(`[Sixb] AI model-call usage ${field} must be a non-negative safe integer.`);
-  }
-}
-function addUsageCounts(left, right, field) {
-  const result = left + right;
-  if (!Number.isSafeInteger(result)) {
-    throw new TypeError(`[Sixb] AI model-call usage ${field} exceeds the safe integer range.`);
-  }
-  return result;
-}
-
-// src/storage/ai-usage/record.ts
-function normalizeAiModelCallRecord(input) {
-  assertNonBlank2(input.id, "id");
-  assertNonBlank2(input.projectId, "projectId");
-  assertAiUsageExecutionId(input.executionId);
-  assertPositiveSafeInteger(input.attempt, "attempt");
-  assertNonBlank2(input.callId, "callId");
-  assertNonBlank2(input.providerId, "providerId");
-  assertNonBlank2(input.requestedModelId, "requestedModelId");
-  if (input.responseModelId !== undefined) {
-    assertNonBlank2(input.responseModelId, "responseModelId");
-  }
-  assertNonBlank2(input.responseId, "responseId");
-  const occurredAt = cloneValidDate(input.occurredAt, "occurredAt");
-  const recordedAt = cloneValidDate(input.recordedAt ?? new Date, "recordedAt");
-  const requesterGroupIds = normalizeRequesterGroupIds(input.requesterGroupIds);
-  const rawUsage = cloneRawUsage(input.rawUsage);
-  return {
-    id: input.id,
-    projectId: input.projectId,
-    executionId: input.executionId,
-    attempt: input.attempt,
-    callId: input.callId,
-    requesterGroupIds,
-    providerId: input.providerId,
-    requestedModelId: input.requestedModelId,
-    ...input.responseModelId === undefined ? {} : { responseModelId: input.responseModelId },
-    responseId: input.responseId,
-    usage: normalizeAiModelCallUsage(input.usage),
-    ...rawUsage === undefined ? {} : { rawUsage },
-    occurredAt,
-    recordedAt
-  };
-}
-function assertAiUsageExecutionId(executionId) {
-  assertNonBlank2(executionId, "executionId");
-}
-function cloneRawUsage(rawUsage) {
-  if (rawUsage === undefined)
-    return;
-  if (!isPlainRecord(rawUsage)) {
-    throw new TypeError("[Sixb] AI usage rawUsage must be a JSON object.");
-  }
-  assertJsonValue(rawUsage, "AI usage rawUsage");
-  return structuredClone(rawUsage);
-}
-function assertNonBlank2(value, field) {
-  if (typeof value !== "string" || value.trim().length === 0) {
-    throw new TypeError(`[Sixb] AI usage ${field} must be nonblank.`);
-  }
-}
-function assertPositiveSafeInteger(value, field) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new TypeError(`[Sixb] AI usage ${field} must be a positive safe integer.`);
+// src/storage/ai-cost/in-memory.ts
+class InMemoryAiCostStorage {
+  usage;
+  attribution;
+  recordsByUsage = new Map;
+  constructor(usage, attribution) {
+    this.usage = usage;
+    this.attribution = attribution;
   }
-}
-function cloneValidDate(value, field) {
-  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
-    throw new TypeError(`[Sixb] AI usage ${field} must be a valid Date.`);
-  }
-  return new Date(value);
-}
-
-// src/storage/ai-usage/in-memory.ts
-class InMemoryAiUsageStorage {
-  executions;
-  records = new Map;
-  recordKeysByIdempotencyKey = new Map;
-  groupRows = new Map;
-  constructor(executions) {
-    this.executions = executions;
+  async recordModelCallCost(input) {
+    const record = normalizeAiModelCallCostRecord(input);
+    const usage = this.usageRecord(record.projectId, record.usageRecordId);
+    if (!usage)
+      throw missingUsage(record);
+    if (!aiModelCallCostMatchesUsage(record, usage)) {
+      throw new AiCostStorageError("cost_mismatch", `[Sixb] AI valuation for usage '${record.usageRecordId}' does not match its usage record.`);
+    }
+    const key2 = usageRecordKey(record.projectId, record.usageRecordId);
+    if (!this.recordsByUsage.has(key2))
+      this.recordsByUsage.set(key2, structuredClone(record));
   }
-  async recordModelCall(input) {
-    const record = normalizeAiModelCallRecord(input);
-    await this.assertExecutionExists(record.projectId, record.executionId);
-    const idempotencyKey = modelCallIdempotencyKey(record);
-    const existingRecordKey = this.recordKeysByIdempotencyKey.get(idempotencyKey);
-    if (existingRecordKey !== undefined) {
-      const existing = this.records.get(existingRecordKey);
-      if (!existing) {
-        throw new Error("[Sixb] In-memory AI usage idempotency index is inconsistent.");
+  async summarizeExecutions(input) {
+    assertNonBlank2(input.projectId, "cost summary projectId");
+    for (const id of input.executionIds)
+      assertNonBlank2(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()) {
+      if (usage.projectId === input.projectId && requested.has(usage.executionId)) {
+        usageByExecution.get(usage.executionId).push(usage.id);
       }
-      return { record: structuredClone(existing), created: false };
-    }
-    const recordKey = modelCallRecordKey(record.projectId, record.id);
-    if (this.records.has(recordKey)) {
-      throw new AiUsageStorageError("duplicate_id", `[Sixb] AI usage record '${record.id}' already exists for project '${record.projectId}'.`);
-    }
-    this.records.set(recordKey, structuredClone(record));
-    this.recordKeysByIdempotencyKey.set(idempotencyKey, recordKey);
-    for (const groupId of record.requesterGroupIds) {
-      const row = {
-        projectId: record.projectId,
-        usageRecordId: record.id,
-        groupId,
-        occurredAt: record.occurredAt
-      };
-      this.groupRows.set(groupRowKey(row), row);
     }
-    return { record: structuredClone(record), created: true };
+    return input.executionIds.map((id) => this.summarizeUsageIds(input.projectId, usageByExecution.get(id) ?? []));
   }
-  async summarizeExecution(input) {
-    const [summary] = await this.summarizeExecutions({
-      projectId: input.projectId,
-      executionIds: [input.executionId]
-    });
-    return summary;
+  async queryProjectOverview(input) {
+    return buildAiAccountingOverview(input, await this.accountingItems());
   }
-  async summarizeExecutions(input) {
-    if (typeof input.projectId !== "string" || input.projectId.trim().length === 0) {
-      throw new TypeError("[Sixb] AI usage projectId must be nonblank.");
-    }
-    const usageByExecutionId = new Map;
-    for (const executionId of input.executionIds) {
-      assertAiUsageExecutionId(executionId);
-      usageByExecutionId.set(executionId, []);
-    }
-    if (usageByExecutionId.size === 0)
-      return [];
-    for (const record of this.records.values()) {
-      if (record.projectId !== input.projectId)
-        continue;
-      usageByExecutionId.get(record.executionId)?.push(record.usage);
-    }
-    return input.executionIds.map((executionId) => {
-      const usages = usageByExecutionId.get(executionId) ?? [];
-      return {
-        modelCallCount: usages.length,
-        usage: aggregateAiModelCallUsage(usages)
-      };
-    });
+  async listModelCalls(input) {
+    return buildAiModelCallAccountingList(input, await this.accountingItems());
   }
   snapshot() {
-    return structuredClone({
-      records: this.records,
-      recordKeysByIdempotencyKey: this.recordKeysByIdempotencyKey,
-      groupRows: this.groupRows
-    });
+    return structuredClone({ recordsByUsage: this.recordsByUsage });
   }
   restore(snapshot) {
-    replaceMap(this.records, snapshot.records);
-    replaceMap(this.recordKeysByIdempotencyKey, snapshot.recordKeysByIdempotencyKey);
-    replaceMap(this.groupRows, snapshot.groupRows);
+    replaceMap(this.recordsByUsage, snapshot.recordsByUsage);
   }
-  async assertExecutionExists(projectId, executionId) {
-    const execution = await this.executions.getById({ projectId, id: executionId });
-    if (execution)
-      return;
-    throw new AiUsageStorageError("missing_execution", `[Sixb] AI usage execution '${executionId}' does not exist in project '${projectId}'.`);
+  usageRecord(projectId, id) {
+    return [...this.usage.snapshot().records.values()].find((record) => record.projectId === projectId && record.id === id);
+  }
+  async accountingItems() {
+    return Promise.all([...this.usage.snapshot().records.values()].map(async (usage) => {
+      const cost = this.recordsByUsage.get(usageRecordKey(usage.projectId, usage.id));
+      const attribution = await this.attribution?.resolve({
+        projectId: usage.projectId,
+        executionId: usage.executionId
+      });
+      return {
+        usage,
+        ...attribution ? { attribution } : {},
+        ...cost ? { cost } : {}
+      };
+    }));
+  }
+  summarizeUsageIds(projectId, ids) {
+    const amounts = new Map;
+    let ratedCallCount = 0;
+    let unpriceableCallCount = 0;
+    let unvaluedCallCount = 0;
+    for (const id of ids) {
+      const cost = this.recordsByUsage.get(usageRecordKey(projectId, id));
+      if (!cost)
+        unvaluedCallCount += 1;
+      else if (cost.status === "unpriceable")
+        unpriceableCallCount += 1;
+      else {
+        ratedCallCount += 1;
+        addMoney(amounts, cost.money);
+      }
+    }
+    return {
+      amounts: [...amounts].sort(([left], [right]) => left.localeCompare(right)).map(([currency, amount]) => ({ currency, amountNanos: amount.toString() })),
+      ratedCallCount,
+      unpriceableCallCount,
+      unvaluedCallCount
+    };
   }
 }
-function modelCallRecordKey(projectId, id) {
-  return JSON.stringify([projectId, id]);
+function missingUsage(record) {
+  return new AiCostStorageError("missing_usage", `[Sixb] AI usage '${record.usageRecordId}' does not exist in project '${record.projectId}'.`);
 }
-function modelCallIdempotencyKey(record) {
-  return JSON.stringify([
-    record.projectId,
-    record.executionId,
-    record.attempt,
-    record.callId,
-    record.responseId
-  ]);
+function addMoney(amounts, money) {
+  amounts.set(money.currency, (amounts.get(money.currency) ?? 0n) + BigInt(money.amountNanos));
+}
+function usageRecordKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
 }
-function groupRowKey(row) {
-  return JSON.stringify([row.projectId, row.usageRecordId, row.groupId]);
+function assertNonBlank2(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
+  }
 }
 function replaceMap(target, source) {
   target.clear();
-  for (const [key2, value] of structuredClone(source)) {
+  for (const [key2, value] of structuredClone(source))
     target.set(key2, value);
-  }
 }
 // src/storage/connector-connections/in-memory.ts
 import { timingSafeEqual } from "crypto";
@@ -3949,6 +3926,7 @@ class InMemoryOntologyMaterializationStorage {
           projectId,
           ref: item.ref,
           value: item.value,
+          editedAt: { ...item.editedAt },
           lastCommitId: item.lastCommitId,
           updatedAt: item.updatedAt
         }));
@@ -6659,6 +6637,9 @@ class InMemoryStorage {
   executionStorage = new InMemoryExecutionStorage(this.authStorage);
   agentStorage = new InMemoryAgentStorage(this.executionStorage);
   aiUsageStorage = new InMemoryAiUsageStorage(this.executionStorage);
+  aiCostStorage = new InMemoryAiCostStorage(this.aiUsageStorage, {
+    resolve: (input) => this.resolveAiAccountingAttribution(input)
+  });
   actionRunStorage = new InMemoryActionRunStorage(this.executionStorage);
   syncRunStorage = new InMemorySyncRunStorage(this.executionStorage);
   pipelineRunStorage = new InMemoryPipelineRunStorage(this.executionStorage);
@@ -6675,6 +6656,7 @@ class InMemoryStorage {
   executions;
   agents;
   aiUsage;
+  aiCosts;
   actionRuns;
   syncRuns;
   pipelineRuns;
@@ -6694,6 +6676,7 @@ class InMemoryStorage {
     this.executions = createOperationScopedFacade(this.executionStorage, scope);
     this.agents = createAgentOperationScope(this.agentStorage, scope);
     this.aiUsage = createOperationScopedFacade(this.aiUsageStorage, scope);
+    this.aiCosts = createOperationScopedFacade(this.aiCostStorage, scope);
     this.actionRuns = createOperationScopedFacade(this.actionRunStorage, scope);
     this.syncRuns = createOperationScopedFacade(this.syncRunStorage, scope);
     this.pipelineRuns = createOperationScopedFacade(this.pipelineRunStorage, scope);
@@ -6715,6 +6698,45 @@ class InMemoryStorage {
     this.ontologyStorage.registerTestingAlias(this.ontology);
     registerInMemoryStorageTestingAdapter(this, { snapshot: () => this.snapshot() });
   }
+  async resolveAiAccountingAttribution(input) {
+    const execution = await this.executionStorage.getById({
+      projectId: input.projectId,
+      id: input.executionId
+    });
+    if (!execution || execution.executor.type !== "agent")
+      return;
+    const directRun = await this.agentStorage.runs.getById({
+      projectId: input.projectId,
+      id: execution.executor.runId
+    });
+    if (directRun) {
+      return {
+        kind: "agent",
+        agentId: directRun.agentId,
+        agentRunId: directRun.id,
+        threadId: directRun.threadId
+      };
+    }
+    const agentRun = await this.workflowRunStorage.agentNodes.getByNodeRunId({
+      projectId: input.projectId,
+      nodeRunId: execution.executor.runId
+    });
+    if (!agentRun)
+      return;
+    const node = await this.workflowRunStorage.nodes.getById({
+      projectId: input.projectId,
+      id: agentRun.nodeRunId
+    });
+    if (!node)
+      return;
+    return {
+      kind: "workflowAgent",
+      agentId: agentRun.agentId,
+      nodeRunId: agentRun.nodeRunId,
+      workflowId: node.workflowId,
+      workflowRunId: node.workflowRunId
+    };
+  }
   transactionScope = new AsyncLocalStorage;
   activeTransactionTokens = new WeakSet;
   materializationLifecycles = new WeakMap;
@@ -6795,6 +6817,7 @@ class InMemoryStorage {
       executions: this.executionStorage,
       agents: this.agentStorage,
       aiUsage: this.aiUsageStorage,
+      aiCosts: this.aiCostStorage,
       actionRuns: this.actionRunStorage,
       syncRuns: this.syncRunStorage,
       pipelineRuns: this.pipelineRunStorage,
@@ -6822,6 +6845,7 @@ class InMemoryStorage {
       executions: this.executionStorage.snapshot(),
       agents: this.agentStorage.snapshot(),
       aiUsage: this.aiUsageStorage.snapshot(),
+      aiCosts: this.aiCostStorage.snapshot(),
       actionRuns: this.actionRunStorage.snapshot(),
       syncRuns: this.syncRunStorage.snapshot(),
       pipelineRuns: this.pipelineRunStorage.snapshot(),
@@ -6842,6 +6866,7 @@ class InMemoryStorage {
     this.executionStorage.restore(snapshot.executions);
     this.agentStorage.restore(snapshot.agents);
     this.aiUsageStorage.restore(snapshot.aiUsage);
+    this.aiCostStorage.restore(snapshot.aiCosts);
     this.actionRunStorage.restore(snapshot.actionRuns);
     this.syncRunStorage.restore(snapshot.syncRuns);
     this.pipelineRunStorage.restore(snapshot.pipelineRuns);
@@ -7063,6 +7088,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, AiUsageStorageError, normalizeAiModelCallUsage, aggregateAiModelCallUsage, normalizeAiModelCallRecord, assertAiUsageExecutionId, InMemoryAiUsageStorage, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, 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, InMemoryConnectorConnectionStorage, ObjectNotFoundError, ObjectStorageError, StorageTransactionError, isStorageSerializationFailure, FileUploadSessionError, DEFAULT_FILE_UPLOAD_SESSION_TTL_MS, DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS, createUploadExpiresAt, createFileUploadId, InMemoryFileUploadSessions, 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=0974A6B3A889270064756E2164756E21
+//# debugId=D421DE165E32FF5B64756E2164756E21