@sixb/core 0.1.21 → 0.1.22

package/dist/chunk-nydf3dbe.js

@@ -0,0 +1,663 @@
+// @bun
+import {
+  MODEL_REASONING_LEVELS2,
+  isModelReasoning2
+} from "./chunk-pdt5cw8z.js";
+import {
+  LANGUAGE_MODEL_TIERS2,
+  isLanguageModelTier2
+} from "./chunk-tdxfsg1c.js";
+import {
+  isFileRef2
+} from "./chunk-wkv3h3q7.js";
+import {
+  findAgentRunExecution
+} from "./chunk-ey1nk510.js";
+import {
+  AGENT_APPROVAL_MODES2,
+  AGENT_HOLDING_APPROVAL_MODES2,
+  AGENT_MEMORY_HISTORY_DAYS
+} from "./chunk-18sk89cg.js";
+import {
+  isJsonObject2,
+  isPlainRecord
+} from "./chunk-wy0qdqfm.js";
+
+// src/storage/agents/provider.ts
+import { isDeepStrictEqual } from "util";
+
+// src/agents/ids.ts
+import { createHash, randomUUID } from "crypto";
+function createAgentThreadId2() {
+  return `agt_thr_${randomUUID()}`;
+}
+function createAgentThreadSandboxName2(projectId, threadId) {
+  const digest = createHash("sha256").update(JSON.stringify([projectId, threadId, randomUUID()])).digest("hex");
+  return `sixb-sb-${digest}`;
+}
+function createAgentRunId2() {
+  return `agt_run_${randomUUID()}`;
+}
+function createSubagentRunId2(parentRunId, spawnKey) {
+  return `agt_run_child_${spawnDigest(parentRunId, spawnKey)}`;
+}
+function createSubagentThreadId2(spawningRunId, spawnKey) {
+  return `agt_thr_child_${spawnDigest(spawningRunId, spawnKey)}`;
+}
+function spawnDigest(runId, spawnKey) {
+  return createHash("sha256").update(runId).update("\x00").update(spawnKey).digest("hex");
+}
+function createSubagentExecutionId2(runId) {
+  return `exec_${runId}`;
+}
+function createAgentMessageId2() {
+  return `agt_msg_${randomUUID()}`;
+}
+function agentContextCheckpointId2(runId) {
+  return `agt_ctx_${runId}`;
+}
+function createCopiedAgentContextCheckpointId() {
+  return `agt_ctx_copy_${randomUUID()}`;
+}
+function createAgentRunExecutionToken2() {
+  return `agt_exec_${randomUUID()}`;
+}
+
+// src/agents/types.ts
+var AGENT_REASONING_LEVELS2 = MODEL_REASONING_LEVELS2;
+
+// src/storage/agents/errors.ts
+class AgentStorageError2 extends Error {
+  code;
+  name = "AgentStorageError";
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+// src/storage/agents/provider.ts
+var SANDBOX_NAME_PATTERN = /^[a-zA-Z0-9-]{1,80}$/;
+function transitionAgentThreadSandbox2(thread, run, input) {
+  const fail = (message) => {
+    throw new AgentStorageError2("invalid_state", `[Sixb] Sandbox ${message}`);
+  };
+  if (!thread || !thread.sandboxParams && thread.kind !== "subagent") {
+    return fail("is not configured on this thread.");
+  }
+  if (!SANDBOX_NAME_PATTERN.test(input.name))
+    return fail("name is invalid.");
+  const state = thread.sandboxState;
+  if (input.action === "recreate") {
+    if (thread.activeRunId !== null)
+      return fail("cannot be recreated during an active run.");
+    if (!state || state.name !== input.expectedSandboxName || input.name === state.name)
+      return fail("changed; reload before recreating.");
+    if (!["busy", "blocked", "unavailable"].includes(state.status)) {
+      return fail("does not require recovery.");
+    }
+    return {
+      name: input.name,
+      status: "new",
+      initialized: false,
+      resetAt: new Date().toISOString()
+    };
+  }
+  if (!run || run.threadId !== thread.id || run.status !== "running" || thread.activeRunId !== run.id || run.id !== input.runId || run.execution?.token !== input.executionToken || run.execution.queueLeaseExpiresAt.getTime() <= Date.now()) {
+    throw new AgentStorageError2("execution_lost", "[Sixb] Sandbox execution ownership was lost.");
+  }
+  if (input.action === "acquire") {
+    if (state && state.status !== "new" && state.status !== "ready") {
+      if (thread.kind === "subagent" && state.name !== input.name) {
+        return startSubagentWorkspaceAgain(input);
+      }
+      return fail("requires recovery; previous operations may still be in flight.");
+    }
+    if (state && state.name !== input.name)
+      return fail("name changed.");
+    if (!/^[a-f0-9]{64}$/.test(input.sourceFingerprint))
+      return fail("source fingerprint is invalid.");
+    if (state?.sourceFingerprint && state.sourceFingerprint !== input.sourceFingerprint) {
+      return fail("source identity changed; the existing checkout was not opened.");
+    }
+    return {
+      name: input.name,
+      status: "busy",
+      initialized: state?.initialized ?? false,
+      ...state?.resetAt ? { resetAt: state.resetAt } : {},
+      sourceFingerprint: input.sourceFingerprint,
+      owner: { runId: input.runId, executionToken: input.executionToken }
+    };
+  }
+  if (state?.status !== "busy" || state.name !== input.name || state.owner?.runId !== input.runId || state.owner.executionToken !== input.executionToken) {
+    return fail("is not owned by this execution.");
+  }
+  if (input.action === "replace") {
+    if (!state.initialized || input.nextName === state.name || !SANDBOX_NAME_PATTERN.test(input.nextName)) {
+      return fail("replacement requires initialized state and a fresh valid name.");
+    }
+    return {
+      ...state,
+      name: input.nextName,
+      initialized: false,
+      resetAt: new Date().toISOString()
+    };
+  }
+  if (input.status === "ready" && !input.initialized)
+    return fail("initialization is incomplete.");
+  return {
+    name: state.name,
+    status: input.status,
+    initialized: input.initialized,
+    sourceFingerprint: state.sourceFingerprint,
+    ...state.resetAt ? { resetAt: state.resetAt } : {}
+  };
+}
+function startSubagentWorkspaceAgain(input) {
+  if (!/^[a-f0-9]{64}$/.test(input.sourceFingerprint)) {
+    throw new AgentStorageError2("invalid_state", "[Sixb] Sandbox source fingerprint is invalid.");
+  }
+  return {
+    name: input.name,
+    status: "busy",
+    initialized: false,
+    resetAt: new Date().toISOString(),
+    sourceFingerprint: input.sourceFingerprint,
+    owner: { runId: input.runId, executionToken: input.executionToken }
+  };
+}
+function snapshotAgentThreadSandboxParams2(value) {
+  if (!isPlainRecord(value) || !isJsonObject2(value)) {
+    throw new AgentStorageError2("invalid_input", "[Sixb] Thread sandbox must contain only JSON params.");
+  }
+  return structuredClone(value);
+}
+function participantsToAdd2(input, existing, prefix = "Sixb") {
+  const taken = new Set(existing.map((participant) => participant.principal.id));
+  const added = input.principals.filter((principal) => !taken.has(principal.id));
+  if (existing.length + added.length > input.maxParticipants) {
+    throw new AgentStorageError2("participant_limit", `[${prefix}] Agent thread '${input.threadId}' can have at most ${input.maxParticipants} participants.`);
+  }
+  return added;
+}
+function compareAgentThreadParticipants2(left, right) {
+  return left.addedAt.getTime() - right.addedAt.getTime() || Buffer.compare(Buffer.from(left.principal.id), Buffer.from(right.principal.id)) || Buffer.compare(Buffer.from(left.threadId), Buffer.from(right.threadId));
+}
+var ARTIFACT_ID_TOKEN = /art_[0-9a-z]{10}/g;
+function remapArtifactIds2(text, copies) {
+  if (!copies || Object.keys(copies).length === 0)
+    return text;
+  return text.replace(ARTIFACT_ID_TOKEN, (id) => copies[id] ?? id);
+}
+function countsAsThreadMessage2(message) {
+  return !(message.parts.length > 0 && message.parts.every((part) => part.type === "approval-outcome"));
+}
+function planAgentThreadFork2(input, source, prefix = "Sixb") {
+  const createdAt = new Date(input.createdAt ?? new Date);
+  const sandboxState = forkedSandboxState(input, createdAt, prefix);
+  const trigger = source.messages.find((message) => message.id === source.triggerMessageId);
+  const copied = trigger === undefined ? source.messages : source.messages.filter((message) => message.seq < trigger.seq);
+  const lastCopiedSeq = copied.at(-1)?.seq ?? 0;
+  const checkpoint = source.checkpoints.find((candidate) => candidate.observedHeadSeq <= lastCopiedSeq);
+  const thread = {
+    id: input.id,
+    projectId: input.projectId,
+    kind: "conversation",
+    ownerPrincipal: structuredClone(input.ownerPrincipal),
+    ...input.title === undefined ? {} : { title: input.title },
+    ...input.sandboxParams === undefined ? {} : { sandboxParams: snapshotAgentThreadSandboxParams2(input.sandboxParams) },
+    ...sandboxState === undefined ? {} : { sandboxState },
+    status: "active",
+    activeRunId: null,
+    messageCount: copied.filter((message) => message.counted !== false).length,
+    createdAt,
+    updatedAt: createdAt
+  };
+  return {
+    thread,
+    messages: copied.map((message) => ({ sourceId: message.id, id: createAgentMessageId2() })),
+    ...checkpoint === undefined ? {} : {
+      checkpoint: {
+        ...copyCheckpoint(checkpoint, input.id),
+        summary: remapArtifactIds2(checkpoint.summary, input.artifactCopies)
+      }
+    }
+  };
+}
+function copyCheckpoint(checkpoint, threadId) {
+  const { previousCheckpointId: _previous, ...copied } = structuredClone(checkpoint);
+  return { ...copied, id: createCopiedAgentContextCheckpointId(), threadId };
+}
+function forkedSandboxState(input, createdAt, prefix) {
+  if (input.sandboxParams === undefined !== (input.sandboxName === undefined)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] A forked thread needs a sandbox name exactly when it has sandbox params.`);
+  }
+  if (input.sandboxName === undefined)
+    return;
+  if (!SANDBOX_NAME_PATTERN.test(input.sandboxName)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Sandbox name is invalid.`);
+  }
+  return {
+    name: input.sandboxName,
+    status: "new",
+    initialized: false,
+    resetAt: createdAt.toISOString()
+  };
+}
+function assertConversationAgentRunSpec2(spec, prefix = "Sixb") {
+  if (!isRecord(spec) || !isRecord(spec.model)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run spec must contain a model reference.`);
+  }
+  for (const [name, value] of [
+    ["model.provider", spec.model.provider],
+    ["model.modelId", spec.model.modelId]
+  ]) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run '${name}' must not be empty.`);
+    }
+  }
+  if (spec.reasoning !== undefined && !isModelReasoning2(spec.reasoning)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent reasoning must be one of: ${AGENT_REASONING_LEVELS2.join(", ")}, or a nonnegative budgetTokens object.`);
+  }
+  if (spec.tier !== undefined && !isLanguageModelTier2(spec.tier)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run 'tier' must be one of: ${LANGUAGE_MODEL_TIERS2.join(", ")}.`);
+  }
+  if (spec.tierProbabilities !== undefined && !isTierProbabilities(spec.tierProbabilities)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run 'tierProbabilities' must give each tier a probability.`);
+  }
+  for (const [name, value] of [
+    ["timeZone", spec.timeZone],
+    ["locale", spec.locale]
+  ]) {
+    if (value !== undefined && (typeof value !== "string" || value.trim().length === 0)) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run '${name}' must be a non-empty string.`);
+    }
+  }
+  assertApprovalModeField(spec.approvalMode, "Conversational Agent run", prefix);
+}
+function isAgentApprovalMode2(value) {
+  return AGENT_APPROVAL_MODES2.includes(value);
+}
+function assertAgentApprovalModeInput2(mode, prefix = "Sixb") {
+  if (!isAgentApprovalMode2(mode)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent approval mode must be one of: ${AGENT_APPROVAL_MODES2.join(", ")}.`);
+  }
+}
+function assertApprovalModeField(value, owner, prefix) {
+  if (value !== undefined && !isAgentApprovalMode2(value)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] ${owner} 'approvalMode' must be one of: ${AGENT_APPROVAL_MODES2.join(", ")}.`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTierProbabilities(value) {
+  if (!isRecord(value) || Object.keys(value).length !== LANGUAGE_MODEL_TIERS2.length)
+    return false;
+  return LANGUAGE_MODEL_TIERS2.every((tier) => {
+    const probability = value[tier];
+    return typeof probability === "number" && probability >= 0 && probability <= 1;
+  });
+}
+async function assertAgentRunExecution2(input) {
+  const execution = await findAgentRunExecution({
+    executions: input.executions,
+    projectId: input.projectId,
+    executionId: input.executionId,
+    runId: input.runId,
+    authority: { type: "inherited" }
+  });
+  if (!execution) {
+    throw new AgentStorageError2("invalid_input", `[Sixb] Execution '${input.executionId}' does not authorize Agent run '${input.runId}'.`);
+  }
+  return execution;
+}
+function assertCreateSubagentRunInput2(input, prefix = "Sixb") {
+  for (const [name, value] of [
+    ["id", input.id],
+    ["projectId", input.projectId],
+    ["executionId", input.executionId],
+    ["parentRunId", input.parentRunId],
+    ["parentExecutionToken", input.parentExecutionToken],
+    ["spawnKey", input.spawnKey],
+    ["model.provider", input.spec.model.provider],
+    ["model.modelId", input.spec.model.modelId],
+    ["task", input.spec.task],
+    ["thread.id", input.thread.id],
+    ["trigger.id", input.trigger.id]
+  ]) {
+    if (value.trim().length === 0) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run '${name}' must not be empty.`);
+    }
+  }
+  if (input.spawnKey.length > 128) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent spawn key must not exceed 128 characters.`);
+  }
+  for (const [name, value] of [
+    ["maxActiveChildren", input.maxActiveChildren],
+    ["spec.maxSteps", input.spec.maxSteps]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run '${name}' must be a positive safe integer.`);
+    }
+  }
+  if (new Set(input.spec.toolNames).size !== input.spec.toolNames.length) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run tool names must be unique.`);
+  }
+  if (input.spec.reasoning !== undefined && !isModelReasoning2(input.spec.reasoning)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent reasoning must be one of: ${AGENT_REASONING_LEVELS2.join(", ")}, or a nonnegative budgetTokens object.`);
+  }
+  assertApprovalModeField(input.spec.approvalMode, "Subagent run", prefix);
+  assertSubagentRunFiles(input.spec.files, "spec.files", prefix);
+  if (input.spec.toolNames.some((name) => !name.trim())) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run tool names must not be empty.`);
+  }
+  if (!Array.isArray(input.trigger.parts) || input.trigger.parts.length === 0) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run trigger must have at least one part.`);
+  }
+  if (input.createdAt && !Number.isFinite(input.createdAt.getTime())) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run createdAt must be a valid date.`);
+  }
+}
+function subagentRunMatchesCreateInput2(run, input) {
+  return run.kind === "subagent" && run.id === input.id && run.projectId === input.projectId && run.executionId === input.executionId && run.parentRunId === input.parentRunId && run.spawnKey === input.spawnKey && run.threadId === input.thread.id && isDeepStrictEqual(run.spec, input.spec);
+}
+function assertConversationThreadRow2(thread, operation, prefix = "Sixb") {
+  if (thread.kind === "conversation")
+    return;
+  throw new AgentStorageError2("thread_not_conversation", `[${prefix}] Agent thread '${thread.id}' is a sub-agent's: only a conversation ${operation}.`);
+}
+function newSubagentThreadRecord2(input, conversation, createdAt) {
+  return {
+    id: input.thread.id,
+    projectId: input.projectId,
+    kind: "subagent",
+    parent: { threadId: conversation.id, spawnedBy: input.parentRunId, key: input.spawnKey },
+    ownerPrincipal: structuredClone(conversation.ownerPrincipal),
+    status: "active",
+    activeRunId: input.id,
+    lastMessageAt: createdAt,
+    messageCount: 1,
+    createdAt,
+    updatedAt: createdAt
+  };
+}
+function assertSubagentThreadTakesRun2(thread, input, conversationId, prefix = "Sixb") {
+  if (!thread) {
+    throw new AgentStorageError2("thread_not_found", `[${prefix}] Agent thread '${input.thread.id}' not found for project '${input.projectId}'.`);
+  }
+  if (thread.kind !== "subagent" || thread.parent?.threadId !== conversationId || thread.parent.key !== input.spawnKey) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent thread '${thread.id}' is not the thread of child '${input.spawnKey}' of this conversation.`);
+  }
+  if (thread.activeRunId !== null) {
+    throw new AgentStorageError2("active_run_exists", `[${prefix}] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
+  }
+}
+function assertAgentRunFinishPayload2(kind, input, runId, prefix = "Sixb") {
+  if (kind === "conversation") {
+    if (input.status === "succeeded" && input.result !== undefined) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run '${runId}' cannot persist a subagent result.`);
+    }
+    if (input.finishReason === "awaiting_answer") {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Conversational Agent run '${runId}' has no parent to wait for: only a subagent finishes awaiting_answer.`);
+    }
+    return;
+  }
+  if (input.status === "succeeded") {
+    const paused = input.finishReason === "awaiting_approval" || input.finishReason === "awaiting_answer";
+    assertSubagentRunResult2(input.result, runId, prefix, paused);
+  }
+}
+function assertSubagentRunResult2(result, runId, prefix = "Sixb", paused = false) {
+  if (typeof result?.text !== "string" || !paused && result.text.trim().length === 0) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Succeeded subagent run '${runId}' requires text.`);
+  }
+  assertSubagentRunFiles(result.files, "result.files", prefix);
+  if (result.filesError !== undefined && (typeof result.filesError !== "string" || !result.filesError.trim() || result.files?.length)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run '${runId}' result.filesError must say why it returned no files.`);
+  }
+}
+function assertSubagentRunFiles(files, field, prefix) {
+  if (files === undefined)
+    return;
+  if (!Array.isArray(files)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run ${field} must be a list.`);
+  }
+  const paths = new Set;
+  for (const file of files) {
+    const segments = typeof file?.path === "string" ? file.path.split("/") : [];
+    const safe = segments.length > 0 && !file.path.includes("\x00") && segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
+    if (!safe || paths.has(file.path) || !isFileRef2(file.fileRef)) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Subagent run ${field} must hold unique relative paths, each with a valid FileRef.`);
+    }
+    paths.add(file.path);
+  }
+}
+function assertCreateAgentContextCheckpointInput2(input, prefix = "Sixb") {
+  for (const [name, value] of [
+    ["id", input.id],
+    ["projectId", input.projectId],
+    ["threadId", input.threadId],
+    ["createdByRunId", input.createdByRunId],
+    ["executionToken", input.executionToken],
+    ["summary", input.summary],
+    ["summaryModelId", input.summaryModelId]
+  ]) {
+    if (value.trim().length === 0) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint '${name}' must not be empty.`);
+    }
+  }
+  if (input.summaryFormatVersion !== 1) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint summary format version must be 1.`);
+  }
+  if (input.reason !== "threshold" && input.reason !== "overflow") {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint reason must be 'threshold' or 'overflow'.`);
+  }
+  if (input.expectedPreviousCheckpointId !== null && input.expectedPreviousCheckpointId.trim().length === 0) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint expected previous id must not be empty.`);
+  }
+  if (input.createdAt && !Number.isFinite(input.createdAt.getTime())) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint createdAt must be a valid date.`);
+  }
+  for (const [name, value, minimum] of [
+    ["expectedHeadSeq", input.expectedHeadSeq, 1],
+    ["summarizedThroughSeq", input.summarizedThroughSeq, 1],
+    ["observedHeadSeq", input.observedHeadSeq, 1],
+    ["estimatedInputTokensBefore", input.estimatedInputTokensBefore, 0],
+    ["estimatedInputTokensAfter", input.estimatedInputTokensAfter, 0]
+  ]) {
+    if (!Number.isSafeInteger(value) || value < minimum) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint '${name}' must be a safe integer greater than or equal to ${minimum}.`);
+    }
+  }
+  if (input.observedHeadSeq !== input.expectedHeadSeq) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint observed head must equal its expected message head.`);
+  }
+  if (input.summarizedThroughSeq >= input.observedHeadSeq) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint must retain the triggering head message.`);
+  }
+}
+function assertAgentContextCheckpointAuthority2(input) {
+  const { create, run, thread } = input;
+  const prefix = input.prefix ?? "Sixb";
+  if (!run) {
+    throw new AgentStorageError2("run_not_found", `[${prefix}] Agent run '${create.createdByRunId}' not found for project '${create.projectId}'.`);
+  }
+  if (!thread) {
+    throw new AgentStorageError2("thread_not_found", `[${prefix}] Agent thread '${create.threadId}' not found for project '${create.projectId}'.`);
+  }
+  if (run.kind !== "conversation" || run.threadId !== create.threadId) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent run '${run.id}' does not belong to thread '${create.threadId}'.`);
+  }
+  if (run.status !== "running") {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent run '${run.id}' is not running (status '${run.status}').`);
+  }
+  if (!run.execution || run.execution.token !== create.executionToken) {
+    throw new AgentStorageError2("execution_lost", `[${prefix}] Execution token is no longer current on agent run '${run.id}'.`);
+  }
+  if (thread.activeRunId !== run.id) {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent run '${run.id}' no longer owns thread '${thread.id}'.`);
+  }
+}
+function assertAgentContextCheckpointAnchors2(input) {
+  const { create, latest, headSeq, firstRetained } = input;
+  const prefix = input.prefix ?? "Sixb";
+  if (headSeq !== create.expectedHeadSeq) {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent thread '${create.threadId}' message head changed from ${create.expectedHeadSeq} to ${headSeq}.`);
+  }
+  const latestId = latest?.id ?? null;
+  if (latestId !== create.expectedPreviousCheckpointId) {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent thread '${create.threadId}' checkpoint head changed.`);
+  }
+  if (latest && create.summarizedThroughSeq <= latest.summarizedThroughSeq) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint boundary must advance beyond sequence ${latest.summarizedThroughSeq}.`);
+  }
+  if (!firstRetained || firstRetained.seq !== create.summarizedThroughSeq + 1) {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent context checkpoint boundary does not align with stored thread messages.`);
+  }
+  if (firstRetained.role !== "user") {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent context checkpoint must retain a complete turn beginning with a user message.`);
+  }
+}
+function assertAgentContextCheckpointReplayState2(input) {
+  const prefix = input.prefix ?? "Sixb";
+  if (input.headSeq !== input.create.expectedHeadSeq) {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent thread '${input.create.threadId}' message head changed from ${input.create.expectedHeadSeq} to ${input.headSeq}.`);
+  }
+  if (input.latest?.id !== input.existing.id) {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent thread '${input.create.threadId}' checkpoint head changed after '${input.existing.id}'.`);
+  }
+}
+function agentContextCheckpointMatchesCreateInput2(record, input) {
+  return record.id === input.id && record.projectId === input.projectId && record.threadId === input.threadId && record.createdByRunId === input.createdByRunId && (record.previousCheckpointId ?? null) === input.expectedPreviousCheckpointId && record.reason === input.reason && record.summary === input.summary && record.summaryFormatVersion === input.summaryFormatVersion && record.summarizedThroughSeq === input.summarizedThroughSeq && record.observedHeadSeq === input.observedHeadSeq && record.estimatedInputTokensBefore === input.estimatedInputTokensBefore && record.estimatedInputTokensAfter === input.estimatedInputTokensAfter && record.summaryModelId === input.summaryModelId;
+}
+function assertSaveAgentMemoryInput2(input, prefix = "Sixb") {
+  const fail = (message) => {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent memory ${message}`);
+  };
+  if (input.projectId.trim().length === 0)
+    fail("project id must not be empty.");
+  if (input.repoId.trim().length === 0)
+    fail("repo id must not be empty.");
+  if (!Number.isSafeInteger(input.baseRevision) || input.baseRevision < 0) {
+    fail("base revision must be a non-negative integer.");
+  }
+  if (input.message.trim().length === 0)
+    fail("save message must not be empty.");
+  if (input.changes.length === 0)
+    fail("save must change at least one file.");
+  const paths = new Set;
+  for (const change of input.changes) {
+    if (change.path.length === 0)
+      fail("paths must not be empty.");
+    if (paths.has(change.path))
+      fail(`save changes '${change.path}' more than once.`);
+    paths.add(change.path);
+  }
+  if (input.createdAt && !Number.isFinite(input.createdAt.getTime())) {
+    fail("save time must be a valid date.");
+  }
+}
+function agentMemoryConflicts2(input, head, latest) {
+  return input.changes.filter((change) => input.baseRevision > head || (latest.get(change.path)?.revision ?? 0) > input.baseRevision).map((change) => ({ path: change.path, contents: latest.get(change.path)?.contents ?? null })).sort((left, right) => compareAgentMemoryPaths2(left.path, right.path));
+}
+function compareAgentMemoryPaths2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function agentMemoryHistoryCutoff2(savedAt) {
+  return new Date(savedAt.getTime() - AGENT_MEMORY_HISTORY_DAYS * 24 * 60 * 60 * 1000);
+}
+var LIVE_AGENT_APPROVAL_STATUSES2 = [
+  "pending",
+  "approved",
+  "denied"
+];
+function agentApprovalHoldsRun2(approval, runId) {
+  return (approval.runId === runId || approval.callerRunId === runId) && LIVE_AGENT_APPROVAL_STATUSES2.includes(approval.status) && approval.reportedInMessageId === undefined;
+}
+function assertAwaitingApprovalFinish2(input) {
+  const prefix = input.prefix ?? "Sixb";
+  if (input.status !== "succeeded") {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent run '${input.runId}' can only pause for approval when it succeeds.`);
+  }
+  if (!input.holdsApproval) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent run '${input.runId}' holds no call waiting for approval, so it cannot finish awaiting one.`);
+  }
+}
+function agentRunMayHoldCalls2(run) {
+  return AGENT_HOLDING_APPROVAL_MODES2.includes(run.spec?.approvalMode);
+}
+function agentApprovalStops2(approval, input) {
+  return approval.projectId === input.projectId && approval.threadId === input.threadId && approval.reportedInMessageId === undefined && (input.runId === undefined || approval.runId === input.runId) && (input.requestedBy === undefined || approval.requestedBy.type === input.requestedBy.type && approval.requestedBy.id === input.requestedBy.id);
+}
+function agentApprovalRepairable2(approval, claimableBefore) {
+  const unfinished = approval.status === "approved" && approval.outcome === undefined && (approval.executionClaimedAt ?? approval.decidedAt ?? new Date(0)) <= claimableBefore;
+  const resumable = (approval.status === "approved" || approval.status === "denied") && approval.reportedInMessageId === undefined && approval.turnStoppedAt === undefined;
+  return unfinished || resumable;
+}
+function agentApprovalClaimable2(approval, staleBefore) {
+  return approval.status === "approved" && approval.outcome === undefined && (approval.executionClaimedAt ?? approval.decidedAt ?? new Date(0)) <= staleBefore;
+}
+function agentApprovalCallKey2(call) {
+  return call.kind === "action" ? call.actionRunId : call.workflowRunId;
+}
+function assertRequestAgentApprovalInput2(input, prefix = "Sixb") {
+  for (const [name, value] of [
+    ["id", input.id],
+    ["projectId", input.projectId],
+    ["runId", input.runId],
+    ["callerRunId", input.callerRunId],
+    ["executionToken", input.executionToken],
+    ["call key", agentApprovalCallKey2(input.call)]
+  ]) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new AgentStorageError2("invalid_input", `[${prefix}] Agent approval '${name}' must not be empty.`);
+    }
+  }
+  if (!AGENT_HOLDING_APPROVAL_MODES2.includes(input.mode)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent approval mode must be one of: ${AGENT_HOLDING_APPROVAL_MODES2.join(", ")}.`);
+  }
+}
+function assertAgentApprovalCaller2(input) {
+  const { request, turn, caller } = input;
+  const prefix = input.prefix ?? "Sixb";
+  if (!turn || !caller) {
+    throw new AgentStorageError2("run_not_found", `[${prefix}] Agent run '${turn ? request.callerRunId : request.runId}' not found for project '${request.projectId}'.`);
+  }
+  if (turn.kind !== "conversation") {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent approval run '${turn.id}' must be a conversation turn.`);
+  }
+  if (caller.id !== turn.id && !(caller.kind === "subagent" && caller.parentRunId === turn.id)) {
+    throw new AgentStorageError2("invalid_input", `[${prefix}] Agent run '${caller.id}' does not belong to turn '${turn.id}'.`);
+  }
+  if (caller.status !== "running") {
+    throw new AgentStorageError2("invalid_state", `[${prefix}] Agent run '${caller.id}' is not running (status '${caller.status}').`);
+  }
+  if (!caller.execution || caller.execution.token !== request.executionToken) {
+    throw new AgentStorageError2("execution_lost", `[${prefix}] Execution token is no longer current on agent run '${caller.id}'.`);
+  }
+  return turn.threadId;
+}
+function newAgentApprovalRecord2(input, threadId) {
+  return {
+    id: input.id,
+    projectId: input.projectId,
+    threadId,
+    runId: input.runId,
+    callerRunId: input.callerRunId,
+    requestedBy: structuredClone(input.requestedBy),
+    mode: input.mode,
+    callKey: agentApprovalCallKey2(input.call),
+    call: structuredClone(input.call),
+    status: "pending",
+    createdAt: new Date(input.createdAt ?? new Date),
+    expiresAt: new Date(input.expiresAt)
+  };
+}
+function agentApprovalMatches2(approval, input) {
+  return approval.projectId === input.projectId && (input.threadId === undefined || approval.threadId === input.threadId) && (input.runId === undefined || approval.runId === input.runId) && (input.requestedBy === undefined || approval.requestedBy.type === input.requestedBy.type && approval.requestedBy.id === input.requestedBy.id) && (input.statuses === undefined || input.statuses.includes(approval.status)) && (input.reported === undefined || approval.reportedInMessageId !== undefined === input.reported);
+}
+
+export { AgentStorageError2, createAgentThreadId2, createAgentThreadSandboxName2, createAgentRunId2, createSubagentRunId2, createSubagentThreadId2, createSubagentExecutionId2, createAgentMessageId2, agentContextCheckpointId2, createAgentRunExecutionToken2, AGENT_REASONING_LEVELS2, transitionAgentThreadSandbox2, snapshotAgentThreadSandboxParams2, participantsToAdd2, compareAgentThreadParticipants2, remapArtifactIds2, countsAsThreadMessage2, planAgentThreadFork2, assertConversationAgentRunSpec2, isAgentApprovalMode2, assertAgentApprovalModeInput2, assertAgentRunExecution2, assertCreateSubagentRunInput2, subagentRunMatchesCreateInput2, assertConversationThreadRow2, newSubagentThreadRecord2, assertSubagentThreadTakesRun2, assertAgentRunFinishPayload2, assertSubagentRunResult2, assertCreateAgentContextCheckpointInput2, assertAgentContextCheckpointAuthority2, assertAgentContextCheckpointAnchors2, assertAgentContextCheckpointReplayState2, agentContextCheckpointMatchesCreateInput2, assertSaveAgentMemoryInput2, agentMemoryConflicts2, compareAgentMemoryPaths2, agentMemoryHistoryCutoff2, LIVE_AGENT_APPROVAL_STATUSES2, agentApprovalHoldsRun2, assertAwaitingApprovalFinish2, agentRunMayHoldCalls2, agentApprovalStops2, agentApprovalRepairable2, agentApprovalClaimable2, agentApprovalCallKey2, assertRequestAgentApprovalInput2, assertAgentApprovalCaller2, newAgentApprovalRecord2, agentApprovalMatches2 };
+
+//# debugId=B924D384F542DD1B64756E2164756E21