@sixb/core 0.1.7 → 0.1.9

package/dist/chunk-h0knpbz5.js

@@ -1,2486 +0,0 @@
-// @bun
-import {
-  SyncValidationError,
-  createConnectorRuntime,
-  requestSyncRun
-} from "./chunk-ha58tjtt.js";
-import {
-  aiLimitSubjectsFromAttribution,
-  aiUsageLimitExceededError,
-  aiUsageLimitUnavailableError,
-  applicableAiLimitPolicyStatuses
-} from "./chunk-c15dr03f.js";
-import {
-  PipelineError,
-  requestPipelineRun
-} from "./chunk-rp1mvzb4.js";
-import {
-  appendTelemetry,
-  createObjectSet,
-  getTelemetryHistoryBatch,
-  listObjects,
-  removeLink1 as removeLink,
-  upsertLink1 as upsertLink,
-  upsertLinkBatch1 as upsertLinkBatch,
-  upsertObject1 as upsertObject,
-  upsertObjectBatch1 as upsertObjectBatch
-} from "./chunk-e4rvtvpw.js";
-import {
-  shareOntologyMutationRuntime
-} from "./chunk-xhy826cz.js";
-import {
-  countObjects,
-  executeObjectQuery,
-  executeObjectQueryLinks,
-  existsObjects,
-  facetObjects
-} from "./chunk-3fqt22c4.js";
-import {
-  registerConnectorConnectionsRuntime
-} from "./chunk-nf4r78r4.js";
-import {
-  isActionDefinition,
-  requestAction,
-  requestActionAndWait
-} from "./chunk-y35ma3mj.js";
-import {
-  createPrimitiveExecutionRecord,
-  ensureExecutionRecord,
-  executionRecordInputFromRuntime
-} from "./chunk-hdz94br2.js";
-import {
-  WORKFLOW_RUN_FAILURE_CODES
-} from "./chunk-6ed5bwnd.js";
-import {
-  WorkflowRunError,
-  agentServiceAccountId
-} from "./chunk-qjzp9xyb.js";
-import {
-  ExecutionStorageError
-} from "./chunk-gbrpsx4m.js";
-import {
-  AGENT_REASONING_LEVELS,
-  AgentStorageError
-} from "./chunk-08twe8m6.js";
-import {
-  isObjectRefSchema,
-  validateSchemaOrRefValue
-} from "./chunk-dqn23610.js";
-import {
-  RuntimeError
-} from "./chunk-p2vqaxkc.js";
-import {
-  isModelReasoning
-} from "./chunk-trxxmgnf.js";
-import {
-  reportRunFailure
-} from "./chunk-jq43kdvk.js";
-import {
-  AgentRequestError,
-  normalizeAgentContextEntries
-} from "./chunk-atmkaf60.js";
-import {
-  publishAgentRunActivity
-} from "./chunk-7y0f6rf1.js";
-import {
-  SYSTEM_PRINCIPAL,
-  principalsEqual
-} from "./chunk-rre42skh.js";
-import {
-  snapshotRequesterGroupIds
-} from "./chunk-4a849fr1.js";
-import {
-  AuthorizationError,
-  assertAuthorized,
-  assertCanManageConnector,
-  assertPrivileged,
-  assertProviderAccess,
-  assertRuntimeAuthorizationBound,
-  canViewActionRun,
-  canViewEvent,
-  canViewPipelineRun,
-  canViewProjection,
-  canViewProjectionRun,
-  canViewWorkflowIntervention,
-  canViewWorkflowRun,
-  createAgentRuntimeAuthorization,
-  getAuthorizationRef,
-  isAllowed,
-  resolveExecutionScopeAuthorization
-} from "./chunk-37wk412q.js";
-import {
-  assertObjectTypeRegistered
-} from "./chunk-d63tybny.js";
-import {
-  supportsDirectUpload,
-  supportsRangeRead
-} from "./chunk-08m3b6w8.js";
-import {
-  captureSixbFailure
-} from "./chunk-2xns679x.js";
-import {
-  isPlainRecord
-} from "./chunk-n6jxh8sw.js";
-
-// src/actions/execution.ts
-function createActionsRuntime(runtime, execution) {
-  const canList = (action) => isAllowed(runtime.authorization, { kind: "action.apply", actionId: action.id }) && (action.binding.kind === "global" || isAllowed(runtime.authorization, {
-    kind: "object.view",
-    objectTypeId: action.binding.objectType.id
-  }));
-  return {
-    list: () => runtime.actionRegistry.list().filter(canList),
-    getById: (actionId) => {
-      const action = runtime.actionRegistry.getById(actionId);
-      return action && canList(action) ? action : null;
-    },
-    listGlobal: () => runtime.actionRegistry.listGlobal().filter(canList),
-    listForType: (objectType) => runtime.actionRegistry.listForType(objectType).filter(canList),
-    request: (input) => requestAction(runtime, execution, input),
-    requestAndWait: (input) => requestActionAndWait(runtime, execution, input),
-    runs: {
-      getById: async (runId) => {
-        const run = await runtime.storage.actionRuns?.getById({
-          projectId: runtime.projectId,
-          id: runId
-        }) ?? null;
-        return run && canViewActionRun(runtime.authorization, run) ? run : null;
-      },
-      list: (input = {}) => {
-        const storage = runtime.storage.actionRuns;
-        if (!storage)
-          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
-        return storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          actionIds: runtime.authorization ? [...runtime.authorization.grants["apply:action"]] : undefined,
-          objectTypeIds: runtime.authorization ? [...runtime.authorization.grants["view:object"]] : undefined
-        });
-      }
-    }
-  };
-}
-
-// src/runtime/ai-cost.ts
-async function resolveExecutionCosts(input) {
-  if (input.executionIds.length === 0)
-    return [];
-  if (!input.storage)
-    return input.executionIds.map(() => {
-      return;
-    });
-  return input.storage.summarizeExecutions({
-    projectId: input.projectId,
-    executionIds: input.executionIds
-  });
-}
-
-// src/runtime/ai-usage.ts
-async function resolveExecutionUsage(input) {
-  if (input.executionIds.length === 0)
-    return [];
-  if (!input.storage)
-    return input.executionIds.map(() => {
-      return;
-    });
-  const summaries = await input.storage.summarizeExecutions({
-    projectId: input.projectId,
-    executionIds: input.executionIds
-  });
-  return summaries.map((summary) => summary.modelCallCount === 0 ? undefined : summary.usage);
-}
-
-// src/agents/ids.ts
-import { createHash, randomUUID } from "crypto";
-function createAgentThreadId() {
-  return `agt_thr_${randomUUID()}`;
-}
-function createAgentRunId() {
-  return `agt_run_${randomUUID()}`;
-}
-function createSubagentRunId(parentRunId, spawnKey) {
-  const digest = createHash("sha256").update(parentRunId).update("\x00").update(spawnKey).digest("hex");
-  return `agt_run_child_${digest}`;
-}
-function createSubagentExecutionId(runId) {
-  return `exec_${runId}`;
-}
-function createAgentMessageId() {
-  return `agt_msg_${randomUUID()}`;
-}
-function agentContextCheckpointId(runId) {
-  return `agt_ctx_${runId}`;
-}
-function createAgentRunExecutionToken() {
-  return `agt_exec_${randomUUID()}`;
-}
-
-// src/agents/request.ts
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/agents/context-resolution.ts
-async function resolveAgentContextParts(runtime, input) {
-  const entries = normalizeAgentContextEntries(input);
-  for (const entry of entries) {
-    if (entry.context.kind !== "object")
-      continue;
-    const { objectTypeId, primaryId } = entry.context.ref;
-    try {
-      runtime.ontology.resolveObjectType(objectTypeId);
-    } catch {
-      invalidContext(`context references an unknown object type '${objectTypeId}'`);
-    }
-    assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-    const object = await runtime.storage.objects.getByPrimaryId({
-      projectId: runtime.projectId,
-      objectTypeId,
-      primaryId
-    });
-    if (!object) {
-      invalidContext(`context references an unknown object '${objectTypeId}:${primaryId}'`);
-    }
-  }
-  return entries.map((entry) => ({ type: "context", ...entry }));
-}
-function invalidContext(message) {
-  throw new AgentRequestError("invalid_context", `[Sixb] Invalid agent context: ${message}.`);
-}
-
-// src/agents/dispatch.ts
-function agentRunQueueJobId(runId) {
-  return `agt_job_${runId}`;
-}
-function subagentRunQueueJobId(runId) {
-  return `agt_child_job_${runId}`;
-}
-function workflowAgentNodeQueueJobId(nodeRunId) {
-  return `wfa_job_${nodeRunId}`;
-}
-async function dispatchQueuedAgentRuns(input) {
-  const limit = normalizeLimit(input.limit);
-  const runs = input.runIds ? await input.storage.runs.getByIds({
-    projectId: input.projectId,
-    ids: [...new Set(input.runIds)].slice(0, limit)
-  }) : (await input.storage.runs.list({
-    projectId: input.projectId,
-    kinds: ["conversation"],
-    statuses: ["queued"],
-    order: "asc",
-    limit
-  })).runs;
-  const queued = runs.filter((run) => run.kind === "conversation" && run.status === "queued");
-  if (queued.length === 0) {
-    return { scanned: 0, dispatched: [], failures: [] };
-  }
-  try {
-    const jobs = await input.queue.enqueue({
-      projectId: input.projectId,
-      jobs: queued.map((run) => ({
-        id: agentRunQueueJobId(run.id),
-        type: "agent.run.requested",
-        payload: { runId: run.id }
-      }))
-    });
-    const jobsById = new Map(jobs.map((job) => [job.id, job]));
-    const dispatched = queued.map((run) => {
-      const jobId = agentRunQueueJobId(run.id);
-      if (!jobsById.has(jobId)) {
-        throw new Error(`[Sixb] Agent queue did not return job '${jobId}'.`);
-      }
-      return { runId: run.id, jobId };
-    });
-    return { scanned: queued.length, dispatched, failures: [] };
-  } catch (error) {
-    return {
-      scanned: queued.length,
-      dispatched: [],
-      failures: queued.map((run) => ({ runId: run.id, error }))
-    };
-  }
-}
-async function dispatchQueuedSubagentRuns(input) {
-  const limit = normalizeLimit(input.limit);
-  const runs = input.runIds ? await input.storage.runs.getByIds({
-    projectId: input.projectId,
-    ids: [...new Set(input.runIds)].slice(0, limit)
-  }) : (await input.storage.runs.list({
-    projectId: input.projectId,
-    kinds: ["subagent"],
-    statuses: ["queued"],
-    order: "asc",
-    limit
-  })).runs;
-  const queued = runs.filter((run) => run.kind === "subagent" && run.status === "queued");
-  if (queued.length === 0)
-    return { scanned: 0, dispatched: [], failures: [] };
-  try {
-    const jobs = await input.queue.enqueue({
-      projectId: input.projectId,
-      jobs: queued.map((run) => ({
-        id: subagentRunQueueJobId(run.id),
-        type: "agent.subagent-run.requested",
-        payload: { runId: run.id }
-      }))
-    });
-    const jobsById = new Set(jobs.map((job) => job.id));
-    const dispatched = queued.map((run) => {
-      const jobId = subagentRunQueueJobId(run.id);
-      if (!jobsById.has(jobId)) {
-        throw new Error(`[Sixb] Subagent queue did not return job '${jobId}'.`);
-      }
-      return { runId: run.id, jobId };
-    });
-    return { scanned: queued.length, dispatched, failures: [] };
-  } catch (error) {
-    return {
-      scanned: queued.length,
-      dispatched: [],
-      failures: queued.map((run) => ({ runId: run.id, error }))
-    };
-  }
-}
-function normalizeLimit(value) {
-  if (value === undefined)
-    return 100;
-  if (!Number.isFinite(value) || value < 1) {
-    throw new Error("[Sixb] Agent dispatch limit must be at least 1.");
-  }
-  return Math.floor(value);
-}
-
-// src/agents/retired-config.ts
-function assertNoAgentDefinitions(input) {
-  if ("agents" in input) {
-    throw new RuntimeError("[Sixb] Agent definitions are no longer supported. Configure 'models' and 'tools' on createSixb() instead.");
-  }
-}
-function assertNoAgentSelector(input) {
-  if ("agentId" in input || "agentIds" in input) {
-    throw new AgentRequestError("agent_selector_removed", "[Sixb] There is one project Agent. Remove the agentId selector and use sixb.agent.");
-  }
-}
-
-// src/agents/request.ts
-async function requestAgentRun(runtime, execution, models, input) {
-  assertNoAgentSelector(input);
-  assertAuthorized(runtime, { kind: "agent.run" });
-  assertRequestAuthorityCanRunAgent(runtime);
-  const spec = resolveConversationRunSpec({ models, input });
-  const contextParts = await resolveAgentContextParts(runtime, input.context);
-  const agents = requireAgentStorage(runtime);
-  const projectId = runtime.projectId;
-  const principal = runtime.authorization?.principal ?? input.principal ?? SYSTEM_PRINCIPAL;
-  const runId = createAgentRunId();
-  const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
-  const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
-    auth: runtime.storage.auth,
-    projectId,
-    principal: durableExecution.requestedBy
-  }) : [];
-  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds);
-  const { thread, createdThread } = await resolveThread(agents, {
-    projectId,
-    threadId: input.threadId,
-    title: input.title,
-    principal
-  });
-  if (thread.activeRunId !== null) {
-    throw new AgentRequestError("active_run_exists", `[Sixb] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
-  }
-  const triggerMessageId = input.messageId ?? createAgentMessageId();
-  let run;
-  try {
-    run = await runtime.storage.transaction(async (tx) => {
-      const agents2 = tx.agents;
-      if (!agents2) {
-        throw new AgentRequestError("storage_unavailable", "[Sixb] Agent storage is not configured.");
-      }
-      await tx.executions.create(durableExecution);
-      await agents2.messages.append({
-        id: triggerMessageId,
-        projectId,
-        threadId: thread.id,
-        runId: null,
-        role: "user",
-        parts: [
-          ...contextParts,
-          { type: "text", text: input.text },
-          ...(input.attachments ?? []).map((fileRef) => ({ type: "file", fileRef }))
-        ],
-        authorPrincipal: principal
-      });
-      return agents2.runs.create({
-        id: runId,
-        projectId,
-        executionId: durableExecution.id,
-        threadId: thread.id,
-        triggerMessageId,
-        spec,
-        requesterGroupIds
-      });
-    });
-  } catch (error) {
-    if (error instanceof AgentStorageError && error.code === "active_run_exists") {
-      throw new AgentRequestError("active_run_exists", error.message);
-    }
-    throw error;
-  }
-  await publishRunActivity(runtime, run);
-  const jobId = await dispatchAgentRun(runtime, agents, runId);
-  return {
-    run,
-    ...jobId ? { jobId } : {},
-    createdThread
-  };
-}
-async function retryAgentRun(runtime, execution, models, failedRun) {
-  assertAuthorized(runtime, { kind: "agent.run" });
-  assertRequestAuthorityCanRunAgent(runtime);
-  if (failedRun.status !== "failed") {
-    throw new AgentRequestError("run_not_retryable", `[Sixb] Only failed Agent runs can be retried.`);
-  }
-  const agents = requireAgentStorage(runtime);
-  const thread = await agents.threads.getById({
-    projectId: runtime.projectId,
-    id: failedRun.threadId
-  });
-  if (!thread) {
-    throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${failedRun.threadId}' was not found.`);
-  }
-  const runId = createAgentRunId();
-  const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
-  const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    principal: durableExecution.requestedBy
-  }) : [];
-  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds);
-  const run = await runtime.storage.transaction(async (tx) => {
-    const agents2 = tx.agents;
-    if (!agents2) {
-      throw new AgentRequestError("storage_unavailable", "[Sixb] Agent storage is not configured.");
-    }
-    await agents2.messages.deleteByRunId({
-      projectId: runtime.projectId,
-      threadId: failedRun.threadId,
-      runId: failedRun.id
-    });
-    await tx.executions.create(durableExecution);
-    return agents2.runs.create({
-      id: runId,
-      projectId: runtime.projectId,
-      executionId: durableExecution.id,
-      threadId: failedRun.threadId,
-      triggerMessageId: failedRun.triggerMessageId,
-      spec: failedRun.spec ?? resolveConversationRunSpec({
-        models,
-        input: {}
-      }),
-      requesterGroupIds
-    });
-  });
-  await publishRunActivity(runtime, run);
-  const jobId = await dispatchAgentRun(runtime, agents, runId);
-  return { run, ...jobId ? { jobId } : {}, createdThread: false };
-}
-async function assertAiLimitPreflight(runtime, execution, requesterGroupIds) {
-  const limits = runtime.storage.aiLimits;
-  if (!limits)
-    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
-  const subjects = aiLimitSubjectsFromAttribution(execution.requestedBy, requesterGroupIds);
-  let applicable;
-  try {
-    applicable = applicableAiLimitPolicyStatuses(await limits.listPolicyStatuses({ projectId: runtime.projectId }), subjects);
-  } catch {
-    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
-  }
-  const unavailable = applicable.filter((status) => status.accountingStatus === "unavailable");
-  if (unavailable.length > 0) {
-    throw aiUsageLimitUnavailableError(["incompleteAccounting"]);
-  }
-  const exhausted = applicable.filter((status) => status.exhausted);
-  if (exhausted.length > 0) {
-    const resetAt = new Date(Math.min(...exhausted.map((status) => status.period.resetAt.getTime())));
-    throw aiUsageLimitExceededError(resetAt);
-  }
-}
-function resolveConversationRunSpec(input) {
-  if (!input.models) {
-    throw new AgentRequestError("model_not_found", "[Sixb] Configure models.language before starting the Agent.");
-  }
-  const selected = input.input.model ?? input.models.default;
-  const model = input.models.getByRef(selected);
-  if (model === null) {
-    throw new AgentRequestError("model_not_found", `[Sixb] Language model '${selected.provider}/${selected.modelId}' is not in the project model catalog.`);
-  }
-  const reasoning = input.input.reasoning;
-  if (reasoning !== undefined && !isModelReasoning(reasoning)) {
-    throw new AgentRequestError("invalid_model_selection", `[Sixb] Agent reasoning must be one of: ${AGENT_REASONING_LEVELS.join(", ")}, or a nonnegative budgetTokens object.`);
-  }
-  return Object.freeze({
-    model: Object.freeze({ provider: selected.provider, modelId: selected.modelId }),
-    ...reasoning === undefined ? {} : { reasoning }
-  });
-}
-async function prepareDurableAgentExecution(runtime, execution, runId) {
-  const parent = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
-    execution,
-    runtimeAuthorization: runtime.runtimeAuthorization
-  }));
-  return createInheritedAgentExecutionRecord({
-    id: `exec_${randomUUID2()}`,
-    parent,
-    runId
-  });
-}
-function assertRequestAuthorityCanRunAgent(runtime) {
-  if (!canInheritAgentRequestAuthorization(runtime.runtimeAuthorization)) {
-    throw new AgentRequestError("authority_not_inheritable", "[Sixb] The Agent requires an authenticated user request or disabled authorization.");
-  }
-}
-async function dispatchAgentRun(runtime, agents, runId) {
-  try {
-    const dispatch = await dispatchQueuedAgentRuns({
-      projectId: runtime.projectId,
-      storage: agents,
-      queue: runtime.queues.agents,
-      runIds: [runId]
-    });
-    const failure = dispatch.failures[0];
-    if (failure) {
-      console.error(`[Sixb] Could not dispatch queued agent run '${runId}'; retrying later.`, failure.error);
-    }
-    return dispatch.dispatched[0]?.jobId;
-  } catch (error) {
-    console.error(`[Sixb] Could not dispatch queued agent run '${runId}'; retrying later.`, error);
-    return;
-  }
-}
-async function publishRunActivity(runtime, run) {
-  try {
-    await publishAgentRunActivity(runtime.broker, run);
-  } catch (error) {
-    console.error(`[Sixb] Agent run '${run.id}' activity stream publish failed:`, error);
-  }
-}
-async function resolveThread(agents, params) {
-  if (params.threadId) {
-    const existing = await agents.threads.getById({
-      projectId: params.projectId,
-      id: params.threadId
-    });
-    if (existing) {
-      return { thread: existing, createdThread: false };
-    }
-  }
-  const thread = await agents.threads.create({
-    id: params.threadId ?? createAgentThreadId(),
-    projectId: params.projectId,
-    ownerPrincipal: params.principal,
-    ...params.title === undefined ? {} : { title: params.title }
-  });
-  return { thread, createdThread: true };
-}
-function requireAgentStorage(runtime) {
-  const agents = runtime.storage.agents;
-  if (!agents) {
-    throw new AgentRequestError("storage_unavailable", "[Sixb] Agent storage is not configured.");
-  }
-  return agents;
-}
-
-// src/agents/execution.ts
-function createAgentRuntime(runtime, execution, models) {
-  const principal = runtime.authorization?.principal ?? SYSTEM_PRINCIPAL;
-  const allowed = () => isAllowed(runtime.authorization, { kind: "agent.run" });
-  const getVisibleThreadRecord = async (threadId) => {
-    const thread = await runtime.storage.agents?.threads.getById({
-      projectId: runtime.projectId,
-      id: threadId
-    }) ?? null;
-    if (!thread || !allowed())
-      return null;
-    return runtime.authorization && !principalsEqual(principal, thread.ownerPrincipal) ? null : thread;
-  };
-  const getAgent = () => {
-    const model = models?.language.default;
-    if (!model || !allowed())
-      return null;
-    return {
-      name: "Sixb",
-      model: { provider: model.provider, modelId: model.modelId }
-    };
-  };
-  const getVisibleRunRecord = async (runId) => {
-    const run = await runtime.storage.agents?.runs.getById({
-      projectId: runtime.projectId,
-      id: runId
-    }) ?? null;
-    if (!run || run.kind !== "conversation")
-      return null;
-    const thread = await getVisibleThreadRecord(run.threadId);
-    return thread ? run : null;
-  };
-  const getRun = async (runId) => {
-    const run = await getVisibleRunRecord(runId);
-    return run ? attachRunView(runtime, run) : null;
-  };
-  return {
-    get: getAgent,
-    threads: {
-      create: async (input) => {
-        assertNoAgentSelector(input);
-        const agent = getAgent();
-        if (!agent) {
-          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
-        }
-        const storage = runtime.storage.agents;
-        if (!storage) {
-          throw new AgentRequestError("storage_unavailable", "[Sixb] Agent storage is not configured.");
-        }
-        return storage.threads.create({
-          id: input.id ?? createAgentThreadId(),
-          projectId: runtime.projectId,
-          ownerPrincipal: principal,
-          ...input.title === undefined ? {} : { title: input.title }
-        });
-      },
-      getById: getVisibleThreadRecord,
-      list: async (input = {}) => {
-        assertNoAgentSelector(input);
-        const storage = runtime.storage.agents;
-        if (!storage || !allowed())
-          return { threads: [], hasMore: false, total: 0 };
-        return storage.threads.list({
-          ...input,
-          projectId: runtime.projectId,
-          ownerPrincipal: runtime.authorization ? principal : undefined
-        });
-      }
-    },
-    runs: {
-      request: async (input) => {
-        assertNoAgentSelector(input);
-        const agent = getAgent();
-        if (!agent) {
-          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
-        }
-        assertAuthorized(runtime, { kind: "agent.run" });
-        if (input.threadId && !await getVisibleThreadRecord(input.threadId)) {
-          throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found.`);
-        }
-        const result = await requestAgentRun(runtime, execution, models?.language, {
-          ...input,
-          principal
-        });
-        return { ...result, run: await attachRunView(runtime, result.run) };
-      },
-      retry: async (runId) => {
-        const failedRun = await getVisibleRunRecord(runId);
-        if (!failedRun) {
-          throw new AgentRequestError("run_not_found", `[Sixb] Agent run '${runId}' was not found.`);
-        }
-        const agent = getAgent();
-        if (!agent) {
-          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
-        }
-        const result = await retryAgentRun(runtime, execution, models?.language, failedRun);
-        return { ...result, run: await attachRunView(runtime, result.run) };
-      },
-      getById: getRun,
-      listForThread: async (threadId, input = {}) => {
-        assertNoAgentSelector(input);
-        const storage = runtime.storage.agents;
-        if (!storage || !await getVisibleThreadRecord(threadId))
-          return null;
-        const result = await storage.runs.list({
-          ...input,
-          projectId: runtime.projectId,
-          threadId
-        });
-        return {
-          ...result,
-          runs: await attachRunViews(runtime, result.runs.filter((run) => run.kind === "conversation"))
-        };
-      }
-    }
-  };
-}
-async function attachRunView(runtime, run) {
-  const [view] = await attachRunViews(runtime, [run]);
-  if (!view)
-    throw new Error(`[Sixb] Could not build Agent run '${run.id}' view.`);
-  return view;
-}
-async function attachRunViews(runtime, runs) {
-  const executionIds = runs.map((run) => run.executionId);
-  const [executions, usages, costs] = await Promise.all([
-    Promise.all(runs.map((run) => runtime.storage.executions.getById({
-      projectId: runtime.projectId,
-      id: run.executionId
-    }))),
-    resolveExecutionUsage({
-      storage: runtime.storage.aiUsage,
-      projectId: runtime.projectId,
-      executionIds
-    }),
-    resolveExecutionCosts({
-      storage: runtime.storage.aiCosts,
-      projectId: runtime.projectId,
-      executionIds
-    })
-  ]);
-  return runs.map((run, index) => {
-    const execution = executions[index];
-    if (!execution) {
-      throw new Error(`[Sixb] Agent run '${run.id}' references missing execution '${run.executionId}'.`);
-    }
-    const usage = usages[index];
-    const cost = usage === undefined ? undefined : costs[index];
-    return {
-      ...run,
-      ...execution.requestedBy === undefined ? {} : { requestedBy: structuredClone(execution.requestedBy) },
-      ...usage === undefined ? {} : { usage },
-      ...cost === undefined ? {} : { cost }
-    };
-  });
-}
-
-// src/ai-usage/execution.ts
-import { randomUUID as randomUUID3 } from "crypto";
-function createAiUsageRuntime(runtime, security) {
-  const assertObservable = () => assertAuthorized(runtime, { kind: "aiUsage.observe" });
-  const assertManageable = () => assertAuthorized(runtime, { kind: "aiUsage.manage" });
-  const assertPolicyReadable = () => {
-    const resolved = assertRuntimeAuthorizationBound(runtime);
-    if (resolved.type === "principal" && !isAllowed(resolved.context, { kind: "aiUsage.observe" }) && !isAllowed(resolved.context, { kind: "aiUsage.manage" })) {
-      assertObservable();
-    }
-  };
-  const requireCosts = () => {
-    if (!runtime.storage.aiCosts) {
-      throw new Error("[Sixb] AI cost storage is not configured.");
-    }
-    return runtime.storage.aiCosts;
-  };
-  const requireLimits = () => {
-    if (!runtime.storage.aiLimits) {
-      throw new Error("[Sixb] AI limit storage is not configured.");
-    }
-    return runtime.storage.aiLimits;
-  };
-  return {
-    accountingConfigured: runtime.storage.aiCosts !== undefined,
-    limitsConfigured: runtime.storage.aiLimits !== undefined,
-    assertObservable,
-    assertManageable,
-    canManageLimits: () => {
-      const resolved = assertRuntimeAuthorizationBound(runtime);
-      return resolved.type !== "principal" || isAllowed(resolved.context, { kind: "aiUsage.manage" });
-    },
-    queryOverview: (input) => {
-      assertObservable();
-      return requireCosts().queryProjectOverview({ ...input, projectId: runtime.projectId });
-    },
-    listModelCalls: (input) => {
-      assertObservable();
-      return requireCosts().listModelCalls({ ...input, projectId: runtime.projectId });
-    },
-    listModelCallGroups: (input) => {
-      assertObservable();
-      return requireCosts().listModelCallGroups({ ...input, projectId: runtime.projectId });
-    },
-    listLimitPolicies: (input = {}) => {
-      assertPolicyReadable();
-      return requireLimits().listPolicies({ ...input, projectId: runtime.projectId });
-    },
-    listLimitStatuses: (input = {}) => {
-      assertObservable();
-      return requireLimits().listPolicyStatuses({
-        ...input.includeDisabled === undefined ? {} : { includeDisabled: input.includeDisabled },
-        projectId: runtime.projectId,
-        existingGroupIds: security.listGroups().map((group) => group.id)
-      });
-    },
-    listLimitSubjectOptions: async () => {
-      assertManageable();
-      const groups = security.listGroups().map((group) => ({
-        id: group.id,
-        ...group.label === undefined ? {} : { label: group.label },
-        ...group.description === undefined ? {} : { description: group.description }
-      }));
-      const auth = runtime.storage.auth;
-      if (!auth)
-        return { groups, users: [], serviceAccounts: [] };
-      const [users, serviceAccounts] = await Promise.all([
-        auth.users.list({ projectId: runtime.projectId, order: "asc" }),
-        auth.serviceAccounts.list({ projectId: runtime.projectId, order: "asc" })
-      ]);
-      return {
-        groups,
-        users: users.users.map((user) => ({
-          id: user.id,
-          email: user.email,
-          ...user.displayName === undefined ? {} : { displayName: user.displayName },
-          status: user.status
-        })),
-        serviceAccounts: serviceAccounts.serviceAccounts.map((serviceAccount) => ({
-          id: serviceAccount.id,
-          name: serviceAccount.name,
-          ...serviceAccount.description === undefined ? {} : { description: serviceAccount.description },
-          status: serviceAccount.status
-        }))
-      };
-    },
-    createLimitPolicy: (input) => {
-      assertManageable();
-      return requireLimits().createPolicy({
-        ...input,
-        id: input.id ?? `ailim_${randomUUID3()}`,
-        projectId: runtime.projectId
-      });
-    },
-    updateLimitPolicy: (input) => {
-      assertManageable();
-      return requireLimits().updatePolicy({ ...input, projectId: runtime.projectId });
-    },
-    deleteLimitPolicy: (id) => {
-      assertManageable();
-      return requireLimits().deletePolicy({ id, projectId: runtime.projectId });
-    }
-  };
-}
-// src/blob-storage/execution.ts
-function createBlobsRuntime(runtime, execution, blobStorage) {
-  const assertAccess = () => assertProviderAccess(runtime, execution, "blobs.access");
-  const executionBlobs = {
-    put: (input) => {
-      assertAccess();
-      return blobStorage.put(input);
-    },
-    open: (blobId) => {
-      assertAccess();
-      return blobStorage.open(blobId);
-    },
-    stat: (blobId) => {
-      assertAccess();
-      return blobStorage.stat(blobId);
-    }
-  };
-  if (supportsRangeRead(blobStorage)) {
-    executionBlobs.openRange = (blobId, range) => {
-      assertAccess();
-      return blobStorage.openRange(blobId, range);
-    };
-  }
-  if (supportsDirectUpload(blobStorage)) {
-    executionBlobs.createUpload = (input) => {
-      assertAccess();
-      return blobStorage.createUpload(input);
-    };
-    executionBlobs.signUploadPart = (input) => {
-      assertAccess();
-      return blobStorage.signUploadPart(input);
-    };
-    executionBlobs.completeUpload = (input) => {
-      assertAccess();
-      return blobStorage.completeUpload(input);
-    };
-    executionBlobs.abortUpload = (input) => {
-      assertAccess();
-      return blobStorage.abortUpload(input);
-    };
-  }
-  return Object.freeze(executionBlobs);
-}
-
-// src/connectors/connections/execution.ts
-function createConnectorConnectionsRuntime(runtime, execution, process) {
-  const contextFor = (connectorId) => commandContext(runtime, execution, connectorId);
-  const connections = {
-    listConnections: (connectorId) => process.listConnections(contextFor(connectorId), connectorId),
-    startConnectionRun: (connectorId, input) => process.startConnectionRun(contextFor(connectorId), connectorId, input),
-    addConnection: (connectorId, input) => process.addConnection(contextFor(connectorId), connectorId, input),
-    getConnectionRun: (connectorId, runId) => process.getConnectionRun(contextFor(connectorId), connectorId, runId),
-    selectConnectionRunAccount: (connectorId, input) => process.selectConnectionRunAccount(contextFor(connectorId), connectorId, input),
-    startReauthorization: (connectorId, connectionId, input) => process.startReauthorization(contextFor(connectorId), connectorId, connectionId, input),
-    revokeConnection: (connectorId, connectionId) => process.revokeConnection(contextFor(connectorId), connectorId, connectionId),
-    startAuthorization: (connectorId, input) => process.startAuthorization(contextFor(connectorId), connectorId, input),
-    completeAuthorization: (connectorId, input) => process.completeAuthorization(contextFor(connectorId), connectorId, input),
-    selectAccount: (connectorId, input) => process.selectAccount(contextFor(connectorId), connectorId, input),
-    disconnect: (connectorId, connectionId) => process.disconnect(contextFor(connectorId), connectorId, connectionId),
-    revokeAuthorization: (connectorId, authorizationId) => process.revokeAuthorization(contextFor(connectorId), connectorId, authorizationId)
-  };
-  return Object.freeze(connections);
-}
-function commandContext(runtime, execution, connectorId) {
-  const resolved = resolveExecutionScopeAuthorization(runtime.projectId, {
-    execution,
-    authorization: runtime.runtimeAuthorization
-  });
-  if (execution.executor.type !== "request" || resolved.type !== "principal" || resolved.ref.type !== "principal") {
-    throw new AuthorizationError(`manage:connector:${connectorId}`, "[Sixb] Connector connections can only be managed by an authenticated request.");
-  }
-  if (!resolved.ref.credential) {
-    throw new AuthorizationError(`manage:connector:${connectorId}`, "[Sixb] Connector connection management requires a session or access token.");
-  }
-  assertCanManageConnector(runtime, connectorId);
-  return Object.freeze({
-    execution: Object.freeze(executionRecordInputFromRuntime({
-      execution,
-      runtimeAuthorization: runtime.runtimeAuthorization
-    }))
-  });
-}
-
-// src/datasets/execution.ts
-function createDatasetsRuntime(runtime, source) {
-  const allowed = (datasetId) => isAllowed(runtime.authorization, { kind: "dataset.view", datasetId });
-  return {
-    list: () => source.list().filter((dataset) => allowed(dataset.id)),
-    getById: (datasetId) => {
-      const dataset = source.getById(datasetId);
-      return dataset && allowed(datasetId) ? dataset : null;
-    }
-  };
-}
-
-// src/events/execution.ts
-function createEventsRuntime(runtime) {
-  return {
-    canRead: (event) => canViewEvent(runtime.authorization, event),
-    append: (input) => {
-      assertPrivileged(runtime, "events.append");
-      return runtime.events.append(input);
-    },
-    emit: (input, options) => {
-      assertPrivileged(runtime, "events.emit");
-      return runtime.events.emit(input, options);
-    },
-    read: async (input) => {
-      const events = await runtime.events.read(input);
-      return events.filter((event) => canViewEvent(runtime.authorization, event));
-    },
-    latestCursor: () => runtime.events.latestCursor(),
-    subscribe: (input, handler) => runtime.events.subscribe(input, (events) => {
-      const visible = events.filter((event) => canViewEvent(runtime.authorization, event));
-      if (visible.length > 0)
-        handler(visible);
-    })
-  };
-}
-
-// src/logging/execution.ts
-function createLogsRuntime(runtime, source) {
-  const assertObservable = () => assertAuthorized(runtime, { kind: "logs.observe" });
-  return {
-    assertObservable,
-    read: (input) => {
-      assertObservable();
-      return source.read(input);
-    },
-    tail: (input) => {
-      assertObservable();
-      return source.tail(input);
-    }
-  };
-}
-
-// src/objects/execution.ts
-function createObjectsRuntime(runtime, execution) {
-  const objects = Object.assign((objectType) => {
-    assertObjectTypeRegistered(runtime.ontology.getObjectTypesById(), objectType);
-    return createObjectSet({ ...runtime, execution, objectType });
-  }, {
-    listTypes: () => runtime.ontology.listObjectTypes().filter((objectType) => isAllowed(runtime.authorization, {
-      kind: "object.view",
-      objectTypeId: objectType.id
-    })),
-    getTypeById: (objectTypeId) => {
-      const objectType = runtime.ontology.getObjectTypeById(objectTypeId);
-      return objectType && isAllowed(runtime.authorization, { kind: "object.view", objectTypeId }) ? objectType : null;
-    },
-    resolveType: (objectTypeId) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-      return runtime.ontology.resolveObjectType(objectTypeId);
-    },
-    getValueTypesById: () => runtime.ontology.getValueTypesById(),
-    listSubTypes: (objectTypeId) => runtime.ontology.listSubTypes(objectTypeId),
-    isValidLinkTarget: (expected, actual) => runtime.ontology.isValidLinkTarget(expected, actual),
-    executeQuery: (input) => executeObjectQuery({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    queryLinks: (input) => executeObjectQueryLinks({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    count: (input) => countObjects({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    exists: (input) => existsObjects({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    facet: (input) => facetObjects({ projectId: runtime.projectId, ...input }, {
-      ontology: runtime.ontology,
-      storage: runtime.storage.objects,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    listLinks: async (input) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId: input.objectTypeId });
-      const links = await runtime.storage.objects.listLinks({
-        projectId: runtime.projectId,
-        ...input
-      });
-      return links.filter((link) => isAllowed(runtime.authorization, {
-        kind: "object.view",
-        objectTypeId: link.sourceTypeId
-      }) && isAllowed(runtime.authorization, {
-        kind: "object.view",
-        objectTypeId: link.targetTypeId
-      }));
-    },
-    getTelemetryHistoryBatch: (input) => getTelemetryHistoryBatch({ projectId: runtime.projectId, ...input }, {
-      storage: runtime.storage.timeseries,
-      runtimeAuthorization: runtime.runtimeAuthorization,
-      authorization: runtime.authorization
-    }),
-    getTelemetryHistory: (input) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId: input.objectTypeId });
-      return runtime.storage.timeseries.getHistory({
-        projectId: runtime.projectId,
-        ...input
-      });
-    },
-    getLatestTelemetry: (input) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId: input.objectTypeId });
-      return runtime.storage.timeseries.getLatest({
-        projectId: runtime.projectId,
-        ...input
-      });
-    },
-    list: (params) => listObjects(runtime, params),
-    get: async (objectTypeId, primaryId) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-      return runtime.storage.objects.getByPrimaryId({
-        projectId: runtime.projectId,
-        objectTypeId,
-        primaryId
-      });
-    },
-    getPrimaryPropertyId: (objectTypeId) => {
-      assertAuthorized(runtime, { kind: "object.view", objectTypeId });
-      return runtime.ontology.getPrimaryPropertyId(objectTypeId);
-    },
-    upsert: (objectTypeId, properties) => upsertObject(runtime, objectTypeId, properties),
-    upsertBatch: (objectTypeId, items) => upsertObjectBatch(runtime, objectTypeId, items),
-    upsertLink: (objectTypeId, sourceId, linkId, target) => upsertLink(runtime, objectTypeId, sourceId, linkId, target),
-    upsertLinkBatch: (items) => upsertLinkBatch(runtime, items),
-    removeLink: (objectTypeId, sourceId, linkId, target) => removeLink(runtime, objectTypeId, sourceId, linkId, target),
-    appendTelemetry: (objectTypeId, items) => appendTelemetry(runtime, objectTypeId, items)
-  });
-  return objects;
-}
-
-// src/pipelines/execution.ts
-function createPipelinesRuntime(runtime, execution, source) {
-  const allowed = (pipelineId) => isAllowed(runtime.authorization, { kind: "pipeline.run", pipelineId });
-  const visibleIds = () => source.list().filter((pipeline) => allowed(pipeline.id)).map((pipeline) => pipeline.id);
-  const getRun = async (runId) => {
-    const run = await runtime.storage.pipelineRuns?.getById({
-      projectId: runtime.projectId,
-      id: runId
-    }) ?? null;
-    return run && canViewPipelineRun(runtime.authorization, run) ? run : null;
-  };
-  return {
-    list: () => source.list().filter((pipeline) => allowed(pipeline.id)),
-    getById: (pipelineId) => {
-      const pipeline = source.getById(pipelineId);
-      return pipeline && allowed(pipelineId) ? pipeline : null;
-    },
-    request: async (input) => {
-      const pipeline = source.getById(input.pipelineId);
-      if (!pipeline)
-        throw new PipelineError(`[Sixb] Unknown pipeline '${input.pipelineId}'`);
-      return requestPipelineRun(runtime, execution, pipeline, input);
-    },
-    runs: {
-      getById: getRun,
-      list: (input = {}) => {
-        const storage = runtime.storage.pipelineRuns;
-        if (!storage)
-          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
-        return storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          pipelineIds: runtime.authorization ? visibleIds() : undefined
-        });
-      },
-      listLatest: (pipelineIds) => {
-        const storage = runtime.storage.pipelineRuns;
-        if (!storage || pipelineIds.length === 0)
-          return Promise.resolve({ runs: [] });
-        const allowedIds = pipelineIds.filter(allowed);
-        return allowedIds.length === 0 ? Promise.resolve({ runs: [] }) : storage.listLatestByPipelineIds({
-          projectId: runtime.projectId,
-          pipelineIds: allowedIds
-        });
-      },
-      listSteps: async (runId, input = {}) => {
-        const storage = runtime.storage.pipelineRuns;
-        if (!storage || !await getRun(runId))
-          return null;
-        return storage.listSteps({
-          projectId: runtime.projectId,
-          ...input,
-          pipelineRunId: runId
-        });
-      }
-    }
-  };
-}
-
-// src/projections/execution.ts
-function createProjectionsRuntime(runtime, source) {
-  const visible = (projection) => canViewProjection(runtime.authorization, projection);
-  const visibleIds = (projectionIds) => projectionIds.filter((projectionId) => {
-    const projection = source.getById(projectionId);
-    return projection !== null && visible(projection);
-  });
-  return {
-    list: () => source.list().filter(visible),
-    listObjects: () => source.listObjects().filter(visible),
-    listLinks: () => source.listLinks().filter(visible),
-    listTelemetry: () => source.listTelemetry().filter(visible),
-    getById: (projectionId) => {
-      const projection = source.getById(projectionId);
-      return projection && visible(projection) ? projection : null;
-    },
-    runs: {
-      getById: async (runId) => {
-        const run = await runtime.storage.projectionRuns?.getById({
-          projectId: runtime.projectId,
-          id: runId
-        }) ?? null;
-        return run && canViewProjectionRun(runtime.authorization, run.target) ? run : null;
-      },
-      list: (input = {}) => {
-        const storage = runtime.storage.projectionRuns;
-        if (!storage)
-          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
-        return storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          objectTypeIds: runtime.authorization ? [...runtime.authorization.grants["view:object"]] : undefined
-        });
-      },
-      listLatest: (projectionIds) => {
-        const storage = runtime.storage.projectionRuns;
-        if (!storage || projectionIds.length === 0)
-          return Promise.resolve({ runs: [] });
-        const ids = visibleIds(projectionIds);
-        return ids.length === 0 ? Promise.resolve({ runs: [] }) : storage.listLatestByProjectionIds({ projectId: runtime.projectId, projectionIds: ids });
-      }
-    }
-  };
-}
-
-// src/rules/execution.ts
-function createRulesRuntime(runtime, source) {
-  const visible = (rule) => isAllowed(runtime.authorization, {
-    kind: "object.view",
-    objectTypeId: rule.subject.objectTypeId
-  });
-  return {
-    list: () => source.list().filter(visible),
-    getById: (ruleId) => {
-      const rule = source.getById(ruleId);
-      return rule && visible(rule) ? rule : null;
-    },
-    states: {
-      list: (input = {}) => {
-        const storage = runtime.storage.rules;
-        if (!storage)
-          return Promise.resolve({ states: [], hasMore: false, total: 0 });
-        return storage.listActive({
-          projectId: runtime.projectId,
-          ...input,
-          objectTypeIds: runtime.authorization ? [...runtime.authorization.grants["view:object"]] : undefined
-        });
-      }
-    }
-  };
-}
-
-// src/schedules/execution.ts
-function createSchedulesRuntime(schedules) {
-  return {
-    list: () => schedules.list(),
-    getById: (scheduleId) => schedules.getById(scheduleId)
-  };
-}
-
-// src/syncs/execution.ts
-function createSyncsRuntime(runtime, execution, source) {
-  const allowed = (syncId) => isAllowed(runtime.authorization, { kind: "sync.run", syncId });
-  const visibleIds = () => source.list().filter((sync) => allowed(sync.id)).map((sync) => sync.id);
-  return {
-    list: () => source.list().filter((sync) => allowed(sync.id)),
-    getById: (syncId) => {
-      const sync = source.getById(syncId);
-      return sync && allowed(syncId) ? sync : null;
-    },
-    request: async (input) => {
-      const sync = source.getById(input.syncId);
-      if (!sync)
-        throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`);
-      return requestSyncRun(runtime, execution, sync, input);
-    },
-    runs: {
-      getById: async (runId) => {
-        const run = await runtime.storage.syncRuns?.getById({
-          projectId: runtime.projectId,
-          id: runId
-        }) ?? null;
-        return run && allowed(run.syncId) ? run : null;
-      },
-      list: (input = {}) => {
-        const storage = runtime.storage.syncRuns;
-        if (!storage)
-          return Promise.resolve({ runs: [], hasMore: false, total: 0 });
-        return storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          syncIds: runtime.authorization ? visibleIds() : undefined
-        });
-      },
-      listLatest: (syncIds) => {
-        const storage = runtime.storage.syncRuns;
-        if (!storage || syncIds.length === 0)
-          return Promise.resolve({ runs: [] });
-        const allowedIds = syncIds.filter(allowed);
-        return allowedIds.length === 0 ? Promise.resolve({ runs: [] }) : storage.listLatestBySyncIds({ projectId: runtime.projectId, syncIds: allowedIds });
-      }
-    }
-  };
-}
-
-// src/workflows/errors.ts
-class WorkflowDefinitionError extends Error {
-  name = "WorkflowDefinitionError";
-}
-
-class WorkflowValidationError extends Error {
-  name = "WorkflowValidationError";
-  cause;
-  constructor(message, options) {
-    super(message);
-    this.cause = options?.cause;
-  }
-}
-
-// src/workflows/run-dispatch.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { isDeepStrictEqual } from "util";
-
-// src/workflows/validation.ts
-function assertNonEmpty(value, subject, field) {
-  if (!value.trim()) {
-    throw new WorkflowDefinitionError(`${subject} ${field} must not be empty.`);
-  }
-}
-function isStepDefinition(value) {
-  return isRecord(value) && value.kind === "step" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.output) && typeof value.handler === "function";
-}
-function isAgentStepDefinition(value) {
-  return isRecord(value) && value.kind === "agentStep" && typeof value.id === "string" && (value.model === undefined || isLanguageModel(value.model)) && (value.reasoning === undefined || isModelReasoning(value.reasoning)) && typeof value.instructions === "string" && isStringArray(value.groupIds) && isStringArray(value.toolNames) && isRecord(value.input) && isRecord(value.output) && typeof value.prompt === "function";
-}
-function isInterventionDefinition(value) {
-  return isRecord(value) && value.kind === "intervention" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.response) && (value.defaults === undefined || typeof value.defaults === "function");
-}
-function isWorkflowDefinition(value) {
-  return isRecord(value) && value.kind === "workflow" && typeof value.id === "string" && isRecord(value.input) && Array.isArray(value.triggers) && Array.isArray(value.nodes);
-}
-function validateWorkflowDefinition(value) {
-  if (!isWorkflowDefinition(value)) {
-    throw new WorkflowDefinitionError("Invalid workflow definition.");
-  }
-  assertNonEmpty(value.id, "Workflow", "id");
-  if (value.nodes.length === 0) {
-    throw new WorkflowDefinitionError(`Workflow "${value.id}" must contain at least one node.`);
-  }
-  const nodeIds = new Set;
-  const nodeKeys = new Set;
-  for (const node of value.nodes) {
-    validateWorkflowNodeDefinition(value.id, node);
-    if (nodeIds.has(node.id)) {
-      throw new WorkflowDefinitionError(`Duplicate workflow node id "${node.id}" in workflow "${value.id}".`);
-    }
-    nodeIds.add(node.id);
-    if (nodeKeys.has(node.key)) {
-      throw new WorkflowDefinitionError(`Duplicate workflow node key "${node.key}" in workflow "${value.id}".`);
-    }
-    nodeKeys.add(node.key);
-  }
-}
-function validateWorkflowsAtStartup(options) {
-  for (const workflow of options.workflows) {
-    validateWorkflowDefinition(workflow);
-    for (const trigger of workflow.triggers) {
-      validateWorkflowTriggerAtStartup(workflow.id, trigger, options.registeredSchedules, Object.keys(workflow.input));
-    }
-    for (const node of workflow.nodes) {
-      if (node.type === "action" && !options.registeredActionIds.has(node.action.id)) {
-        throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown action "${node.action.id}". Add it to 'actions' in createSixb() or export it from 'actions/'.`);
-      }
-      if (node.type === "agent") {
-        validateWorkflowAgentStepRuntimeReferences(workflow.id, node.agentStep, options);
-      }
-    }
-  }
-  return options.workflows;
-}
-function validateWorkflowAgentStepGroupReferences(workflows, security) {
-  for (const workflow of workflows) {
-    for (const node of workflow.nodes) {
-      if (node.type !== "agent")
-        continue;
-      for (const groupId of node.agentStep.groupIds) {
-        if (!security.getGroupById(groupId)) {
-          throw new WorkflowDefinitionError(`Workflow "${workflow.id}" agent step "${node.id}" references unknown group "${groupId}". Add it to 'security/groups/' or pass it to createSixb({ groups }).`);
-        }
-      }
-    }
-  }
-}
-function validateWorkflowAgentStepRuntimeReferences(workflowId, step, options) {
-  if (step.model === undefined && options.models === undefined) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" needs a model. Configure 'models.language' or pass 'model' to defineAgentStep().`);
-  }
-  if (step.model !== undefined && options.models !== undefined) {
-    const ref = { provider: step.model.providerId, modelId: step.model.modelId };
-    if (options.models.language.getByRef(ref) === null) {
-      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" uses unknown language model "${ref.provider}/${ref.modelId}". Add it to 'models.language' in createSixb().`);
-    }
-  }
-  for (const toolName of step.toolNames) {
-    if (options.tools.getByName(toolName) === null) {
-      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" uses unknown project tool "${toolName}". Add it to 'tools' in createSixb().`);
-    }
-  }
-}
-function validateWorkflowInput(params) {
-  return validateWorkflowContractRecord({
-    shape: params.workflow.input,
-    value: params.value,
-    path: `Workflow "${params.workflow.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowStepInput(params) {
-  return validateWorkflowContractRecord({
-    shape: params.step.input,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" step "${params.step.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowStepOutput(params) {
-  return validateWorkflowContractRecord({
-    shape: params.step.output,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" step "${params.step.id}" output`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowInterventionInput(params) {
-  return validateWorkflowContractRecord({
-    shape: params.intervention.input,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowInterventionResponse(params) {
-  return validateWorkflowInterventionResponseRecord({
-    response: params.intervention.response,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" response`,
-    partial: false,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowInterventionDefaultResponse(params) {
-  return validateWorkflowInterventionResponseRecord({
-    response: params.intervention.response,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" defaultResponse`,
-    partial: true,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowTriggerAtStartup(workflowId, trigger, registeredSchedules, inputFields) {
-  if (!isRecord(trigger) || trigger.type !== "schedule") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported trigger.`);
-  }
-  validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedules, inputFields);
-}
-function validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedules, inputFields) {
-  if (typeof trigger.scheduleId !== "string" || !trigger.scheduleId.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains a schedule trigger with an empty schedule id.`);
-  }
-  const schedule = registeredSchedules.get(trigger.scheduleId);
-  if (!schedule) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" references unknown schedule "${trigger.scheduleId}". Add it to 'schedules' in createSixb() or export it from 'schedules/'.`);
-  }
-  if (trigger.mapper !== undefined && typeof trigger.mapper !== "function") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" schedule "${trigger.scheduleId}" mapper must be a function.`);
-  }
-  if (trigger.mapper !== undefined && schedule.trigger.type !== "event") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" cron schedule "${trigger.scheduleId}" does not accept a mapper.`);
-  }
-  if (trigger.mapper === undefined && inputFields.length > 0) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" schedule "${trigger.scheduleId}" requires a mapper because workflow input is not empty: ${inputFields.join(", ")}.`);
-  }
-}
-function validateWorkflowNodeDefinition(workflowId, node) {
-  if (!isRecord(node)) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid node.`);
-  }
-  if (node.type === "step") {
-    validateStepNodeDefinition(workflowId, node);
-    return;
-  }
-  if (node.type === "agent") {
-    validateAgentNodeDefinition(workflowId, node);
-    return;
-  }
-  if (node.type === "intervention") {
-    validateInterventionNodeDefinition(workflowId, node);
-    return;
-  }
-  if (node.type === "action") {
-    validateActionNodeDefinition(workflowId, node);
-    return;
-  }
-  throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported node type.`);
-}
-function validateAgentNodeDefinition(workflowId, node) {
-  if (typeof node.id !== "string" || !node.id.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an agent step with an empty id.`);
-  }
-  if (typeof node.key !== "string" || !node.key.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains agent step "${node.id}" with an empty derived key.`);
-  }
-  if (!isAgentStepDefinition(node.agentStep)) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid agent node "${node.id}".`);
-  }
-  if (node.id !== node.agentStep.id) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node id "${node.id}" does not match agent step definition id "${node.agentStep.id}".`);
-  }
-  if (!node.agentStep.instructions.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${node.id}" instructions must not be empty.`);
-  }
-  assertUniqueNonEmptyAgentStepValues(workflowId, node.id, "group", node.agentStep.groupIds);
-  assertUniqueNonEmptyAgentStepValues(workflowId, node.id, "tool", node.agentStep.toolNames);
-  if (node.mapper !== undefined && typeof node.mapper !== "function") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node "${node.id}" mapper must be a function.`);
-  }
-}
-function assertUniqueNonEmptyAgentStepValues(workflowId, stepId, kind, values) {
-  const seen = new Set;
-  for (const value of values) {
-    if (!value.trim()) {
-      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${stepId}" has an empty ${kind} id.`);
-    }
-    if (seen.has(value)) {
-      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${stepId}" has duplicate ${kind} '${value}'.`);
-    }
-    seen.add(value);
-  }
-}
-function isLanguageModel(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null;
-}
-function isStringArray(value) {
-  if (!Array.isArray(value))
-    return false;
-  for (let index = 0;index < value.length; index += 1) {
-    if (!Object.hasOwn(value, index) || typeof value[index] !== "string")
-      return false;
-  }
-  return true;
-}
-function validateWorkflowAgentStepInput(params) {
-  return validateWorkflowContractRecord({
-    shape: params.agentStep.input,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateWorkflowAgentStepOutput(params) {
-  return validateWorkflowContractRecord({
-    shape: params.agentStep.output,
-    value: params.value,
-    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" output`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function validateStepNodeDefinition(workflowId, node) {
-  if (typeof node.id !== "string" || !node.id.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains a step with an empty id.`);
-  }
-  if (typeof node.key !== "string" || !node.key.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains step "${node.id}" with an empty derived key.`);
-  }
-  if (!isStepDefinition(node.step)) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid step node "${node.id}".`);
-  }
-  if (node.id !== node.step.id) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" step node id "${node.id}" does not match step definition id "${node.step.id}".`);
-  }
-  if (node.mapper !== undefined && typeof node.mapper !== "function") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" step node "${node.id}" mapper must be a function.`);
-  }
-}
-function validateInterventionNodeDefinition(workflowId, node) {
-  if (typeof node.id !== "string" || !node.id.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an intervention with an empty id.`);
-  }
-  if (typeof node.key !== "string" || !node.key.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains intervention "${node.id}" with an empty derived key.`);
-  }
-  if (!isInterventionDefinition(node.intervention)) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid intervention node "${node.id}".`);
-  }
-  if (node.id !== node.intervention.id) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" intervention node id "${node.id}" does not match intervention definition id "${node.intervention.id}".`);
-  }
-  if (node.mapper !== undefined && typeof node.mapper !== "function") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" intervention node "${node.id}" mapper must be a function.`);
-  }
-}
-function validateActionNodeDefinition(workflowId, node) {
-  if (typeof node.id !== "string" || !node.id.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an action with an empty id.`);
-  }
-  if (typeof node.key !== "string" || !node.key.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains action "${node.id}" with an empty derived key.`);
-  }
-  if (!isActionDefinition(node.action)) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid action node "${node.id}".`);
-  }
-  if (node.id !== node.action.id) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" action node id "${node.id}" does not match action definition id "${node.action.id}".`);
-  }
-  if (node.mapper !== undefined && typeof node.mapper !== "function") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" action node "${node.id}" mapper must be a function.`);
-  }
-}
-function validateWorkflowContractRecord(params) {
-  if (!isRecord(params.value)) {
-    throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
-  }
-  const fieldIds = new Set(Object.keys(params.shape));
-  for (const fieldId of Object.keys(params.value)) {
-    if (!fieldIds.has(fieldId)) {
-      throw new WorkflowValidationError(`[Sixb] Unknown field '${params.path}.${fieldId}'`);
-    }
-  }
-  for (const [fieldId, schema] of Object.entries(params.shape)) {
-    const fieldValue = params.value[fieldId];
-    if (fieldValue === undefined) {
-      throw new WorkflowValidationError(`[Sixb] Missing required field '${params.path}.${fieldId}'`);
-    }
-    try {
-      validateSchemaOrRefValue(schema, fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
-    } catch (error) {
-      throw toWorkflowValidationError(error);
-    }
-  }
-  return params.value;
-}
-function validateWorkflowInterventionResponseRecord(params) {
-  if (!isRecord(params.value)) {
-    throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
-  }
-  const fieldIds = new Set(Object.keys(params.response));
-  for (const fieldId of Object.keys(params.value)) {
-    if (!fieldIds.has(fieldId)) {
-      throw new WorkflowValidationError(`[Sixb] Unknown field '${params.path}.${fieldId}'`);
-    }
-  }
-  for (const [fieldId, field] of Object.entries(params.response)) {
-    const fieldValue = params.value[fieldId];
-    if (fieldValue === undefined) {
-      if (!params.partial && isInterventionResponseFieldRequired(field)) {
-        throw new WorkflowValidationError(`[Sixb] Missing required field '${params.path}.${fieldId}'`);
-      }
-      continue;
-    }
-    try {
-      validateSchemaOrRefValue(interventionResponseFieldSchema(field), fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
-    } catch (error) {
-      throw toWorkflowValidationError(error);
-    }
-  }
-  return params.value;
-}
-function isInterventionFieldConfig(value) {
-  return isRecord(value) && "schema" in value;
-}
-function interventionResponseFieldSchema(field) {
-  return isInterventionFieldConfig(field) ? field.schema : field;
-}
-function isInterventionResponseFieldRequired(field) {
-  return !isInterventionFieldConfig(field) || field.required !== false;
-}
-function toWorkflowValidationError(error) {
-  if (error instanceof WorkflowValidationError) {
-    return error;
-  }
-  if (error instanceof Error) {
-    return new WorkflowValidationError(error.message, { cause: error });
-  }
-  return new WorkflowValidationError(String(error), { cause: error });
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/workflows/snapshot.ts
-function snapshotWorkflowAgentStepInput(params) {
-  const value = validateWorkflowAgentStepInput(params);
-  return snapshotWorkflowContractRecord({
-    shape: params.agentStep.input,
-    value,
-    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowAgentStepOutput(params) {
-  const value = validateWorkflowAgentStepOutput(params);
-  return snapshotWorkflowContractRecord({
-    shape: params.agentStep.output,
-    value,
-    path: `Workflow "${params.workflowId}" agent step "${params.agentStep.id}" output`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowInput(params) {
-  const value = validateWorkflowInput(params);
-  return snapshotWorkflowContractRecord({
-    shape: params.workflow.input,
-    value,
-    path: `Workflow "${params.workflow.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowStepInput(params) {
-  const value = validateWorkflowStepInput(params);
-  return snapshotWorkflowContractRecord({
-    shape: params.step.input,
-    value,
-    path: `Workflow "${params.workflowId}" step "${params.step.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowStepOutput(params) {
-  const value = validateWorkflowStepOutput(params);
-  return snapshotWorkflowContractRecord({
-    shape: params.step.output,
-    value,
-    path: `Workflow "${params.workflowId}" step "${params.step.id}" output`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowInterventionInput(params) {
-  const value = validateWorkflowInterventionInput(params);
-  return snapshotWorkflowContractRecord({
-    shape: params.intervention.input,
-    value,
-    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" input`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowInterventionResponse(params) {
-  const value = validateWorkflowInterventionResponse(params);
-  return snapshotWorkflowInterventionResponseRecord({
-    response: params.intervention.response,
-    value,
-    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" response`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowInterventionDefaultResponse(params) {
-  const value = validateWorkflowInterventionDefaultResponse(params);
-  return snapshotWorkflowInterventionResponseRecord({
-    response: params.intervention.response,
-    value,
-    path: `Workflow "${params.workflowId}" intervention "${params.intervention.id}" defaultResponse`,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotWorkflowActionInput(params) {
-  const snapshot = {
-    params: snapshotJsonValue(params.params, "Workflow action params")
-  };
-  if (params.subject && params.subject.kind !== "none") {
-    snapshot.subject = snapshotJsonValue(params.subject, "Workflow action subject");
-  }
-  return snapshot;
-}
-function snapshotWorkflowContractRecord(params) {
-  const snapshot = {};
-  for (const [fieldId, schema] of Object.entries(params.shape)) {
-    snapshot[fieldId] = snapshotSchemaOrRefValue({
-      schema,
-      value: params.value[fieldId],
-      path: `${params.path}.${fieldId}`,
-      valueTypesById: params.valueTypesById
-    });
-  }
-  return snapshot;
-}
-function snapshotWorkflowInterventionResponseRecord(params) {
-  const snapshot = {};
-  for (const [fieldId, value] of Object.entries(params.value)) {
-    if (value === undefined) {
-      continue;
-    }
-    snapshot[fieldId] = snapshotSchemaOrRefValue({
-      schema: interventionResponseFieldSchema(params.response[fieldId]),
-      value,
-      path: `${params.path}.${fieldId}`,
-      valueTypesById: params.valueTypesById
-    });
-  }
-  return snapshot;
-}
-function snapshotSchemaOrRefValue(params) {
-  if (isObjectRefSchema(params.schema)) {
-    if (!isRecord2(params.value)) {
-      throw cannotSerialize(params.path);
-    }
-    return {
-      objectTypeId: String(params.value.objectTypeId),
-      primaryId: String(params.value.primaryId)
-    };
-  }
-  return snapshotSchemaValue({
-    schema: params.schema,
-    value: params.value,
-    path: params.path,
-    valueTypesById: params.valueTypesById
-  });
-}
-function snapshotSchemaValue(params) {
-  const { schema, value, path, valueTypesById } = params;
-  if (typeof schema === "string") {
-    if (schema === "date" || schema === "timestamp") {
-      if (value instanceof Date) {
-        return snapshotDate(value, path);
-      }
-      return snapshotJsonValue(value, path);
-    }
-    return snapshotJsonValue(value, path);
-  }
-  if (schema.type === "enum") {
-    return snapshotJsonValue(value, path);
-  }
-  if (schema.type === "array") {
-    if (!Array.isArray(value)) {
-      throw cannotSerialize(path);
-    }
-    return value.map((item, index) => snapshotSchemaValue({
-      schema: schema.items,
-      value: item,
-      path: `${path}[${index}]`,
-      valueTypesById
-    }));
-  }
-  if (schema.type === "map") {
-    if (!isRecord2(value)) {
-      throw cannotSerialize(path);
-    }
-    const snapshot = {};
-    for (const [key, entry] of Object.entries(value)) {
-      snapshot[key] = snapshotSchemaValue({
-        schema: schema.valueSchema,
-        value: entry,
-        path: `${path}.${key}`,
-        valueTypesById
-      });
-    }
-    return snapshot;
-  }
-  if (schema.type === "object") {
-    if (!isRecord2(value)) {
-      throw cannotSerialize(path);
-    }
-    const snapshot = {};
-    for (const [fieldId, field] of Object.entries(schema.properties)) {
-      const fieldValue = value[fieldId];
-      if (fieldValue === undefined) {
-        continue;
-      }
-      if (fieldValue === null) {
-        snapshot[fieldId] = null;
-        continue;
-      }
-      snapshot[fieldId] = snapshotSchemaValue({
-        schema: field.schema,
-        value: fieldValue,
-        path: `${path}.${fieldId}`,
-        valueTypesById
-      });
-    }
-    return snapshot;
-  }
-  if (schema.type === "valueTypeRef") {
-    const valueType = valueTypesById.get(schema.valueTypeId);
-    if (!valueType) {
-      throw new WorkflowValidationError(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
-    }
-    return snapshotSchemaValue({
-      schema: valueType.schema,
-      value,
-      path,
-      valueTypesById
-    });
-  }
-  return snapshotJsonValue(value, path);
-}
-function snapshotJsonValue(value, path) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw cannotSerialize(path);
-    }
-    return value;
-  }
-  if (value instanceof Date) {
-    return snapshotDate(value, path);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item, index) => snapshotJsonValue(item, `${path}[${index}]`));
-  }
-  if (isPlainRecord(value)) {
-    const snapshot = {};
-    for (const [key, entry] of Object.entries(value)) {
-      snapshot[key] = snapshotJsonValue(entry, `${path}.${key}`);
-    }
-    return snapshot;
-  }
-  throw cannotSerialize(path);
-}
-function snapshotDate(value, path) {
-  if (Number.isNaN(value.getTime())) {
-    throw cannotSerialize(path);
-  }
-  return value.toISOString();
-}
-function cannotSerialize(path) {
-  return new WorkflowValidationError(`[Sixb] ${path} cannot be serialized as workflow IO`);
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/workflows/run-dispatch.ts
-class WorkflowRunDispatcher {
-  dependencies;
-  constructor(dependencies) {
-    this.dependencies = dependencies;
-  }
-  async dispatch(input) {
-    assertAutomaticDispatchInput(input);
-    const workflow = this.dependencies.definitions.workflows.getById(input.workflowId);
-    if (!workflow) {
-      throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`);
-    }
-    const result = await dispatchWorkflowRun({
-      errorReporterHost: this.dependencies,
-      projectId: this.dependencies.id,
-      workflow,
-      valueTypesById: this.dependencies.definitions.ontology.getValueTypesById(),
-      storage: this.dependencies.storage,
-      queue: this.dependencies.queues.workflows,
-      events: this.dependencies.events,
-      runId: input.runId,
-      input: input.input,
-      source: {
-        type: "schedule",
-        scheduleId: input.scheduleId,
-        eventId: input.source.eventId,
-        principal: SYSTEM_PRINCIPAL
-      },
-      requesterGroupIds: [],
-      metadata: input.metadata,
-      queueJobId: input.runId,
-      createExecution: async (executionId, runId) => createPrimitiveExecutionRecord({
-        id: executionId,
-        primitive: { kind: "workflow", id: workflow.id, runId },
-        origin: {
-          type: "automatic",
-          projectId: this.dependencies.id,
-          source: input.source,
-          correlationId: input.correlationId
-        }
-      })
-    });
-    if (!result.created) {
-      await assertAutomaticExecutionIdentity(this.dependencies, input, result.runId);
-    }
-    return result;
-  }
-}
-async function dispatchWorkflowRun(input) {
-  const request = prepareWorkflowRun(input);
-  const persisted = await persistWorkflowRun(input, request);
-  if (!persisted.created)
-    return existingWorkflowRunResult(persisted.run);
-  return publishWorkflowRun(input, persisted);
-}
-function prepareWorkflowRun(input) {
-  const value = input.input ?? {};
-  return {
-    runId: resolveWorkflowRunId(input.runId),
-    snapshot: snapshotWorkflowInput({
-      workflow: input.workflow,
-      value,
-      valueTypesById: input.valueTypesById
-    })
-  };
-}
-async function persistWorkflowRun(input, request) {
-  const workflowRuns = input.storage.workflowRuns;
-  if (!workflowRuns) {
-    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
-  }
-  const existing = await workflowRuns.getById({
-    projectId: input.projectId,
-    id: request.runId
-  });
-  if (existing) {
-    assertExistingWorkflowRun(existing, input.workflow.id, request.snapshot);
-    return { run: existing, created: false };
-  }
-  const execution = await input.createExecution(`exec_${randomUUID4()}`, request.runId);
-  const queuedAt = new Date;
-  try {
-    return await input.storage.transaction(async (tx) => {
-      const raced = await tx.workflowRuns?.getById({
-        projectId: input.projectId,
-        id: request.runId
-      });
-      if (raced) {
-        assertExistingWorkflowRun(raced, input.workflow.id, request.snapshot);
-        return { run: raced, created: false };
-      }
-      if (!tx.workflowRuns) {
-        throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
-      }
-      await tx.executions.create(execution);
-      const run = await tx.workflowRuns.queue({
-        projectId: input.projectId,
-        id: request.runId,
-        executionId: execution.id,
-        workflowId: input.workflow.id,
-        input: request.snapshot,
-        queuedAt,
-        requesterGroupIds: input.requesterGroupIds
-      });
-      return { run, execution, queuedAt, created: true };
-    }, { isolation: "serializable" });
-  } catch (error) {
-    if (!(error instanceof WorkflowRunError))
-      throw error;
-    const raced = await workflowRuns.getById({
-      projectId: input.projectId,
-      id: request.runId
-    });
-    if (!raced)
-      throw error;
-    assertExistingWorkflowRun(raced, input.workflow.id, request.snapshot);
-    return { run: raced, created: false };
-  }
-}
-async function publishWorkflowRun(input, persisted) {
-  let job;
-  try {
-    const jobs = await input.queue.enqueue({
-      projectId: input.projectId,
-      jobs: [
-        {
-          ...input.queueJobId === undefined ? {} : { id: input.queueJobId },
-          type: "workflow.run.requested",
-          payload: { runId: persisted.run.id },
-          ...input.metadata === undefined ? {} : { metadata: input.metadata }
-        }
-      ]
-    });
-    job = jobs[0];
-  } catch (error) {
-    await failWorkflowRunPublication(input, persisted.run, error);
-    throw error;
-  }
-  await input.events.emit({
-    events: [
-      {
-        type: "workflow.run.queued",
-        payload: {
-          workflowId: persisted.run.workflowId,
-          runId: persisted.run.id,
-          queuedAt: persisted.queuedAt.toISOString(),
-          ...job?.id ? { jobId: job.id } : {},
-          ...input.source === undefined ? {} : { source: input.source }
-        }
-      }
-    ],
-    correlationId: persisted.execution.correlationId
-  }, { source: "Sixb" });
-  return {
-    workflowId: persisted.run.workflowId,
-    runId: persisted.run.id,
-    queuedAt: persisted.queuedAt.toISOString(),
-    jobId: job?.id,
-    created: true
-  };
-}
-async function failWorkflowRunPublication(input, run, error) {
-  const workflowRuns = input.storage.workflowRuns;
-  if (!workflowRuns) {
-    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
-  }
-  const failure = captureSixbFailure(error, {
-    allowedCodes: WORKFLOW_RUN_FAILURE_CODES,
-    defaultCode: "internal.unexpected",
-    details: { workflowId: run.workflowId, runId: run.id }
-  });
-  await workflowRuns.finish({
-    projectId: input.projectId,
-    id: run.id,
-    status: "failed",
-    error: failure
-  });
-  reportRunFailure(input.errorReporterHost, error, {
-    projectId: input.projectId,
-    runKind: "workflow",
-    run: { runId: run.id, workflowId: run.workflowId },
-    failure
-  });
-}
-function resolveWorkflowRunId(runId) {
-  if (runId === undefined)
-    return `run_${randomUUID4()}`;
-  if (!runId.trim()) {
-    throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty");
-  }
-  return runId;
-}
-function assertExistingWorkflowRun(existing, workflowId, input) {
-  if (existing.workflowId !== workflowId || !isDeepStrictEqual(existing.input, input)) {
-    throw new WorkflowValidationError(`[Sixb] Workflow run '${existing.id}' already exists with a different request payload.`);
-  }
-}
-function existingWorkflowRunResult(existing) {
-  return {
-    workflowId: existing.workflowId,
-    runId: existing.id,
-    queuedAt: (existing.queuedAt ?? existing.startedAt).toISOString(),
-    created: false
-  };
-}
-function assertAutomaticDispatchInput(input) {
-  assertNonBlank(input.workflowId, "Workflow id");
-  assertNonBlank(input.runId, "Workflow run id");
-  assertNonBlank(input.scheduleId, "Workflow schedule id");
-  assertNonBlank(input.source.eventId, "Workflow source event id");
-  assertNonBlank(input.correlationId, "Workflow correlation id");
-}
-async function assertAutomaticExecutionIdentity(dependencies, input, runId) {
-  const run = await dependencies.storage.workflowRuns?.getById({
-    projectId: dependencies.id,
-    id: runId
-  });
-  const execution = run ? await dependencies.storage.executions.getById({
-    projectId: dependencies.id,
-    id: run.executionId
-  }) : null;
-  if (!execution || execution.source.type !== input.source.type || execution.source.eventId !== input.source.eventId || execution.correlationId !== input.correlationId || execution.requestedBy !== undefined) {
-    throw new WorkflowValidationError(`[Sixb] Workflow run '${runId}' already exists with different automatic provenance.`);
-  }
-}
-function assertNonBlank(value, label) {
-  if (!value.trim())
-    throw new WorkflowValidationError(`[Sixb] ${label} must not be empty.`);
-}
-
-// src/workflows/request.ts
-async function requestWorkflowRun(runtime, execution, workflow, options = {}) {
-  assertAuthorized(runtime, { kind: "workflow.run", workflowId: workflow.id });
-  const requesterGroupIds = execution.requestedBy ? await snapshotRequesterGroupIds({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    principal: execution.requestedBy
-  }) : [];
-  return dispatchWorkflowRun({
-    errorReporterHost: runtime,
-    projectId: runtime.projectId,
-    workflow,
-    valueTypesById: runtime.ontology.getValueTypesById(),
-    storage: runtime.storage,
-    queue: runtime.queues.workflows,
-    events: runtime.events,
-    runId: options.runId,
-    input: options.input,
-    source: options.source,
-    requesterGroupIds,
-    createExecution: async (executionId, runId) => {
-      const caller = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
-        execution,
-        runtimeAuthorization: runtime.runtimeAuthorization
-      }));
-      return createPrimitiveExecutionRecord({
-        id: executionId,
-        primitive: { kind: "workflow", id: workflow.id, runId },
-        origin: { type: "execution", parent: caller }
-      });
-    }
-  });
-}
-
-// src/workflows/execution.ts
-function createWorkflowsRuntime(runtime, execution, source) {
-  const allowed = (workflowId) => isAllowed(runtime.authorization, { kind: "workflow.run", workflowId });
-  const canAccessHistory = (workflowId) => allowed(workflowId) && (!runtime.authorization || source.getById(workflowId) !== null);
-  const visibleIds = () => source.list().filter((workflow) => allowed(workflow.id)).map((workflow) => workflow.id);
-  const getVisibleRunRecord = async (runId) => {
-    const run = await runtime.storage.workflowRuns?.getById({
-      projectId: runtime.projectId,
-      id: runId
-    }) ?? null;
-    return run && canViewWorkflowRun(runtime.authorization, run) && canAccessHistory(run.workflowId) ? run : null;
-  };
-  const getRun = async (runId) => {
-    const run = await getVisibleRunRecord(runId);
-    return run ? attachRequestedBy(runtime, run) : null;
-  };
-  const listNodes = async (runId, input = {}) => {
-    const storage = runtime.storage.workflowRuns;
-    if (!storage || !await getVisibleRunRecord(runId))
-      return null;
-    const result = await storage.nodes.list({
-      projectId: runtime.projectId,
-      ...input,
-      workflowRunId: runId
-    });
-    return {
-      ...result,
-      nodes: await attachWorkflowNodeViews(runtime, storage, result.nodes)
-    };
-  };
-  return {
-    list: () => source.list().filter((workflow) => allowed(workflow.id)),
-    getById: (workflowId) => {
-      const workflow = source.getById(workflowId);
-      return workflow && allowed(workflowId) ? workflow : null;
-    },
-    request: (workflow, options) => requestWorkflowRun(runtime, execution, workflow, options),
-    requestById: async (input) => {
-      const workflow = source.getById(input.workflowId);
-      if (!workflow) {
-        throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`);
-      }
-      return requestWorkflowRun(runtime, execution, workflow, input);
-    },
-    runs: {
-      getById: getRun,
-      list: async (input = {}) => {
-        const storage = runtime.storage.workflowRuns;
-        if (!storage)
-          return { runs: [], hasMore: false, total: 0 };
-        const result = await storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          workflowIds: runtime.authorization ? visibleIds() : undefined
-        });
-        return {
-          ...result,
-          runs: await Promise.all(result.runs.map((run) => attachRequestedBy(runtime, run)))
-        };
-      },
-      listLatest: async (workflowIds) => {
-        const storage = runtime.storage.workflowRuns;
-        if (!storage || workflowIds.length === 0)
-          return { runs: [] };
-        const allowedIds = workflowIds.filter(canAccessHistory);
-        if (allowedIds.length === 0)
-          return { runs: [] };
-        const result = await storage.listLatestByWorkflowIds({
-          projectId: runtime.projectId,
-          workflowIds: allowedIds
-        });
-        return {
-          runs: await Promise.all(result.runs.map((run) => attachRequestedBy(runtime, run)))
-        };
-      },
-      listNodes
-    },
-    interventions: {
-      getById: async (interventionId) => {
-        const intervention = await runtime.storage.workflowInterventions?.getById({
-          projectId: runtime.projectId,
-          id: interventionId
-        }) ?? null;
-        return intervention && canViewWorkflowIntervention(runtime.authorization, intervention) && canAccessHistory(intervention.workflowId) ? intervention : null;
-      },
-      list: (input = {}) => {
-        const storage = runtime.storage.workflowInterventions;
-        if (!storage)
-          return Promise.resolve({ interventions: [], hasMore: false, total: 0 });
-        return storage.list({
-          projectId: runtime.projectId,
-          ...input,
-          workflowIds: runtime.authorization ? visibleIds() : undefined
-        });
-      }
-    }
-  };
-}
-async function attachWorkflowNodeViews(runtime, storage, nodes) {
-  const executions = await Promise.all(nodes.map((node) => node.nodeType === "agent" ? storage.agentNodes.getByNodeRunId({
-    projectId: runtime.projectId,
-    nodeRunId: node.id
-  }) : null));
-  const agentExecutions = executions.filter((execution) => execution !== null);
-  if (agentExecutions.length === 0)
-    return nodes;
-  const executionIds = agentExecutions.map((execution) => execution.executionId);
-  const [usages, costs] = await Promise.all([
-    resolveExecutionUsage({
-      storage: runtime.storage.aiUsage,
-      projectId: runtime.projectId,
-      executionIds
-    }),
-    resolveExecutionCosts({
-      storage: runtime.storage.aiCosts,
-      projectId: runtime.projectId,
-      executionIds
-    })
-  ]);
-  const accountingByExecutionId = new Map(agentExecutions.map((execution, index) => [
-    execution.executionId,
-    { usage: usages[index], cost: costs[index] }
-  ]));
-  return nodes.map((node, index) => {
-    const execution = executions[index];
-    if (!execution)
-      return node;
-    const accounting = accountingByExecutionId.get(execution.executionId);
-    return {
-      ...node,
-      agentExecution: toWorkflowAgentNodeRunView(execution, accounting?.usage, accounting?.usage === undefined ? undefined : accounting.cost)
-    };
-  });
-}
-function toWorkflowAgentNodeRunView(execution, usage, cost) {
-  return {
-    projectId: execution.projectId,
-    nodeRunId: execution.nodeRunId,
-    executionId: execution.executionId,
-    status: execution.status,
-    prompt: execution.prompt,
-    modelId: execution.modelId,
-    finishReason: execution.finishReason,
-    trace: execution.trace,
-    diagnostics: execution.diagnostics,
-    error: execution.error,
-    attempt: execution.attempt,
-    createdAt: execution.createdAt,
-    startedAt: execution.startedAt,
-    completedAt: execution.completedAt,
-    ...usage === undefined ? {} : { usage },
-    ...usage === undefined || cost === undefined ? {} : { cost }
-  };
-}
-async function attachRequestedBy(runtime, run) {
-  const execution = await runtime.storage.executions.getById({
-    projectId: runtime.projectId,
-    id: run.executionId
-  });
-  if (!execution) {
-    throw new Error(`[Sixb] Workflow run '${run.id}' references missing execution '${run.executionId}'.`);
-  }
-  return {
-    ...run,
-    ...execution.requestedBy === undefined ? {} : { requestedBy: structuredClone(execution.requestedBy) }
-  };
-}
-
-// src/runtime/sixb.ts
-var boundSixbInstances = new WeakSet;
-function createBoundSixb(runtime, dependencies, execution) {
-  const sixb = {
-    execution,
-    ...createExecutionFacades(runtime, execution, dependencies)
-  };
-  shareOntologyMutationRuntime(runtime, sixb);
-  if (dependencies.connectorConnections) {
-    registerConnectorConnectionsRuntime(sixb, createConnectorConnectionsRuntime(runtime, execution, dependencies.connectorConnections));
-  }
-  boundSixbInstances.add(sixb);
-  return sixb;
-}
-function isBoundSixb(value) {
-  return typeof value === "object" && value !== null && boundSixbInstances.has(value);
-}
-function createExecutionFacades(runtime, execution, dependencies) {
-  return {
-    objects: createObjectsRuntime(runtime, execution),
-    actions: createActionsRuntime(runtime, execution),
-    datasets: createDatasetsRuntime(runtime, dependencies.definitions.datasets),
-    workflows: createWorkflowsRuntime(runtime, execution, dependencies.definitions.workflows),
-    syncs: createSyncsRuntime(runtime, execution, dependencies.definitions.syncs),
-    pipelines: createPipelinesRuntime(runtime, execution, dependencies.definitions.pipelines),
-    projections: createProjectionsRuntime(runtime, dependencies.definitions.projections),
-    rules: createRulesRuntime(runtime, dependencies.definitions.rules),
-    agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
-    aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
-    events: createEventsRuntime(runtime),
-    logs: createLogsRuntime(runtime, dependencies.logging),
-    schedules: createSchedulesRuntime(dependencies.definitions.schedules),
-    connector: createConnectorRuntime(runtime, execution, dependencies.connectorService),
-    blobs: createBlobsRuntime(runtime, execution, dependencies.blobStorage)
-  };
-}
-// src/execution/agent.ts
-function canInheritAgentRequestAuthorization(authorization) {
-  const ref = getAuthorizationRef(authorization);
-  return ref.type === "disabled" || ref.type === "principal" && ref.principal.type === "user" && ref.credential !== undefined;
-}
-function createAgentExecutionRecord(input) {
-  assertAgentPrincipal(input.actorId, input.principal);
-  return {
-    id: input.id,
-    projectId: input.parent.projectId,
-    ...input.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.parent.requestedBy) },
-    executor: { type: "agent", runId: input.runId },
-    source: { type: "execution", executionId: input.parent.id },
-    correlationId: input.parent.correlationId,
-    authorizationRef: {
-      type: "principal",
-      principal: structuredClone(input.principal)
-    }
-  };
-}
-function createInheritedAgentExecutionRecord(input) {
-  const authority = input.parent.authorizationRef;
-  if (authority.type !== "disabled" && !(authority.type === "principal" && authority.principal.type === "user" && authority.credential !== undefined)) {
-    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent run '${input.runId}' requires inheritable user or auth-disabled authority.`);
-  }
-  return {
-    id: input.id,
-    projectId: input.parent.projectId,
-    ...input.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.parent.requestedBy) },
-    executor: { type: "agent", runId: input.runId },
-    source: { type: "execution", executionId: input.parent.id },
-    correlationId: input.parent.correlationId,
-    authorizationRef: structuredClone(authority)
-  };
-}
-function bindDurableAgentExecution(host, input) {
-  const scope = restoreAgentExecutionScope(input);
-  const sixb = host.withScope(scope);
-  if (!isBoundSixb(sixb)) {
-    throw new Error("[Sixb] Agent execution host returned an invalid bound SDK.");
-  }
-  return sixb;
-}
-function restoreAgentExecutionScope(input) {
-  assertAgentExecutionRecord(input);
-  const context = Object.freeze({
-    id: input.execution.id,
-    projectId: input.execution.projectId,
-    ...input.execution.requestedBy === undefined ? {} : { requestedBy: Object.freeze(structuredClone(input.execution.requestedBy)) },
-    executor: Object.freeze({
-      type: "agent",
-      ...input.actorId === undefined ? {} : { actorId: input.actorId },
-      runId: input.runId
-    }),
-    source: Object.freeze(structuredClone(input.execution.source)),
-    correlationId: input.execution.correlationId
-  });
-  return Object.freeze({
-    execution: context,
-    authorization: createAgentRuntimeAuthorization({
-      projectId: input.execution.projectId,
-      executionId: input.execution.id,
-      ...input.actorId === undefined ? {} : { actorId: input.actorId },
-      runId: input.runId,
-      authority: input.authorization.type === "principal" ? {
-        type: "principal",
-        context: input.authorization.context,
-        ...input.execution.authorizationRef.type === "principal" && input.execution.authorizationRef.credential !== undefined ? { credential: input.execution.authorizationRef.credential } : {}
-      } : { type: "disabled" }
-    })
-  });
-}
-function assertAgentExecutionRecord(input) {
-  const authority = input.execution.authorizationRef;
-  if (input.execution.executor.type !== "agent" || input.execution.executor.runId !== input.runId || input.execution.source.type !== "execution") {
-    invalidAgentExecution(input.execution.id, input.runId);
-  }
-  if (input.authorization.type === "disabled" || input.authorization.context.principal.type === "user") {
-    assertInheritedAgentAuthority(input.execution, input.runId, input.authorization);
-    return;
-  }
-  if (input.authorization.type !== "principal" || authority.type !== "principal" || authority.principal.type !== "serviceAccount" || input.authorization.context.principal.type !== "serviceAccount" || authority.principal.id !== input.authorization.context.principal.id || authority.credential !== undefined) {
-    invalidAgentExecution(input.execution.id, input.runId);
-  }
-  if (input.actorId === undefined) {
-    invalidAgentExecution(input.execution.id, input.runId);
-  }
-  assertAgentPrincipal(input.actorId, authority.principal);
-}
-function assertInheritedAgentAuthority(execution, runId, authorization) {
-  const authority = execution.authorizationRef;
-  if (authorization.type === "disabled") {
-    if (authority.type !== "disabled")
-      invalidAgentExecution(execution.id, runId);
-    return;
-  }
-  const principal = authorization.context.principal;
-  if (authority.type !== "principal" || authority.principal.type !== "user" || principal.type !== "user" || authority.principal.id !== principal.id || authority.credential === undefined || (authority.credential.type === "session" ? authorization.context.sessionId !== authority.credential.id : authorization.context.sessionId !== undefined)) {
-    invalidAgentExecution(execution.id, runId);
-  }
-}
-function assertAgentPrincipal(actorId, principal) {
-  const expectedId = agentServiceAccountId(actorId);
-  if (principal.id !== expectedId) {
-    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent '${actorId}' execution authority must reference service account '${expectedId}'.`);
-  }
-}
-function invalidAgentExecution(executionId, runId) {
-  throw new ExecutionStorageError("invalid_input", `[Sixb] Execution '${executionId}' does not authorize Agent run '${runId}'.`);
-}
-
-export { resolveAgentContextParts, agentRunQueueJobId, subagentRunQueueJobId, workflowAgentNodeQueueJobId, dispatchQueuedAgentRuns, dispatchQueuedSubagentRuns, createAgentThreadId, createAgentRunId, createSubagentRunId, createSubagentExecutionId, createAgentMessageId, agentContextCheckpointId, createAgentRunExecutionToken, assertNoAgentDefinitions, WorkflowDefinitionError, WorkflowValidationError, assertNonEmpty, isStepDefinition, isAgentStepDefinition, isInterventionDefinition, isWorkflowDefinition, validateWorkflowDefinition, validateWorkflowsAtStartup, validateWorkflowAgentStepGroupReferences, validateWorkflowInput, validateWorkflowStepInput, validateWorkflowStepOutput, validateWorkflowInterventionInput, validateWorkflowInterventionResponse, validateWorkflowInterventionDefaultResponse, validateWorkflowAgentStepInput, validateWorkflowAgentStepOutput, snapshotWorkflowAgentStepInput, snapshotWorkflowAgentStepOutput, snapshotWorkflowInput, snapshotWorkflowStepInput, snapshotWorkflowStepOutput, snapshotWorkflowInterventionInput, snapshotWorkflowInterventionResponse, snapshotWorkflowInterventionDefaultResponse, snapshotWorkflowActionInput, WorkflowRunDispatcher, requestWorkflowRun, createBoundSixb, isBoundSixb, canInheritAgentRequestAuthorization, createAgentExecutionRecord, createInheritedAgentExecutionRecord, bindDurableAgentExecution, restoreAgentExecutionScope, assertAgentExecutionRecord, requestAgentRun, retryAgentRun };
-
-//# debugId=00C5E0281CC5D43264756E2164756E21