@sixb/core 0.1.2 → 0.1.4

package/dist/{chunk-ys1nse2v.js → chunk-1wk20wn3.js}

@@ -27,7 +27,7 @@ import {
   startScopeAccumulator,
   uniqueSorted,
   workUniquenessKey
-} from "./chunk-fmx1sz2h.js";
+} from "./chunk-72q2y8hn.js";
 import {
   createAgentOperationScope,
   createAuthOperationScope,
@@ -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-a09jx26t.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-xdf9yswn.js";
+import {
+  InMemoryAiUsageStorage,
+  aiModelCallCostMatchesUsage,
+  buildAiAccountingOverview,
+  buildAiModelCallAccountingList,
+  normalizeAiModelCallCostRecord
+} from "./chunk-drjqm1aa.js";
 import {
   CONNECTOR_CONNECTION_RUN_FAILURE_CODES,
   ConnectorConnectionStorageError
@@ -119,28 +131,27 @@ import {
   MaterializationConflictError,
   MaterializationValidationError
 } from "./chunk-ry24jbr1.js";
-import {
-  compareQueryScalarValues,
-  queryScalarValuesEqual
-} 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-tkdscva6.js";
+import {
+  normalizeRequesterGroupIds
+} from "./chunk-rhrbz7d4.js";
+import {
+  compareDecimalValues
+} from "./chunk-04b07a9q.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 +740,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 +771,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 +786,107 @@ 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;
+  }
+  async getByRunIds(input) {
+    const byRunId = new Map([...this.state.checkpoints.values()].filter((checkpoint) => checkpoint.projectId === input.projectId).map((checkpoint) => [checkpoint.createdByRunId, checkpoint]));
+    return [...new Set(input.runIds)].flatMap((runId) => {
+      const checkpoint = byRunId.get(runId);
+      return checkpoint ? [clone(checkpoint)] : [];
+    });
+  }
+  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 +895,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);
+// src/storage/ai-cost/in-memory.ts
+class InMemoryAiCostStorage {
+  usage;
+  attribution;
+  recordsByUsage = new Map;
+  constructor(usage, attribution) {
+    this.usage = usage;
+    this.attribution = attribution;
   }
-  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.`);
-  }
-}
-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 groupRowKey(row) {
-  return JSON.stringify([row.projectId, row.usageRecordId, row.groupId]);
+function usageRecordKey(projectId, id) {
+  return JSON.stringify([projectId, id]);
+}
+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";
@@ -2127,6 +2110,110 @@ class InMemoryExecutionStorage {
   }
 }
 
+// src/objects/query/scalar-values.ts
+function compareQueryScalarValues(left, right, scalarKind) {
+  if (left === undefined || right === undefined || left === null || right === null) {
+    return Number.NaN;
+  }
+  if (scalarKind === undefined)
+    return compareRuntimeValues(left, right);
+  switch (scalarKind) {
+    case "string":
+    case "uuid":
+      return typeof left === "string" && typeof right === "string" ? compareStrings(left, right) : Number.NaN;
+    case "boolean":
+      return typeof left === "boolean" && typeof right === "boolean" ? Number(left) - Number(right) : Number.NaN;
+    case "integer":
+    case "double":
+      return typeof left === "number" && typeof right === "number" ? left - right : Number.NaN;
+    case "decimal":
+      return typeof left === "string" && typeof right === "string" ? compareDecimalValues(left, right) : Number.NaN;
+    case "date":
+    case "timestamp":
+      return compareTemporalValues(left, right);
+  }
+}
+function queryScalarValuesEqual(left, right, scalarKind) {
+  if (scalarKind === "decimal") {
+    const comparison = compareQueryScalarValues(left, right, scalarKind);
+    return !Number.isNaN(comparison) && comparison === 0;
+  }
+  if (scalarKind === "date" || scalarKind === "timestamp") {
+    const comparison = compareTemporalValues(left, right);
+    return !Number.isNaN(comparison) && comparison === 0;
+  }
+  if (scalarKind !== undefined)
+    return Object.is(left, right);
+  return runtimeValuesEqual(left, right);
+}
+function compareRuntimeValues(left, right) {
+  if (typeof left === "number" && typeof right === "number")
+    return left - right;
+  if (typeof left === "string" && typeof right === "string")
+    return compareStrings(left, right);
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return Number(left) - Number(right);
+  }
+  if (left instanceof Date || right instanceof Date)
+    return compareTemporalValues(left, right);
+  return Number.NaN;
+}
+function runtimeValuesEqual(left, right) {
+  if (left instanceof Date || right instanceof Date) {
+    const comparison = compareTemporalValues(left, right);
+    return !Number.isNaN(comparison) && comparison === 0;
+  }
+  return Object.is(left, right);
+}
+function compareTemporalValues(left, right) {
+  const leftTime = dateTime(left);
+  const rightTime = dateTime(right);
+  if (leftTime === null || rightTime === null)
+    return Number.NaN;
+  return leftTime - rightTime;
+}
+function dateTime(value) {
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isNaN(time) ? null : time;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const time = new Date(value).getTime();
+    return Number.isNaN(time) ? null : time;
+  }
+  return null;
+}
+function compareStrings(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+
+// src/storage/objects/keys.ts
+function objectBatchKey(objectTypeId, primaryId) {
+  return JSON.stringify([objectTypeId, primaryId]);
+}
+function linkBatchKey(objectTypeId, objectId, linkId) {
+  return JSON.stringify([objectTypeId, objectId, linkId]);
+}
+function objectLinkCursor(link) {
+  return [link.sourceTypeId, link.sourceId, link.linkId, link.targetTypeId, link.targetId];
+}
+function compareObjectLinkCursors(left, right) {
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] < right[index])
+      return -1;
+    if (left[index] > right[index])
+      return 1;
+  }
+  return 0;
+}
+function compareObjectLinks(left, right) {
+  return compareObjectLinkCursors(objectLinkCursor(left), objectLinkCursor(right));
+}
+
 // src/storage/objects/in-memory.ts
 var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   queryObjects: true,
@@ -2135,6 +2222,7 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   facetObjects: true,
   nodes: {
     start: true,
+    refs: true,
     filter: true,
     text: true,
     vector: true,
@@ -2188,23 +2276,37 @@ var IN_MEMORY_OBJECT_QUERY_CAPABILITIES = {
   }
 };
 function objectRowKey(projectId, objectTypeId) {
-  return `${projectId}:${objectTypeId}`;
+  return JSON.stringify([projectId, objectTypeId]);
 }
-function comparePrimaryIds(left, right) {
+function objectRowProjectPrefix(projectId) {
+  return `[${JSON.stringify(projectId)},`;
+}
+function compareStrings2(left, right) {
   if (left < right)
     return -1;
   if (left > right)
     return 1;
   return 0;
 }
+function assertLinkQueryLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new Error("Object link query limit must be a positive safe integer.");
+  }
+}
 function sourceLinkBucketKey(projectId, sourceTypeId, sourceId) {
-  return `${projectId}:${sourceTypeId}:${sourceId}`;
+  return JSON.stringify([projectId, sourceTypeId, sourceId]);
 }
 function linkRowKey(linkId, targetTypeId, targetId) {
-  return `${linkId}:${targetTypeId}:${targetId}`;
+  return JSON.stringify([linkId, targetTypeId, targetId]);
 }
 function fullLinkRowKey(row) {
-  return `${row.sourceTypeId}:${row.sourceId}:${row.linkId}:${row.targetTypeId}:${row.targetId}`;
+  return JSON.stringify([
+    row.sourceTypeId,
+    row.sourceId,
+    row.linkId,
+    row.targetTypeId,
+    row.targetId
+  ]);
 }
 var PAGE_TOKEN_PREFIX = "offset:";
 var materializerAdapters = new WeakMap;
@@ -2339,6 +2441,8 @@ class InMemoryObjectStorage {
     switch (query.kind) {
       case "start":
         return this.evaluateStart(projectId, query.objectTypeId);
+      case "refs":
+        return this.evaluateRefs(projectId, query.refs);
       case "filter": {
         const input = this.evaluateObjectQuery(projectId, query.input);
         const entries = input.entries.filter((entry) => matchesPredicate(entry.row, query.predicate));
@@ -2428,6 +2532,18 @@ class InMemoryObjectStorage {
     }));
     return completeEvaluation(entries);
   }
+  evaluateRefs(projectId, refs) {
+    const seen = new Set;
+    const entries = refs.flatMap((ref) => {
+      const key2 = JSON.stringify([ref.objectTypeId, ref.primaryId]);
+      if (seen.has(key2))
+        return [];
+      seen.add(key2);
+      const row = this.rows.get(objectRowKey(projectId, ref.objectTypeId))?.get(ref.primaryId);
+      return row ? [row] : [];
+    }).sort((left, right) => compareStrings2(left.objectTypeId, right.objectTypeId) || compareStrings2(left.primaryId, right.primaryId)).map((row, order) => ({ row, score: 0, order }));
+    return completeEvaluation(entries);
+  }
   evaluateSet(projectId, op, inputs) {
     const evaluations = inputs.map((input) => this.evaluateObjectQuery(projectId, input));
     const first = evaluations[0];
@@ -2535,7 +2651,7 @@ class InMemoryObjectStorage {
         primaryId: item.primaryId
       });
       if (row) {
-        result.set(`${item.objectTypeId}:${item.primaryId}`, row);
+        result.set(objectBatchKey(item.objectTypeId, item.primaryId), row);
       }
     }
     return result;
@@ -2550,11 +2666,39 @@ class InMemoryObjectStorage {
         linkId: item.linkId
       });
       if (rows.length > 0) {
-        result.set(`${item.objectTypeId}:${item.objectId}:${item.linkId}`, [...rows]);
+        result.set(linkBatchKey(item.objectTypeId, item.objectId, item.linkId), [...rows]);
       }
     }
     return result;
   }
+  async queryLinks(params) {
+    assertLinkQueryLimit(params.limit);
+    if (params.objectRefs.length === 0 || params.endpointObjectTypeIds?.length === 0) {
+      return { links: [], hasMore: false };
+    }
+    const allowedTypes = params.endpointObjectTypeIds ? new Set(params.endpointObjectTypeIds) : undefined;
+    const deduped = new Map;
+    for (const object of params.objectRefs) {
+      const rows2 = await this.listLinks({
+        projectId: params.projectId,
+        objectTypeId: object.objectTypeId,
+        objectId: object.primaryId,
+        direction: params.direction,
+        ...params.linkId === undefined ? {} : { linkId: params.linkId }
+      });
+      for (const row of rows2) {
+        if (allowedTypes && (!allowedTypes.has(row.sourceTypeId) || !allowedTypes.has(row.targetTypeId))) {
+          continue;
+        }
+        if (params.after && compareObjectLinkCursors(objectLinkCursor(row), params.after) <= 0) {
+          continue;
+        }
+        deduped.set(fullLinkRowKey(row), row);
+      }
+    }
+    const rows = [...deduped.values()].sort(compareObjectLinks).slice(0, params.limit + 1);
+    return { links: rows.slice(0, params.limit), hasMore: rows.length > params.limit };
+  }
   async listIncidentLinksBatch(params) {
     const deduped = new Map;
     for (const item of params.items) {
@@ -2573,7 +2717,7 @@ class InMemoryObjectStorage {
   async listByPrimaryIdPage(params) {
     assertReconciliationPageLimit(params.limit);
     const bucket = this.rows.get(objectRowKey(params.projectId, params.objectTypeId));
-    const rows = [...bucket?.values() ?? []].filter((row) => !params.afterPrimaryId || comparePrimaryIds(row.primaryId, params.afterPrimaryId) > 0).sort((left, right) => comparePrimaryIds(left.primaryId, right.primaryId)).slice(0, params.limit + 1);
+    const rows = [...bucket?.values() ?? []].filter((row) => !params.afterPrimaryId || compareStrings2(row.primaryId, params.afterPrimaryId) > 0).sort((left, right) => compareStrings2(left.primaryId, right.primaryId)).slice(0, params.limit + 1);
     const hasMore = rows.length > params.limit;
     const objects = rows.slice(0, params.limit).map((row) => structuredClone(row));
     const last = objects.at(-1);
@@ -2594,7 +2738,7 @@ class InMemoryObjectStorage {
       }
     } else {
       for (const [key2, bucket] of this.rows) {
-        if (key2.startsWith(`${params.projectId}:`)) {
+        if (key2.startsWith(objectRowProjectPrefix(params.projectId))) {
           allRows.push(...bucket.values());
         }
       }
@@ -2860,7 +3004,7 @@ function rowIdentityKey(row) {
   return rowIdentityKeyParts(row.objectTypeId, row.primaryId);
 }
 function rowIdentityKeyParts(objectTypeId, primaryId) {
-  return `${objectTypeId}:${primaryId}`;
+  return objectBatchKey(objectTypeId, primaryId);
 }
 function upsertEntry(entriesByKey, entry) {
   const key2 = rowIdentityKey(entry.row);
@@ -3949,6 +4093,7 @@ class InMemoryOntologyMaterializationStorage {
           projectId,
           ref: item.ref,
           value: item.value,
+          editedAt: { ...item.editedAt },
           lastCommitId: item.lastCommitId,
           updatedAt: item.updatedAt
         }));
@@ -6659,6 +6804,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 +6823,7 @@ class InMemoryStorage {
   executions;
   agents;
   aiUsage;
+  aiCosts;
   actionRuns;
   syncRuns;
   pipelineRuns;
@@ -6694,6 +6843,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 +6865,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 +6984,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 +7012,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 +7033,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 +7255,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, 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=0974A6B3A889270064756E2164756E21
+//# debugId=0AE8BF2E3686BC2F64756E2164756E21