@sentry/junior 0.94.0 → 0.96.0

package/dist/chunk-MNTINMWR.js

@@ -0,0 +1,865 @@
+import {
+  ensureLegacyConversationImport
+} from "./chunk-5C6XTTFI.js";
+import {
+  contextProvenance,
+  getAgentStepStore,
+  getConversationStore,
+  instructionActors,
+  instructionProvenanceFor
+} from "./chunk-RITD7E5L.js";
+import {
+  getStateAdapter
+} from "./chunk-YDVEH3SB.js";
+import {
+  toStoredSlackActor
+} from "./chunk-I35CTGPO.js";
+
+// src/chat/conversations/projection.ts
+import { isDeepStrictEqual } from "util";
+function authorizationObservationMessage(entry, createdAtMs) {
+  const label = entry.kind === "mcp" ? "MCP authorization" : "Authorization";
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `${label} completed for provider "${entry.provider}". Continue the blocked request and retry the provider operation if needed.`
+      }
+    ],
+    timestamp: createdAtMs
+  };
+}
+function piEntryProvenance(entry) {
+  return entry.provenance ?? contextProvenance;
+}
+function projectSteps(steps, opts) {
+  const messages = [];
+  const provenance = [];
+  const seqs = [];
+  for (const step of steps) {
+    if (opts?.maxSeq !== void 0 && step.seq > opts.maxSeq) {
+      break;
+    }
+    if (step.entry.type === "pi_message") {
+      messages.push(step.entry.message);
+      provenance.push(piEntryProvenance(step.entry));
+      seqs.push(step.seq);
+      continue;
+    }
+    if (step.entry.type === "authorization_completed") {
+      messages.push(
+        authorizationObservationMessage(step.entry, step.createdAtMs)
+      );
+      provenance.push(contextProvenance);
+      seqs.push(step.seq);
+    }
+  }
+  return { messages, provenance, seqs };
+}
+function connectedMcpProvidersFromSteps(steps) {
+  const providers = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (step.entry.type === "mcp_provider_connected") {
+      providers.add(step.entry.provider);
+    }
+  }
+  return [...providers].sort((left, right) => left.localeCompare(right));
+}
+function isUserMessage(message) {
+  return message.role === "user";
+}
+function countMatchingPrefix(left, right) {
+  const limit = Math.min(left.length, right.length);
+  for (let index = 0; index < limit; index += 1) {
+    if (!isDeepStrictEqual(left[index], right[index])) {
+      return index;
+    }
+  }
+  return limit;
+}
+function resolveCommitProvenance(args) {
+  if (args.explicitProvenance) {
+    if (args.explicitProvenance.length !== args.nextMessages.length) {
+      throw new Error("commit provenance must align one-to-one with messages");
+    }
+    return args.explicitProvenance;
+  }
+  const matchingPrefix = args.matchingPrefix;
+  const provenance = args.nextMessages.map(
+    (_, index) => index < matchingPrefix ? args.existing.provenance[index] ?? contextProvenance : contextProvenance
+  );
+  if (args.newMessageProvenance) {
+    for (let index = args.nextMessages.length - 1; index >= matchingPrefix; index -= 1) {
+      if (isUserMessage(args.nextMessages[index])) {
+        provenance[index] = args.newMessageProvenance;
+        break;
+      }
+    }
+  }
+  if (args.trailingMessageProvenance) {
+    if (args.trailingMessageProvenance.length > provenance.length) {
+      throw new Error(
+        "trailing commit provenance cannot exceed committed messages"
+      );
+    }
+    const newMessageCount = args.nextMessages.length - matchingPrefix;
+    if (args.trailingMessageProvenance.length > newMessageCount) {
+      throw new Error(
+        "trailing commit provenance must align to newly committed messages"
+      );
+    }
+    const start = provenance.length - args.trailingMessageProvenance.length;
+    args.trailingMessageProvenance.forEach((entry, offset) => {
+      provenance[start + offset] = entry;
+    });
+  }
+  return provenance;
+}
+async function importLegacyIfNeeded(args) {
+  await ensureLegacyConversationImport({ conversationId: args.conversationId });
+}
+async function loadProjection(args) {
+  await importLegacyIfNeeded(args);
+  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
+  return projectSteps(steps).messages;
+}
+async function loadProjectionWithProvenance(args) {
+  await importLegacyIfNeeded(args);
+  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
+  const { messages, provenance } = projectSteps(steps);
+  return { messages, provenance };
+}
+async function loadTurnProjection(args) {
+  await importLegacyIfNeeded(args);
+  const stepStore = getAgentStepStore();
+  if (args.committedSeq < 0) {
+    return projectSteps(await stepStore.loadCurrentEpoch(args.conversationId));
+  }
+  const history = await stepStore.loadHistory(args.conversationId);
+  const committedStep = history.find((step) => step.seq === args.committedSeq);
+  if (!committedStep) {
+    return void 0;
+  }
+  const epochSteps = history.filter(
+    (step) => step.contextEpoch === committedStep.contextEpoch
+  );
+  return args.includeTail ? projectSteps(epochSteps) : projectSteps(epochSteps, { maxSeq: args.committedSeq });
+}
+async function loadConnectedMcpProviders(args) {
+  await importLegacyIfNeeded(args);
+  const steps = await getAgentStepStore().loadCurrentEpoch(args.conversationId);
+  return connectedMcpProvidersFromSteps(steps);
+}
+function messageTimestamp(message) {
+  const timestamp = message.timestamp;
+  return typeof timestamp === "number" ? timestamp : Date.now();
+}
+async function commitMessages(args) {
+  const stepStore = getAgentStepStore();
+  const existing = projectSteps(
+    await stepStore.loadCurrentEpoch(args.conversationId)
+  );
+  const matchingPrefix = countMatchingPrefix(existing.messages, args.messages);
+  const nextProvenance = resolveCommitProvenance({
+    existing,
+    nextMessages: args.messages,
+    matchingPrefix,
+    ...args.provenance ? { explicitProvenance: args.provenance } : {},
+    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {},
+    ...args.newMessageProvenance ? { newMessageProvenance: args.newMessageProvenance } : {}
+  });
+  if (matchingPrefix === existing.messages.length) {
+    const newMessages = args.messages.slice(matchingPrefix);
+    await stepStore.append(
+      args.conversationId,
+      newMessages.map((message, index) => ({
+        entry: {
+          type: "pi_message",
+          message,
+          provenance: nextProvenance[matchingPrefix + index]
+        },
+        createdAtMs: messageTimestamp(message)
+      }))
+    );
+  } else {
+    await stepStore.startEpoch(args.conversationId, {
+      reason: "rollback",
+      messages: args.messages.map((message, index) => ({
+        message,
+        createdAtMs: messageTimestamp(message),
+        provenance: nextProvenance[index]
+      }))
+    });
+  }
+  const committed = projectSteps(
+    await stepStore.loadCurrentEpoch(args.conversationId)
+  );
+  return {
+    committedSeq: committed.seqs.at(-1) ?? -1,
+    messageSeqs: committed.seqs,
+    provenance: nextProvenance
+  };
+}
+async function recordMcpProviderConnected(args) {
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  if (connectedMcpProvidersFromSteps(steps).includes(args.provider)) {
+    return;
+  }
+  await stepStore.append(args.conversationId, [
+    {
+      entry: { type: "mcp_provider_connected", provider: args.provider },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordAuthorizationRequested(args) {
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  if (steps.some(
+    (step) => step.entry.type === "authorization_requested" && step.entry.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await stepStore.append(args.conversationId, [
+    {
+      entry: {
+        type: "authorization_requested",
+        kind: args.kind,
+        provider: args.provider,
+        actorId: args.actorId,
+        authorizationId: args.authorizationId,
+        delivery: args.delivery
+      },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordAuthorizationCompleted(args) {
+  const stepStore = getAgentStepStore();
+  const steps = await stepStore.loadCurrentEpoch(args.conversationId);
+  if (steps.some(
+    (step) => step.entry.type === "authorization_completed" && step.entry.authorizationId === args.authorizationId
+  )) {
+    return;
+  }
+  await stepStore.append(args.conversationId, [
+    {
+      entry: {
+        type: "authorization_completed",
+        kind: args.kind,
+        provider: args.provider,
+        actorId: args.actorId,
+        authorizationId: args.authorizationId
+      },
+      createdAtMs: Date.now()
+    }
+  ]);
+}
+async function recordToolExecutionStarted(args) {
+  await getAgentStepStore().append(args.conversationId, [
+    {
+      entry: {
+        type: "tool_execution_started",
+        toolCallId: args.toolCallId,
+        toolName: args.toolName,
+        ...args.args !== void 0 ? { args: args.args } : {}
+      },
+      createdAtMs: args.createdAtMs ?? Date.now()
+    }
+  ]);
+}
+
+// src/chat/usage.ts
+import { z } from "zod";
+var agentTurnCostSchema = z.object({
+  input: z.number().finite().nonnegative().optional(),
+  output: z.number().finite().nonnegative().optional(),
+  cacheRead: z.number().finite().nonnegative().optional(),
+  cacheWrite: z.number().finite().nonnegative().optional(),
+  total: z.number().finite().nonnegative().optional()
+}).strict();
+var agentTurnUsageSchema = z.object({
+  inputTokens: z.number().int().nonnegative().optional(),
+  outputTokens: z.number().int().nonnegative().optional(),
+  cachedInputTokens: z.number().int().nonnegative().optional(),
+  cacheCreationTokens: z.number().int().nonnegative().optional(),
+  reasoningTokens: z.number().int().nonnegative().optional(),
+  totalTokens: z.number().int().nonnegative().optional(),
+  cost: agentTurnCostSchema.optional()
+}).strict();
+var COMPONENT_USAGE_FIELDS = [
+  "inputTokens",
+  "outputTokens",
+  "cachedInputTokens",
+  "cacheCreationTokens"
+];
+var COST_COMPONENT_FIELDS = [
+  "input",
+  "output",
+  "cacheRead",
+  "cacheWrite"
+];
+function hasAgentTurnUsage(usage) {
+  return Boolean(
+    usage && (Object.entries(usage).some(
+      ([field, value]) => field !== "cost" && typeof value === "number" && Number.isFinite(value)
+    ) || Object.values(usage.cost ?? {}).some(
+      (value) => typeof value === "number" && Number.isFinite(value)
+    ))
+  );
+}
+function getFiniteCount(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : void 0;
+}
+function getFiniteCost(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : void 0;
+}
+function addCost(left, right) {
+  return Math.round(((left ?? 0) + right) * 1e12) / 1e12;
+}
+function getComponentTotal(usage) {
+  let total;
+  for (const field of COMPONENT_USAGE_FIELDS) {
+    const value = getFiniteCount(usage[field]);
+    if (value === void 0) continue;
+    total = (total ?? 0) + value;
+  }
+  return total;
+}
+function addAgentTurnUsage(...usages) {
+  const components = {};
+  let componentTotal;
+  let totalOnlyTokens;
+  let reasoningTokens;
+  const cost = {};
+  for (const usage of usages) {
+    if (!usage) continue;
+    const reasoning = getFiniteCount(usage.reasoningTokens);
+    if (reasoning !== void 0) {
+      reasoningTokens = (reasoningTokens ?? 0) + reasoning;
+    }
+    if (usage.cost) {
+      for (const field of [...COST_COMPONENT_FIELDS, "total"]) {
+        const value = getFiniteCost(usage.cost[field]);
+        if (value === void 0) continue;
+        cost[field] = addCost(cost[field], value);
+      }
+    }
+    const usageComponentTotal = getComponentTotal(usage);
+    if (usageComponentTotal !== void 0) {
+      componentTotal = (componentTotal ?? 0) + usageComponentTotal;
+      for (const field of COMPONENT_USAGE_FIELDS) {
+        const value = getFiniteCount(usage[field]);
+        if (value === void 0) continue;
+        components[field] = (components[field] ?? 0) + value;
+      }
+      continue;
+    }
+    const totalTokens = getFiniteCount(usage.totalTokens);
+    if (totalTokens !== void 0) {
+      totalOnlyTokens = (totalOnlyTokens ?? 0) + totalTokens;
+    }
+  }
+  if (totalOnlyTokens !== void 0) {
+    return {
+      totalTokens: totalOnlyTokens + (componentTotal ?? 0),
+      ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
+      ...Object.keys(cost).length > 0 ? { cost } : {}
+    };
+  }
+  const result = {
+    ...components,
+    ...reasoningTokens !== void 0 ? { reasoningTokens } : {},
+    ...Object.keys(cost).length > 0 ? { cost } : {}
+  };
+  return hasAgentTurnUsage(result) ? result : void 0;
+}
+
+// src/chat/state/turn-session.ts
+import { THREAD_STATE_TTL_MS } from "chat";
+import {
+  actorSchema,
+  destinationSchema,
+  sourceSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+var AGENT_TURN_SESSION_INDEX_KEY = `${AGENT_TURN_SESSION_PREFIX}:index`;
+var AGENT_TURN_SESSION_INDEX_MAX_LENGTH = 5e3;
+var AGENT_TURN_SESSION_INDEX_READ_CONCURRENCY = 25;
+var AGENT_TURN_SESSION_TTL_MS = THREAD_STATE_TTL_MS;
+var agentTurnSessionStatusSchema = z2.enum([
+  "running",
+  "awaiting_resume",
+  "completed",
+  "failed",
+  "abandoned"
+]);
+var agentTurnSurfaceSchema = z2.enum([
+  "slack",
+  "api",
+  "scheduler",
+  "internal"
+]);
+var agentTurnResumeReasonSchema = z2.enum([
+  "timeout",
+  "auth",
+  "yield"
+]);
+var nonNegativeNumberSchema = z2.number().finite().nonnegative();
+var seqCursorSchema = z2.number().int().min(-1);
+var agentTurnSessionSummarySchema = z2.object({
+  channelName: z2.string().min(1).optional(),
+  version: z2.number().int().nonnegative(),
+  conversationId: z2.string().min(1),
+  cumulativeDurationMs: nonNegativeNumberSchema,
+  cumulativeUsage: agentTurnUsageSchema.optional(),
+  destination: destinationSchema.optional(),
+  source: sourceSchema.optional(),
+  lastProgressAtMs: nonNegativeNumberSchema,
+  loadedSkillNames: z2.array(z2.string()).optional(),
+  modelId: z2.string().min(1).optional(),
+  reasoningLevel: z2.string().min(1).optional(),
+  actor: actorSchema.optional(),
+  resumeReason: agentTurnResumeReasonSchema.optional(),
+  resumedFromSliceId: z2.number().int().nonnegative().optional(),
+  sessionId: z2.string().min(1),
+  sliceId: z2.number().int().nonnegative(),
+  startedAtMs: nonNegativeNumberSchema,
+  state: agentTurnSessionStatusSchema,
+  surface: agentTurnSurfaceSchema.optional(),
+  traceId: z2.string().optional(),
+  updatedAtMs: nonNegativeNumberSchema
+}).strict();
+var storedAgentTurnSessionRecordSchema = agentTurnSessionSummarySchema.extend({
+  committedSeq: seqCursorSchema,
+  errorMessage: z2.string().optional(),
+  turnStartSeq: seqCursorSchema.optional()
+}).strict();
+function agentTurnSessionKey(conversationId, sessionId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+}
+function agentTurnSessionConversationIndexKey(conversationId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:conversation:${conversationId}:index`;
+}
+function conversationExecutionFromSummary(summary) {
+  const status = summary.state === "completed" || summary.state === "abandoned" ? "idle" : summary.state;
+  return {
+    status,
+    runId: summary.sessionId,
+    updatedAtMs: summary.updatedAtMs
+  };
+}
+function sessionLogActor(actor) {
+  return actor?.platform === "slack" ? toStoredSlackActor(actor) : void 0;
+}
+function parseAgentTurnSessionRecord(value) {
+  return storedAgentTurnSessionRecordSchema.parse(value);
+}
+function parseAgentTurnSessionSummary(value) {
+  return agentTurnSessionSummarySchema.parse(value);
+}
+async function appendAgentTurnSessionSummary(summary, ttlMs) {
+  const stateAdapter = getStateAdapter();
+  await Promise.all([
+    stateAdapter.appendToList(AGENT_TURN_SESSION_INDEX_KEY, summary, {
+      maxLength: AGENT_TURN_SESSION_INDEX_MAX_LENGTH,
+      ttlMs
+    }),
+    stateAdapter.appendToList(
+      agentTurnSessionConversationIndexKey(summary.conversationId),
+      summary,
+      { ttlMs }
+    )
+  ]);
+}
+async function recordConversationActivityMetadata(args) {
+  const conversationStore = args.conversationStore ?? getConversationStore();
+  const source = args.summary.destination?.platform === "local" ? "local" : args.summary.surface;
+  await conversationStore.recordActivity({
+    activityAtMs: args.summary.updatedAtMs,
+    channelName: args.summary.channelName,
+    conversationId: args.summary.conversationId,
+    destination: args.summary.destination,
+    nowMs: args.nowMs,
+    actor: sessionLogActor(args.summary.actor),
+    source,
+    visibility: args.destinationVisibility
+  });
+  await conversationStore.recordExecution({
+    channelName: args.summary.channelName,
+    conversationId: args.summary.conversationId,
+    createdAtMs: args.summary.startedAtMs,
+    destination: args.summary.destination,
+    execution: conversationExecutionFromSummary(args.summary),
+    lastActivityAtMs: args.summary.updatedAtMs,
+    actor: sessionLogActor(args.summary.actor),
+    source,
+    updatedAtMs: args.nowMs,
+    visibility: args.destinationVisibility
+  });
+}
+function materializeAgentTurnSessionRecord(stored, piProjection, turnStartMessageIndex) {
+  return {
+    version: stored.version,
+    ...stored.channelName ? { channelName: stored.channelName } : {},
+    conversationId: stored.conversationId,
+    sessionId: stored.sessionId,
+    sliceId: stored.sliceId,
+    state: stored.state,
+    startedAtMs: stored.startedAtMs,
+    lastProgressAtMs: stored.lastProgressAtMs,
+    updatedAtMs: stored.updatedAtMs,
+    piMessages: piProjection.messages,
+    piMessageProvenance: piProjection.provenance,
+    actors: instructionActors(piProjection.provenance),
+    cumulativeDurationMs: stored.cumulativeDurationMs,
+    ...stored.destination ? { destination: stored.destination } : {},
+    ...stored.source ? { source: stored.source } : {},
+    ...stored.cumulativeUsage ? { cumulativeUsage: stored.cumulativeUsage } : {},
+    ...stored.resumeReason ? { resumeReason: stored.resumeReason } : {},
+    ...stored.errorMessage ? { errorMessage: stored.errorMessage } : {},
+    ...stored.loadedSkillNames ? { loadedSkillNames: stored.loadedSkillNames } : {},
+    ...stored.modelId ? { modelId: stored.modelId } : {},
+    ...stored.reasoningLevel ? { reasoningLevel: stored.reasoningLevel } : {},
+    ...stored.actor ? { actor: stored.actor } : {},
+    ...stored.resumedFromSliceId !== void 0 ? { resumedFromSliceId: stored.resumedFromSliceId } : {},
+    ...stored.surface ? { surface: stored.surface } : {},
+    ...stored.traceId ? { traceId: stored.traceId } : {},
+    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {}
+  };
+}
+async function getStoredAgentTurnSessionRecord(conversationId, sessionId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const value = await stateAdapter.get(
+    agentTurnSessionKey(conversationId, sessionId)
+  );
+  return value == null ? void 0 : parseAgentTurnSessionRecord(value);
+}
+async function getAgentTurnSessionRecord(conversationId, sessionId) {
+  const parsed = await getStoredAgentTurnSessionRecord(
+    conversationId,
+    sessionId
+  );
+  if (!parsed) {
+    return void 0;
+  }
+  const piProjection = await loadTurnProjection({
+    conversationId,
+    committedSeq: parsed.committedSeq,
+    // Unfinished records include the current-epoch tail so parked input
+    // appended after the last safe boundary stays model-visible on resume.
+    includeTail: parsed.state === "running" || parsed.state === "awaiting_resume"
+  });
+  if (!piProjection) {
+    return void 0;
+  }
+  const turnStartMessageIndex = parsed.turnStartSeq === void 0 ? void 0 : piProjection.seqs.filter((seq) => seq <= parsed.turnStartSeq).length;
+  return materializeAgentTurnSessionRecord(
+    parsed,
+    piProjection,
+    turnStartMessageIndex
+  );
+}
+function buildStoredRecord(args) {
+  const nowMs = Date.now();
+  return {
+    version: (args.previousVersion ?? 0) + 1,
+    ...args.channelName ? { channelName: args.channelName } : {},
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: args.state,
+    startedAtMs: args.startedAtMs ?? nowMs,
+    lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+    updatedAtMs: nowMs,
+    committedSeq: args.committedSeq,
+    ...args.turnStartSeq !== void 0 ? { turnStartSeq: args.turnStartSeq } : {},
+    cumulativeDurationMs: args.cumulativeDurationMs,
+    ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
+    ...args.destination ? { destination: args.destination } : {},
+    ...args.source ? { source: args.source } : {},
+    ...args.actor ? { actor: args.actor } : {},
+    ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+    ...args.modelId ? { modelId: args.modelId } : {},
+    ...args.reasoningLevel ? { reasoningLevel: args.reasoningLevel } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+    ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+    ...args.surface ? { surface: args.surface } : {},
+    ...args.traceId ? { traceId: args.traceId } : {}
+  };
+}
+async function setStoredRecord(args) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  await recordConversationActivityMetadata({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    nowMs: Date.now(),
+    summary: args.record
+  });
+  await stateAdapter.set(
+    agentTurnSessionKey(args.record.conversationId, args.record.sessionId),
+    args.record,
+    args.ttlMs
+  );
+  const {
+    committedSeq: _committedSeq,
+    errorMessage: _errorMessage,
+    turnStartSeq: _turnStartSeq,
+    ...summary
+  } = args.record;
+  await appendAgentTurnSessionSummary(summary, args.ttlMs);
+  return materializeAgentTurnSessionRecord(
+    args.record,
+    {
+      messages: [...args.piMessages],
+      provenance: [...args.piMessageProvenance]
+    },
+    args.turnStartMessageIndex
+  );
+}
+async function updateAgentTurnSessionState(args) {
+  const parsed = await getStoredAgentTurnSessionRecord(
+    args.existing.conversationId,
+    args.existing.sessionId
+  );
+  if (!parsed || parsed.version !== args.existing.version) {
+    return void 0;
+  }
+  return await setStoredRecord({
+    piMessages: args.existing.piMessages,
+    piMessageProvenance: args.existing.piMessageProvenance,
+    ttlMs: AGENT_TURN_SESSION_TTL_MS,
+    ...args.existing.turnStartMessageIndex !== void 0 ? { turnStartMessageIndex: args.existing.turnStartMessageIndex } : {},
+    record: buildStoredRecord({
+      conversationId: args.existing.conversationId,
+      sessionId: args.existing.sessionId,
+      sliceId: args.existing.sliceId,
+      state: args.state,
+      committedSeq: parsed.committedSeq,
+      ...parsed.turnStartSeq !== void 0 ? { turnStartSeq: parsed.turnStartSeq } : {},
+      ...parsed.channelName ? { channelName: parsed.channelName } : {},
+      startedAtMs: parsed.startedAtMs,
+      lastProgressAtMs: parsed.lastProgressAtMs,
+      previousVersion: parsed.version,
+      cumulativeDurationMs: args.existing.cumulativeDurationMs,
+      ...args.existing.cumulativeUsage ? { cumulativeUsage: args.existing.cumulativeUsage } : {},
+      ...args.existing.destination ? { destination: args.existing.destination } : {},
+      ...args.existing.source ? { source: args.existing.source } : {},
+      ...args.existing.loadedSkillNames ? { loadedSkillNames: args.existing.loadedSkillNames } : {},
+      ...args.existing.modelId ? { modelId: args.existing.modelId } : {},
+      ...args.existing.reasoningLevel ? { reasoningLevel: args.existing.reasoningLevel } : {},
+      ...args.existing.actor ? { actor: args.existing.actor } : {},
+      ...args.existing.resumeReason ? { resumeReason: args.existing.resumeReason } : {},
+      ...args.existing.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.existing.resumedFromSliceId } : {},
+      ...args.existing.surface ? { surface: args.existing.surface } : {},
+      ...args.existing.traceId ? { traceId: args.existing.traceId } : {},
+      ...args.errorMessage ?? args.existing.errorMessage ? { errorMessage: args.errorMessage ?? args.existing.errorMessage } : {}
+    })
+  });
+}
+async function upsertAgentTurnSessionRecord(args) {
+  const existingRecord = await getStoredAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  const instructionActor = args.actor ?? existingRecord?.actor;
+  const commit = await commitMessages({
+    conversationId: args.conversationId,
+    messages: args.piMessages,
+    ...instructionActor ? { newMessageProvenance: instructionProvenanceFor(instructionActor) } : {},
+    ...args.trailingMessageProvenance ? { trailingMessageProvenance: args.trailingMessageProvenance } : {}
+  });
+  const turnStartSeq = args.turnStartMessageIndex === void 0 ? existingRecord?.turnStartSeq : args.turnStartMessageIndex <= 0 ? -1 : commit.messageSeqs[args.turnStartMessageIndex - 1] ?? commit.committedSeq;
+  const turnStartMessageIndex = args.turnStartMessageIndex ?? (turnStartSeq === void 0 ? void 0 : commit.messageSeqs.filter((seq) => seq <= turnStartSeq).length);
+  return await setStoredRecord({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    piMessages: args.piMessages,
+    piMessageProvenance: commit.provenance,
+    ttlMs,
+    ...turnStartMessageIndex !== void 0 ? { turnStartMessageIndex } : {},
+    record: buildStoredRecord({
+      ...args.channelName ?? existingRecord?.channelName ? { channelName: args.channelName ?? existingRecord?.channelName } : {},
+      conversationId: args.conversationId,
+      sessionId: args.sessionId,
+      sliceId: args.sliceId,
+      state: args.state,
+      ...existingRecord?.startedAtMs !== void 0 ? { startedAtMs: existingRecord.startedAtMs } : {},
+      ...args.lastProgressAtMs !== void 0 ? { lastProgressAtMs: args.lastProgressAtMs } : {},
+      committedSeq: commit.committedSeq,
+      ...turnStartSeq !== void 0 ? { turnStartSeq } : {},
+      previousVersion: existingRecord?.version,
+      cumulativeDurationMs: args.cumulativeDurationMs ?? existingRecord?.cumulativeDurationMs ?? 0,
+      ...args.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage } : {},
+      ...args.destination ?? existingRecord?.destination ? { destination: args.destination ?? existingRecord?.destination } : {},
+      ...args.source ?? existingRecord?.source ? { source: args.source ?? existingRecord?.source } : {},
+      ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : {},
+      ...existingRecord?.modelId ?? args.modelId ? { modelId: existingRecord?.modelId ?? args.modelId } : {},
+      ...args.reasoningLevel ?? existingRecord?.reasoningLevel ? {
+        reasoningLevel: args.reasoningLevel ?? existingRecord?.reasoningLevel
+      } : {},
+      ...args.actor ?? existingRecord?.actor ? { actor: args.actor ?? existingRecord?.actor } : {},
+      ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+      ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+      ...args.resumedFromSliceId !== void 0 ? { resumedFromSliceId: args.resumedFromSliceId } : {},
+      ...args.surface ?? existingRecord?.surface ? { surface: args.surface ?? existingRecord?.surface } : {},
+      ...args.traceId ?? existingRecord?.traceId ? { traceId: args.traceId ?? existingRecord?.traceId } : {}
+    })
+  });
+}
+async function recordAgentTurnSessionSummary(args) {
+  const existing = await getStoredAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  const nowMs = Date.now();
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  const summary = {
+    version: existing?.version ?? 0,
+    ...args.channelName ?? existing?.channelName ? { channelName: args.channelName ?? existing?.channelName } : {},
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    startedAtMs: existing?.startedAtMs ?? args.startedAtMs ?? nowMs,
+    lastProgressAtMs: args.lastProgressAtMs ?? nowMs,
+    state: args.state,
+    updatedAtMs: nowMs,
+    cumulativeDurationMs: args.cumulativeDurationMs ?? existing?.cumulativeDurationMs ?? 0,
+    ...args.cumulativeUsage ?? existing?.cumulativeUsage ? { cumulativeUsage: args.cumulativeUsage ?? existing?.cumulativeUsage } : {},
+    ...args.destination ?? existing?.destination ? { destination: args.destination ?? existing?.destination } : {},
+    ...args.source ?? existing?.source ? { source: args.source ?? existing?.source } : {},
+    ...args.actor ?? existing?.actor ? { actor: args.actor ?? existing?.actor } : {},
+    ...args.loadedSkillNames ? { loadedSkillNames: args.loadedSkillNames } : existing?.loadedSkillNames ? { loadedSkillNames: existing.loadedSkillNames } : {},
+    ...existing?.modelId ?? args.modelId ? { modelId: existing?.modelId ?? args.modelId } : {},
+    ...args.reasoningLevel ?? existing?.reasoningLevel ? { reasoningLevel: args.reasoningLevel ?? existing?.reasoningLevel } : {},
+    ...args.resumeReason ? { resumeReason: args.resumeReason } : {},
+    ...args.surface ?? existing?.surface ? { surface: args.surface ?? existing?.surface } : {},
+    ...args.traceId ?? existing?.traceId ? { traceId: args.traceId ?? existing?.traceId } : {}
+  };
+  await recordConversationActivityMetadata({
+    conversationStore: args.conversationStore,
+    destinationVisibility: args.destinationVisibility,
+    nowMs,
+    summary
+  });
+  await appendAgentTurnSessionSummary(summary, ttlMs);
+}
+async function readAgentTurnSessionSummariesFromIndex(key) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const values = await stateAdapter.getList(key);
+  const summaries = /* @__PURE__ */ new Map();
+  for (const value of [...values].reverse()) {
+    const summary = parseAgentTurnSessionSummary(value);
+    const key2 = `${summary.conversationId}:${summary.sessionId}`;
+    if (!summaries.has(key2)) {
+      summaries.set(key2, summary);
+    }
+  }
+  return [...summaries.values()].sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs
+  );
+}
+async function listAgentTurnSessionSummariesForConversation(conversationId) {
+  const summaries = await readAgentTurnSessionSummariesFromIndex(
+    agentTurnSessionConversationIndexKey(conversationId)
+  );
+  if (summaries.length > 0) {
+    return summaries;
+  }
+  return (await readAgentTurnSessionSummariesFromIndex(AGENT_TURN_SESSION_INDEX_KEY)).filter((summary) => summary.conversationId === conversationId);
+}
+async function listAgentTurnSessionSummariesForConversations(conversationIds) {
+  const ids = [...new Set(conversationIds)];
+  const globalSummaries = await readAgentTurnSessionSummariesFromIndex(
+    AGENT_TURN_SESSION_INDEX_KEY
+  );
+  const globalByConversation = /* @__PURE__ */ new Map();
+  for (const summary of globalSummaries) {
+    globalByConversation.set(summary.conversationId, [
+      ...globalByConversation.get(summary.conversationId) ?? [],
+      summary
+    ]);
+  }
+  const summariesByConversation = /* @__PURE__ */ new Map();
+  let nextIndex = 0;
+  const readNext = async () => {
+    while (nextIndex < ids.length) {
+      const conversationId = ids[nextIndex];
+      nextIndex += 1;
+      if (!conversationId) continue;
+      const summaries = await readAgentTurnSessionSummariesFromIndex(
+        agentTurnSessionConversationIndexKey(conversationId)
+      );
+      summariesByConversation.set(
+        conversationId,
+        summaries.length > 0 ? summaries : globalByConversation.get(conversationId) ?? []
+      );
+    }
+  };
+  await Promise.all(
+    Array.from(
+      {
+        length: Math.min(AGENT_TURN_SESSION_INDEX_READ_CONCURRENCY, ids.length)
+      },
+      readNext
+    )
+  );
+  return summariesByConversation;
+}
+async function abandonAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned") {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "abandoned",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
+}
+async function failAgentTurnSessionRecord(args) {
+  const existing = await getAgentTurnSessionRecord(
+    args.conversationId,
+    args.sessionId
+  );
+  if (!existing || existing.state === "completed" || existing.state === "failed" || existing.state === "abandoned" || existing.version !== args.expectedVersion) {
+    return void 0;
+  }
+  return await updateAgentTurnSessionState({
+    existing,
+    state: "failed",
+    errorMessage: args.errorMessage ?? existing.errorMessage
+  });
+}
+
+export {
+  projectSteps,
+  loadProjection,
+  loadProjectionWithProvenance,
+  loadConnectedMcpProviders,
+  commitMessages,
+  recordMcpProviderConnected,
+  recordAuthorizationRequested,
+  recordAuthorizationCompleted,
+  recordToolExecutionStarted,
+  hasAgentTurnUsage,
+  addAgentTurnUsage,
+  getAgentTurnSessionRecord,
+  upsertAgentTurnSessionRecord,
+  recordAgentTurnSessionSummary,
+  listAgentTurnSessionSummariesForConversation,
+  listAgentTurnSessionSummariesForConversations,
+  abandonAgentTurnSessionRecord,
+  failAgentTurnSessionRecord
+};