@sixb/core 0.1.8 → 0.1.10

package/dist/{chunk-xajtptbw.js → chunk-5p1v802y.js}

@@ -1,139 +1,164 @@
 // @bun
 import {
-  SyncValidationError,
-  createConnectorRuntime,
-  requestSyncRun
-} from "./chunk-wtf06et8.js";
+  agentServiceAccountId2,
+  assertObjectReadOutputWithinLimit2,
+  createAgentRuntimeAuthorization,
+  resolveRuntimeAuthorizationForProject,
+  getAuthorizationRef,
+  resolveExecutionScopeAuthorization,
+  AuthorizationError2,
+  isAllowed2,
+  assertAuthorized2,
+  isRuntimeAllowed2,
+  assertCanManageConnector2,
+  assertPrivileged2,
+  assertProviderAccess2,
+  canViewEvent2,
+  canViewActionRun2,
+  canViewWorkflowRun2,
+  canViewWorkflowIntervention2,
+  canViewPipelineRun2,
+  canViewProjectionRun2,
+  canViewProjection2
+} from "./chunk-dz5h08xv.js";
 import {
-  aiLimitSubjectsFromAttribution,
-  aiUsageLimitExceededError,
-  aiUsageLimitUnavailableError,
-  applicableAiLimitPolicyStatuses
-} from "./chunk-c15dr03f.js";
+  captureSixbFailure2
+} from "./chunk-f4w3yp4f.js";
 import {
-  compileShareAccessPlan
-} from "./chunk-v4en4jc2.js";
+  isRecord2,
+  normalizeSchemaValue2,
+  coerceSchemaValueToTyped2,
+  assertObjectTypeRegistered2
+} from "./chunk-ms2tmn1k.js";
 import {
-  PipelineError,
-  requestPipelineRun
-} from "./chunk-w9tg6yyb.js";
+  isActionDefinition2,
+  SYSTEM_PRINCIPAL2,
+  principalsEqual2
+} from "./chunk-g00bfdq6.js";
 import {
-  appendTelemetry,
-  createObjectSet,
-  getLatestTelemetryPoint,
-  getTelemetryHistoryBatch,
-  listObjects,
-  removeLink1 as removeLink,
-  upsertLink1 as upsertLink,
-  upsertLinkBatch1 as upsertLinkBatch,
-  upsertObject1 as upsertObject,
-  upsertObjectBatch1 as upsertObjectBatch
-} from "./chunk-aa2pen2v.js";
+  isModelReasoning2,
+  modelReasoningSupportIssue2
+} from "./chunk-pqajwytd.js";
 import {
-  shareOntologyMutationRuntime
-} from "./chunk-xhy826cz.js";
+  RuntimeError2,
+  ModelProviderError2,
+  ModelStreamError2,
+  UnsupportedModelFeatureError2,
+  StructuredOutputError2,
+  estimateModelCall,
+  rateModelCall2
+} from "./chunk-e0d1rzef.js";
 import {
-  registerConnectorConnectionsRuntime
-} from "./chunk-nf4r78r4.js";
+  AgentStorageError2,
+  AGENT_REASONING_LEVELS2
+} from "./chunk-7bs40fe1.js";
+import {
+  ObjectNotFoundError2
+} from "./chunk-8vj0rjgs.js";
 import {
-  writeDataset
-} from "./chunk-359jm1jw.js";
+  ExecutionStorageError2
+} from "./chunk-93csa55g.js";
 import {
-  getDatasetPrimaryKeyColumns
-} from "./chunk-n4khvw9n.js";
+  WORKFLOW_RUN_FAILURE_CODES2
+} from "./chunk-p6a4npdx.js";
+import {
+  WorkflowRunError2
+} from "./chunk-pr2h4bv4.js";
 import {
   assertAuthorizedObjectReaderBinding,
-  canDelegationAccessActionRun,
   getAuthorizedOntologyView,
-  requestAction,
-  requestActionAndWait
-} from "./chunk-h5vqbfmd.js";
+  canDelegationAccessActionRun,
+  requestAction3,
+  requestActionAndWait2
+} from "./chunk-nmbxcaqx.js";
 import {
-  createPrimitiveExecutionRecord,
-  ensureExecutionRecord,
-  executionRecordInputFromRuntime
-} from "./chunk-k522z7v6.js";
+  shareSixbErrorReporter2,
+  reportRunFailure2
+} from "./chunk-7apz6hg4.js";
 import {
-  ObjectNotFoundError,
-  WORKFLOW_RUN_FAILURE_CODES
-} from "./chunk-sbzzr4kx.js";
+  aiLimitSubjectsFromAttribution2,
+  applicableAiLimitPolicyStatuses2,
+  aiUsageLimitExceededError2,
+  aiUsageLimitUnavailableError2
+} from "./chunk-0y39rgsb.js";
 import {
-  ShareGrantStorageError
-} from "./chunk-nx7k8tpr.js";
+  AgentRequestError2,
+  normalizeAgentContextEntries2
+} from "./chunk-dmn70ztd.js";
 import {
-  WorkflowRunError
-} from "./chunk-nn0tekr1.js";
+  publishAgentRunActivity2
+} from "./chunk-92vk7gta.js";
 import {
-  ExecutionStorageError
-} from "./chunk-rafagrwr.js";
+  registerConnectorConnectionsRuntime
+} from "./chunk-5a4a52tq.js";
 import {
-  AGENT_REASONING_LEVELS,
-  AgentStorageError
-} from "./chunk-p1rzczbt.js";
+  createConnectorRuntime
+} from "./chunk-v2vcg0w6.js";
 import {
-  RuntimeError
-} from "./chunk-p2vqaxkc.js";
+  writeDataset2
+} from "./chunk-mrp7k0pw.js";
 import {
-  isModelReasoning
-} from "./chunk-trxxmgnf.js";
+  shareOntologyMutationRuntime2
+} from "./chunk-85cd7e8c.js";
 import {
-  reportRunFailure,
-  shareSixbErrorReporter
-} from "./chunk-jq43kdvk.js";
+  compileShareAccessPlan
+} from "./chunk-awbhdqyc.js";
 import {
-  AgentRequestError,
-  normalizeAgentContextEntries
-} from "./chunk-5e3pq99w.js";
+  SyncValidationError2,
+  requestSyncRun2
+} from "./chunk-5c7ga8zz.js";
 import {
-  publishAgentRunActivity
-} from "./chunk-7y0f6rf1.js";
+  getTelemetryHistoryBatch2,
+  getLatestTelemetryPoint,
+  createObjectSet2,
+  upsertLink3,
+  upsertLinkBatch3,
+  removeLink3,
+  listObjects,
+  upsertObject3,
+  upsertObjectBatch3,
+  appendTelemetry
+} from "./chunk-976rxdpx.js";
 import {
-  SYSTEM_PRINCIPAL,
-  isActionDefinition,
-  principalsEqual
-} from "./chunk-4sm0aznx.js";
+  schemaRecordToJsonSchema2
+} from "./chunk-7zgecwy1.js";
 import {
-  snapshotRequesterGroupIds
-} from "./chunk-4a849fr1.js";
+  PipelineError2,
+  requestPipelineRun2
+} from "./chunk-b0ec55a1.js";
 import {
-  isObjectRefSchema,
-  validateSchemaOrRefValue
-} from "./chunk-2dw777qw.js";
+  requireAccountingCapabilities,
+  aiModelCallOutputTokenAllowance,
+  createAiModelCallLimitController2,
+  AiModelCallRecorder2,
+  enqueueAiModelCallRecovery2,
+  resolveLanguageModel2
+} from "./chunk-28ja2cjs.js";
 import {
-  AuthorizationError,
-  agentServiceAccountId,
-  assertAuthorized,
-  assertCanManageConnector,
-  assertObjectReadOutputWithinLimit,
-  assertPrivileged,
-  assertProviderAccess,
-  canViewActionRun,
-  canViewEvent,
-  canViewPipelineRun,
-  canViewProjection,
-  canViewProjectionRun,
-  canViewWorkflowIntervention,
-  canViewWorkflowRun,
-  createAgentRuntimeAuthorization,
-  getAuthorizationRef,
-  isAllowed,
-  isRuntimeAllowed,
-  resolveExecutionScopeAuthorization,
-  resolveRuntimeAuthorizationForProject
-} from "./chunk-p1x242ad.js";
+  getDatasetPrimaryKeyColumns2
+} from "./chunk-9qsh3p5y.js";
+import {
+  executionRecordInputFromRuntime,
+  ensureExecutionRecord2,
+  createPrimitiveExecutionRecord
+} from "./chunk-17kfctj6.js";
 import {
-  assertObjectTypeRegistered
-} from "./chunk-h0k55pc7.js";
+  ShareGrantStorageError2
+} from "./chunk-br3k6qbf.js";
 import {
-  supportsDirectUpload,
-  supportsRangeRead
-} from "./chunk-08m3b6w8.js";
+  isObjectRefSchema2,
+  validateSchemaOrRefValue2
+} from "./chunk-f0rwz2vh.js";
 import {
-  captureSixbFailure
-} from "./chunk-2xns679x.js";
+  supportsDirectUpload2,
+  supportsRangeRead2
+} from "./chunk-h3v76ams.js";
 import {
+  isJsonValue2,
+  assertJsonValue2,
+  assertJsonObject2,
   isPlainRecord
-} from "./chunk-n6jxh8sw.js";
+} from "./chunk-wy0qdqfm.js";
 
 // src/actions/descriptor.ts
 function snapshotActionDescriptor(action) {
@@ -185,14 +210,14 @@ function createActionsRuntime(runtime, execution) {
     }
     if (authorization.type === "unrestricted")
       return true;
-    return isAllowed(authorization.context, { kind: "action.apply", actionId: action.id }) && (action.binding.kind === "global" || isAllowed(authorization.context, {
+    return isAllowed2(authorization.context, { kind: "action.apply", actionId: action.id }) && (action.binding.kind === "global" || isAllowed2(authorization.context, {
       kind: "object.view",
       objectTypeId: action.binding.objectType.id
     }));
   };
   const release = (value) => {
     if (authorization.type === "delegated") {
-      assertObjectReadOutputWithinLimit(value, authorization.objectRead.limits);
+      assertObjectReadOutputWithinLimit2(value, authorization.objectRead.limits);
     }
     return value;
   };
@@ -205,8 +230,8 @@ function createActionsRuntime(runtime, execution) {
     },
     listGlobal: () => describeAll(runtime.actionRegistry.listGlobal()),
     listForType: (objectType) => describeAll(runtime.actionRegistry.listForType(objectType).filter((action) => authorization.type !== "delegated" || action.binding.kind === "object" && action.binding.objectType.id === objectType.id)),
-    request: (input) => requestAction(runtime, execution, input),
-    requestAndWait: (input) => requestActionAndWait(runtime, execution, input),
+    request: (input) => requestAction3(runtime, execution, input),
+    requestAndWait: (input) => requestActionAndWait2(runtime, execution, input),
     runs: {
       getById: async (runId) => {
         if (authorization.type === "denied" || authorization.type === "delegated" && (!authorization.delegation || authorization.actionApply.length === 0))
@@ -215,7 +240,7 @@ function createActionsRuntime(runtime, execution) {
           projectId,
           id: runId
         }) ?? null;
-        return run && (authorization.type === "unrestricted" || authorization.type === "principal" && canViewActionRun(authorization.context, run) || authorization.type === "delegated" && await canDelegationAccessActionRun({
+        return run && (authorization.type === "unrestricted" || authorization.type === "principal" && canViewActionRun2(authorization.context, run) || authorization.type === "delegated" && await canDelegationAccessActionRun({
           storage: runtime.storage,
           projectId,
           authority: authorization,
@@ -271,26 +296,26 @@ async function resolveExecutionUsage(input) {
 
 // src/agents/ids.ts
 import { createHash, randomUUID } from "crypto";
-function createAgentThreadId() {
+function createAgentThreadId2() {
   return `agt_thr_${randomUUID()}`;
 }
-function createAgentRunId() {
+function createAgentRunId2() {
   return `agt_run_${randomUUID()}`;
 }
-function createSubagentRunId(parentRunId, spawnKey) {
+function createSubagentRunId2(parentRunId, spawnKey) {
   const digest = createHash("sha256").update(parentRunId).update("\x00").update(spawnKey).digest("hex");
   return `agt_run_child_${digest}`;
 }
-function createSubagentExecutionId(runId) {
+function createSubagentExecutionId2(runId) {
   return `exec_${runId}`;
 }
-function createAgentMessageId() {
+function createAgentMessageId2() {
   return `agt_msg_${randomUUID()}`;
 }
-function agentContextCheckpointId(runId) {
+function agentContextCheckpointId2(runId) {
   return `agt_ctx_${runId}`;
 }
-function createAgentRunExecutionToken() {
+function createAgentRunExecutionToken2() {
   return `agt_exec_${randomUUID()}`;
 }
 
@@ -298,8 +323,8 @@ function createAgentRunExecutionToken() {
 import { randomUUID as randomUUID2 } from "crypto";
 
 // src/agents/context-resolution.ts
-async function resolveAgentContextParts(runtime, input) {
-  const entries = normalizeAgentContextEntries(input);
+async function resolveAgentContextParts2(runtime, input) {
+  const entries = normalizeAgentContextEntries2(input);
   for (const entry of entries) {
     if (entry.context.kind !== "object")
       continue;
@@ -320,20 +345,20 @@ async function resolveAgentContextParts(runtime, input) {
   return entries.map((entry) => ({ type: "context", ...entry }));
 }
 function invalidContext(message) {
-  throw new AgentRequestError("invalid_context", `[Sixb] Invalid agent context: ${message}.`);
+  throw new AgentRequestError2("invalid_context", `[Sixb] Invalid agent context: ${message}.`);
 }
 
 // src/agents/dispatch.ts
-function agentRunQueueJobId(runId) {
+function agentRunQueueJobId2(runId) {
   return `agt_job_${runId}`;
 }
-function subagentRunQueueJobId(runId) {
+function subagentRunQueueJobId2(runId) {
   return `agt_child_job_${runId}`;
 }
-function workflowAgentNodeQueueJobId(nodeRunId) {
+function workflowAgentNodeQueueJobId2(nodeRunId) {
   return `wfa_job_${nodeRunId}`;
 }
-async function dispatchQueuedAgentRuns(input) {
+async function dispatchQueuedAgentRuns2(input) {
   const limit = normalizeLimit(input.limit);
   const runs = input.runIds ? await input.storage.runs.getByIds({
     projectId: input.projectId,
@@ -353,14 +378,14 @@ async function dispatchQueuedAgentRuns(input) {
     const jobs = await input.queue.enqueue({
       projectId: input.projectId,
       jobs: queued.map((run) => ({
-        id: agentRunQueueJobId(run.id),
+        id: agentRunQueueJobId2(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);
+      const jobId = agentRunQueueJobId2(run.id);
       if (!jobsById.has(jobId)) {
         throw new Error(`[Sixb] Agent queue did not return job '${jobId}'.`);
       }
@@ -375,7 +400,7 @@ async function dispatchQueuedAgentRuns(input) {
     };
   }
 }
-async function dispatchQueuedSubagentRuns(input) {
+async function dispatchQueuedSubagentRuns2(input) {
   const limit = normalizeLimit(input.limit);
   const runs = input.runIds ? await input.storage.runs.getByIds({
     projectId: input.projectId,
@@ -394,14 +419,14 @@ async function dispatchQueuedSubagentRuns(input) {
     const jobs = await input.queue.enqueue({
       projectId: input.projectId,
       jobs: queued.map((run) => ({
-        id: subagentRunQueueJobId(run.id),
+        id: subagentRunQueueJobId2(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);
+      const jobId = subagentRunQueueJobId2(run.id);
       if (!jobsById.has(jobId)) {
         throw new Error(`[Sixb] Subagent queue did not return job '${jobId}'.`);
       }
@@ -428,37 +453,32 @@ function normalizeLimit(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.");
+    throw new RuntimeError2("[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.");
+    throw new AgentRequestError2("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) {
+async function requestAgentRun2(runtime, execution, models, input) {
   const authority = resolveExecutionScopeAuthorization(runtime.projectId, {
     execution,
     authorization: runtime.runtimeAuthorization
   });
   assertNoAgentSelector(input);
-  assertAuthorized(runtime, { kind: "agent.run" });
+  assertAuthorized2(runtime, { kind: "agent.run" });
   assertRequestAuthorityCanRunAgent(runtime);
   const spec = resolveConversationRunSpec({ models, input });
-  const contextParts = await resolveAgentContextParts(runtime, input.context);
+  const contextParts = await resolveAgentContextParts2(runtime, input.context);
   const agents = requireAgentStorage(runtime);
   const projectId = runtime.projectId;
-  const principal = authority.type === "principal" ? authority.context.principal : input.principal ?? SYSTEM_PRINCIPAL;
-  const runId = createAgentRunId();
+  const principal = authority.type === "principal" ? authority.context.principal : input.principal ?? SYSTEM_PRINCIPAL2;
+  const runId = createAgentRunId2();
   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);
+  await assertAiLimitPreflight(runtime, durableExecution);
   const { thread, createdThread } = await resolveThread(agents, {
     projectId,
     threadId: input.threadId,
@@ -466,18 +486,18 @@ async function requestAgentRun(runtime, execution, models, input) {
     principal
   });
   if (thread.activeRunId !== null) {
-    throw new AgentRequestError("active_run_exists", `[Sixb] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
+    throw new AgentRequestError2("active_run_exists", `[Sixb] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
   }
-  const triggerMessageId = input.messageId ?? createAgentMessageId();
+  const triggerMessageId = input.messageId ?? createAgentMessageId2();
   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.");
+      const agents = tx.agents;
+      if (!agents) {
+        throw new AgentRequestError2("storage_unavailable", "[Sixb] Agent storage is not configured.");
       }
       await tx.executions.create(durableExecution);
-      await agents2.messages.append({
+      await agents.messages.append({
         id: triggerMessageId,
         projectId,
         threadId: thread.id,
@@ -490,19 +510,18 @@ async function requestAgentRun(runtime, execution, models, input) {
         ],
         authorPrincipal: principal
       });
-      return agents2.runs.create({
+      return agents.runs.create({
         id: runId,
         projectId,
         executionId: durableExecution.id,
         threadId: thread.id,
         triggerMessageId,
-        spec,
-        requesterGroupIds
+        spec
       });
     });
   } catch (error) {
-    if (error instanceof AgentStorageError && error.code === "active_run_exists") {
-      throw new AgentRequestError("active_run_exists", error.message);
+    if (error instanceof AgentStorageError2 && error.code === "active_run_exists") {
+      throw new AgentRequestError2("active_run_exists", error.message);
     }
     throw error;
   }
@@ -514,15 +533,15 @@ async function requestAgentRun(runtime, execution, models, input) {
     createdThread
   };
 }
-async function retryAgentRun(runtime, execution, models, failedRun) {
+async function retryAgentRun2(runtime, execution, models, failedRun) {
   resolveExecutionScopeAuthorization(runtime.projectId, {
     execution,
     authorization: runtime.runtimeAuthorization
   });
-  assertAuthorized(runtime, { kind: "agent.run" });
+  assertAuthorized2(runtime, { kind: "agent.run" });
   assertRequestAuthorityCanRunAgent(runtime);
   if (failedRun.status !== "failed") {
-    throw new AgentRequestError("run_not_retryable", `[Sixb] Only failed Agent runs can be retried.`);
+    throw new AgentRequestError2("run_not_retryable", `[Sixb] Only failed Agent runs can be retried.`);
   }
   const agents = requireAgentStorage(runtime);
   const thread = await agents.threads.getById({
@@ -530,28 +549,23 @@ async function retryAgentRun(runtime, execution, models, failedRun) {
     id: failedRun.threadId
   });
   if (!thread) {
-    throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${failedRun.threadId}' was not found.`);
+    throw new AgentRequestError2("thread_not_found", `[Sixb] Agent thread '${failedRun.threadId}' was not found.`);
   }
-  const runId = createAgentRunId();
+  const runId = createAgentRunId2();
   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);
+  await assertAiLimitPreflight(runtime, durableExecution);
   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.");
+    const agents = tx.agents;
+    if (!agents) {
+      throw new AgentRequestError2("storage_unavailable", "[Sixb] Agent storage is not configured.");
     }
-    await agents2.messages.deleteByRunId({
+    await agents.messages.deleteByRunId({
       projectId: runtime.projectId,
       threadId: failedRun.threadId,
       runId: failedRun.id
     });
     await tx.executions.create(durableExecution);
-    return agents2.runs.create({
+    return agents.runs.create({
       id: runId,
       projectId: runtime.projectId,
       executionId: durableExecution.id,
@@ -560,47 +574,46 @@ async function retryAgentRun(runtime, execution, models, failedRun) {
       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) {
+async function assertAiLimitPreflight(runtime, execution) {
   const limits = runtime.storage.aiLimits;
   if (!limits)
-    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
-  const subjects = aiLimitSubjectsFromAttribution(execution.requestedBy, requesterGroupIds);
+    throw aiUsageLimitUnavailableError2(["limitStorageUnavailable"]);
+  const subjects = aiLimitSubjectsFromAttribution2(execution.requestedBy, execution.requesterGroupIds);
   let applicable;
   try {
-    applicable = applicableAiLimitPolicyStatuses(await limits.listPolicyStatuses({ projectId: runtime.projectId }), subjects);
+    applicable = applicableAiLimitPolicyStatuses2(await limits.listPolicyStatuses({ projectId: runtime.projectId }), subjects);
   } catch {
-    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
+    throw aiUsageLimitUnavailableError2(["limitStorageUnavailable"]);
   }
   const unavailable = applicable.filter((status) => status.accountingStatus === "unavailable");
   if (unavailable.length > 0) {
-    throw aiUsageLimitUnavailableError(["incompleteAccounting"]);
+    throw aiUsageLimitUnavailableError2(["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);
+    throw aiUsageLimitExceededError2(resetAt);
   }
 }
 function resolveConversationRunSpec(input) {
   if (!input.models) {
-    throw new AgentRequestError("model_not_found", "[Sixb] Configure models.language before starting the Agent.");
+    throw new AgentRequestError2("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.`);
+    throw new AgentRequestError2("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.`);
+  if (reasoning !== undefined && !isModelReasoning2(reasoning)) {
+    throw new AgentRequestError2("invalid_model_selection", `[Sixb] Agent reasoning must be one of: ${AGENT_REASONING_LEVELS2.join(", ")}, or a nonnegative budgetTokens object.`);
   }
   return Object.freeze({
     model: Object.freeze({ provider: selected.provider, modelId: selected.modelId }),
@@ -608,24 +621,24 @@ function resolveConversationRunSpec(input) {
   });
 }
 async function prepareDurableAgentExecution(runtime, execution, runId) {
-  const parent = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
+  const parent = await ensureExecutionRecord2(runtime.storage.executions, executionRecordInputFromRuntime({
     execution,
     runtimeAuthorization: runtime.runtimeAuthorization
   }));
-  return createInheritedAgentExecutionRecord({
+  return createInheritedAgentExecutionRecord2({
     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.");
+  if (!canInheritAgentRequestAuthorization2(runtime.runtimeAuthorization)) {
+    throw new AgentRequestError2("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({
+    const dispatch = await dispatchQueuedAgentRuns2({
       projectId: runtime.projectId,
       storage: agents,
       queue: runtime.queues.agents,
@@ -643,7 +656,7 @@ async function dispatchAgentRun(runtime, agents, runId) {
 }
 async function publishRunActivity(runtime, run) {
   try {
-    await publishAgentRunActivity(runtime.broker, run);
+    await publishAgentRunActivity2(runtime.broker, run);
   } catch (error) {
     console.error(`[Sixb] Agent run '${run.id}' activity stream publish failed:`, error);
   }
@@ -659,7 +672,7 @@ async function resolveThread(agents, params) {
     }
   }
   const thread = await agents.threads.create({
-    id: params.threadId ?? createAgentThreadId(),
+    id: params.threadId ?? createAgentThreadId2(),
     projectId: params.projectId,
     ownerPrincipal: params.principal,
     ...params.title === undefined ? {} : { title: params.title }
@@ -669,7 +682,7 @@ async function resolveThread(agents, params) {
 function requireAgentStorage(runtime) {
   const agents = runtime.storage.agents;
   if (!agents) {
-    throw new AgentRequestError("storage_unavailable", "[Sixb] Agent storage is not configured.");
+    throw new AgentRequestError2("storage_unavailable", "[Sixb] Agent storage is not configured.");
   }
   return agents;
 }
@@ -677,8 +690,8 @@ function requireAgentStorage(runtime) {
 // src/agents/execution.ts
 function createAgentRuntime(runtime, execution, models) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
-  const principal = authority.type === "principal" ? authority.context.principal : SYSTEM_PRINCIPAL;
-  const allowed = () => isRuntimeAllowed(runtime, { kind: "agent.run" });
+  const principal = authority.type === "principal" ? authority.context.principal : SYSTEM_PRINCIPAL2;
+  const allowed = () => isRuntimeAllowed2(runtime, { kind: "agent.run" });
   const getVisibleThreadRecord = async (threadId) => {
     if (authority.type === "denied" || authority.type === "delegated")
       return null;
@@ -688,7 +701,7 @@ function createAgentRuntime(runtime, execution, models) {
     }) ?? null;
     if (!thread || !allowed())
       return null;
-    return authority.type === "principal" && !principalsEqual(principal, thread.ownerPrincipal) ? null : thread;
+    return authority.type === "principal" && !principalsEqual2(principal, thread.ownerPrincipal) ? null : thread;
   };
   const getAgent = () => {
     if (authority.type === "denied" || authority.type === "delegated")
@@ -724,14 +737,14 @@ function createAgentRuntime(runtime, execution, models) {
         assertNoAgentSelector(input);
         const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
+          throw new AgentRequestError2("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.");
+          throw new AgentRequestError2("storage_unavailable", "[Sixb] Agent storage is not configured.");
         }
         return storage.threads.create({
-          id: input.id ?? createAgentThreadId(),
+          id: input.id ?? createAgentThreadId2(),
           projectId: runtime.projectId,
           ownerPrincipal: principal,
           ...input.title === undefined ? {} : { title: input.title }
@@ -758,13 +771,13 @@ function createAgentRuntime(runtime, execution, models) {
         assertNoAgentSelector(input);
         const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
+          throw new AgentRequestError2("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
-        assertAuthorized(runtime, { kind: "agent.run" });
+        assertAuthorized2(runtime, { kind: "agent.run" });
         if (input.threadId && !await getVisibleThreadRecord(input.threadId)) {
-          throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found.`);
+          throw new AgentRequestError2("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found.`);
         }
-        const result = await requestAgentRun(runtime, execution, models?.language, {
+        const result = await requestAgentRun2(runtime, execution, models?.language, {
           ...input,
           principal
         });
@@ -773,13 +786,13 @@ function createAgentRuntime(runtime, execution, models) {
       retry: async (runId) => {
         const failedRun = await getVisibleRunRecord(runId);
         if (!failedRun) {
-          throw new AgentRequestError("run_not_found", `[Sixb] Agent run '${runId}' was not found.`);
+          throw new AgentRequestError2("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.");
+          throw new AgentRequestError2("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
-        const result = await retryAgentRun(runtime, execution, models?.language, failedRun);
+        const result = await retryAgentRun2(runtime, execution, models?.language, failedRun);
         return { ...result, run: await attachRunView(runtime, result.run) };
       },
       getById: getRun,
@@ -844,10 +857,10 @@ async function attachRunViews(runtime, runs) {
 // 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 assertObservable = () => assertAuthorized2(runtime, { kind: "aiUsage.observe" });
+  const assertManageable = () => assertAuthorized2(runtime, { kind: "aiUsage.manage" });
   const assertPolicyReadable = () => {
-    if (!isRuntimeAllowed(runtime, { kind: "aiUsage.observe" }) && !isRuntimeAllowed(runtime, { kind: "aiUsage.manage" })) {
+    if (!isRuntimeAllowed2(runtime, { kind: "aiUsage.observe" }) && !isRuntimeAllowed2(runtime, { kind: "aiUsage.manage" })) {
       assertObservable();
     }
   };
@@ -868,7 +881,7 @@ function createAiUsageRuntime(runtime, security) {
     limitsConfigured: runtime.storage.aiLimits !== undefined,
     assertObservable,
     assertManageable,
-    canManageLimits: () => isRuntimeAllowed(runtime, { kind: "aiUsage.manage" }),
+    canManageLimits: () => isRuntimeAllowed2(runtime, { kind: "aiUsage.manage" }),
     queryOverview: (input) => {
       assertObservable();
       return requireCosts().queryProjectOverview({ ...input, projectId: runtime.projectId });
@@ -943,7 +956,7 @@ function createAiUsageRuntime(runtime, security) {
 }
 // src/blob-storage/execution.ts
 function createBlobsRuntime(runtime, execution, blobStorage) {
-  const assertAccess = () => assertProviderAccess(runtime, execution, "blobs.access");
+  const assertAccess = () => assertProviderAccess2(runtime, execution, "blobs.access");
   const executionBlobs = {
     put: (input) => {
       assertAccess();
@@ -958,13 +971,13 @@ function createBlobsRuntime(runtime, execution, blobStorage) {
       return blobStorage.stat(blobId);
     }
   };
-  if (supportsRangeRead(blobStorage)) {
+  if (supportsRangeRead2(blobStorage)) {
     executionBlobs.openRange = (blobId, range) => {
       assertAccess();
       return blobStorage.openRange(blobId, range);
     };
   }
-  if (supportsDirectUpload(blobStorage)) {
+  if (supportsDirectUpload2(blobStorage)) {
     executionBlobs.createUpload = (input) => {
       assertAccess();
       return blobStorage.createUpload(input);
@@ -1010,12 +1023,12 @@ function commandContext(runtime, execution, connectorId) {
     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.");
+    throw new AuthorizationError2(`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.");
+    throw new AuthorizationError2(`manage:connector:${connectorId}`, "[Sixb] Connector connection management requires a session or access token.");
   }
-  assertCanManageConnector(runtime, connectorId);
+  assertCanManageConnector2(runtime, connectorId);
   return Object.freeze({
     execution: Object.freeze(executionRecordInputFromRuntime({
       execution,
@@ -1027,7 +1040,7 @@ function commandContext(runtime, execution, connectorId) {
 // src/datasets/execution.ts
 function createDatasetsRuntime(runtime, execution, source, lakeStorage, blobStorage) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
-  const allowed = (datasetId) => isRuntimeAllowed(runtime, { kind: "dataset.view", datasetId });
+  const allowed = (datasetId) => isRuntimeAllowed2(runtime, { kind: "dataset.view", datasetId });
   return {
     list: () => authority.type === "denied" || authority.type === "delegated" ? [] : source.list().filter((dataset) => allowed(dataset.id)),
     getById: (datasetId) => {
@@ -1037,18 +1050,18 @@ function createDatasetsRuntime(runtime, execution, source, lakeStorage, blobStor
       return dataset && allowed(datasetId) ? dataset : null;
     },
     async ingest(dataset, input) {
-      assertPrivileged(runtime, "datasets.ingest");
+      assertPrivileged2(runtime, "datasets.ingest");
       const registered = source.getById(dataset.id);
       if (!registered)
         throw new Error(`[Sixb] Dataset '${dataset.id}' is not registered.`);
-      if (getDatasetPrimaryKeyColumns(registered) === null) {
+      if (getDatasetPrimaryKeyColumns2(registered) === null) {
         throw new Error(`[Sixb] Dataset '${dataset.id}' must define a primaryKey before ingestion.`);
       }
       if (typeof lakeStorage.beginMerge !== "function") {
         throw new Error("[Sixb] Dataset ingestion requires a lake provider with merge support.");
       }
       const producer = { kind: "ingest", id: execution.id };
-      const result = await writeDataset({
+      const result = await writeDataset2({
         lakeStorage,
         blobStorage,
         dataset: registered,
@@ -1090,7 +1103,7 @@ function createEventsRuntime(runtime) {
       case "delegated":
         return [];
       case "principal":
-        return events.filter((event) => canViewEvent(authority.context, event));
+        return events.filter((event) => canViewEvent2(authority.context, event));
       case "unrestricted":
         return [...events];
     }
@@ -1102,17 +1115,17 @@ function createEventsRuntime(runtime) {
         case "delegated":
           return false;
         case "principal":
-          return canViewEvent(authority.context, event);
+          return canViewEvent2(authority.context, event);
         case "unrestricted":
           return true;
       }
     },
     append: (input) => {
-      assertPrivileged(runtime, "events.append");
+      assertPrivileged2(runtime, "events.append");
       return runtime.events.append(input);
     },
     emit: (input, options) => {
-      assertPrivileged(runtime, "events.emit");
+      assertPrivileged2(runtime, "events.emit");
       return runtime.events.emit(input, options);
     },
     read: async (input) => {
@@ -1149,7 +1162,7 @@ function createEventsRuntime(runtime) {
       return runtime.events.subscribe(input, (events) => {
         const visible = visibleEvents(events);
         if (visible.length > 0)
-          handler(visible);
+          return handler(visible);
       });
     }
   };
@@ -1157,7 +1170,7 @@ function createEventsRuntime(runtime) {
 
 // src/logging/execution.ts
 function createLogsRuntime(runtime, source) {
-  const assertObservable = () => assertAuthorized(runtime, { kind: "logs.observe" });
+  const assertObservable = () => assertAuthorized2(runtime, { kind: "logs.observe" });
   return {
     assertObservable,
     read: (input) => {
@@ -1171,6 +1184,949 @@ function createLogsRuntime(runtime, source) {
   };
 }
 
+// src/agents/model-loop.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var MAX_PROVIDER_DATA_BYTES = 256 * 1024;
+async function runModelLoop2(input) {
+  assertLoopInput(input);
+  const tools = indexTools(input.tools ?? []);
+  const toolSpecifications = [...tools.values()].map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+  let messages = [...input.messages];
+  const steps = [];
+  const generateCallId = input.generateCallId ?? (() => `model_call_${randomUUID4()}`);
+  const callIds = new Set;
+  for (let stepIndex = 0;stepIndex < input.maxSteps; stepIndex += 1) {
+    if (input.signal.aborted) {
+      return { status: "aborted", steps, partialContent: [] };
+    }
+    await input.onEvent?.({ type: "start-step" });
+    let requestMessages;
+    try {
+      const prepared = await input.prepareStep?.({
+        stepIndex,
+        messages,
+        model: input.model,
+        signal: input.signal
+      });
+      requestMessages = prepared?.messages ?? messages;
+    } catch (error) {
+      if (!input.signal.aborted && !isAbortError(error))
+        throw error;
+      return { status: "aborted", steps, partialContent: [] };
+    }
+    if (input.signal.aborted) {
+      return { status: "aborted", steps, partialContent: [] };
+    }
+    let requestTools = toolSpecifications;
+    if (input.finalStepInstruction !== undefined && stepIndex === input.maxSteps - 1) {
+      requestMessages = [
+        ...requestMessages,
+        { role: "user", content: [{ type: "text", text: input.finalStepInstruction }] }
+      ];
+      requestTools = [];
+    }
+    const callId = generateCallId();
+    if (!callId || callIds.has(callId)) {
+      throw new ModelStreamError2(`[SixbModels] Model call IDs must be nonempty and unique.`);
+    }
+    callIds.add(callId);
+    const accumulator = new StreamAccumulator(input.onEvent);
+    let accepted = false;
+    let cost = { status: "unpriceable", reason: "missing-usage" };
+    let terminalStreamError;
+    try {
+      const stream = await input.model.stream({
+        callId,
+        messages: requestMessages,
+        tools: requestTools,
+        ...input.reasoning === undefined ? {} : { reasoning: input.reasoning },
+        ...input.maxOutputTokens === undefined ? {} : { maxOutputTokens: input.maxOutputTokens },
+        ...input.caching === undefined ? {} : { caching: input.caching },
+        ...input.output === undefined ? {} : {
+          responseFormat: {
+            type: "json",
+            name: input.output.name,
+            ...input.output.description === undefined ? {} : { description: input.output.description },
+            schema: input.output.schema
+          }
+        },
+        signal: input.signal
+      });
+      accepted = true;
+      for await (const event of stream.events) {
+        await accumulator.accept(event);
+      }
+    } catch (error) {
+      const aborted = input.signal.aborted || isAbortError(error);
+      if (accumulator.isFinished()) {
+        if (!aborted)
+          terminalStreamError = { error };
+      } else if (!aborted) {
+        throw error;
+      } else {
+        return {
+          status: "aborted",
+          steps,
+          partialContent: accumulator.partialContent()
+        };
+      }
+    } finally {
+      if (accepted) {
+        const facts = accumulator.accounting();
+        const estimate = accumulator.isFinished() ? estimateModelCall(input.model, facts) : cost;
+        cost = facts.reportedCost ? rateModelCall2({ usage: facts.usage, reported: facts.reportedCost }) : estimate;
+        await input.onModelCallEnd?.({
+          callId,
+          providerId: input.model.providerId,
+          modelId: input.model.modelId,
+          responseId: facts.responseId ?? `${callId}:response`,
+          providerIds: facts.providerIds,
+          responseModelId: facts.responseModelId,
+          usage: facts.usage,
+          cost,
+          ...facts.reportedCost === undefined ? {} : { estimate },
+          ...input.reasoning === undefined ? {} : { requestedReasoning: input.reasoning },
+          ...facts.route === undefined ? {} : { route: facts.route }
+        });
+      }
+    }
+    if (input.signal.aborted && !accumulator.isFinished()) {
+      return { status: "aborted", steps, partialContent: accumulator.partialContent() };
+    }
+    const response = accumulator.complete();
+    const responseId = response.responseId ?? `${callId}:response`;
+    if (terminalStreamError)
+      throw terminalStreamError.error;
+    if (response.projectionError)
+      throw response.projectionError;
+    if (input.signal.aborted) {
+      return { status: "aborted", steps, partialContent: response.content };
+    }
+    const localCalls = response.toolCalls.filter((call) => call.part.providerExecuted !== true);
+    if (input.rejectLocalToolCalls && (localCalls.length > 0 || response.finishReason === "tool-calls")) {
+      throw new ModelStreamError2("[SixbModels] Direct generation cannot continue local tool calls.");
+    }
+    if (response.finishReason === "pause" && localCalls.length === 0) {
+      const step = modelStep(response, responseId, response.content, cost);
+      steps.push(step);
+      await input.onStepEnd?.(step);
+      messages = [...requestMessages, { role: "assistant", content: response.content }];
+      if (stepIndex + 1 === input.maxSteps) {
+        throw new ModelStreamError2("[SixbModels] Model reached the step limit while a provider continuation was pending.");
+      }
+      continue;
+    }
+    if (localCalls.length === 0) {
+      const step = modelStep(response, responseId, response.content, cost);
+      steps.push(step);
+      await input.onStepEnd?.(step);
+      if (input.output) {
+        const text = responseText(response);
+        if (response.finishReason !== "stop") {
+          throw new StructuredOutputError2(`[SixbModels] Structured output did not complete successfully (${response.finishReason}).`, structuredOutputErrorContext(input, response, responseId, cost, text));
+        }
+        let raw;
+        try {
+          raw = JSON.parse(text);
+        } catch (error) {
+          throw new StructuredOutputError2("[SixbModels] Model did not produce valid JSON output.", {
+            cause: error,
+            ...structuredOutputErrorContext(input, response, responseId, cost, text)
+          });
+        }
+        try {
+          return {
+            status: "completed",
+            output: input.output.validate(raw),
+            steps,
+            finishReason: response.finishReason
+          };
+        } catch (error) {
+          throw new StructuredOutputError2("[SixbModels] Structured output validation failed.", {
+            cause: error,
+            ...structuredOutputErrorContext(input, response, responseId, cost, text)
+          });
+        }
+      }
+      const output = responseText(response);
+      return { status: "completed", output, steps, finishReason: response.finishReason };
+    }
+    const toolResults = await Promise.all(localCalls.map((call) => executeToolCall(call, tools, callId, input.signal, input.onEvent)));
+    const step = modelStep(response, responseId, [...response.content, ...toolResults], cost);
+    steps.push(step);
+    await input.onStepEnd?.(step);
+    if (input.signal.aborted) {
+      return {
+        status: "aborted",
+        steps,
+        partialContent: []
+      };
+    }
+    const assistantContent = response.content.filter((part) => part.type !== "tool-result" || part.providerExecuted === true);
+    messages = [
+      ...requestMessages,
+      { role: "assistant", content: assistantContent },
+      { role: "tool", content: toolResults }
+    ];
+    if (stepIndex + 1 === input.maxSteps) {
+      if (input.output) {
+        throw new StructuredOutputError2("[SixbModels] Model reached the step limit without structured output.", structuredOutputErrorContext(input, response, responseId, cost, responseText(response)));
+      }
+      const output = responseText(response);
+      return { status: "completed", output, steps, finishReason: response.finishReason };
+    }
+  }
+  throw new ModelStreamError2("[SixbModels] Model loop exited without a terminal result.");
+}
+function assertLoopInput(input) {
+  if (input.maxOutputTokens !== undefined && (!Number.isSafeInteger(input.maxOutputTokens) || input.maxOutputTokens <= 0)) {
+    throw new TypeError("[SixbModels] maxOutputTokens must be a positive safe integer.");
+  }
+  if (!Number.isInteger(input.maxSteps) || input.maxSteps <= 0) {
+    throw new TypeError("[SixbModels] maxSteps must be a positive integer.");
+  }
+  if (!input.model.providerId.trim() || !input.model.modelId.trim()) {
+    throw new TypeError("[SixbModels] Model providerId and modelId must not be empty.");
+  }
+  if (input.model.definition.providerId !== input.model.providerId || input.model.definition.modelId !== input.model.modelId) {
+    throw new TypeError(`[SixbModels] Model definition for '${input.model.providerId}/${input.model.modelId}' has a different identity.`);
+  }
+  if (input.output) {
+    if (!input.output.name.trim()) {
+      throw new TypeError("[SixbModels] Structured output names must not be empty.");
+    }
+    assertJsonObject2(input.output.schema, "structured output schema");
+  }
+}
+function indexTools(tools) {
+  const result = new Map;
+  for (const tool of tools) {
+    if (!tool.name.trim())
+      throw new TypeError("[SixbModels] Tool names must not be empty.");
+    if (result.has(tool.name)) {
+      throw new TypeError(`[SixbModels] Duplicate tool name '${tool.name}'.`);
+    }
+    assertJsonObject2(tool.inputSchema, `tool '${tool.name}' input schema`);
+    result.set(tool.name, tool);
+  }
+  return result;
+}
+function responseText(response) {
+  return response.content.filter((part) => part.type === "text").map((part) => part.text).join("");
+}
+function structuredOutputErrorContext(input, response, responseId, cost, text) {
+  return {
+    text,
+    providerId: input.model.providerId,
+    modelId: input.model.modelId,
+    responseId,
+    ...response.responseModelId === undefined ? {} : { responseModelId: response.responseModelId },
+    finishReason: response.finishReason,
+    usage: response.usage,
+    cost
+  };
+}
+function modelStep(response, responseId, content, cost) {
+  return {
+    content,
+    finishReason: response.finishReason,
+    ...response.rawFinishReason === undefined ? {} : { rawFinishReason: response.rawFinishReason },
+    usage: response.usage,
+    responseId,
+    ...response.responseModelId === undefined ? {} : { responseModelId: response.responseModelId },
+    cost,
+    ...response.route === undefined ? {} : { route: response.route }
+  };
+}
+async function executeToolCall(call, tools, callId, signal, onEvent) {
+  const { part } = call;
+  if (call.inputError) {
+    const errorText = `Tool input is not valid JSON: ${call.inputError.message}`;
+    await onEvent?.({
+      type: "tool-input-error",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      input: part.input,
+      errorText
+    });
+    return toolErrorResult(part, errorText);
+  }
+  const tool = tools.get(part.toolName);
+  if (!tool) {
+    const errorText = `Tool '${part.toolName}' is not available.`;
+    await onEvent?.({
+      type: "tool-output-error",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      errorText
+    });
+    return toolErrorResult(part, errorText);
+  }
+  let parsed;
+  try {
+    parsed = tool.parseInput(part.input);
+  } catch (error) {
+    const errorText = error instanceof Error ? error.message : "Tool input validation failed.";
+    await onEvent?.({
+      type: "tool-input-error",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      input: part.input,
+      errorText
+    });
+    return toolErrorResult(part, errorText);
+  }
+  await onEvent?.({
+    type: "tool-input-available",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    input: part.input
+  });
+  let output;
+  let modelOutput;
+  try {
+    const context = { signal, callId, toolCallId: part.toolCallId };
+    output = await tool.execute(parsed, context);
+    assertJsonValue2(output, `tool '${part.toolName}' output`);
+    modelOutput = tool.toModelOutput ? await tool.toModelOutput(output, context) : modelToolOutput(output);
+    validateModelToolOutput(modelOutput, part.toolName);
+  } catch (error) {
+    const errorText = tool.errorText(error);
+    await onEvent?.({
+      type: "tool-output-error",
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      errorText
+    });
+    return toolErrorResult(part, errorText);
+  }
+  await onEvent?.({
+    type: "tool-output-available",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    output
+  });
+  return {
+    type: "tool-result",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    output: modelOutput,
+    ...modelOutputMatchesOriginal(modelOutput, output) ? {} : { originalOutput: output }
+  };
+}
+function validateModelToolOutput(output, toolName) {
+  if (output.type === "text" || output.type === "error-text") {
+    if (typeof output.value !== "string") {
+      throw new TypeError(`[SixbModels] Tool '${toolName}' model output must contain text.`);
+    }
+    return;
+  }
+  if (output.type !== "json" && output.type !== "error-json") {
+    throw new TypeError(`[SixbModels] Tool '${toolName}' returned an unsupported model output type.`);
+  }
+  assertJsonValue2(output.value, `tool '${toolName}' model output`);
+}
+function modelOutputMatchesOriginal(output, original) {
+  if (output.type === "text")
+    return typeof original === "string" && output.value === original;
+  if (output.type === "json")
+    return output.value === original;
+  return false;
+}
+function modelToolOutput(value) {
+  return typeof value === "string" ? { type: "text", value } : { type: "json", value };
+}
+function toolErrorResult(part, errorText) {
+  if (typeof errorText !== "string") {
+    throw new TypeError(`[SixbModels] Tool '${part.toolName}' error text must be a string.`);
+  }
+  return {
+    type: "tool-result",
+    toolCallId: part.toolCallId,
+    toolName: part.toolName,
+    output: { type: "error-text", value: errorText }
+  };
+}
+
+class StreamAccumulator {
+  onEvent;
+  parts = [];
+  spans = new Map;
+  toolCalls = new Map;
+  started = false;
+  finished = false;
+  finishReason;
+  rawFinishReason;
+  usage = {};
+  responseId;
+  providerIds;
+  responseModelId;
+  projectionError;
+  reportedCost;
+  route;
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+  }
+  isFinished() {
+    return this.finished;
+  }
+  async accept(event) {
+    if (this.finished) {
+      throw new ModelStreamError2(`[SixbModels] Received '${event.type}' after stream finish.`);
+    }
+    switch (event.type) {
+      case "stream-start":
+        if (this.started)
+          throw new ModelStreamError2("[SixbModels] Duplicate stream-start event.");
+        this.started = true;
+        return;
+      case "response-metadata":
+        this.requireStarted(event.type);
+        this.responseId = event.id ?? this.responseId;
+        if (event.providerIds)
+          this.providerIds = { ...this.providerIds, ...event.providerIds };
+        this.responseModelId = event.modelId ?? this.responseModelId;
+        return;
+      case "text-start":
+        await this.startText(event);
+        return;
+      case "text-delta":
+        await this.appendText(event, "text");
+        return;
+      case "text-end":
+        await this.endText(event, "text");
+        return;
+      case "reasoning-start":
+        await this.startReasoning(event);
+        return;
+      case "reasoning-delta":
+        await this.appendText(event, "reasoning");
+        return;
+      case "reasoning-end":
+        await this.endText(event, "reasoning");
+        return;
+      case "tool-input-start":
+        await this.startTool(event);
+        return;
+      case "tool-input-delta":
+        await this.appendTool(event);
+        return;
+      case "tool-input-end":
+        this.endTool(event);
+        return;
+      case "tool-call":
+        await this.completeTool(event);
+        return;
+      case "tool-result":
+        this.addProviderToolResult(event);
+        return;
+      case "provider-state":
+        if (typeof event.providerId !== "string" || event.providerId.length === 0) {
+          this.captureProjectionError(new ModelStreamError2("[SixbModels] Provider state requires a nonempty provider ID."));
+          return;
+        }
+        if (this.captureProviderState(event.data)) {
+          this.parts.push({
+            type: "provider-state",
+            providerId: event.providerId,
+            data: event.data
+          });
+        }
+        return;
+      case "finish":
+        this.requireStarted(event.type);
+        validateUsage(event.usage);
+        this.captureProviderData(event.providerData);
+        this.finished = true;
+        this.finishReason = event.finishReason;
+        this.rawFinishReason = event.rawFinishReason;
+        this.usage = event.usage;
+        this.reportedCost = event.reportedCost;
+        this.route = event.route;
+        return;
+      case "error":
+        throw event.error instanceof Error ? event.error : new ModelProviderError2("[SixbModels] Provider stream failed.", "unknown", "unknown", {
+          cause: event.error
+        });
+    }
+  }
+  complete() {
+    if (!this.started)
+      throw new ModelStreamError2("[SixbModels] Stream did not start.");
+    if (!this.finished || !this.finishReason) {
+      throw new ModelStreamError2("[SixbModels] Stream ended without a finish event.");
+    }
+    for (const part of this.parts) {
+      if ("complete" in part && !part.complete) {
+        throw new ModelStreamError2(`[SixbModels] Stream finished with incomplete ${part.type} content.`);
+      }
+    }
+    const parsed = this.parseParts(false);
+    return {
+      content: parsed.content,
+      toolCalls: parsed.toolCalls,
+      finishReason: this.finishReason,
+      ...this.rawFinishReason === undefined ? {} : { rawFinishReason: this.rawFinishReason },
+      ...this.accounting(),
+      ...this.projectionError === undefined ? {} : { projectionError: this.projectionError }
+    };
+  }
+  accounting() {
+    return {
+      usage: this.usage,
+      ...this.responseId === undefined ? {} : { responseId: this.responseId },
+      ...this.providerIds === undefined ? {} : { providerIds: this.providerIds },
+      ...this.responseModelId === undefined ? {} : { responseModelId: this.responseModelId },
+      ...this.reportedCost === undefined ? {} : { reportedCost: this.reportedCost },
+      ...this.route === undefined ? {} : { route: this.route }
+    };
+  }
+  partialContent() {
+    return this.parseParts(true).content;
+  }
+  parseParts(partial) {
+    const content = [];
+    const toolCalls = [];
+    for (const part of this.parts) {
+      if (part.type === "text") {
+        if ((!partial || part.text.length > 0) && (part.complete || partial)) {
+          content.push({
+            type: "text",
+            text: part.text,
+            ...part.providerData === undefined ? {} : { providerData: part.providerData }
+          });
+        }
+      } else if (part.type === "reasoning") {
+        if (part.complete) {
+          content.push({
+            type: "reasoning",
+            text: part.text,
+            ...part.providerData === undefined ? {} : { providerData: part.providerData }
+          });
+        }
+      } else if (part.type === "tool-call") {
+        if (!part.complete)
+          continue;
+        let value = null;
+        let inputError;
+        try {
+          const parsed = JSON.parse(part.inputText);
+          if (!isJsonValue2(parsed))
+            throw new TypeError("input is not a JSON value");
+          value = parsed;
+        } catch (error) {
+          inputError = error instanceof Error ? error : new Error(String(error));
+        }
+        const call = {
+          type: "tool-call",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: value,
+          ...part.providerData === undefined ? {} : { providerData: part.providerData },
+          ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
+          ...part.dynamic === undefined ? {} : { dynamic: part.dynamic }
+        };
+        content.push(call);
+        toolCalls.push({ part: call, ...inputError === undefined ? {} : { inputError } });
+      } else {
+        content.push(part);
+      }
+    }
+    return { content, toolCalls };
+  }
+  async startText(event) {
+    this.requireStarted(event.type);
+    this.assertNewSpan(event.id);
+    const providerData = this.captureProviderData(event.providerData);
+    const part = {
+      type: "text",
+      text: "",
+      complete: false,
+      ...providerData === undefined ? {} : { providerData }
+    };
+    this.spans.set(event.id, part);
+    this.parts.push(part);
+    await this.onEvent?.({ type: "text-start", id: event.id });
+  }
+  async startReasoning(event) {
+    this.requireStarted(event.type);
+    this.assertNewSpan(event.id);
+    const providerData = this.captureProviderData(event.providerData);
+    const part = {
+      type: "reasoning",
+      text: "",
+      complete: false,
+      ...providerData === undefined ? {} : { providerData }
+    };
+    this.spans.set(event.id, part);
+    this.parts.push(part);
+    await this.onEvent?.({ type: "reasoning-start", id: event.id });
+  }
+  async appendText(event, expected) {
+    const part = this.spans.get(event.id);
+    if (!part || part.type !== expected || part.complete) {
+      throw new ModelStreamError2(`[SixbModels] ${event.type} references unopened ${expected} span '${event.id}'.`);
+    }
+    part.text += event.delta;
+    await this.onEvent?.({ type: event.type, id: event.id, delta: event.delta });
+  }
+  async endText(event, expected) {
+    const part = this.spans.get(event.id);
+    if (!part || part.type !== expected || part.complete) {
+      throw new ModelStreamError2(`[SixbModels] ${event.type} references unopened ${expected} span '${event.id}'.`);
+    }
+    part.providerData = mergeProviderData(part.providerData, this.captureProviderData(event.providerData));
+    part.complete = true;
+    this.spans.delete(event.id);
+    await this.onEvent?.({ type: event.type, id: event.id });
+  }
+  async startTool(event) {
+    this.requireStarted(event.type);
+    if (typeof event.id !== "string" || !event.id || typeof event.toolName !== "string" || !event.toolName) {
+      throw new ModelStreamError2("[SixbModels] Tool calls require nonempty IDs and names.");
+    }
+    if (this.toolCalls.has(event.id)) {
+      throw new ModelStreamError2(`[SixbModels] Duplicate tool call ID '${event.id}'.`);
+    }
+    const providerData = this.captureProviderData(event.providerData);
+    const part = {
+      type: "tool-call",
+      toolCallId: event.id,
+      toolName: event.toolName,
+      inputText: "",
+      complete: false,
+      ...providerData === undefined ? {} : { providerData },
+      ...event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted },
+      ...event.dynamic === undefined ? {} : { dynamic: event.dynamic }
+    };
+    this.toolCalls.set(event.id, part);
+    this.parts.push(part);
+    await this.onEvent?.({
+      type: "tool-input-start",
+      toolCallId: event.id,
+      toolName: event.toolName
+    });
+  }
+  async appendTool(event) {
+    const part = this.toolCalls.get(event.id);
+    if (!part || part.complete) {
+      throw new ModelStreamError2(`[SixbModels] tool-input-delta references unopened tool call '${event.id}'.`);
+    }
+    part.inputText += event.delta;
+    await this.onEvent?.({
+      type: "tool-input-delta",
+      toolCallId: event.id,
+      toolName: part.toolName,
+      inputTextDelta: event.delta
+    });
+  }
+  endTool(event) {
+    const part = this.toolCalls.get(event.id);
+    if (!part || part.complete) {
+      throw new ModelStreamError2(`[SixbModels] tool-input-end references unopened tool call '${event.id}'.`);
+    }
+    part.providerData = mergeProviderData(part.providerData, this.captureProviderData(event.providerData));
+    part.complete = true;
+  }
+  async completeTool(event) {
+    await this.startTool({
+      type: "tool-input-start",
+      id: event.toolCallId,
+      toolName: event.toolName,
+      ...event.providerData === undefined ? {} : { providerData: event.providerData },
+      ...event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted },
+      ...event.dynamic === undefined ? {} : { dynamic: event.dynamic }
+    });
+    const part = this.toolCalls.get(event.toolCallId);
+    if (!part)
+      throw new ModelStreamError2("[SixbModels] Failed to index completed tool call.");
+    part.inputText = event.input;
+    part.complete = true;
+  }
+  addProviderToolResult(event) {
+    if (!this.captureJsonValue(event.output, "provider tool result"))
+      return;
+    const providerData = this.captureProviderData(event.providerData);
+    this.parts.push({
+      type: "tool-result",
+      toolCallId: event.toolCallId,
+      toolName: event.toolName,
+      output: event.isError ? { type: "error-json", value: event.output } : modelToolOutput(event.output),
+      providerExecuted: event.providerExecuted ?? true,
+      ...event.dynamic === undefined ? {} : { dynamic: event.dynamic },
+      ...providerData === undefined ? {} : { providerData }
+    });
+  }
+  captureProviderData(data) {
+    if (data === undefined)
+      return;
+    try {
+      return normalizeProviderData(data);
+    } catch (error) {
+      this.captureProjectionError(error);
+      return;
+    }
+  }
+  captureProviderState(value) {
+    if (!this.captureJsonValue(value, "provider state"))
+      return false;
+    if (JSON.stringify(value).length > MAX_PROVIDER_DATA_BYTES) {
+      this.captureProjectionError(new ModelStreamError2(`[SixbModels] Provider state exceeds the ${MAX_PROVIDER_DATA_BYTES}-byte response limit.`));
+      return false;
+    }
+    return true;
+  }
+  captureJsonValue(value, label) {
+    try {
+      assertJsonValue2(value, label);
+      return true;
+    } catch (error) {
+      this.captureProjectionError(error);
+      return false;
+    }
+  }
+  captureProjectionError(error) {
+    this.projectionError ??= error instanceof Error ? error : new Error(String(error));
+  }
+  requireStarted(type) {
+    if (!this.started) {
+      throw new ModelStreamError2(`[SixbModels] Received '${type}' before stream-start.`);
+    }
+  }
+  assertNewSpan(id) {
+    if (!id)
+      throw new ModelStreamError2("[SixbModels] Content span IDs must not be empty.");
+    if (this.spans.has(id)) {
+      throw new ModelStreamError2(`[SixbModels] Duplicate open content span '${id}'.`);
+    }
+  }
+}
+function validateUsage(usage) {
+  for (const [key, value] of Object.entries(usage)) {
+    if (key === "raw") {
+      if (value !== undefined)
+        assertJsonValue2(value, "raw model usage");
+      continue;
+    }
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) {
+      throw new ModelStreamError2(`[SixbModels] Usage field '${key}' must be a nonnegative integer.`);
+    }
+  }
+}
+function normalizeProviderData(value) {
+  const data = omitUndefinedObjectProperties(value);
+  assertJsonValue2(data, "provider data");
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new TypeError("[SixbModels] provider data must be a JSON object.");
+  }
+  if (JSON.stringify(data).length > MAX_PROVIDER_DATA_BYTES) {
+    throw new ModelStreamError2(`[SixbModels] Provider data exceeds the ${MAX_PROVIDER_DATA_BYTES}-byte response limit.`);
+  }
+  return data;
+}
+function omitUndefinedObjectProperties(value, seen = new Set) {
+  if (typeof value !== "object" || value === null || seen.has(value))
+    return value;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((entry) => omitUndefinedObjectProperties(entry, seen));
+    }
+    if (!isPlainRecord(value))
+      return value;
+    return Object.fromEntries(Reflect.ownKeys(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key)).map((key) => [key, Reflect.get(value, key)]).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, omitUndefinedObjectProperties(entry, seen)]));
+  } finally {
+    seen.delete(value);
+  }
+}
+function mergeProviderData(first, second) {
+  if (first === undefined)
+    return second;
+  if (second === undefined)
+    return first;
+  return { ...first, ...second };
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+
+// src/models/execution/binding.ts
+var bindings = new WeakMap;
+function registerModelExecutionBinding(models, bind) {
+  bindings.set(models, bind);
+}
+function bindModelExecutionAttempt(models, input) {
+  const bind = bindings.get(models);
+  if (!bind)
+    throw new Error("[SixbModels] Model runtime has no execution binding.");
+  if (!Number.isSafeInteger(input.attempt) || input.attempt < 1) {
+    throw new TypeError("[SixbModels] Execution attempt must be a positive safe integer.");
+  }
+  bind(input);
+  bindings.delete(models);
+}
+
+// src/models/output.ts
+function languageModelOutput(shape, valueTypesById) {
+  if (!isRecord2(shape))
+    throw new TypeError("[SixbModels] output must be a Sixb schema record.");
+  const schema = schemaRecordToJsonSchema2({ shape, valueTypesById });
+  assertJsonObject2(schema, "model output schema");
+  return {
+    name: "sixb_output",
+    schema,
+    validate(value) {
+      if (!isRecord2(value))
+        throw new TypeError("[SixbModels] Output must be an object.");
+      for (const key of Object.keys(value)) {
+        if (!Object.hasOwn(shape, key)) {
+          throw new TypeError(`[SixbModels] Unknown output field '${key}'.`);
+        }
+      }
+      return Object.fromEntries(Object.entries(shape).map(([key, field]) => {
+        if (!Object.hasOwn(value, key)) {
+          throw new TypeError(`[SixbModels] Missing output field '${key}'.`);
+        }
+        validateSchemaOrRefValue2(field, value[key], `output.${key}`, valueTypesById);
+        const output = isObjectRefSchema2(field) ? value[key] : coerceSchemaValueToTyped2(field, normalizeSchemaValue2(field, value[key], `output.${key}`, valueTypesById), valueTypesById);
+        return [key, output];
+      }));
+    }
+  };
+}
+
+// src/models/execution.ts
+function createModelsRuntime(runtime, execution, catalog) {
+  let binding;
+  let recorder;
+  async function createRecorder() {
+    const storage = {
+      ...requireAccountingCapabilities(runtime.storage),
+      transaction: runtime.storage.transaction.bind(runtime.storage)
+    };
+    if (!binding) {
+      throw new Error("[SixbModels] Generation requires a bound request or worker execution attempt.");
+    }
+    const { requesterGroupIds } = await ensureExecutionRecord2(runtime.storage.executions, executionRecordInputFromRuntime({
+      execution,
+      runtimeAuthorization: runtime.runtimeAuthorization
+    }));
+    return new AiModelCallRecorder2({
+      storage,
+      projectId: runtime.projectId,
+      executionId: execution.id,
+      attempt: binding.attempt,
+      requesterGroupIds,
+      limits: createAiModelCallLimitController2({
+        storage,
+        projectId: runtime.projectId,
+        requestedBy: execution.requestedBy,
+        requesterGroupIds
+      }),
+      recoverAiModelCall: (input) => enqueueAiModelCallRecovery2(runtime.queues.agents, input)
+    });
+  }
+  async function generate(input) {
+    assertProviderAccess2(runtime, execution, "models.language.generate");
+    const messages = generationMessages(input);
+    if (!binding) {
+      throw new Error("[SixbModels] Generation requires a bound request or worker execution attempt.");
+    }
+    const signal = input.signal ? AbortSignal.any([binding.signal, input.signal]) : binding.signal;
+    signal.throwIfAborted();
+    const selected = input.model ? catalog ? catalog.language.getByRef({
+      provider: input.model.providerId,
+      modelId: input.model.modelId
+    })?.model : input.model : catalog?.language.default.model;
+    if (!selected) {
+      throw new Error(input.model ? `[SixbModels] Model '${input.model.providerId}/${input.model.modelId}' is not configured in models.language.` : "[SixbModels] Configure models.language in createSixb() or supply a model to generate().");
+    }
+    const output = input.output === undefined ? undefined : languageModelOutput(input.output, runtime.ontology.getValueTypesById());
+    const model = await resolveLanguageModel2(selected);
+    const reasoningIssue = modelReasoningSupportIssue2(model.definition.capabilities.reasoning, input.reasoning);
+    if (reasoningIssue)
+      throw new UnsupportedModelFeatureError2(`[SixbModels] ${reasoningIssue}.`);
+    if (output && model.definition.capabilities.nativeStructuredOutput === false) {
+      throw new UnsupportedModelFeatureError2("[SixbModels] Model does not support native structured output.");
+    }
+    const maxOutputTokens = Math.min(aiModelCallOutputTokenAllowance(input.maxOutputTokens ?? model.definition.maxOutputTokens), model.definition.maxOutputTokens ?? Infinity);
+    if (typeof input.reasoning === "object" && input.reasoning.budgetTokens >= maxOutputTokens) {
+      throw new TypeError("[SixbModels] Output allowance must exceed the reasoning token budget.");
+    }
+    recorder ??= createRecorder();
+    const accounting = await recorder;
+    accounting.assertHealthy();
+    signal.throwIfAborted();
+    let event;
+    const options = {
+      model: accounting.wrapModel(model),
+      messages,
+      maxSteps: 1,
+      rejectLocalToolCalls: true,
+      maxOutputTokens,
+      reasoning: input.reasoning,
+      caching: input.caching,
+      signal,
+      onModelCallEnd: async (completed) => {
+        await accounting.onModelCallEnd(completed);
+        event = completed;
+      }
+    };
+    const result = output ? await runModelLoop2({ ...options, output }) : await runModelLoop2(options);
+    if (result.status === "aborted") {
+      signal.throwIfAborted();
+      throw new DOMException("Model generation aborted", "AbortError");
+    }
+    if (result.finishReason === "error" || result.finishReason === "content-filter") {
+      throw new ModelProviderError2(`[SixbModels] Generation ended with '${result.finishReason}'.`, model.providerId, model.modelId);
+    }
+    if (!event)
+      throw new ModelStreamError2("[SixbModels] Generation completed without accounting metadata.");
+    return {
+      output: result.output,
+      usage: event.usage,
+      cost: event.cost,
+      callId: event.callId,
+      finishReason: result.finishReason
+    };
+  }
+  const models = {
+    language: { generate }
+  };
+  registerModelExecutionBinding(models, (input) => {
+    binding = { attempt: input.attempt, signal: input.signal };
+  });
+  return models;
+}
+function generationMessages(input) {
+  if (input.prompt === undefined === (input.messages === undefined)) {
+    throw new TypeError("[SixbModels] Supply exactly one of prompt or messages.");
+  }
+  if (input.prompt !== undefined && typeof input.prompt !== "string") {
+    throw new TypeError("[SixbModels] prompt must be a string.");
+  }
+  if (input.messages !== undefined && !Array.isArray(input.messages)) {
+    throw new TypeError("[SixbModels] messages must be an array.");
+  }
+  if (input.instructions !== undefined && typeof input.instructions !== "string") {
+    throw new TypeError("[SixbModels] instructions must be a string.");
+  }
+  if (input.maxOutputTokens !== undefined && (!Number.isSafeInteger(input.maxOutputTokens) || input.maxOutputTokens <= 0)) {
+    throw new TypeError("[SixbModels] maxOutputTokens must be a positive safe integer.");
+  }
+  if (input.caching !== undefined && input.caching !== "auto" && input.caching !== "off") {
+    throw new TypeError("[SixbModels] caching must be 'auto' or 'off'.");
+  }
+  return [
+    ...input.instructions === undefined ? [] : [{ role: "system", content: input.instructions }],
+    ...input.prompt !== undefined ? [{ role: "user", content: [{ type: "text", text: input.prompt }] }] : input.messages ?? []
+  ];
+}
+
 // src/objects/execution.ts
 function createObjectsRuntime(runtime, execution) {
   const runtimeAuthorization = runtime.runtimeAuthorization;
@@ -1192,13 +2148,13 @@ function createObjectsRuntime(runtime, execution) {
     objectReader,
     ...authorization === undefined ? {} : { authorization }
   };
-  shareOntologyMutationRuntime(runtime, capturedRuntime);
-  shareSixbErrorReporter(runtime, capturedRuntime);
+  shareOntologyMutationRuntime2(runtime, capturedRuntime);
+  shareSixbErrorReporter2(runtime, capturedRuntime);
   Object.freeze(capturedRuntime);
   const ontologyView = () => getAuthorizedOntologyView(objectReader);
   const objects = Object.assign((objectType) => {
-    assertObjectTypeRegistered(capturedRuntime.ontology.getObjectTypesById(), objectType);
-    return createObjectSet({ ...capturedRuntime, execution, objectType });
+    assertObjectTypeRegistered2(capturedRuntime.ontology.getObjectTypesById(), objectType);
+    return createObjectSet2({ ...capturedRuntime, execution, objectType });
   }, {
     listTypes: () => ontologyView().listObjectTypes(),
     getTypeById: (objectTypeId) => ontologyView().getObjectTypeById(objectTypeId),
@@ -1216,7 +2172,7 @@ function createObjectsRuntime(runtime, execution) {
     },
     getTelemetryHistoryBatch: (input) => {
       const timeseries = capturedRuntime.storage.timeseries;
-      return getTelemetryHistoryBatch(input, { storage: timeseries, objectReader });
+      return getTelemetryHistoryBatch2(input, { storage: timeseries, objectReader });
     },
     getTelemetryHistory: async (input) => {
       const timeseries = capturedRuntime.storage.timeseries;
@@ -1227,7 +2183,7 @@ function createObjectsRuntime(runtime, execution) {
       const to = input.to;
       const limit = input.limit;
       const order = input.order;
-      const [result] = await getTelemetryHistoryBatch({
+      const [result] = await getTelemetryHistoryBatch2({
         series: [{ objectTypeId, objectId, propertyId }],
         ...from === undefined ? {} : { from },
         ...to === undefined ? {} : { to },
@@ -1248,11 +2204,11 @@ function createObjectsRuntime(runtime, execution) {
     getPrimaryPropertyId: (objectTypeId) => {
       return ontologyView().getPrimaryPropertyId(objectTypeId);
     },
-    upsert: (objectTypeId, properties) => upsertObject(capturedRuntime, objectTypeId, properties),
-    upsertBatch: (objectTypeId, items) => upsertObjectBatch(capturedRuntime, objectTypeId, items),
-    upsertLink: (objectTypeId, sourceId, linkId, target) => upsertLink(capturedRuntime, objectTypeId, sourceId, linkId, target),
-    upsertLinkBatch: (items) => upsertLinkBatch(capturedRuntime, items),
-    removeLink: (objectTypeId, sourceId, linkId, target) => removeLink(capturedRuntime, objectTypeId, sourceId, linkId, target),
+    upsert: (objectTypeId, properties) => upsertObject3(capturedRuntime, objectTypeId, properties),
+    upsertBatch: (objectTypeId, items) => upsertObjectBatch3(capturedRuntime, objectTypeId, items),
+    upsertLink: (objectTypeId, sourceId, linkId, target) => upsertLink3(capturedRuntime, objectTypeId, sourceId, linkId, target),
+    upsertLinkBatch: (items) => upsertLinkBatch3(capturedRuntime, items),
+    removeLink: (objectTypeId, sourceId, linkId, target) => removeLink3(capturedRuntime, objectTypeId, sourceId, linkId, target),
     appendTelemetry: (objectTypeId, items) => appendTelemetry(capturedRuntime, objectTypeId, items)
   });
   return objects;
@@ -1261,7 +2217,7 @@ function createObjectsRuntime(runtime, execution) {
 // src/pipelines/execution.ts
 function createPipelinesRuntime(runtime, execution, source) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
-  const allowed = (pipelineId) => isRuntimeAllowed(runtime, { kind: "pipeline.run", pipelineId });
+  const allowed = (pipelineId) => isRuntimeAllowed2(runtime, { kind: "pipeline.run", pipelineId });
   const visibleIds = () => source.list().filter((pipeline) => allowed(pipeline.id)).map((pipeline) => pipeline.id);
   const historyFilterIds = () => authority.type === "unrestricted" ? undefined : authority.type === "principal" ? visibleIds() : [];
   const getRun = async (runId) => {
@@ -1273,7 +2229,7 @@ function createPipelinesRuntime(runtime, execution, source) {
     }) ?? null;
     if (!run)
       return null;
-    return authority.type === "unrestricted" || canViewPipelineRun(authority.context, run) ? run : null;
+    return authority.type === "unrestricted" || canViewPipelineRun2(authority.context, run) ? run : null;
   };
   return {
     list: () => authority.type === "denied" || authority.type === "delegated" ? [] : source.list().filter((pipeline) => allowed(pipeline.id)),
@@ -1284,11 +2240,11 @@ function createPipelinesRuntime(runtime, execution, source) {
       return pipeline && allowed(pipelineId) ? pipeline : null;
     },
     request: async (input) => {
-      assertAuthorized(runtime, { kind: "pipeline.run", pipelineId: input.pipelineId });
+      assertAuthorized2(runtime, { kind: "pipeline.run", pipelineId: input.pipelineId });
       const pipeline = source.getById(input.pipelineId);
       if (!pipeline)
-        throw new PipelineError(`[Sixb] Unknown pipeline '${input.pipelineId}'`);
-      return requestPipelineRun(runtime, execution, pipeline, input);
+        throw new PipelineError2(`[Sixb] Unknown pipeline '${input.pipelineId}'`);
+      return requestPipelineRun2(runtime, execution, pipeline, input);
     },
     runs: {
       getById: getRun,
@@ -1341,7 +2297,7 @@ function createProjectionsRuntime(runtime, source) {
       case "delegated":
         return [];
       case "principal":
-        return list().filter((projection) => canViewProjection(authority.context, projection));
+        return list().filter((projection) => canViewProjection2(authority.context, projection));
       case "unrestricted":
         return [...list()];
     }
@@ -1352,7 +2308,7 @@ function createProjectionsRuntime(runtime, source) {
       case "delegated":
         return false;
       case "principal":
-        return canViewProjection(authority.context, projection);
+        return canViewProjection2(authority.context, projection);
       case "unrestricted":
         return true;
     }
@@ -1394,7 +2350,7 @@ function createProjectionsRuntime(runtime, source) {
         }) ?? null;
         if (!run)
           return null;
-        return authority.type === "unrestricted" || canViewProjectionRun(authority.context, run.target) ? run : null;
+        return authority.type === "unrestricted" || canViewProjectionRun2(authority.context, run.target) ? run : null;
       },
       list: (input = {}) => {
         switch (authority.type) {
@@ -1439,7 +2395,7 @@ function createRulesRuntime(runtime, source) {
   const visible = (rule) => {
     if (authority.type === "denied" || authority.type === "delegated")
       return false;
-    return isRuntimeAllowed(runtime, {
+    return isRuntimeAllowed2(runtime, {
       kind: "object.view",
       objectTypeId: rule.subject.objectTypeId
     });
@@ -1498,10 +2454,10 @@ function createSchedulesRuntime(runtime, schedules) {
 }
 
 // src/shares/execution.ts
-import { createHash as createHash2, randomBytes, randomUUID as randomUUID4 } from "crypto";
+import { createHash as createHash2, randomBytes, randomUUID as randomUUID5 } from "crypto";
 var MAX_CREATE_ATTEMPTS = 5;
 
-class ShareError extends Error {
+class ShareError2 extends Error {
   reason;
   name = "ShareError";
   constructor(reason, message, options) {
@@ -1516,7 +2472,7 @@ function createSharesRuntime(runtime, execution, definitions) {
       authorization: runtime.runtimeAuthorization
     });
     if (authority.type !== "principal" || authority.context.principal.type === "system") {
-      throw new ShareError("unauthenticated", "[Sixb] Shared access grants require user or service-account authority.");
+      throw new ShareError2("unauthenticated", "[Sixb] Shared access grants require user or service-account authority.");
     }
     return {
       type: authority.context.principal.type,
@@ -1526,7 +2482,7 @@ function createSharesRuntime(runtime, execution, definitions) {
   const canManage = (shareId) => {
     try {
       managementPrincipal();
-      return isRuntimeAllowed(runtime, { kind: "share.manage", shareId });
+      return isRuntimeAllowed2(runtime, { kind: "share.manage", shareId });
     } catch {
       return false;
     }
@@ -1550,7 +2506,7 @@ function createSharesRuntime(runtime, execution, definitions) {
       primaryId: target.primaryId
     });
     if (!object) {
-      throw new ObjectNotFoundError(target.objectTypeId, target.primaryId, "Share target not found");
+      throw new ObjectNotFoundError2(target.objectTypeId, target.primaryId, "Share target not found");
     }
     const authoritySnapshot = {
       version: 1,
@@ -1565,7 +2521,7 @@ function createSharesRuntime(runtime, execution, definitions) {
       const secret = randomBytes(32).toString("base64url");
       try {
         const grant = await storage.create({
-          id: `shr_${randomUUID4()}`,
+          id: `shr_${randomUUID5()}`,
           projectId: runtime.projectId,
           definitionId: definition.id,
           target,
@@ -1578,10 +2534,10 @@ function createSharesRuntime(runtime, execution, definitions) {
         });
         return { grant: publicGrant(grant), secret };
       } catch (error) {
-        if (error instanceof ShareGrantStorageError && error.code === "invalid_input") {
-          throw new ShareError("invalid_input", error.message, { cause: error });
+        if (error instanceof ShareGrantStorageError2 && error.code === "invalid_input") {
+          throw new ShareError2("invalid_input", error.message, { cause: error });
         }
-        if (!(error instanceof ShareGrantStorageError) || error.code !== "duplicate" || attempt === MAX_CREATE_ATTEMPTS - 1) {
+        if (!(error instanceof ShareGrantStorageError2) || error.code !== "duplicate" || attempt === MAX_CREATE_ATTEMPTS - 1) {
           throw storageFailure("issue", error);
         }
       }
@@ -1607,8 +2563,8 @@ function createSharesRuntime(runtime, execution, definitions) {
       });
       return { ...result, grants: result.grants.map(publicGrant) };
     } catch (error) {
-      if (error instanceof ShareGrantStorageError && error.code === "invalid_input") {
-        throw new ShareError("invalid_input", error.message, { cause: error });
+      if (error instanceof ShareGrantStorageError2 && error.code === "invalid_input") {
+        throw new ShareError2("invalid_input", error.message, { cause: error });
       }
       throw storageFailure("list", error);
     }
@@ -1650,7 +2606,7 @@ function createSharesRuntime(runtime, execution, definitions) {
       const actor = managementPrincipal();
       const storage = requireShareStorage(runtime);
       if (typeof grantId !== "string" || !grantId.trim()) {
-        throw new ShareError("invalid_input", "[Sixb] Shared access grant id must not be empty.");
+        throw new ShareError2("invalid_input", "[Sixb] Shared access grant id must not be empty.");
       }
       let current;
       try {
@@ -1682,50 +2638,50 @@ function definitionIdFromReference(value) {
 }
 function assertInputObject(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new ShareError("invalid_input", `[Sixb] ${label} must be an object.`);
+    throw new ShareError2("invalid_input", `[Sixb] ${label} must be an object.`);
   }
 }
 function resolveDefinition(definitions, definitionId) {
   const id = validDefinitionId(definitionId);
   const definition = definitions.getById(id);
   if (!definition) {
-    throw new ShareError("not_found", `[Sixb] Unknown Share definition '${id}'.`);
+    throw new ShareError2("not_found", `[Sixb] Unknown Share definition '${id}'.`);
   }
   return definition;
 }
 function validDefinitionId(value) {
   if (typeof value !== "string" || !value.trim()) {
-    throw new ShareError("invalid_input", "[Sixb] Share definition id must not be empty.");
+    throw new ShareError2("invalid_input", "[Sixb] Share definition id must not be empty.");
   }
   return value;
 }
 function assertCanManage(runtime, shareId) {
-  assertAuthorized(runtime, { kind: "share.manage", shareId });
+  assertAuthorized2(runtime, { kind: "share.manage", shareId });
 }
 function requireShareStorage(runtime) {
   const storage = runtime.storage.shareGrants;
   if (!storage) {
-    throw new ShareError("storage_unavailable", "[Sixb] Share grant storage is not configured on this runtime.");
+    throw new ShareError2("storage_unavailable", "[Sixb] Share grant storage is not configured on this runtime.");
   }
   return storage;
 }
 function exactTarget(definition, value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new ShareError("invalid_input", "[Sixb] Share target must be an exact object reference.");
+    throw new ShareError2("invalid_input", "[Sixb] Share target must be an exact object reference.");
   }
   const objectTypeId = value.objectTypeId;
   const primaryId = value.primaryId;
   if (typeof objectTypeId !== "string" || typeof primaryId !== "string" || !primaryId.trim()) {
-    throw new ShareError("invalid_input", "[Sixb] Share target must be an exact object reference.");
+    throw new ShareError2("invalid_input", "[Sixb] Share target must be an exact object reference.");
   }
   if (objectTypeId !== definition.target.objectTypeId) {
-    throw new ShareError("invalid_input", `[Sixb] Share '${definition.id}' targets '${definition.target.objectTypeId}', not '${objectTypeId}'.`);
+    throw new ShareError2("invalid_input", `[Sixb] Share '${definition.id}' targets '${definition.target.objectTypeId}', not '${objectTypeId}'.`);
   }
   return Object.freeze({ objectTypeId, primaryId });
 }
 function validFutureDate(value, now) {
   if (!(value instanceof Date) || !Number.isFinite(value.getTime()) || value <= now) {
-    throw new ShareError("invalid_input", "[Sixb] Shared access expiry must be a valid future date.");
+    throw new ShareError2("invalid_input", "[Sixb] Shared access expiry must be a valid future date.");
   }
   return new Date(value);
 }
@@ -1743,7 +2699,7 @@ function publicGrant(record) {
   return structuredClone(grant);
 }
 function storageFailure(operation, cause) {
-  return new ShareError("storage_failure", `[Sixb] Share grant storage failed to ${operation}.`, {
+  return new ShareError2("storage_failure", `[Sixb] Share grant storage failed to ${operation}.`, {
     cause
   });
 }
@@ -1751,7 +2707,7 @@ function storageFailure(operation, cause) {
 // src/syncs/execution.ts
 function createSyncsRuntime(runtime, execution, source) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
-  const allowed = (syncId) => isRuntimeAllowed(runtime, { kind: "sync.run", syncId });
+  const allowed = (syncId) => isRuntimeAllowed2(runtime, { kind: "sync.run", syncId });
   const visibleIds = () => source.list().filter((sync) => allowed(sync.id)).map((sync) => sync.id);
   const historyFilterIds = () => authority.type === "unrestricted" ? undefined : authority.type === "principal" ? visibleIds() : [];
   return {
@@ -1763,11 +2719,11 @@ function createSyncsRuntime(runtime, execution, source) {
       return sync && allowed(syncId) ? sync : null;
     },
     request: async (input) => {
-      assertAuthorized(runtime, { kind: "sync.run", syncId: input.syncId });
+      assertAuthorized2(runtime, { kind: "sync.run", syncId: input.syncId });
       const sync = source.getById(input.syncId);
       if (!sync)
-        throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`);
-      return requestSyncRun(runtime, execution, sync, input);
+        throw new SyncValidationError2(`[Sixb] Unknown sync '${input.syncId}'`);
+      return requestSyncRun2(runtime, execution, sync, input);
     },
     runs: {
       getById: async (runId) => {
@@ -1807,11 +2763,11 @@ function createSyncsRuntime(runtime, execution, source) {
 }
 
 // src/workflows/errors.ts
-class WorkflowDefinitionError extends Error {
+class WorkflowDefinitionError2 extends Error {
   name = "WorkflowDefinitionError";
 }
 
-class WorkflowValidationError extends Error {
+class WorkflowValidationError2 extends Error {
   name = "WorkflowValidationError";
   cause;
   constructor(message, options) {
@@ -1821,58 +2777,58 @@ class WorkflowValidationError extends Error {
 }
 
 // src/workflows/run-dispatch.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } 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.`);
+    throw new WorkflowDefinitionError2(`${subject} ${field} must not be empty.`);
   }
 }
-function isStepDefinition(value) {
+function isStepDefinition2(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 isAgentStepDefinition2(value) {
+  return isRecord(value) && value.kind === "agentStep" && typeof value.id === "string" && (value.model === undefined || isLanguageModel(value.model)) && (value.reasoning === undefined || isModelReasoning2(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) {
+function isInterventionDefinition2(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) {
+function isWorkflowDefinition2(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.");
+function validateWorkflowDefinition2(value) {
+  if (!isWorkflowDefinition2(value)) {
+    throw new WorkflowDefinitionError2("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.`);
+    throw new WorkflowDefinitionError2(`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}".`);
+      throw new WorkflowDefinitionError2(`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}".`);
+      throw new WorkflowDefinitionError2(`Duplicate workflow node key "${node.key}" in workflow "${value.id}".`);
     }
     nodeKeys.add(node.key);
   }
 }
-function validateWorkflowsAtStartup(options) {
+function validateWorkflowsAtStartup2(options) {
   for (const workflow of options.workflows) {
-    validateWorkflowDefinition(workflow);
+    validateWorkflowDefinition2(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/'.`);
+        throw new WorkflowDefinitionError2(`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);
@@ -1881,14 +2837,14 @@ function validateWorkflowsAtStartup(options) {
   }
   return options.workflows;
 }
-function validateWorkflowAgentStepGroupReferences(workflows, security) {
+function validateWorkflowAgentStepGroupReferences2(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 }).`);
+          throw new WorkflowDefinitionError2(`Workflow "${workflow.id}" agent step "${node.id}" references unknown group "${groupId}". Add it to 'security/groups/' or pass it to createSixb({ groups }).`);
         }
       }
     }
@@ -1896,21 +2852,21 @@ function validateWorkflowAgentStepGroupReferences(workflows, security) {
 }
 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().`);
+    throw new WorkflowDefinitionError2(`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().`);
+      throw new WorkflowDefinitionError2(`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().`);
+      throw new WorkflowDefinitionError2(`Workflow "${workflowId}" agent step "${step.id}" uses unknown project tool "${toolName}". Add it to 'tools' in createSixb().`);
     }
   }
 }
-function validateWorkflowInput(params) {
+function validateWorkflowInput2(params) {
   return validateWorkflowContractRecord({
     shape: params.workflow.input,
     value: params.value,
@@ -1918,7 +2874,7 @@ function validateWorkflowInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function validateWorkflowStepInput(params) {
+function validateWorkflowStepInput2(params) {
   return validateWorkflowContractRecord({
     shape: params.step.input,
     value: params.value,
@@ -1926,7 +2882,7 @@ function validateWorkflowStepInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function validateWorkflowStepOutput(params) {
+function validateWorkflowStepOutput2(params) {
   return validateWorkflowContractRecord({
     shape: params.step.output,
     value: params.value,
@@ -1934,7 +2890,7 @@ function validateWorkflowStepOutput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function validateWorkflowInterventionInput(params) {
+function validateWorkflowInterventionInput2(params) {
   return validateWorkflowContractRecord({
     shape: params.intervention.input,
     value: params.value,
@@ -1942,7 +2898,7 @@ function validateWorkflowInterventionInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function validateWorkflowInterventionResponse(params) {
+function validateWorkflowInterventionResponse2(params) {
   return validateWorkflowInterventionResponseRecord({
     response: params.intervention.response,
     value: params.value,
@@ -1951,7 +2907,7 @@ function validateWorkflowInterventionResponse(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function validateWorkflowInterventionDefaultResponse(params) {
+function validateWorkflowInterventionDefaultResponse2(params) {
   return validateWorkflowInterventionResponseRecord({
     response: params.intervention.response,
     value: params.value,
@@ -1962,31 +2918,31 @@ function validateWorkflowInterventionDefaultResponse(params) {
 }
 function validateWorkflowTriggerAtStartup(workflowId, trigger, registeredSchedules, inputFields) {
   if (!isRecord(trigger) || trigger.type !== "schedule") {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported trigger.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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/'.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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(", ")}.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`Workflow "${workflowId}" contains an invalid node.`);
   }
   if (node.type === "step") {
     validateStepNodeDefinition(workflowId, node);
@@ -2004,38 +2960,38 @@ function validateWorkflowNodeDefinition(workflowId, node) {
     validateActionNodeDefinition(workflowId, node);
     return;
   }
-  throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported node type.`);
+  throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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 (!isAgentStepDefinition2(node.agentStep)) {
+    throw new WorkflowDefinitionError2(`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}".`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+      throw new WorkflowDefinitionError2(`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}'.`);
+      throw new WorkflowDefinitionError2(`Workflow "${workflowId}" agent step "${stepId}" has duplicate ${kind} '${value}'.`);
     }
     seen.add(value);
   }
@@ -2052,7 +3008,7 @@ function isStringArray(value) {
   }
   return true;
 }
-function validateWorkflowAgentStepInput(params) {
+function validateWorkflowAgentStepInput2(params) {
   return validateWorkflowContractRecord({
     shape: params.agentStep.input,
     value: params.value,
@@ -2060,7 +3016,7 @@ function validateWorkflowAgentStepInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function validateWorkflowAgentStepOutput(params) {
+function validateWorkflowAgentStepOutput2(params) {
   return validateWorkflowContractRecord({
     shape: params.agentStep.output,
     value: params.value,
@@ -2070,72 +3026,72 @@ function validateWorkflowAgentStepOutput(params) {
 }
 function validateStepNodeDefinition(workflowId, node) {
   if (typeof node.id !== "string" || !node.id.trim()) {
-    throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains a step with an empty id.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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 (!isStepDefinition2(node.step)) {
+    throw new WorkflowDefinitionError2(`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}".`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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 (!isInterventionDefinition2(node.intervention)) {
+    throw new WorkflowDefinitionError2(`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}".`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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 (!isActionDefinition2(node.action)) {
+    throw new WorkflowDefinitionError2(`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}".`);
+    throw new WorkflowDefinitionError2(`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.`);
+    throw new WorkflowDefinitionError2(`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`);
+    throw new WorkflowValidationError2(`[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}'`);
+      throw new WorkflowValidationError2(`[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}'`);
+      throw new WorkflowValidationError2(`[Sixb] Missing required field '${params.path}.${fieldId}'`);
     }
     try {
-      validateSchemaOrRefValue(schema, fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
+      validateSchemaOrRefValue2(schema, fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
     } catch (error) {
       throw toWorkflowValidationError(error);
     }
@@ -2144,24 +3100,24 @@ function validateWorkflowContractRecord(params) {
 }
 function validateWorkflowInterventionResponseRecord(params) {
   if (!isRecord(params.value)) {
-    throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
+    throw new WorkflowValidationError2(`[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}'`);
+      throw new WorkflowValidationError2(`[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}'`);
+        throw new WorkflowValidationError2(`[Sixb] Missing required field '${params.path}.${fieldId}'`);
       }
       continue;
     }
     try {
-      validateSchemaOrRefValue(interventionResponseFieldSchema(field), fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
+      validateSchemaOrRefValue2(interventionResponseFieldSchema(field), fieldValue, `${params.path}.${fieldId}`, params.valueTypesById);
     } catch (error) {
       throw toWorkflowValidationError(error);
     }
@@ -2178,21 +3134,21 @@ function isInterventionResponseFieldRequired(field) {
   return !isInterventionFieldConfig(field) || field.required !== false;
 }
 function toWorkflowValidationError(error) {
-  if (error instanceof WorkflowValidationError) {
+  if (error instanceof WorkflowValidationError2) {
     return error;
   }
   if (error instanceof Error) {
-    return new WorkflowValidationError(error.message, { cause: error });
+    return new WorkflowValidationError2(error.message, { cause: error });
   }
-  return new WorkflowValidationError(String(error), { cause: error });
+  return new WorkflowValidationError2(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);
+function snapshotWorkflowAgentStepInput2(params) {
+  const value = validateWorkflowAgentStepInput2(params);
   return snapshotWorkflowContractRecord({
     shape: params.agentStep.input,
     value,
@@ -2200,8 +3156,8 @@ function snapshotWorkflowAgentStepInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowAgentStepOutput(params) {
-  const value = validateWorkflowAgentStepOutput(params);
+function snapshotWorkflowAgentStepOutput2(params) {
+  const value = validateWorkflowAgentStepOutput2(params);
   return snapshotWorkflowContractRecord({
     shape: params.agentStep.output,
     value,
@@ -2209,8 +3165,8 @@ function snapshotWorkflowAgentStepOutput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowInput(params) {
-  const value = validateWorkflowInput(params);
+function snapshotWorkflowInput2(params) {
+  const value = validateWorkflowInput2(params);
   return snapshotWorkflowContractRecord({
     shape: params.workflow.input,
     value,
@@ -2218,8 +3174,8 @@ function snapshotWorkflowInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowStepInput(params) {
-  const value = validateWorkflowStepInput(params);
+function snapshotWorkflowStepInput2(params) {
+  const value = validateWorkflowStepInput2(params);
   return snapshotWorkflowContractRecord({
     shape: params.step.input,
     value,
@@ -2227,8 +3183,8 @@ function snapshotWorkflowStepInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowStepOutput(params) {
-  const value = validateWorkflowStepOutput(params);
+function snapshotWorkflowStepOutput2(params) {
+  const value = validateWorkflowStepOutput2(params);
   return snapshotWorkflowContractRecord({
     shape: params.step.output,
     value,
@@ -2236,8 +3192,8 @@ function snapshotWorkflowStepOutput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowInterventionInput(params) {
-  const value = validateWorkflowInterventionInput(params);
+function snapshotWorkflowInterventionInput2(params) {
+  const value = validateWorkflowInterventionInput2(params);
   return snapshotWorkflowContractRecord({
     shape: params.intervention.input,
     value,
@@ -2245,8 +3201,8 @@ function snapshotWorkflowInterventionInput(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowInterventionResponse(params) {
-  const value = validateWorkflowInterventionResponse(params);
+function snapshotWorkflowInterventionResponse2(params) {
+  const value = validateWorkflowInterventionResponse2(params);
   return snapshotWorkflowInterventionResponseRecord({
     response: params.intervention.response,
     value,
@@ -2254,8 +3210,8 @@ function snapshotWorkflowInterventionResponse(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowInterventionDefaultResponse(params) {
-  const value = validateWorkflowInterventionDefaultResponse(params);
+function snapshotWorkflowInterventionDefaultResponse2(params) {
+  const value = validateWorkflowInterventionDefaultResponse2(params);
   return snapshotWorkflowInterventionResponseRecord({
     response: params.intervention.response,
     value,
@@ -2263,7 +3219,7 @@ function snapshotWorkflowInterventionDefaultResponse(params) {
     valueTypesById: params.valueTypesById
   });
 }
-function snapshotWorkflowActionInput(params) {
+function snapshotWorkflowActionInput2(params) {
   const snapshot = {
     params: snapshotJsonValue(params.params, "Workflow action params")
   };
@@ -2300,8 +3256,8 @@ function snapshotWorkflowInterventionResponseRecord(params) {
   return snapshot;
 }
 function snapshotSchemaOrRefValue(params) {
-  if (isObjectRefSchema(params.schema)) {
-    if (!isRecord2(params.value)) {
+  if (isObjectRefSchema2(params.schema)) {
+    if (!isRecord3(params.value)) {
       throw cannotSerialize(params.path);
     }
     return {
@@ -2342,7 +3298,7 @@ function snapshotSchemaValue(params) {
     }));
   }
   if (schema.type === "map") {
-    if (!isRecord2(value)) {
+    if (!isRecord3(value)) {
       throw cannotSerialize(path);
     }
     const snapshot = {};
@@ -2357,7 +3313,7 @@ function snapshotSchemaValue(params) {
     return snapshot;
   }
   if (schema.type === "object") {
-    if (!isRecord2(value)) {
+    if (!isRecord3(value)) {
       throw cannotSerialize(path);
     }
     const snapshot = {};
@@ -2382,7 +3338,7 @@ function snapshotSchemaValue(params) {
   if (schema.type === "valueTypeRef") {
     const valueType = valueTypesById.get(schema.valueTypeId);
     if (!valueType) {
-      throw new WorkflowValidationError(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
+      throw new WorkflowValidationError2(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
     }
     return snapshotSchemaValue({
       schema: valueType.schema,
@@ -2425,14 +3381,14 @@ function snapshotDate(value, path) {
   return value.toISOString();
 }
 function cannotSerialize(path) {
-  return new WorkflowValidationError(`[Sixb] ${path} cannot be serialized as workflow IO`);
+  return new WorkflowValidationError2(`[Sixb] ${path} cannot be serialized as workflow IO`);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/workflows/run-dispatch.ts
-class WorkflowRunDispatcher {
+class WorkflowRunDispatcher2 {
   dependencies;
   constructor(dependencies) {
     this.dependencies = dependencies;
@@ -2441,9 +3397,9 @@ class WorkflowRunDispatcher {
     assertAutomaticDispatchInput(input);
     const workflow = this.dependencies.definitions.workflows.getById(input.workflowId);
     if (!workflow) {
-      throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`);
+      throw new WorkflowValidationError2(`[Sixb] Unknown workflow '${input.workflowId}'`);
     }
-    const result = await dispatchWorkflowRun({
+    return dispatchWorkflowRun({
       errorReporterHost: this.dependencies,
       projectId: this.dependencies.id,
       workflow,
@@ -2457,11 +3413,11 @@ class WorkflowRunDispatcher {
         type: "schedule",
         scheduleId: input.scheduleId,
         eventId: input.source.eventId,
-        principal: SYSTEM_PRINCIPAL
+        principal: SYSTEM_PRINCIPAL2
       },
-      requesterGroupIds: [],
       metadata: input.metadata,
       queueJobId: input.runId,
+      validateExistingRun: (run) => assertAutomaticExecutionIdentity(this.dependencies, input, run),
       createExecution: async (executionId, runId) => createPrimitiveExecutionRecord({
         id: executionId,
         primitive: { kind: "workflow", id: workflow.id, runId },
@@ -2473,24 +3429,25 @@ class WorkflowRunDispatcher {
         }
       })
     });
-    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)
+  if (!persisted.created) {
+    await input.validateExistingRun?.(persisted.run);
+    if (input.validateExistingRun && persisted.run.status === "queued") {
+      await enqueueWorkflowRun(input, persisted.run);
+    }
     return existingWorkflowRunResult(persisted.run);
+  }
   return publishWorkflowRun(input, persisted);
 }
 function prepareWorkflowRun(input) {
   const value = input.input ?? {};
   return {
     runId: resolveWorkflowRunId(input.runId),
-    snapshot: snapshotWorkflowInput({
+    snapshot: snapshotWorkflowInput2({
       workflow: input.workflow,
       value,
       valueTypesById: input.valueTypesById
@@ -2500,7 +3457,7 @@ function prepareWorkflowRun(input) {
 async function persistWorkflowRun(input, request) {
   const workflowRuns = input.storage.workflowRuns;
   if (!workflowRuns) {
-    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
+    throw new WorkflowValidationError2("[Sixb] Workflow run storage is not configured.");
   }
   const existing = await workflowRuns.getById({
     projectId: input.projectId,
@@ -2510,7 +3467,7 @@ async function persistWorkflowRun(input, request) {
     assertExistingWorkflowRun(existing, input.workflow.id, request.snapshot);
     return { run: existing, created: false };
   }
-  const execution = await input.createExecution(`exec_${randomUUID5()}`, request.runId);
+  const execution = await input.createExecution(`exec_${randomUUID6()}`, request.runId);
   const queuedAt = new Date;
   try {
     return await input.storage.transaction(async (tx) => {
@@ -2523,7 +3480,7 @@ async function persistWorkflowRun(input, request) {
         return { run: raced, created: false };
       }
       if (!tx.workflowRuns) {
-        throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
+        throw new WorkflowValidationError2("[Sixb] Workflow run storage is not configured.");
       }
       await tx.executions.create(execution);
       const run = await tx.workflowRuns.queue({
@@ -2532,13 +3489,12 @@ async function persistWorkflowRun(input, request) {
         executionId: execution.id,
         workflowId: input.workflow.id,
         input: request.snapshot,
-        queuedAt,
-        requesterGroupIds: input.requesterGroupIds
+        queuedAt
       });
       return { run, execution, queuedAt, created: true };
     }, { isolation: "serializable" });
   } catch (error) {
-    if (!(error instanceof WorkflowRunError))
+    if (!(error instanceof WorkflowRunError2))
       throw error;
     const raced = await workflowRuns.getById({
       projectId: input.projectId,
@@ -2553,20 +3509,10 @@ async function persistWorkflowRun(input, request) {
 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];
+    job = await enqueueWorkflowRun(input, persisted.run);
   } catch (error) {
-    await failWorkflowRunPublication(input, persisted.run, error);
+    if (!input.validateExistingRun)
+      await failWorkflowRunPublication(input, persisted.run, error);
     throw error;
   }
   await input.events.emit({
@@ -2592,13 +3538,30 @@ async function publishWorkflowRun(input, persisted) {
     created: true
   };
 }
+async function enqueueWorkflowRun(input, run) {
+  const [job] = await input.queue.enqueue({
+    projectId: input.projectId,
+    jobs: [
+      {
+        ...input.queueJobId === undefined ? {} : { id: input.queueJobId },
+        type: "workflow.run.requested",
+        payload: { runId: run.id },
+        ...input.metadata === undefined ? {} : { metadata: input.metadata }
+      }
+    ]
+  });
+  if (!job || input.queueJobId !== undefined && job.id !== input.queueJobId) {
+    throw new WorkflowRunError2(`[Sixb] Queue did not acknowledge workflow run '${run.id}'.`);
+  }
+  return job;
+}
 async function failWorkflowRunPublication(input, run, error) {
   const workflowRuns = input.storage.workflowRuns;
   if (!workflowRuns) {
-    throw new WorkflowValidationError("[Sixb] Workflow run storage is not configured.");
+    throw new WorkflowValidationError2("[Sixb] Workflow run storage is not configured.");
   }
-  const failure = captureSixbFailure(error, {
-    allowedCodes: WORKFLOW_RUN_FAILURE_CODES,
+  const failure = captureSixbFailure2(error, {
+    allowedCodes: WORKFLOW_RUN_FAILURE_CODES2,
     defaultCode: "internal.unexpected",
     details: { workflowId: run.workflowId, runId: run.id }
   });
@@ -2608,7 +3571,7 @@ async function failWorkflowRunPublication(input, run, error) {
     status: "failed",
     error: failure
   });
-  reportRunFailure(input.errorReporterHost, error, {
+  reportRunFailure2(input.errorReporterHost, error, {
     projectId: input.projectId,
     runKind: "workflow",
     run: { runId: run.id, workflowId: run.workflowId },
@@ -2617,15 +3580,15 @@ async function failWorkflowRunPublication(input, run, error) {
 }
 function resolveWorkflowRunId(runId) {
   if (runId === undefined)
-    return `run_${randomUUID5()}`;
+    return `run_${randomUUID6()}`;
   if (!runId.trim()) {
-    throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty");
+    throw new WorkflowValidationError2("[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.`);
+    throw new WorkflowValidationError2(`[Sixb] Workflow run '${existing.id}' already exists with a different request payload.`);
   }
 }
 function existingWorkflowRunResult(existing) {
@@ -2643,36 +3606,27 @@ function assertAutomaticDispatchInput(input) {
   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({
+async function assertAutomaticExecutionIdentity(dependencies, input, run) {
+  const execution = 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.`);
+    throw new WorkflowValidationError2(`[Sixb] Workflow run '${run.id}' already exists with different automatic provenance.`);
   }
 }
 function assertNonBlank(value, label) {
   if (!value.trim())
-    throw new WorkflowValidationError(`[Sixb] ${label} must not be empty.`);
+    throw new WorkflowValidationError2(`[Sixb] ${label} must not be empty.`);
 }
 
 // src/workflows/request.ts
-async function requestWorkflowRun(runtime, execution, workflow, options = {}) {
+async function requestWorkflowRun2(runtime, execution, workflow, options = {}) {
   resolveExecutionScopeAuthorization(runtime.projectId, {
     execution,
     authorization: runtime.runtimeAuthorization
   });
-  assertAuthorized(runtime, { kind: "workflow.run", workflowId: workflow.id });
-  const requesterGroupIds = execution.requestedBy ? await snapshotRequesterGroupIds({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    principal: execution.requestedBy
-  }) : [];
+  assertAuthorized2(runtime, { kind: "workflow.run", workflowId: workflow.id });
   return dispatchWorkflowRun({
     errorReporterHost: runtime,
     projectId: runtime.projectId,
@@ -2684,9 +3638,8 @@ async function requestWorkflowRun(runtime, execution, workflow, options = {}) {
     runId: options.runId,
     input: options.input,
     source: options.source,
-    requesterGroupIds,
     createExecution: async (executionId, runId) => {
-      const caller = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
+      const caller = await ensureExecutionRecord2(runtime.storage.executions, executionRecordInputFromRuntime({
         execution,
         runtimeAuthorization: runtime.runtimeAuthorization
       }));
@@ -2702,7 +3655,7 @@ async function requestWorkflowRun(runtime, execution, workflow, options = {}) {
 // src/workflows/execution.ts
 function createWorkflowsRuntime(runtime, execution, source) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
-  const allowed = (workflowId) => isRuntimeAllowed(runtime, { kind: "workflow.run", workflowId });
+  const allowed = (workflowId) => isRuntimeAllowed2(runtime, { kind: "workflow.run", workflowId });
   const canAccessHistory = (workflowId) => {
     switch (authority.type) {
       case "denied":
@@ -2725,7 +3678,7 @@ function createWorkflowsRuntime(runtime, execution, source) {
     }) ?? null;
     if (!run || !canAccessHistory(run.workflowId))
       return null;
-    return authority.type === "unrestricted" || canViewWorkflowRun(authority.context, run) ? run : null;
+    return authority.type === "unrestricted" || canViewWorkflowRun2(authority.context, run) ? run : null;
   };
   const getRun = async (runId) => {
     const run = await getVisibleRunRecord(runId);
@@ -2753,14 +3706,14 @@ function createWorkflowsRuntime(runtime, execution, source) {
       const workflow = source.getById(workflowId);
       return workflow && allowed(workflowId) ? workflow : null;
     },
-    request: (workflow, options) => requestWorkflowRun(runtime, execution, workflow, options),
+    request: (workflow, options) => requestWorkflowRun2(runtime, execution, workflow, options),
     requestById: async (input) => {
-      assertAuthorized(runtime, { kind: "workflow.run", workflowId: input.workflowId });
+      assertAuthorized2(runtime, { kind: "workflow.run", workflowId: input.workflowId });
       const workflow = source.getById(input.workflowId);
       if (!workflow) {
-        throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`);
+        throw new WorkflowValidationError2(`[Sixb] Unknown workflow '${input.workflowId}'`);
       }
-      return requestWorkflowRun(runtime, execution, workflow, input);
+      return requestWorkflowRun2(runtime, execution, workflow, input);
     },
     runs: {
       getById: getRun,
@@ -2811,7 +3764,7 @@ function createWorkflowsRuntime(runtime, execution, source) {
         }) ?? null;
         if (!intervention || !canAccessHistory(intervention.workflowId))
           return null;
-        return authority.type === "unrestricted" || canViewWorkflowIntervention(authority.context, intervention) ? intervention : null;
+        return authority.type === "unrestricted" || canViewWorkflowIntervention2(authority.context, intervention) ? intervention : null;
       },
       list: (input = {}) => {
         if (authority.type === "denied" || authority.type === "delegated") {
@@ -2914,7 +3867,7 @@ function createBoundSixb(runtime, dependencies, execution) {
     execution,
     ...createExecutionFacades(runtime, execution, dependencies)
   };
-  shareOntologyMutationRuntime(runtime, sixb);
+  shareOntologyMutationRuntime2(runtime, sixb);
   if (dependencies.connectorConnections) {
     registerConnectorConnectionsRuntime(sixb, createConnectorConnectionsRuntime(runtime, execution, dependencies.connectorConnections));
   }
@@ -2935,6 +3888,7 @@ function createExecutionFacades(runtime, execution, dependencies) {
     projections: createProjectionsRuntime(runtime, dependencies.definitions.projections),
     rules: createRulesRuntime(runtime, dependencies.definitions.rules),
     agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
+    models: createModelsRuntime(runtime, execution, dependencies.definitions.models),
     aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
     events: createEventsRuntime(runtime),
     logs: createLogsRuntime(runtime, dependencies.logging),
@@ -2945,15 +3899,16 @@ function createExecutionFacades(runtime, execution, dependencies) {
   };
 }
 // src/execution/agent.ts
-function canInheritAgentRequestAuthorization(authorization) {
+function canInheritAgentRequestAuthorization2(authorization) {
   const ref = getAuthorizationRef(authorization);
   return ref.type === "disabled" || ref.type === "principal" && ref.principal.type === "user" && ref.credential !== undefined;
 }
-function createAgentExecutionRecord(input) {
+function createAgentExecutionRecord2(input) {
   assertAgentPrincipal(input.actorId, input.principal);
   return {
     id: input.id,
     projectId: input.parent.projectId,
+    requesterGroupIds: [...input.parent.requesterGroupIds],
     ...input.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.parent.requestedBy) },
     executor: { type: "agent", runId: input.runId },
     source: { type: "execution", executionId: input.parent.id },
@@ -2964,14 +3919,15 @@ function createAgentExecutionRecord(input) {
     }
   };
 }
-function createInheritedAgentExecutionRecord(input) {
+function createInheritedAgentExecutionRecord2(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.`);
+    throw new ExecutionStorageError2("invalid_input", `[Sixb] Agent run '${input.runId}' requires inheritable user or auth-disabled authority.`);
   }
   return {
     id: input.id,
     projectId: input.parent.projectId,
+    requesterGroupIds: [...input.parent.requesterGroupIds],
     ...input.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.parent.requestedBy) },
     executor: { type: "agent", runId: input.runId },
     source: { type: "execution", executionId: input.parent.id },
@@ -2979,16 +3935,16 @@ function createInheritedAgentExecutionRecord(input) {
     authorizationRef: structuredClone(authority)
   };
 }
-function bindDurableAgentExecution(host, input) {
-  const scope = restoreAgentExecutionScope(input);
+function bindDurableAgentExecution2(host, input) {
+  const scope = restoreAgentExecutionScope2(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);
+function restoreAgentExecutionScope2(input) {
+  assertAgentExecutionRecord2(input);
   const context = Object.freeze({
     id: input.execution.id,
     projectId: input.execution.projectId,
@@ -3013,7 +3969,7 @@ function restoreAgentExecutionScope(input) {
     })
   });
 }
-function assertAgentExecutionRecord(input) {
+function assertAgentExecutionRecord2(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);
@@ -3043,15 +3999,15 @@ function assertInheritedAgentAuthority(execution, runId, authorization) {
   }
 }
 function assertAgentPrincipal(actorId, principal) {
-  const expectedId = agentServiceAccountId(actorId);
+  const expectedId = agentServiceAccountId2(actorId);
   if (principal.id !== expectedId) {
-    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent '${actorId}' execution authority must reference service account '${expectedId}'.`);
+    throw new ExecutionStorageError2("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}'.`);
+  throw new ExecutionStorageError2("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, ShareError, 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 };
+export { resolveAgentContextParts2, agentRunQueueJobId2, subagentRunQueueJobId2, workflowAgentNodeQueueJobId2, dispatchQueuedAgentRuns2, dispatchQueuedSubagentRuns2, createAgentThreadId2, createAgentRunId2, createSubagentRunId2, createSubagentExecutionId2, createAgentMessageId2, agentContextCheckpointId2, createAgentRunExecutionToken2, runModelLoop2, assertNoAgentDefinitions, bindModelExecutionAttempt, ShareError2, WorkflowDefinitionError2, WorkflowValidationError2, assertNonEmpty, isStepDefinition2, isAgentStepDefinition2, isInterventionDefinition2, isWorkflowDefinition2, validateWorkflowDefinition2, validateWorkflowsAtStartup2, validateWorkflowAgentStepGroupReferences2, validateWorkflowInput2, validateWorkflowStepInput2, validateWorkflowStepOutput2, validateWorkflowInterventionInput2, validateWorkflowInterventionResponse2, validateWorkflowInterventionDefaultResponse2, validateWorkflowAgentStepInput2, validateWorkflowAgentStepOutput2, snapshotWorkflowAgentStepInput2, snapshotWorkflowAgentStepOutput2, snapshotWorkflowInput2, snapshotWorkflowStepInput2, snapshotWorkflowStepOutput2, snapshotWorkflowInterventionInput2, snapshotWorkflowInterventionResponse2, snapshotWorkflowInterventionDefaultResponse2, snapshotWorkflowActionInput2, WorkflowRunDispatcher2, requestWorkflowRun2, createBoundSixb, isBoundSixb, canInheritAgentRequestAuthorization2, createAgentExecutionRecord2, createInheritedAgentExecutionRecord2, bindDurableAgentExecution2, restoreAgentExecutionScope2, assertAgentExecutionRecord2, requestAgentRun2, retryAgentRun2 };
 
-//# debugId=3C841C41C07F660564756E2164756E21
+//# debugId=54032C3CC8C5EB0064756E2164756E21