@sixb/core 0.1.6 → 0.1.7

package/dist/{chunk-nva1xkjz.js → chunk-h0knpbz5.js}

@@ -3,11 +3,17 @@ import {
   SyncValidationError,
   createConnectorRuntime,
   requestSyncRun
-} from "./chunk-tg5mee00.js";
+} from "./chunk-ha58tjtt.js";
+import {
+  aiLimitSubjectsFromAttribution,
+  aiUsageLimitExceededError,
+  aiUsageLimitUnavailableError,
+  applicableAiLimitPolicyStatuses
+} from "./chunk-c15dr03f.js";
 import {
   PipelineError,
   requestPipelineRun
-} from "./chunk-8gv5z0zm.js";
+} from "./chunk-rp1mvzb4.js";
 import {
   appendTelemetry,
   createObjectSet,
@@ -18,7 +24,7 @@ import {
   upsertLinkBatch1 as upsertLinkBatch,
   upsertObject1 as upsertObject,
   upsertObjectBatch1 as upsertObjectBatch
-} from "./chunk-5sxb1168.js";
+} from "./chunk-e4rvtvpw.js";
 import {
   shareOntologyMutationRuntime
 } from "./chunk-xhy826cz.js";
@@ -28,12 +34,7 @@ import {
   executeObjectQueryLinks,
   existsObjects,
   facetObjects
-} from "./chunk-md8k0r54.js";
-import {
-  SIXB_API_ROUTES,
-  matchesPathPattern,
-  normalizeRoutePath
-} from "./chunk-qewtks41.js";
+} from "./chunk-3fqt22c4.js";
 import {
   registerConnectorConnectionsRuntime
 } from "./chunk-nf4r78r4.js";
@@ -41,59 +42,60 @@ import {
   isActionDefinition,
   requestAction,
   requestActionAndWait
-} from "./chunk-a44d5zgd.js";
+} from "./chunk-y35ma3mj.js";
 import {
   createPrimitiveExecutionRecord,
   ensureExecutionRecord,
   executionRecordInputFromRuntime
-} from "./chunk-f6erf2vv.js";
+} from "./chunk-hdz94br2.js";
 import {
   WORKFLOW_RUN_FAILURE_CODES
-} from "./chunk-t624af60.js";
-import {
-  WorkflowRunError
-} from "./chunk-fe5ev6mr.js";
-import {
-  AgentStorageError
-} from "./chunk-1g8negke.js";
+} from "./chunk-6ed5bwnd.js";
 import {
-  agentServiceAccountId,
-  ensureAgentExecutionIdentity,
-  resolveAgentExecutionAuthorization
-} from "./chunk-hceck7dq.js";
+  WorkflowRunError,
+  agentServiceAccountId
+} from "./chunk-qjzp9xyb.js";
 import {
   ExecutionStorageError
-} from "./chunk-h9kxd41f.js";
+} from "./chunk-gbrpsx4m.js";
+import {
+  AGENT_REASONING_LEVELS,
+  AgentStorageError
+} from "./chunk-08twe8m6.js";
 import {
   isObjectRefSchema,
   validateSchemaOrRefValue
-} from "./chunk-4gz41why.js";
+} from "./chunk-dqn23610.js";
+import {
+  RuntimeError
+} from "./chunk-p2vqaxkc.js";
+import {
+  isModelReasoning
+} from "./chunk-trxxmgnf.js";
 import {
   reportRunFailure
-} from "./chunk-dsrkgtnh.js";
+} from "./chunk-jq43kdvk.js";
 import {
-  AgentDefinitionError,
-  AgentMessageAdapterError,
   AgentRequestError,
-  AgentToolResultValidationError,
   normalizeAgentContextEntries
-} from "./chunk-rdeagz6b.js";
+} from "./chunk-atmkaf60.js";
 import {
   publishAgentRunActivity
-} from "./chunk-dm72y8wt.js";
+} from "./chunk-7y0f6rf1.js";
 import {
   SYSTEM_PRINCIPAL,
   principalsEqual
-} from "./chunk-1e8m6yn3.js";
+} from "./chunk-rre42skh.js";
 import {
   snapshotRequesterGroupIds
-} from "./chunk-rhrbz7d4.js";
+} from "./chunk-4a849fr1.js";
 import {
   AuthorizationError,
   assertAuthorized,
   assertCanManageConnector,
   assertPrivileged,
   assertProviderAccess,
+  assertRuntimeAuthorizationBound,
   canViewActionRun,
   canViewEvent,
   canViewPipelineRun,
@@ -102,31 +104,23 @@ import {
   canViewWorkflowIntervention,
   canViewWorkflowRun,
   createAgentRuntimeAuthorization,
+  getAuthorizationRef,
   isAllowed,
   resolveExecutionScopeAuthorization
-} from "./chunk-f83ka50g.js";
-import {
-  assertObjectTypeRegistered,
-  normalizeSchemaValue,
-  validateSchemaValue
-} from "./chunk-rnshztfq.js";
+} from "./chunk-37wk412q.js";
 import {
-  OntologyValidationError
-} from "./chunk-dktq02ne.js";
+  assertObjectTypeRegistered
+} from "./chunk-d63tybny.js";
 import {
-  isFileRef,
   supportsDirectUpload,
   supportsRangeRead
-} from "./chunk-zqysyfjt.js";
+} from "./chunk-08m3b6w8.js";
 import {
   captureSixbFailure
-} from "./chunk-0172wgm9.js";
+} from "./chunk-2xns679x.js";
 import {
-  cloneJsonValue,
-  getInvalidJsonValueReason,
-  isPlainRecord,
-  stableJsonStringify
-} from "./chunk-t8t39h7v.js";
+  isPlainRecord
+} from "./chunk-n6jxh8sw.js";
 
 // src/actions/execution.ts
 function createActionsRuntime(runtime, execution) {
@@ -197,13 +191,20 @@ async function resolveExecutionUsage(input) {
 }
 
 // src/agents/ids.ts
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 function createAgentThreadId() {
   return `agt_thr_${randomUUID()}`;
 }
 function createAgentRunId() {
   return `agt_run_${randomUUID()}`;
 }
+function createSubagentRunId(parentRunId, spawnKey) {
+  const digest = createHash("sha256").update(parentRunId).update("\x00").update(spawnKey).digest("hex");
+  return `agt_run_child_${digest}`;
+}
+function createSubagentExecutionId(runId) {
+  return `exec_${runId}`;
+}
 function createAgentMessageId() {
   return `agt_msg_${randomUUID()}`;
 }
@@ -249,6 +250,9 @@ function invalidContext(message) {
 function agentRunQueueJobId(runId) {
   return `agt_job_${runId}`;
 }
+function subagentRunQueueJobId(runId) {
+  return `agt_child_job_${runId}`;
+}
 function workflowAgentNodeQueueJobId(nodeRunId) {
   return `wfa_job_${nodeRunId}`;
 }
@@ -259,11 +263,12 @@ async function dispatchQueuedAgentRuns(input) {
     ids: [...new Set(input.runIds)].slice(0, limit)
   }) : (await input.storage.runs.list({
     projectId: input.projectId,
+    kinds: ["conversation"],
     statuses: ["queued"],
     order: "asc",
     limit
   })).runs;
-  const queued = runs.filter((run) => run.status === "queued");
+  const queued = runs.filter((run) => run.kind === "conversation" && run.status === "queued");
   if (queued.length === 0) {
     return { scanned: 0, dispatched: [], failures: [] };
   }
@@ -293,6 +298,47 @@ async function dispatchQueuedAgentRuns(input) {
     };
   }
 }
+async function dispatchQueuedSubagentRuns(input) {
+  const limit = normalizeLimit(input.limit);
+  const runs = input.runIds ? await input.storage.runs.getByIds({
+    projectId: input.projectId,
+    ids: [...new Set(input.runIds)].slice(0, limit)
+  }) : (await input.storage.runs.list({
+    projectId: input.projectId,
+    kinds: ["subagent"],
+    statuses: ["queued"],
+    order: "asc",
+    limit
+  })).runs;
+  const queued = runs.filter((run) => run.kind === "subagent" && run.status === "queued");
+  if (queued.length === 0)
+    return { scanned: 0, dispatched: [], failures: [] };
+  try {
+    const jobs = await input.queue.enqueue({
+      projectId: input.projectId,
+      jobs: queued.map((run) => ({
+        id: subagentRunQueueJobId(run.id),
+        type: "agent.subagent-run.requested",
+        payload: { runId: run.id }
+      }))
+    });
+    const jobsById = new Set(jobs.map((job) => job.id));
+    const dispatched = queued.map((run) => {
+      const jobId = subagentRunQueueJobId(run.id);
+      if (!jobsById.has(jobId)) {
+        throw new Error(`[Sixb] Subagent queue did not return job '${jobId}'.`);
+      }
+      return { runId: run.id, jobId };
+    });
+    return { scanned: queued.length, dispatched, failures: [] };
+  } catch (error) {
+    return {
+      scanned: queued.length,
+      dispatched: [],
+      failures: queued.map((run) => ({ runId: run.id, error }))
+    };
+  }
+}
 function normalizeLimit(value) {
   if (value === undefined)
     return 100;
@@ -302,16 +348,38 @@ function normalizeLimit(value) {
   return Math.floor(value);
 }
 
+// src/agents/retired-config.ts
+function assertNoAgentDefinitions(input) {
+  if ("agents" in input) {
+    throw new RuntimeError("[Sixb] Agent definitions are no longer supported. Configure 'models' and 'tools' on createSixb() instead.");
+  }
+}
+function assertNoAgentSelector(input) {
+  if ("agentId" in input || "agentIds" in input) {
+    throw new AgentRequestError("agent_selector_removed", "[Sixb] There is one project Agent. Remove the agentId selector and use sixb.agent.");
+  }
+}
+
 // src/agents/request.ts
-async function requestAgentRun(runtime, execution, security, agent, input) {
-  assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id });
+async function requestAgentRun(runtime, execution, models, input) {
+  assertNoAgentSelector(input);
+  assertAuthorized(runtime, { kind: "agent.run" });
+  assertRequestAuthorityCanRunAgent(runtime);
+  const spec = resolveConversationRunSpec({ models, input });
   const contextParts = await resolveAgentContextParts(runtime, input.context);
   const agents = requireAgentStorage(runtime);
   const projectId = runtime.projectId;
   const principal = runtime.authorization?.principal ?? input.principal ?? SYSTEM_PRINCIPAL;
+  const runId = createAgentRunId();
+  const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
+  const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
+    auth: runtime.storage.auth,
+    projectId,
+    principal: durableExecution.requestedBy
+  }) : [];
+  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds);
   const { thread, createdThread } = await resolveThread(agents, {
     projectId,
-    agentId: agent.id,
     threadId: input.threadId,
     title: input.title,
     principal
@@ -319,13 +387,6 @@ async function requestAgentRun(runtime, execution, security, agent, input) {
   if (thread.activeRunId !== null) {
     throw new AgentRequestError("active_run_exists", `[Sixb] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
   }
-  const runId = createAgentRunId();
-  const durableExecution = await prepareDurableAgentExecution(runtime, execution, security, agent, runId);
-  const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
-    auth: runtime.storage.auth,
-    projectId,
-    principal: durableExecution.requestedBy
-  }) : [];
   const triggerMessageId = input.messageId ?? createAgentMessageId();
   let run;
   try {
@@ -353,8 +414,8 @@ async function requestAgentRun(runtime, execution, security, agent, input) {
         projectId,
         executionId: durableExecution.id,
         threadId: thread.id,
-        agentId: agent.id,
         triggerMessageId,
+        spec,
         requesterGroupIds
       });
     });
@@ -372,22 +433,28 @@ async function requestAgentRun(runtime, execution, security, agent, input) {
     createdThread
   };
 }
-async function retryAgentRun(runtime, execution, security, agent, failedRun) {
-  assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id });
-  if (failedRun.agentId !== agent.id) {
-    throw new AgentRequestError("agent_not_found", `[Sixb] Agent run '${failedRun.id}' does not belong to agent '${agent.id}'.`);
-  }
+async function retryAgentRun(runtime, execution, models, failedRun) {
+  assertAuthorized(runtime, { kind: "agent.run" });
+  assertRequestAuthorityCanRunAgent(runtime);
   if (failedRun.status !== "failed") {
     throw new AgentRequestError("run_not_retryable", `[Sixb] Only failed Agent runs can be retried.`);
   }
   const agents = requireAgentStorage(runtime);
+  const thread = await agents.threads.getById({
+    projectId: runtime.projectId,
+    id: failedRun.threadId
+  });
+  if (!thread) {
+    throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${failedRun.threadId}' was not found.`);
+  }
   const runId = createAgentRunId();
-  const durableExecution = await prepareDurableAgentExecution(runtime, execution, security, agent, runId);
+  const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
   const requesterGroupIds = durableExecution.requestedBy ? await snapshotRequesterGroupIds({
     auth: runtime.storage.auth,
     projectId: runtime.projectId,
     principal: durableExecution.requestedBy
   }) : [];
+  await assertAiLimitPreflight(runtime, durableExecution, requesterGroupIds);
   const run = await runtime.storage.transaction(async (tx) => {
     const agents2 = tx.agents;
     if (!agents2) {
@@ -404,8 +471,11 @@ async function retryAgentRun(runtime, execution, security, agent, failedRun) {
       projectId: runtime.projectId,
       executionId: durableExecution.id,
       threadId: failedRun.threadId,
-      agentId: agent.id,
       triggerMessageId: failedRun.triggerMessageId,
+      spec: failedRun.spec ?? resolveConversationRunSpec({
+        models,
+        input: {}
+      }),
       requesterGroupIds
     });
   });
@@ -413,31 +483,61 @@ async function retryAgentRun(runtime, execution, security, agent, failedRun) {
   const jobId = await dispatchAgentRun(runtime, agents, runId);
   return { run, ...jobId ? { jobId } : {}, createdThread: false };
 }
-async function prepareDurableAgentExecution(runtime, execution, security, agent, runId) {
-  const identity = await ensureAgentExecutionIdentity({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    agent
-  });
-  const resolved = await resolveAgentExecutionAuthorization({
-    auth: runtime.storage.auth,
-    projectId: runtime.projectId,
-    agentId: agent.id,
-    authorizationRef: { type: "principal", principal: identity.principal },
-    security
+async function assertAiLimitPreflight(runtime, execution, requesterGroupIds) {
+  const limits = runtime.storage.aiLimits;
+  if (!limits)
+    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
+  const subjects = aiLimitSubjectsFromAttribution(execution.requestedBy, requesterGroupIds);
+  let applicable;
+  try {
+    applicable = applicableAiLimitPolicyStatuses(await limits.listPolicyStatuses({ projectId: runtime.projectId }), subjects);
+  } catch {
+    throw aiUsageLimitUnavailableError(["limitStorageUnavailable"]);
+  }
+  const unavailable = applicable.filter((status) => status.accountingStatus === "unavailable");
+  if (unavailable.length > 0) {
+    throw aiUsageLimitUnavailableError(["incompleteAccounting"]);
+  }
+  const exhausted = applicable.filter((status) => status.exhausted);
+  if (exhausted.length > 0) {
+    const resetAt = new Date(Math.min(...exhausted.map((status) => status.period.resetAt.getTime())));
+    throw aiUsageLimitExceededError(resetAt);
+  }
+}
+function resolveConversationRunSpec(input) {
+  if (!input.models) {
+    throw new AgentRequestError("model_not_found", "[Sixb] Configure models.language before starting the Agent.");
+  }
+  const selected = input.input.model ?? input.models.default;
+  const model = input.models.getByRef(selected);
+  if (model === null) {
+    throw new AgentRequestError("model_not_found", `[Sixb] Language model '${selected.provider}/${selected.modelId}' is not in the project model catalog.`);
+  }
+  const reasoning = input.input.reasoning;
+  if (reasoning !== undefined && !isModelReasoning(reasoning)) {
+    throw new AgentRequestError("invalid_model_selection", `[Sixb] Agent reasoning must be one of: ${AGENT_REASONING_LEVELS.join(", ")}, or a nonnegative budgetTokens object.`);
+  }
+  return Object.freeze({
+    model: Object.freeze({ provider: selected.provider, modelId: selected.modelId }),
+    ...reasoning === undefined ? {} : { reasoning }
   });
+}
+async function prepareDurableAgentExecution(runtime, execution, runId) {
   const parent = await ensureExecutionRecord(runtime.storage.executions, executionRecordInputFromRuntime({
     execution,
     runtimeAuthorization: runtime.runtimeAuthorization
   }));
-  return createAgentExecutionRecord({
+  return createInheritedAgentExecutionRecord({
     id: `exec_${randomUUID2()}`,
     parent,
-    agentId: agent.id,
-    runId,
-    principal: resolved.identity.principal
+    runId
   });
 }
+function assertRequestAuthorityCanRunAgent(runtime) {
+  if (!canInheritAgentRequestAuthorization(runtime.runtimeAuthorization)) {
+    throw new AgentRequestError("authority_not_inheritable", "[Sixb] The Agent requires an authenticated user request or disabled authorization.");
+  }
+}
 async function dispatchAgentRun(runtime, agents, runId) {
   try {
     const dispatch = await dispatchQueuedAgentRuns({
@@ -470,16 +570,12 @@ async function resolveThread(agents, params) {
       id: params.threadId
     });
     if (existing) {
-      if (existing.agentId !== params.agentId) {
-        throw new AgentRequestError("thread_agent_mismatch", `[Sixb] Agent thread '${existing.id}' belongs to agent '${existing.agentId}', not '${params.agentId}'.`);
-      }
       return { thread: existing, createdThread: false };
     }
   }
   const thread = await agents.threads.create({
     id: params.threadId ?? createAgentThreadId(),
     projectId: params.projectId,
-    agentId: params.agentId,
     ownerPrincipal: params.principal,
     ...params.title === undefined ? {} : { title: params.title }
   });
@@ -494,44 +590,49 @@ function requireAgentStorage(runtime) {
 }
 
 // src/agents/execution.ts
-function createAgentsRuntime(runtime, execution, source, security) {
+function createAgentRuntime(runtime, execution, models) {
   const principal = runtime.authorization?.principal ?? SYSTEM_PRINCIPAL;
-  const allowed = (agentId) => isAllowed(runtime.authorization, { kind: "agent.run", agentId });
-  const getThread = async (threadId) => {
+  const allowed = () => isAllowed(runtime.authorization, { kind: "agent.run" });
+  const getVisibleThreadRecord = async (threadId) => {
     const thread = await runtime.storage.agents?.threads.getById({
       projectId: runtime.projectId,
       id: threadId
     }) ?? null;
-    if (!thread || !allowed(thread.agentId))
+    if (!thread || !allowed())
       return null;
     return runtime.authorization && !principalsEqual(principal, thread.ownerPrincipal) ? null : thread;
   };
-  const getAgent = (agentId) => {
-    const agent = source.getById(agentId);
-    return agent && allowed(agentId) ? agent : null;
+  const getAgent = () => {
+    const model = models?.language.default;
+    if (!model || !allowed())
+      return null;
+    return {
+      name: "Sixb",
+      model: { provider: model.provider, modelId: model.modelId }
+    };
   };
   const getVisibleRunRecord = async (runId) => {
     const run = await runtime.storage.agents?.runs.getById({
       projectId: runtime.projectId,
       id: runId
     }) ?? null;
-    if (!run)
+    if (!run || run.kind !== "conversation")
       return null;
-    const thread = await getThread(run.threadId);
-    return thread?.agentId === run.agentId ? run : null;
+    const thread = await getVisibleThreadRecord(run.threadId);
+    return thread ? run : null;
   };
   const getRun = async (runId) => {
     const run = await getVisibleRunRecord(runId);
     return run ? attachRunView(runtime, run) : null;
   };
   return {
-    list: () => source.list().filter((agent) => allowed(agent.id)),
-    getById: getAgent,
+    get: getAgent,
     threads: {
       create: async (input) => {
-        const agent = getAgent(input.agentId);
+        assertNoAgentSelector(input);
+        const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${input.agentId}'.`);
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
         const storage = runtime.storage.agents;
         if (!storage) {
@@ -540,35 +641,35 @@ function createAgentsRuntime(runtime, execution, source, security) {
         return storage.threads.create({
           id: input.id ?? createAgentThreadId(),
           projectId: runtime.projectId,
-          agentId: agent.id,
           ownerPrincipal: principal,
           ...input.title === undefined ? {} : { title: input.title }
         });
       },
-      getById: getThread,
-      list: (input = {}) => {
+      getById: getVisibleThreadRecord,
+      list: async (input = {}) => {
+        assertNoAgentSelector(input);
         const storage = runtime.storage.agents;
-        if (!storage)
-          return Promise.resolve({ threads: [], hasMore: false, total: 0 });
+        if (!storage || !allowed())
+          return { threads: [], hasMore: false, total: 0 };
         return storage.threads.list({
-          projectId: runtime.projectId,
           ...input,
-          agentIds: runtime.authorization ? [...runtime.authorization.grants["run:agent"]] : undefined,
+          projectId: runtime.projectId,
           ownerPrincipal: runtime.authorization ? principal : undefined
         });
       }
     },
     runs: {
       request: async (input) => {
-        const agent = source.getById(input.agentId);
+        assertNoAgentSelector(input);
+        const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${input.agentId}'.`);
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
-        assertAuthorized(runtime, { kind: "agent.run", agentId: agent.id });
-        if (input.threadId && !await getThread(input.threadId)) {
+        assertAuthorized(runtime, { kind: "agent.run" });
+        if (input.threadId && !await getVisibleThreadRecord(input.threadId)) {
           throw new AgentRequestError("thread_not_found", `[Sixb] Agent thread '${input.threadId}' not found.`);
         }
-        const result = await requestAgentRun(runtime, execution, security, agent, {
+        const result = await requestAgentRun(runtime, execution, models?.language, {
           ...input,
           principal
         });
@@ -579,26 +680,27 @@ function createAgentsRuntime(runtime, execution, source, security) {
         if (!failedRun) {
           throw new AgentRequestError("run_not_found", `[Sixb] Agent run '${runId}' was not found.`);
         }
-        const agent = getAgent(failedRun.agentId);
+        const agent = getAgent();
         if (!agent) {
-          throw new AgentRequestError("agent_not_found", `[Sixb] Unknown agent '${failedRun.agentId}'.`);
+          throw new AgentRequestError("agent_not_found", "[Sixb] The project Agent is unavailable.");
         }
-        const result = await retryAgentRun(runtime, execution, security, agent, failedRun);
+        const result = await retryAgentRun(runtime, execution, models?.language, failedRun);
         return { ...result, run: await attachRunView(runtime, result.run) };
       },
       getById: getRun,
       listForThread: async (threadId, input = {}) => {
+        assertNoAgentSelector(input);
         const storage = runtime.storage.agents;
-        if (!storage || !await getThread(threadId))
+        if (!storage || !await getVisibleThreadRecord(threadId))
           return null;
         const result = await storage.runs.list({
-          projectId: runtime.projectId,
           ...input,
+          projectId: runtime.projectId,
           threadId
         });
         return {
           ...result,
-          runs: await attachRunViews(runtime, result.runs)
+          runs: await attachRunViews(runtime, result.runs.filter((run) => run.kind === "conversation"))
         };
       }
     }
@@ -644,6 +746,110 @@ 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 assertPolicyReadable = () => {
+    const resolved = assertRuntimeAuthorizationBound(runtime);
+    if (resolved.type === "principal" && !isAllowed(resolved.context, { kind: "aiUsage.observe" }) && !isAllowed(resolved.context, { kind: "aiUsage.manage" })) {
+      assertObservable();
+    }
+  };
+  const requireCosts = () => {
+    if (!runtime.storage.aiCosts) {
+      throw new Error("[Sixb] AI cost storage is not configured.");
+    }
+    return runtime.storage.aiCosts;
+  };
+  const requireLimits = () => {
+    if (!runtime.storage.aiLimits) {
+      throw new Error("[Sixb] AI limit storage is not configured.");
+    }
+    return runtime.storage.aiLimits;
+  };
+  return {
+    accountingConfigured: runtime.storage.aiCosts !== undefined,
+    limitsConfigured: runtime.storage.aiLimits !== undefined,
+    assertObservable,
+    assertManageable,
+    canManageLimits: () => {
+      const resolved = assertRuntimeAuthorizationBound(runtime);
+      return resolved.type !== "principal" || isAllowed(resolved.context, { kind: "aiUsage.manage" });
+    },
+    queryOverview: (input) => {
+      assertObservable();
+      return requireCosts().queryProjectOverview({ ...input, projectId: runtime.projectId });
+    },
+    listModelCalls: (input) => {
+      assertObservable();
+      return requireCosts().listModelCalls({ ...input, projectId: runtime.projectId });
+    },
+    listModelCallGroups: (input) => {
+      assertObservable();
+      return requireCosts().listModelCallGroups({ ...input, projectId: runtime.projectId });
+    },
+    listLimitPolicies: (input = {}) => {
+      assertPolicyReadable();
+      return requireLimits().listPolicies({ ...input, projectId: runtime.projectId });
+    },
+    listLimitStatuses: (input = {}) => {
+      assertObservable();
+      return requireLimits().listPolicyStatuses({
+        ...input.includeDisabled === undefined ? {} : { includeDisabled: input.includeDisabled },
+        projectId: runtime.projectId,
+        existingGroupIds: security.listGroups().map((group) => group.id)
+      });
+    },
+    listLimitSubjectOptions: async () => {
+      assertManageable();
+      const groups = security.listGroups().map((group) => ({
+        id: group.id,
+        ...group.label === undefined ? {} : { label: group.label },
+        ...group.description === undefined ? {} : { description: group.description }
+      }));
+      const auth = runtime.storage.auth;
+      if (!auth)
+        return { groups, users: [], serviceAccounts: [] };
+      const [users, serviceAccounts] = await Promise.all([
+        auth.users.list({ projectId: runtime.projectId, order: "asc" }),
+        auth.serviceAccounts.list({ projectId: runtime.projectId, order: "asc" })
+      ]);
+      return {
+        groups,
+        users: users.users.map((user) => ({
+          id: user.id,
+          email: user.email,
+          ...user.displayName === undefined ? {} : { displayName: user.displayName },
+          status: user.status
+        })),
+        serviceAccounts: serviceAccounts.serviceAccounts.map((serviceAccount) => ({
+          id: serviceAccount.id,
+          name: serviceAccount.name,
+          ...serviceAccount.description === undefined ? {} : { description: serviceAccount.description },
+          status: serviceAccount.status
+        }))
+      };
+    },
+    createLimitPolicy: (input) => {
+      assertManageable();
+      return requireLimits().createPolicy({
+        ...input,
+        id: input.id ?? `ailim_${randomUUID3()}`,
+        projectId: runtime.projectId
+      });
+    },
+    updateLimitPolicy: (input) => {
+      assertManageable();
+      return requireLimits().updatePolicy({ ...input, projectId: runtime.projectId });
+    },
+    deleteLimitPolicy: (id) => {
+      assertManageable();
+      return requireLimits().deletePolicy({ id, projectId: runtime.projectId });
+    }
+  };
+}
 // src/blob-storage/execution.ts
 function createBlobsRuntime(runtime, execution, blobStorage) {
   const assertAccess = () => assertProviderAccess(runtime, execution, "blobs.access");
@@ -1086,1112 +1292,32 @@ class WorkflowValidationError extends Error {
 }
 
 // src/workflows/run-dispatch.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { isDeepStrictEqual } from "util";
 
-// src/agents/context-model.ts
-function serializeAgentContextForModel(parts) {
-  if (parts.length === 0)
-    return;
-  const lines = ["<sixb_user_context>"];
-  for (const part of parts) {
-    if (part.context.kind === "object") {
-      lines.push("  <object_context>", `    <object_type_id>${escapeXml(part.context.ref.objectTypeId)}</object_type_id>`, `    <primary_id>${escapeXml(part.context.ref.primaryId)}</primary_id>`, "  </object_context>");
-      continue;
-    }
-    lines.push("  <app_state_context>", `    <id>${escapeXml(part.context.id)}</id>`, `    <description>${escapeXml(part.context.description)}</description>`, `    <value format="json">${escapeXml(stableJsonStringify(part.context.value))}</value>`, "  </app_state_context>");
-  }
-  lines.push("</sixb_user_context>");
-  return lines.join(`
-`);
-}
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-
-// src/agents/tool-result.ts
-function isAgentToolResult(value) {
-  return isPlainRecord(value) && value.kind === "agentToolResult" && getInvalidAgentToolResultReason(value) === undefined;
-}
-function getInvalidAgentToolResultReason(value) {
-  if (!isPlainRecord(value) || value.kind !== "agentToolResult") {
-    return;
-  }
-  if (!Array.isArray(value.content)) {
-    return "result.content must be an array";
-  }
-  const unsupportedKey = Object.keys(value).find((key) => key !== "kind" && key !== "content");
-  if (unsupportedKey) {
-    return `result.${unsupportedKey} is not supported`;
-  }
-  if (value.content.length === 0) {
-    return "result.content must contain at least one content part";
-  }
-  for (let index = 0;index < value.content.length; index += 1) {
-    const part = value.content[index];
-    const path = `result.content[${index}]`;
-    if (!isPlainRecord(part)) {
-      return `${path} must be a text or file content part`;
-    }
-    if (part.type === "text") {
-      if (typeof part.text !== "string") {
-        return `${path}.text must be a string`;
-      }
-      const unsupportedKey2 = Object.keys(part).find((key) => key !== "type" && key !== "text");
-      if (unsupportedKey2) {
-        return `${path}.${unsupportedKey2} is not supported`;
-      }
-      continue;
-    }
-    if (part.type === "file") {
-      if (!isFileRef(part.fileRef)) {
-        return `${path}.fileRef must be a valid FileRef`;
-      }
-      const unsupportedKey2 = Object.keys(part).find((key) => key !== "type" && key !== "fileRef");
-      if (unsupportedKey2) {
-        return `${path}.${unsupportedKey2} is not supported`;
-      }
-      continue;
-    }
-    return `${path}.type must be 'text' or 'file'`;
-  }
-  return;
-}
-
-// src/agents/adapters.ts
-var TOOL_TYPE_PREFIX = "tool-";
-function assertAdapter(condition, message) {
-  if (!condition) {
-    throw new AgentMessageAdapterError(`[Sixb] ${message}`);
-  }
-}
-function requireJson(value, label) {
-  const reason = getInvalidJsonValueReason(value, label);
-  assertAdapter(reason === undefined, `agent message ${label} must be a JSON value; ${reason}`);
-  return value;
-}
-function optionalJson(value, label) {
-  if (value === undefined)
-    return;
-  return requireJson(omitUndefinedObjectProperties(value), label);
-}
-function omitUndefinedObjectProperties(value) {
-  return omitUndefinedObjectPropertiesInternal(value, new Set);
-}
-function omitUndefinedObjectPropertiesInternal(value, seen) {
-  if (typeof value !== "object" || value === null)
-    return value;
-  if (seen.has(value))
-    return value;
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) {
-      return value.map((entry) => omitUndefinedObjectPropertiesInternal(entry, seen));
-    }
-    if (!isPlainRecord(value))
-      return value;
-    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).map(([key, entry]) => [key, omitUndefinedObjectPropertiesInternal(entry, seen)]));
-  } finally {
-    seen.delete(value);
-  }
-}
-function isToolType(type) {
-  return type === "dynamic-tool" || type.startsWith(TOOL_TYPE_PREFIX);
-}
-function toolNameFromInbound(part) {
-  if (part.type === "dynamic-tool") {
-    assertAdapter(typeof part.toolName === "string" && part.toolName.length > 0, "dynamic-tool part is missing a tool name");
-    return part.toolName;
-  }
-  const name = part.type.slice(TOOL_TYPE_PREFIX.length);
-  assertAdapter(name.length > 0, `tool part type '${part.type}' is missing a tool name`);
-  return name;
-}
-function fromAiSdk(message) {
-  const { role } = message;
-  assertAdapter(role === "system" || role === "user" || role === "assistant", `unsupported message role '${role}'`);
-  const parts = message.parts.map((part) => fromAiSdkPart(part));
-  assertAdapter(role === "user" || !parts.some((part) => part.type === "context"), "context parts are only valid on user messages");
-  const metadata = optionalJson(message.metadata, "metadata");
-  return {
-    role,
-    parts,
-    ...metadata === undefined ? {} : { metadata }
-  };
-}
-function fromAiSdkPart(part) {
-  switch (part.type) {
-    case "text":
-    case "reasoning": {
-      assertAdapter(typeof part.text === "string", `${part.type} part is missing text`);
-      assertAdapter(part.state !== "streaming", `cannot persist a streaming ${part.type} part; messages are written only once finalized`);
-      const providerMetadata = optionalJson(part.providerMetadata, `${part.type}.providerMetadata`);
-      return {
-        type: part.type,
-        text: part.text,
-        ...providerMetadata === undefined ? {} : { providerMetadata }
-      };
-    }
-    case "step-start":
-      return { type: "step-start" };
-    case "file": {
-      assertAdapter(isFileRef(part.fileRef), "file part is missing a valid fileRef");
-      const providerMetadata = optionalJson(part.providerMetadata, "file.providerMetadata");
-      return {
-        type: "file",
-        fileRef: part.fileRef,
-        ...providerMetadata === undefined ? {} : { providerMetadata }
-      };
-    }
-    case "context":
-      return fromUiContextPart(part);
-    default: {
-      assertAdapter(isToolType(part.type), `unsupported message part type '${part.type}'; extend the Sixb message part union to support it`);
-      return fromAiSdkToolPart(part);
-    }
-  }
-}
-function fromUiContextPart(part) {
-  try {
-    const [entry] = normalizeAgentContextEntries([
-      { context: part.context, origin: part.origin }
-    ]);
-    return { type: "context", ...entry };
-  } catch (error) {
-    throw new AgentMessageAdapterError(error instanceof Error ? error.message : "[Sixb] Invalid agent context part.");
-  }
-}
-function fromAiSdkToolPart(part) {
-  const dynamic = part.type === "dynamic-tool";
-  const toolName = toolNameFromInbound(part);
-  assertAdapter(typeof part.toolCallId === "string" && part.toolCallId.length > 0, `tool part '${part.type}' is missing a toolCallId`);
-  assertAdapter(part.state === "output-available" || part.state === "output-error", `cannot persist tool part '${part.toolCallId}' in transient state '${part.state}'; only terminal states are stored`);
-  const input = part.input === undefined ? null : requireJson(part.input, "tool input");
-  const providerMetadata = optionalJson(part.callProviderMetadata, "tool callProviderMetadata");
-  const base = {
-    type: "tool-call",
-    toolCallId: part.toolCallId,
-    toolName,
-    input,
-    ...dynamic ? { dynamic: true } : {},
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...providerMetadata === undefined ? {} : { providerMetadata }
-  };
-  if (part.state === "output-available") {
-    return { ...base, state: "output-available", output: requireJson(part.output, "tool output") };
-  }
-  assertAdapter(typeof part.errorText === "string", `tool part '${part.toolCallId}' is missing errorText`);
-  return { ...base, state: "output-error", errorText: part.errorText };
-}
-function toUiMessage(message) {
-  return {
-    role: message.role,
-    parts: message.parts.map((part) => toUiPart(part)),
-    ...message.metadata === undefined ? {} : { metadata: message.metadata }
-  };
-}
-function toUiPart(part) {
-  switch (part.type) {
-    case "text":
-    case "reasoning":
-      return {
-        type: part.type,
-        text: part.text,
-        ...part.providerMetadata === undefined ? {} : { providerMetadata: part.providerMetadata }
-      };
-    case "step-start":
-      return { type: "step-start" };
-    case "file":
-      return {
-        type: "file",
-        fileRef: part.fileRef,
-        ...part.providerMetadata === undefined ? {} : { providerMetadata: part.providerMetadata }
-      };
-    case "context":
-      return { type: "context", context: part.context, origin: part.origin };
-    case "tool-call":
-      return toUiToolPart(part);
-  }
-}
-function toUiToolPart(part) {
-  const body = {
-    toolCallId: part.toolCallId,
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...part.providerMetadata === undefined ? {} : { callProviderMetadata: part.providerMetadata }
-  };
-  const state = part.state === "output-available" ? { state: "output-available", input: part.input, output: part.output } : { state: "output-error", input: part.input, errorText: part.errorText };
-  if (part.dynamic) {
-    return { type: "dynamic-tool", toolName: part.toolName, ...body, ...state };
-  }
-  return { type: `tool-${part.toolName}`, ...body, ...state };
-}
-function toModelMessages(messages, options = {}) {
-  const result = [];
-  for (const message of messages) {
-    switch (message.role) {
-      case "system":
-        result.push(systemModelMessage(message));
-        break;
-      case "user":
-        result.push(userModelMessage(message, options));
-        break;
-      case "assistant":
-        appendAssistantModelMessages(result, message, options);
-        break;
-    }
-  }
-  return result;
-}
-function systemModelMessage(message) {
-  const textParts = message.parts.filter(isTextPart);
-  const providerOptions = mergeProviderMetadata(textParts);
-  return {
-    role: "system",
-    content: textParts.map((part) => part.text).join(""),
-    ...providerOptions === undefined ? {} : { providerOptions }
-  };
-}
-function mergeProviderMetadata(parts) {
-  let merged;
-  for (const part of parts) {
-    const meta = part.providerMetadata;
-    if (meta !== undefined && typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
-      merged = { ...merged ?? {}, ...meta };
-    }
-  }
-  return merged;
-}
-function userModelMessage(message, options) {
-  const content = [];
-  const serializedContext = serializeAgentContextForModel(message.parts.filter((part) => part.type === "context"));
-  if (serializedContext) {
-    content.push({ type: "text", text: `${serializedContext}
-
-` });
-  }
-  message.parts.forEach((part, partIndex) => {
-    if (part.type === "text") {
-      content.push({
-        type: "text",
-        text: part.text,
-        ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-      });
-      return;
-    }
-    if (part.type === "file") {
-      const fileContext = options.fileText?.({ message, part, partIndex });
-      if (fileContext) {
-        content.push({ type: "text", text: fileContext });
-      }
-      const resolved = options.fileData?.({ message, part, partIndex });
-      if (resolved) {
-        const projection = resolved instanceof URL ? { data: resolved } : resolved;
-        content.push({
-          type: "file",
-          data: projection.data,
-          mediaType: projection.mediaType ?? part.fileRef.mediaType ?? "application/octet-stream",
-          ...projection.filename !== undefined ? { filename: projection.filename } : part.fileRef.fileName === undefined ? {} : { filename: part.fileRef.fileName },
-          ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-        });
-      }
-    }
-  });
-  return { role: "user", content };
-}
-function appendAssistantModelMessages(result, message, options) {
-  let block = [];
-  const flush = () => {
-    if (block.length === 0) {
-      return;
-    }
-    const current = block;
-    block = [];
-    const content = [];
-    for (const { part, partIndex } of current) {
-      if (part.type === "text") {
-        content.push({
-          type: "text",
-          text: part.text,
-          ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-        });
-      } else if (part.type === "reasoning") {
-        content.push({
-          type: "reasoning",
-          text: part.text,
-          ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-        });
-      } else if (part.type === "file") {
-        const fileContext = options.fileText?.({ message, part, partIndex });
-        if (fileContext) {
-          content.push({ type: "text", text: fileContext });
-        }
-      } else if (part.type === "tool-call") {
-        content.push(toolCallModelPart(part));
-        if (part.providerExecuted === true) {
-          content.push(toolResultModelPart(message, part, partIndex, "json", options));
-        }
-      }
-    }
-    result.push({ role: "assistant", content });
-    const toolResults = current.flatMap(({ part, partIndex }) => part.type === "tool-call" && part.providerExecuted !== true ? [toolResultModelPart(message, part, partIndex, "text", options)] : []);
-    if (toolResults.length > 0) {
-      result.push({ role: "tool", content: toolResults });
-    }
-  };
-  message.parts.forEach((part, partIndex) => {
-    if (part.type === "step-start") {
-      flush();
-    } else {
-      block.push({ part, partIndex });
-    }
-  });
-  flush();
-}
-function toolCallModelPart(part) {
-  return {
-    type: "tool-call",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    input: part.input,
-    ...part.providerExecuted === undefined ? {} : { providerExecuted: part.providerExecuted },
-    ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-  };
-}
-function toolResultModelPart(message, part, partIndex, errorMode, options) {
-  return {
-    type: "tool-result",
-    toolCallId: part.toolCallId,
-    toolName: part.toolName,
-    output: toolResultOutput(message, part, partIndex, errorMode, options),
-    ...part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata }
-  };
-}
-function toolResultOutput(message, part, partIndex, errorMode, options) {
-  if (part.state === "output-error") {
-    return errorMode === "json" ? { type: "error-json", value: part.errorText } : { type: "error-text", value: part.errorText };
-  }
-  if (isAgentToolResult(part.output)) {
-    const value = [];
-    part.output.content.forEach((contentPart, contentIndex) => {
-      if (contentPart.type === "text") {
-        value.push(contentPart.text);
-        return;
-      }
-      const resolverInput = { message, part, partIndex, contentPart, contentIndex };
-      const fileContext = options.toolResultFileText?.(resolverInput);
-      if (fileContext) {
-        value.push(fileContext);
-      } else {
-        value.push(toolResultFileFallbackText(contentPart));
-      }
-    });
-    return { type: "text", value: value.join(`
-`) };
-  }
-  return typeof part.output === "string" ? { type: "text", value: part.output } : { type: "json", value: part.output };
-}
-function toolResultFileFallbackText(part) {
-  const attributes = [
-    part.fileRef.fileName ? `name=${JSON.stringify(part.fileRef.fileName)}` : undefined,
-    part.fileRef.mediaType ? `mediaType=${JSON.stringify(part.fileRef.mediaType)}` : undefined,
-    `sizeBytes=${part.fileRef.sizeBytes}`
-  ].filter((value) => value !== undefined);
-  return `[Tool-created file: ${attributes.join(" ")}. Contents are not available inline.]`;
-}
-function isTextPart(part) {
-  return part.type === "text";
-}
-// src/agents/api-gateway.ts
-import { createHmac, timingSafeEqual } from "crypto";
-var AGENT_API_GATEWAY_PREFIX = "/__sixb/agent-api";
-var AGENT_API_GATEWAY_CAPABILITY_PREFIX = "sixb_agw_v1_";
-var AGENT_API_ROUTES = SIXB_API_ROUTES.filter((route) => route.agentApi).map((route) => ({ method: route.method, path: route.path }));
-function createAgentApiGatewayCapability(input) {
-  return `${AGENT_API_GATEWAY_CAPABILITY_PREFIX}${capabilityDigest(input)}`;
-}
-function isValidAgentApiGatewayCapability(input) {
-  const expected = createAgentApiGatewayCapability(input);
-  const actual = input.capability;
-  const expectedBuffer = Buffer.from(expected);
-  const actualBuffer = Buffer.from(actual);
-  return expectedBuffer.byteLength === actualBuffer.byteLength && timingSafeEqual(expectedBuffer, actualBuffer);
-}
-function isAllowedAgentApiRequest(method, pathname) {
-  const normalizedMethod = method.toUpperCase();
-  const normalizedPath = normalizeRoutePath(pathname);
-  return AGENT_API_ROUTES.some((route) => route.method === normalizedMethod && matchesPathPattern(normalizedPath, route.path));
-}
-function capabilityDigest(input) {
-  return createHmac("sha256", input.executionToken).update(`agent-api-gateway:${input.projectId}:${input.runId}`).digest("base64url");
-}
-// src/agents/types.ts
-var AGENT_REASONING_LEVELS = [
-  "provider-default",
-  "none",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-
-// src/agents/validation.ts
-var AGENT_TOOL_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
-var AGENT_TOOL_PRIMITIVE_SCHEMAS = new Set([
-  "string",
-  "integer",
-  "double",
-  "decimal",
-  "boolean",
-  "date",
-  "timestamp",
-  "uuid",
-  "fileRef"
-]);
-var AGENT_RESERVED_TOOL_NAMES = ["bash", "read", "view_file"];
-function assertNonEmpty(value, field) {
-  if (!value.trim()) {
-    throw new AgentDefinitionError(`[Sixb] Agent ${field} must not be empty.`);
-  }
-}
-function isAgentDefinition(value) {
-  return isRecord(value) && value.kind === "agent" && typeof value.id === "string" && typeof value.name === "string" && typeof value.instructions === "string" && (value.reasoning === undefined || isAgentReasoningLevel(value.reasoning)) && (value.providerOptions === undefined || isProviderOptions(value.providerOptions)) && Array.isArray(value.groupIds) && isAgentToolDefinitionArray(value.tools);
-}
-function isAgentToolDefinition(value) {
-  return isRecord(value) && value.kind === "agentTool" && typeof value.name === "string" && typeof value.description === "string" && isPlainRecord(value.input) && typeof value.handler === "function";
-}
-function assertValidAgentToolName(name) {
-  if (typeof name !== "string" || !AGENT_TOOL_NAME_PATTERN.test(name)) {
-    throw new AgentDefinitionError("[Sixb] Agent tool name must be 1-64 characters, start with a letter or underscore, and contain only letters, numbers, underscores, or hyphens.");
-  }
-  if (AGENT_RESERVED_TOOL_NAMES.includes(name)) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool name '${name}' is reserved by the framework.`);
-  }
-}
-function assertValidAgentToolDescription(name, description) {
-  if (typeof description !== "string" || !description.trim()) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' description must not be empty.`);
-  }
-}
-function assertValidAgentToolInput(name, input) {
-  if (!isPlainRecord(input)) {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' input must be a schema object.`);
-  }
-  for (const [field, schema] of Object.entries(input)) {
-    if (!field.trim()) {
-      throw new AgentDefinitionError(`[Sixb] Agent tool '${name}' input field names must not be empty.`);
-    }
-    assertValidAgentToolSchema(name, schema, `input.${field}`, new Set);
-  }
-}
-function validateAndSnapshotAgentToolInput(toolName, input) {
-  assertValidAgentToolInput(toolName, input);
-  try {
-    return deepFreeze(structuredClone(input));
-  } catch {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${toolName}' input must be safely snapshot-compatible.`);
-  }
-}
-function validateAndNormalizeAgentToolInput(toolName, shape, value, valueTypesById) {
-  const label = `Agent tool '${toolName}' input`;
-  if (!isPlainRecord(value)) {
-    throw new OntologyValidationError(`[Sixb] ${label} must be a JSON object.`);
-  }
-  const reason = getInvalidJsonValueReason(value, label);
-  if (reason) {
-    throw new OntologyValidationError(`[Sixb] ${label} must be JSON-compatible; ${reason}.`);
-  }
-  const schema = {
-    type: "object",
-    properties: Object.fromEntries(Object.entries(shape).map(([field, fieldSchema]) => [
-      field,
-      { schema: fieldSchema, required: true }
-    ]))
-  };
-  validateSchemaValue(schema, value, label, valueTypesById);
-  return deepFreeze(normalizeSchemaValue(schema, value, label, valueTypesById));
-}
-function validateAgentToolsAtStartup(agents) {
-  for (const agent of agents) {
-    if (!isAgentDefinition(agent)) {
-      throw new AgentDefinitionError("[Sixb] Agents must contain only valid agent definitions.");
-    }
-    assertValidAgentToolDefinitions(agent.id, agent.tools);
-    for (const tool of agent.tools) {
-      deepFreeze(tool.input);
-      Object.freeze(tool);
-    }
-    Object.freeze(agent.tools);
-    Object.freeze(agent);
-  }
-}
-function resolveAgentLoopConfig(loop) {
-  if (loop === undefined)
-    return;
-  const maxSteps = loop?.stopWhen?.maxSteps;
-  if (maxSteps !== undefined && (!Number.isSafeInteger(maxSteps) || maxSteps <= 0)) {
-    throw new AgentDefinitionError("[Sixb] Agent loop.stopWhen.maxSteps must be a positive safe integer.");
-  }
-  if (loop.caching !== undefined && loop.caching !== "auto" && loop.caching !== "off") {
-    throw new AgentDefinitionError("[Sixb] Agent loop.caching must be 'auto' or 'off'.");
-  }
-  const context = loop.context ? snapshotAgentContextConfig(loop.context) : undefined;
-  return Object.freeze({
-    ...loop.stopWhen === undefined ? {} : { stopWhen: Object.freeze({ ...maxSteps === undefined ? {} : { maxSteps } }) },
-    ...context === undefined ? {} : { context },
-    ...loop.caching === undefined ? {} : { caching: loop.caching }
-  });
-}
-function snapshotAgentContextConfig(context) {
-  const snapshot = {};
-  for (const field of ["windowTokens", "reserveTokens", "keepRecentTokens"]) {
-    const value = context[field];
-    if (value === undefined)
-      continue;
-    assertPositiveSafeInteger(value, field);
-    snapshot[field] = value;
-  }
-  return Object.freeze(snapshot);
-}
-function assertPositiveSafeInteger(value, field) {
-  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
-    throw new AgentDefinitionError(`[Sixb] Agent loop.context.${field} must be a positive safe integer.`);
-  }
-}
-function assertValidReasoningLevel(reasoning) {
-  if (reasoning === undefined) {
-    return;
-  }
-  if (!isAgentReasoningLevel(reasoning)) {
-    throw new AgentDefinitionError(`[Sixb] Agent reasoning must be one of: ${AGENT_REASONING_LEVELS.join(", ")}.`);
-  }
-}
-function assertValidProviderOptions(providerOptions) {
-  if (providerOptions === undefined) {
-    return;
-  }
-  const reason = getInvalidJsonValueReason(providerOptions, "providerOptions");
-  if (!isRecord(providerOptions) || reason) {
-    throw new AgentDefinitionError(`[Sixb] Agent providerOptions must be a provider-keyed JSON object${reason ? `; ${reason}` : "."}`);
-  }
-  for (const [provider, options] of Object.entries(providerOptions)) {
-    if (!provider.trim()) {
-      throw new AgentDefinitionError("[Sixb] Agent providerOptions provider names must not be empty.");
-    }
-    const optionsReason = getInvalidJsonValueReason(options, `providerOptions.${provider}`);
-    if (!isRecord(options) || optionsReason) {
-      throw new AgentDefinitionError(`[Sixb] Agent providerOptions.${provider} must be a JSON object${optionsReason ? `; ${optionsReason}` : "."}`);
-    }
-  }
-}
-function groupIdsFromDefinitions(agentId, groups) {
-  const groupIds = (groups ?? []).map((group) => {
-    if (!isRecord(group) || group.kind !== "group") {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' groups must contain only group definitions.`);
-    }
-    assertNonEmpty(group.id, `Agent '${agentId}' group id`);
-    return group.id;
-  });
-  assertNoDuplicateGroupIds(agentId, groupIds);
-  return Object.freeze(groupIds);
-}
-function validateAgentGroupReferences(agents, security) {
-  for (const agent of agents) {
-    assertNoDuplicateGroupIds(agent.id, agent.groupIds);
-    for (const groupId of agent.groupIds) {
-      if (!security.getGroupById(groupId)) {
-        throw new AgentDefinitionError(`[Sixb] Agent '${agent.id}' groups references unknown group '${groupId}'. Add it to 'security/groups/' or pass it to createSixb({ groups }).`);
-      }
-    }
-  }
-}
-function assertNoDuplicateGroupIds(agentId, groupIds) {
-  const seen = new Set;
-  for (const groupId of groupIds) {
-    assertNonEmpty(groupId, `Agent '${agentId}' group id`);
-    if (seen.has(groupId)) {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' groups contains duplicate group id '${groupId}'.`);
-    }
-    seen.add(groupId);
-  }
-}
-function isAgentReasoningLevel(value) {
-  return typeof value === "string" && AGENT_REASONING_LEVELS.includes(value);
-}
-function isProviderOptions(value) {
-  if (!isRecord(value) || getInvalidJsonValueReason(value) !== undefined) {
-    return false;
-  }
-  return Object.entries(value).every(([provider, options]) => provider.trim().length > 0 && isRecord(options) && getInvalidJsonValueReason(options) === undefined);
-}
-function assertValidAgentToolSchema(toolName, schema, path, visiting) {
-  if (typeof schema === "string") {
-    if (AGENT_TOOL_PRIMITIVE_SCHEMAS.has(schema)) {
-      return;
-    }
-    throw invalidAgentToolSchema(toolName, path);
-  }
-  if (!isPlainRecord(schema) || typeof schema.type !== "string" || visiting.has(schema)) {
-    throw invalidAgentToolSchema(toolName, path);
-  }
-  visiting.add(schema);
-  switch (schema.type) {
-    case "enum": {
-      const values = schema.values;
-      const validValues = isValidAgentToolEnumValues(values, schema.valueType);
-      if (!validValues || new Set(values).size !== values.length) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      break;
-    }
-    case "array":
-      assertValidAgentToolSchema(toolName, schema.items, `${path}.items`, visiting);
-      break;
-    case "map":
-      if (schema.keySchema !== "string") {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      assertValidAgentToolSchema(toolName, schema.valueSchema, `${path}.valueSchema`, visiting);
-      break;
-    case "object": {
-      if (!isPlainRecord(schema.properties)) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      for (const [fieldId, field] of Object.entries(schema.properties)) {
-        if (!fieldId.trim() || !isPlainRecord(field) || !("schema" in field)) {
-          throw invalidAgentToolSchema(toolName, `${path}.properties.${fieldId}`);
-        }
-        if (field.required !== undefined && typeof field.required !== "boolean" || field.nullable !== undefined && typeof field.nullable !== "boolean" || field.description !== undefined && (typeof field.description !== "string" || !field.description.trim())) {
-          throw invalidAgentToolSchema(toolName, `${path}.properties.${fieldId}`);
-        }
-        assertValidAgentToolSchema(toolName, field.schema, `${path}.properties.${fieldId}.schema`, visiting);
-      }
-      break;
-    }
-    case "valueTypeRef":
-      if (typeof schema.valueTypeId !== "string" || !schema.valueTypeId.trim()) {
-        throw invalidAgentToolSchema(toolName, path);
-      }
-      if (schema._resolved !== undefined) {
-        assertValidAgentToolSchema(toolName, schema._resolved, `${path}._resolved`, visiting);
-      }
-      break;
-    default:
-      throw invalidAgentToolSchema(toolName, path);
-  }
-  visiting.delete(schema);
-}
-function invalidAgentToolSchema(toolName, path) {
-  return new AgentDefinitionError(`[Sixb] Agent tool '${toolName}' ${path} must be a valid Sixb schema.`);
-}
-function isAgentToolDefinitionArray(value) {
-  if (!Array.isArray(value)) {
-    return false;
-  }
-  for (let index = 0;index < value.length; index += 1) {
-    if (!Object.hasOwn(value, index) || !isAgentToolDefinition(value[index])) {
-      return false;
-    }
-  }
-  return true;
-}
-function assertValidAgentToolDefinitions(agentId, tools) {
-  const seen = new Set;
-  for (let index = 0;index < tools.length; index += 1) {
-    const tool = tools[index];
-    if (!Object.hasOwn(tools, index) || !isAgentToolDefinition(tool)) {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' tools must contain only agent tool definitions.`);
-    }
-    assertValidAgentToolName(tool.name);
-    assertValidAgentToolDescription(tool.name, tool.description);
-    assertValidAgentToolInput(tool.name, tool.input);
-    if (seen.has(tool.name)) {
-      throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' tools contains duplicate tool name '${tool.name}'.`);
-    }
-    seen.add(tool.name);
-  }
-}
-function isValidAgentToolEnumValues(values, valueType) {
-  if (!Array.isArray(values) || values.length === 0) {
-    return false;
-  }
-  for (let index = 0;index < values.length; index += 1) {
-    if (!Object.hasOwn(values, index)) {
-      return false;
-    }
-    const value = values[index];
-    if (valueType === "string" ? typeof value !== "string" : valueType !== "integer" || typeof value !== "number" || !Number.isInteger(value)) {
-      return false;
-    }
-  }
-  return true;
-}
-function deepFreeze(value, seen = new Set) {
-  if (value === null || typeof value !== "object" || seen.has(value)) {
-    return value;
-  }
-  seen.add(value);
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor && "value" in descriptor) {
-      deepFreeze(descriptor.value, seen);
-    }
-  }
-  return Object.freeze(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-// src/agents/tool-definition.ts
-var EMPTY_AGENT_TOOLS = Object.freeze([]);
-var normalizedAgentTools = new WeakSet;
-function createAgentToolDefinition(definition) {
-  assertValidAgentToolName(definition.name);
-  assertValidAgentToolDescription(definition.name, definition.description);
-  if (typeof definition.handler !== "function") {
-    throw new AgentDefinitionError(`[Sixb] Agent tool '${definition.name}' handler must be a function.`);
-  }
-  const input = validateAndSnapshotAgentToolInput(definition.name, definition.input);
-  const tool = {
-    kind: "agentTool",
-    name: definition.name,
-    description: definition.description,
-    input,
-    handler: async (context) => {
-      const result = await definition.handler(context);
-      let snapshot;
-      try {
-        snapshot = cloneJsonValue(result, "result");
-      } catch (cause) {
-        throw new AgentToolResultValidationError(definition.name, getInvalidJsonValueReason(result, "result") ?? "result could not be cloned safely", { cause });
-      }
-      const richResultReason = getInvalidAgentToolResultReason(snapshot);
-      if (richResultReason) {
-        throw new AgentToolResultValidationError(definition.name, richResultReason);
-      }
-      return snapshot;
-    }
-  };
-  normalizedAgentTools.add(tool);
-  return Object.freeze(tool);
-}
-function toolsFromDefinitions(agentId, tools) {
-  if (tools === undefined) {
-    return EMPTY_AGENT_TOOLS;
-  }
-  if (!Array.isArray(tools)) {
-    throw new AgentDefinitionError(`[Sixb] Agent '${agentId}' tools must be an array of agent tool definitions.`);
-  }
-  assertValidAgentToolDefinitions(agentId, tools);
-  const normalized = [];
-  for (const tool of tools) {
-    normalized.push(normalizeAgentToolDefinition(tool));
-  }
-  return Object.freeze(normalized);
-}
-function normalizeAgentToolDefinition(tool) {
-  if (normalizedAgentTools.has(tool)) {
-    return tool;
-  }
-  return createAgentToolDefinition({
-    name: tool.name,
-    description: tool.description,
-    input: tool.input,
-    handler: (context) => tool.handler(context)
-  });
-}
-
-// src/agents/builders.ts
-function defineAgentTool(name) {
-  assertValidAgentToolName(name);
-  return {
-    description(description) {
-      assertValidAgentToolDescription(name, description);
-      return {
-        input(input) {
-          assertValidAgentToolInput(name, input);
-          return {
-            run(handler) {
-              return createAgentToolDefinition({ name, description, input, handler });
-            }
-          };
-        }
-      };
-    }
-  };
-}
-function defineAgent(id, config) {
-  assertNonEmpty(id, "id");
-  assertNonEmpty(config.name, "name");
-  assertNonEmpty(config.instructions, "instructions");
-  if (config.model === undefined || config.model === null) {
-    throw new AgentDefinitionError("[Sixb] Agent model is required.");
-  }
-  assertValidReasoningLevel(config.reasoning);
-  assertValidProviderOptions(config.providerOptions);
-  const loop = resolveAgentLoopConfig(config.loop);
-  const groupIds = groupIdsFromDefinitions(id, config.groups);
-  const tools = toolsFromDefinitions(id, config.tools);
-  return Object.freeze({
-    kind: "agent",
-    id,
-    name: config.name,
-    model: config.model,
-    ...config.reasoning !== undefined ? { reasoning: config.reasoning } : {},
-    ...config.providerOptions !== undefined ? { providerOptions: config.providerOptions } : {},
-    instructions: config.instructions,
-    groupIds,
-    tools,
-    ...config.description !== undefined ? { description: config.description } : {},
-    ...loop !== undefined ? { loop } : {}
-  });
-}
-// src/agents/context-compaction.ts
-var AGENT_CONTEXT_ESTIMATOR_VERSION = 1;
-var CHARS_PER_TOKEN = 4;
-var REQUEST_OVERHEAD_TOKENS = 8;
-var MESSAGE_OVERHEAD_TOKENS = 8;
-var TOOL_OVERHEAD_TOKENS = 16;
-var STEP_OVERHEAD_TOKENS = 2;
-var IMAGE_ALLOWANCE_TOKENS = 1200;
-var FILE_TEXT_INLINE_MAX_BYTES = 50 * 1024;
-var FILE_TEXT_INLINE_TOTAL_MAX_BYTES = 200 * 1024;
-var TOOL_RESULT_SUMMARY_MAX_CHARS = 2000;
-function shouldCompactAgentContext(input) {
-  return input.estimatedInputTokens > input.inputBudgetTokens;
-}
-function estimateAgentContextRequestTokens(input) {
-  const toolTokens = input.tools.reduce((total, tool) => total + TOOL_OVERHEAD_TOKENS + textTokens(tool.name) + textTokens(tool.description) + textTokens(tool.inputSchema), 0);
-  return {
-    tokens: REQUEST_OVERHEAD_TOKENS + textTokens(input.systemPrompt) + toolTokens + estimateAgentContextMessagesTokens(input.messages).tokens,
-    estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION
-  };
-}
-function estimateAgentContextMessagesTokens(messages) {
-  const attachments = { textBytesRemaining: FILE_TEXT_INLINE_TOTAL_MAX_BYTES };
-  let tokens = 0;
-  for (const message of messages) {
-    tokens += estimateMessageTokens(message, attachments);
-  }
-  return { tokens, estimatorVersion: AGENT_CONTEXT_ESTIMATOR_VERSION };
-}
-function selectAgentContextCompactionBoundary(input) {
-  if (input.messages.length < 2)
-    return null;
-  let retainedTokens = 0;
-  let boundaryIndex = null;
-  let closestDistance = Number.POSITIVE_INFINITY;
-  for (let index = input.messages.length - 1;index > 0; index -= 1) {
-    retainedTokens += estimateAgentContextMessagesTokens([input.messages[index]]).tokens;
-    if (input.messages[index]?.role !== "user")
-      continue;
-    const distance = Math.abs(input.keepRecentTokens - retainedTokens);
-    if (distance <= closestDistance) {
-      boundaryIndex = index;
-      closestDistance = distance;
-    }
-    if (retainedTokens >= input.keepRecentTokens)
-      break;
-  }
-  if (boundaryIndex === null)
-    return null;
-  const summarizedThroughSeq = input.messages[boundaryIndex - 1]?.seq;
-  if (summarizedThroughSeq === undefined)
-    return null;
-  return {
-    messagesToSummarize: input.messages.slice(0, boundaryIndex),
-    retainedMessages: input.messages.slice(boundaryIndex),
-    summarizedThroughSeq
-  };
-}
-function serializeAgentMessagesForSummary(messages) {
-  const lines = ["<sixb_conversation_history>"];
-  for (const message of messages) {
-    lines.push(`  <message id="${escapeXml2(message.id)}" seq="${message.seq}" role="${message.role}">`);
-    message.parts.forEach((part, partIndex) => {
-      lines.push(...serializeSummaryPart(message, part, partIndex));
-    });
-    lines.push("  </message>");
-  }
-  lines.push("</sixb_conversation_history>");
-  return lines.join(`
-`);
-}
-function estimateMessageTokens(message, attachments) {
-  let tokens = MESSAGE_OVERHEAD_TOKENS;
-  for (const part of message.parts) {
-    switch (part.type) {
-      case "text":
-      case "reasoning":
-        tokens += textTokens(part.text);
-        break;
-      case "step-start":
-        tokens += STEP_OVERHEAD_TOKENS;
-        break;
-      case "context":
-        tokens += textTokens(stableJsonStringify(part.context));
-        break;
-      case "tool-call":
-        tokens += TOOL_OVERHEAD_TOKENS + textTokens(part.toolName) + textTokens(stableJsonStringify(part.input)) + (part.state === "output-available" ? textTokens(stableJsonStringify(part.output)) : textTokens(part.errorText));
-        break;
-      case "file": {
-        const file = part.fileRef;
-        tokens += textTokens([file.blobId, file.digest, file.fileName, file.mediaType, file.logicalPath].filter((value) => value !== undefined).join(" "));
-        if (message.role !== "assistant") {
-          if (looksLikeImage(file.mediaType, file.fileName)) {
-            tokens += IMAGE_ALLOWANCE_TOKENS;
-          } else {
-            const inlineBytes = Math.min(file.sizeBytes, FILE_TEXT_INLINE_MAX_BYTES, attachments.textBytesRemaining);
-            attachments.textBytesRemaining -= inlineBytes;
-            tokens += Math.ceil(inlineBytes / CHARS_PER_TOKEN);
-          }
-        }
-        break;
-      }
-    }
-  }
-  return tokens;
-}
-function serializeSummaryPart(message, part, partIndex) {
-  const indent = "    ";
-  switch (part.type) {
-    case "text":
-      return [`${indent}<text>${escapeXml2(part.text)}</text>`];
-    case "reasoning":
-    case "step-start":
-      return [];
-    case "context":
-      return part.context.kind === "object" ? [
-        `${indent}<object_context origin="${part.origin}" object_type_id="${escapeXml2(part.context.ref.objectTypeId)}" primary_id="${escapeXml2(part.context.ref.primaryId)}" />`
-      ] : [
-        `${indent}<app_context origin="${part.origin}" id="${escapeXml2(part.context.id)}" label="${escapeXml2(part.context.label)}">`,
-        `${indent}  <description>${escapeXml2(part.context.description)}</description>`,
-        `${indent}  <value format="json">${escapeXml2(stableJsonStringify(part.context.value))}</value>`,
-        `${indent}</app_context>`
-      ];
-    case "file": {
-      const file = part.fileRef;
-      const attributes = [
-        `message_id="${escapeXml2(message.id)}"`,
-        `part_index="${partIndex}"`,
-        `blob_id="${escapeXml2(file.blobId)}"`,
-        `digest="${escapeXml2(file.digest)}"`,
-        `size_bytes="${file.sizeBytes}"`,
-        ...file.fileName === undefined ? [] : [`file_name="${escapeXml2(file.fileName)}"`],
-        ...file.mediaType === undefined ? [] : [`media_type="${escapeXml2(file.mediaType)}"`],
-        ...file.logicalPath === undefined ? [] : [`logical_path="${escapeXml2(file.logicalPath)}"`]
-      ];
-      return [`${indent}<file ${attributes.join(" ")} />`];
-    }
-    case "tool-call": {
-      const output = part.state === "output-available" ? truncateToolResult(stableJsonStringify(part.output)) : truncateToolResult(part.errorText);
-      return [
-        `${indent}<tool_call id="${escapeXml2(part.toolCallId)}" name="${escapeXml2(part.toolName)}" state="${part.state}">`,
-        `${indent}  <input format="json">${escapeXml2(stableJsonStringify(part.input))}</input>`,
-        `${indent}  <result>${escapeXml2(output)}</result>`,
-        `${indent}</tool_call>`
-      ];
-    }
-  }
-}
-function truncateToolResult(value) {
-  if (value.length <= TOOL_RESULT_SUMMARY_MAX_CHARS)
-    return value;
-  return `${value.slice(0, TOOL_RESULT_SUMMARY_MAX_CHARS)}
-[truncated ${value.length - TOOL_RESULT_SUMMARY_MAX_CHARS} characters]`;
-}
-function looksLikeImage(mediaType, fileName) {
-  if (mediaType?.toLowerCase().startsWith("image/"))
-    return true;
-  return /\.(?:avif|gif|jpe?g|png|webp)$/i.test(fileName ?? "");
-}
-function textTokens(value) {
-  return Math.ceil(new TextEncoder().encode(value).byteLength / CHARS_PER_TOKEN);
-}
-function escapeXml2(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
-// src/agents/thread-context-projection.ts
-function projectAgentThreadModelContext(input) {
-  const { checkpoint, messages } = input;
-  if (!checkpoint)
-    return messages;
-  assertConsistentCheckpointProjection(checkpoint, messages);
-  return [
-    {
-      role: "user",
-      parts: [{ type: "text", text: serializeThreadSummary(checkpoint.summary) }]
-    },
-    ...messages
-  ];
-}
-function assertConsistentCheckpointProjection(checkpoint, messages) {
-  if (checkpoint.summaryFormatVersion !== 1 || checkpoint.summary.trim().length === 0) {
-    throw projectionError(checkpoint, "has an invalid summary");
-  }
-  if (checkpoint.summarizedThroughSeq >= checkpoint.observedHeadSeq) {
-    throw projectionError(checkpoint, "does not retain its observed head");
-  }
-  if (messages.length === 0) {
-    throw projectionError(checkpoint, "has no retained messages");
-  }
-  let expectedSeq = checkpoint.summarizedThroughSeq + 1;
-  for (const message of messages) {
-    if (message.projectId !== checkpoint.projectId || message.threadId !== checkpoint.threadId) {
-      throw projectionError(checkpoint, "contains a message from another thread");
-    }
-    if (message.seq !== expectedSeq) {
-      throw projectionError(checkpoint, `has a sequence gap before message '${message.id}'`);
-    }
-    expectedSeq += 1;
-  }
-  if (messages[0]?.role !== "user") {
-    throw projectionError(checkpoint, "does not begin at a user turn boundary");
-  }
-  if ((messages.at(-1)?.seq ?? 0) < checkpoint.observedHeadSeq) {
-    throw projectionError(checkpoint, "ends before the checkpoint's observed head");
-  }
-}
-function serializeThreadSummary(summary) {
-  return [
-    "The earlier conversation was compacted into this continuation summary.",
-    "",
-    "<sixb_thread_summary>",
-    escapeXml3(summary),
-    "</sixb_thread_summary>"
-  ].join(`
-`);
-}
-function projectionError(checkpoint, detail) {
-  return new Error(`[Sixb] Agent context checkpoint '${checkpoint.id}' for thread '${checkpoint.threadId}' ${detail}.`);
-}
-function escapeXml3(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
-}
 // src/workflows/validation.ts
-function assertNonEmpty2(value, subject, field) {
+function assertNonEmpty(value, subject, field) {
   if (!value.trim()) {
     throw new WorkflowDefinitionError(`${subject} ${field} must not be empty.`);
   }
 }
 function isStepDefinition(value) {
-  return isRecord2(value) && value.kind === "step" && typeof value.id === "string" && isRecord2(value.input) && isRecord2(value.output) && typeof value.handler === "function";
+  return isRecord(value) && value.kind === "step" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.output) && typeof value.handler === "function";
 }
 function isAgentStepDefinition(value) {
-  return isRecord2(value) && value.kind === "agentStep" && typeof value.id === "string" && isAgentDefinition(value.agent) && isRecord2(value.input) && isRecord2(value.output) && typeof value.prompt === "function";
+  return isRecord(value) && value.kind === "agentStep" && typeof value.id === "string" && (value.model === undefined || isLanguageModel(value.model)) && (value.reasoning === undefined || isModelReasoning(value.reasoning)) && typeof value.instructions === "string" && isStringArray(value.groupIds) && isStringArray(value.toolNames) && isRecord(value.input) && isRecord(value.output) && typeof value.prompt === "function";
 }
 function isInterventionDefinition(value) {
-  return isRecord2(value) && value.kind === "intervention" && typeof value.id === "string" && isRecord2(value.input) && isRecord2(value.response) && (value.defaults === undefined || typeof value.defaults === "function");
+  return isRecord(value) && value.kind === "intervention" && typeof value.id === "string" && isRecord(value.input) && isRecord(value.response) && (value.defaults === undefined || typeof value.defaults === "function");
 }
 function isWorkflowDefinition(value) {
-  return isRecord2(value) && value.kind === "workflow" && typeof value.id === "string" && isRecord2(value.input) && Array.isArray(value.triggers) && Array.isArray(value.nodes);
+  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.");
   }
-  assertNonEmpty2(value.id, "Workflow", "id");
+  assertNonEmpty(value.id, "Workflow", "id");
   if (value.nodes.length === 0) {
     throw new WorkflowDefinitionError(`Workflow "${value.id}" must contain at least one node.`);
   }
@@ -2219,13 +1345,42 @@ function validateWorkflowsAtStartup(options) {
       if (node.type === "action" && !options.registeredActionIds.has(node.action.id)) {
         throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown action "${node.action.id}". Add it to 'actions' in createSixb() or export it from 'actions/'.`);
       }
-      if (node.type === "agent" && !options.registeredAgentIds.has(node.agentStep.agent.id)) {
-        throw new WorkflowDefinitionError(`Workflow "${workflow.id}" references unknown agent "${node.agentStep.agent.id}". Add it to 'agents' in createSixb() or export it from 'agents/'.`);
+      if (node.type === "agent") {
+        validateWorkflowAgentStepRuntimeReferences(workflow.id, node.agentStep, options);
       }
     }
   }
   return options.workflows;
 }
+function validateWorkflowAgentStepGroupReferences(workflows, security) {
+  for (const workflow of workflows) {
+    for (const node of workflow.nodes) {
+      if (node.type !== "agent")
+        continue;
+      for (const groupId of node.agentStep.groupIds) {
+        if (!security.getGroupById(groupId)) {
+          throw new WorkflowDefinitionError(`Workflow "${workflow.id}" agent step "${node.id}" references unknown group "${groupId}". Add it to 'security/groups/' or pass it to createSixb({ groups }).`);
+        }
+      }
+    }
+  }
+}
+function validateWorkflowAgentStepRuntimeReferences(workflowId, step, options) {
+  if (step.model === undefined && options.models === undefined) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" needs a model. Configure 'models.language' or pass 'model' to defineAgentStep().`);
+  }
+  if (step.model !== undefined && options.models !== undefined) {
+    const ref = { provider: step.model.providerId, modelId: step.model.modelId };
+    if (options.models.language.getByRef(ref) === null) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" uses unknown language model "${ref.provider}/${ref.modelId}". Add it to 'models.language' in createSixb().`);
+    }
+  }
+  for (const toolName of step.toolNames) {
+    if (options.tools.getByName(toolName) === null) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${step.id}" uses unknown project tool "${toolName}". Add it to 'tools' in createSixb().`);
+    }
+  }
+}
 function validateWorkflowInput(params) {
   return validateWorkflowContractRecord({
     shape: params.workflow.input,
@@ -2277,7 +1432,7 @@ function validateWorkflowInterventionDefaultResponse(params) {
   });
 }
 function validateWorkflowTriggerAtStartup(workflowId, trigger, registeredSchedules, inputFields) {
-  if (!isRecord2(trigger) || trigger.type !== "schedule") {
+  if (!isRecord(trigger) || trigger.type !== "schedule") {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an unsupported trigger.`);
   }
   validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedules, inputFields);
@@ -2301,7 +1456,7 @@ function validateScheduleWorkflowTrigger(workflowId, trigger, registeredSchedule
   }
 }
 function validateWorkflowNodeDefinition(workflowId, node) {
-  if (!isRecord2(node)) {
+  if (!isRecord(node)) {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" contains an invalid node.`);
   }
   if (node.type === "step") {
@@ -2335,10 +1490,39 @@ function validateAgentNodeDefinition(workflowId, node) {
   if (node.id !== node.agentStep.id) {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node id "${node.id}" does not match agent step definition id "${node.agentStep.id}".`);
   }
+  if (!node.agentStep.instructions.trim()) {
+    throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${node.id}" instructions must not be empty.`);
+  }
+  assertUniqueNonEmptyAgentStepValues(workflowId, node.id, "group", node.agentStep.groupIds);
+  assertUniqueNonEmptyAgentStepValues(workflowId, node.id, "tool", node.agentStep.toolNames);
   if (node.mapper !== undefined && typeof node.mapper !== "function") {
     throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent node "${node.id}" mapper must be a function.`);
   }
 }
+function assertUniqueNonEmptyAgentStepValues(workflowId, stepId, kind, values) {
+  const seen = new Set;
+  for (const value of values) {
+    if (!value.trim()) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${stepId}" has an empty ${kind} id.`);
+    }
+    if (seen.has(value)) {
+      throw new WorkflowDefinitionError(`Workflow "${workflowId}" agent step "${stepId}" has duplicate ${kind} '${value}'.`);
+    }
+    seen.add(value);
+  }
+}
+function isLanguageModel(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function isStringArray(value) {
+  if (!Array.isArray(value))
+    return false;
+  for (let index = 0;index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index) || typeof value[index] !== "string")
+      return false;
+  }
+  return true;
+}
 function validateWorkflowAgentStepInput(params) {
   return validateWorkflowContractRecord({
     shape: params.agentStep.input,
@@ -2407,7 +1591,7 @@ function validateActionNodeDefinition(workflowId, node) {
   }
 }
 function validateWorkflowContractRecord(params) {
-  if (!isRecord2(params.value)) {
+  if (!isRecord(params.value)) {
     throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
   }
   const fieldIds = new Set(Object.keys(params.shape));
@@ -2430,7 +1614,7 @@ function validateWorkflowContractRecord(params) {
   return params.value;
 }
 function validateWorkflowInterventionResponseRecord(params) {
-  if (!isRecord2(params.value)) {
+  if (!isRecord(params.value)) {
     throw new WorkflowValidationError(`[Sixb] ${params.path} must be an object`);
   }
   const fieldIds = new Set(Object.keys(params.response));
@@ -2456,7 +1640,7 @@ function validateWorkflowInterventionResponseRecord(params) {
   return params.value;
 }
 function isInterventionFieldConfig(value) {
-  return isRecord2(value) && "schema" in value;
+  return isRecord(value) && "schema" in value;
 }
 function interventionResponseFieldSchema(field) {
   return isInterventionFieldConfig(field) ? field.schema : field;
@@ -2473,7 +1657,7 @@ function toWorkflowValidationError(error) {
   }
   return new WorkflowValidationError(String(error), { cause: error });
 }
-function isRecord2(value) {
+function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -2588,7 +1772,7 @@ function snapshotWorkflowInterventionResponseRecord(params) {
 }
 function snapshotSchemaOrRefValue(params) {
   if (isObjectRefSchema(params.schema)) {
-    if (!isRecord3(params.value)) {
+    if (!isRecord2(params.value)) {
       throw cannotSerialize(params.path);
     }
     return {
@@ -2629,7 +1813,7 @@ function snapshotSchemaValue(params) {
     }));
   }
   if (schema.type === "map") {
-    if (!isRecord3(value)) {
+    if (!isRecord2(value)) {
       throw cannotSerialize(path);
     }
     const snapshot = {};
@@ -2644,7 +1828,7 @@ function snapshotSchemaValue(params) {
     return snapshot;
   }
   if (schema.type === "object") {
-    if (!isRecord3(value)) {
+    if (!isRecord2(value)) {
       throw cannotSerialize(path);
     }
     const snapshot = {};
@@ -2714,7 +1898,7 @@ function snapshotDate(value, path) {
 function cannotSerialize(path) {
   return new WorkflowValidationError(`[Sixb] ${path} cannot be serialized as workflow IO`);
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -2797,7 +1981,7 @@ async function persistWorkflowRun(input, request) {
     assertExistingWorkflowRun(existing, input.workflow.id, request.snapshot);
     return { run: existing, created: false };
   }
-  const execution = await input.createExecution(`exec_${randomUUID3()}`, request.runId);
+  const execution = await input.createExecution(`exec_${randomUUID4()}`, request.runId);
   const queuedAt = new Date;
   try {
     return await input.storage.transaction(async (tx) => {
@@ -2904,7 +2088,7 @@ async function failWorkflowRunPublication(input, run, error) {
 }
 function resolveWorkflowRunId(runId) {
   if (runId === undefined)
-    return `run_${randomUUID3()}`;
+    return `run_${randomUUID4()}`;
   if (!runId.trim()) {
     throw new WorkflowValidationError("[Sixb] Workflow run id must not be empty");
   }
@@ -3121,7 +2305,6 @@ function toWorkflowAgentNodeRunView(execution, usage, cost) {
     projectId: execution.projectId,
     nodeRunId: execution.nodeRunId,
     executionId: execution.executionId,
-    agentId: execution.agentId,
     status: execution.status,
     prompt: execution.prompt,
     modelId: execution.modelId,
@@ -3178,7 +2361,8 @@ function createExecutionFacades(runtime, execution, dependencies) {
     pipelines: createPipelinesRuntime(runtime, execution, dependencies.definitions.pipelines),
     projections: createProjectionsRuntime(runtime, dependencies.definitions.projections),
     rules: createRulesRuntime(runtime, dependencies.definitions.rules),
-    agents: createAgentsRuntime(runtime, execution, dependencies.definitions.agents, dependencies.definitions.security),
+    agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
+    aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
     events: createEventsRuntime(runtime),
     logs: createLogsRuntime(runtime, dependencies.logging),
     schedules: createSchedulesRuntime(dependencies.definitions.schedules),
@@ -3186,10 +2370,13 @@ function createExecutionFacades(runtime, execution, dependencies) {
     blobs: createBlobsRuntime(runtime, execution, dependencies.blobStorage)
   };
 }
-
 // src/execution/agent.ts
+function canInheritAgentRequestAuthorization(authorization) {
+  const ref = getAuthorizationRef(authorization);
+  return ref.type === "disabled" || ref.type === "principal" && ref.principal.type === "user" && ref.credential !== undefined;
+}
 function createAgentExecutionRecord(input) {
-  assertAgentPrincipal(input.agentId, input.principal);
+  assertAgentPrincipal(input.actorId, input.principal);
   return {
     id: input.id,
     projectId: input.parent.projectId,
@@ -3203,6 +2390,21 @@ function createAgentExecutionRecord(input) {
     }
   };
 }
+function createInheritedAgentExecutionRecord(input) {
+  const authority = input.parent.authorizationRef;
+  if (authority.type !== "disabled" && !(authority.type === "principal" && authority.principal.type === "user" && authority.credential !== undefined)) {
+    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent run '${input.runId}' requires inheritable user or auth-disabled authority.`);
+  }
+  return {
+    id: input.id,
+    projectId: input.parent.projectId,
+    ...input.parent.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.parent.requestedBy) },
+    executor: { type: "agent", runId: input.runId },
+    source: { type: "execution", executionId: input.parent.id },
+    correlationId: input.parent.correlationId,
+    authorizationRef: structuredClone(authority)
+  };
+}
 function bindDurableAgentExecution(host, input) {
   const scope = restoreAgentExecutionScope(input);
   const sixb = host.withScope(scope);
@@ -3217,7 +2419,11 @@ function restoreAgentExecutionScope(input) {
     id: input.execution.id,
     projectId: input.execution.projectId,
     ...input.execution.requestedBy === undefined ? {} : { requestedBy: Object.freeze(structuredClone(input.execution.requestedBy)) },
-    executor: Object.freeze({ type: "agent", agentId: input.agentId, runId: input.runId }),
+    executor: Object.freeze({
+      type: "agent",
+      ...input.actorId === undefined ? {} : { actorId: input.actorId },
+      runId: input.runId
+    }),
     source: Object.freeze(structuredClone(input.execution.source)),
     correlationId: input.execution.correlationId
   });
@@ -3225,30 +2431,56 @@ function restoreAgentExecutionScope(input) {
     execution: context,
     authorization: createAgentRuntimeAuthorization({
       projectId: input.execution.projectId,
-      context: input.authorization,
       executionId: input.execution.id,
-      agentId: input.agentId,
-      runId: input.runId
+      ...input.actorId === undefined ? {} : { actorId: input.actorId },
+      runId: input.runId,
+      authority: input.authorization.type === "principal" ? {
+        type: "principal",
+        context: input.authorization.context,
+        ...input.execution.authorizationRef.type === "principal" && input.execution.authorizationRef.credential !== undefined ? { credential: input.execution.authorizationRef.credential } : {}
+      } : { type: "disabled" }
     })
   });
 }
 function assertAgentExecutionRecord(input) {
   const authority = input.execution.authorizationRef;
-  if (input.execution.executor.type !== "agent" || input.execution.executor.runId !== input.runId || input.execution.source.type !== "execution" || authority.type !== "principal" || authority.principal.type !== "serviceAccount" || input.authorization.principal.type !== "serviceAccount" || authority.principal.id !== input.authorization.principal.id || authority.credential !== undefined) {
+  if (input.execution.executor.type !== "agent" || input.execution.executor.runId !== input.runId || input.execution.source.type !== "execution") {
+    invalidAgentExecution(input.execution.id, input.runId);
+  }
+  if (input.authorization.type === "disabled" || input.authorization.context.principal.type === "user") {
+    assertInheritedAgentAuthority(input.execution, input.runId, input.authorization);
+    return;
+  }
+  if (input.authorization.type !== "principal" || authority.type !== "principal" || authority.principal.type !== "serviceAccount" || input.authorization.context.principal.type !== "serviceAccount" || authority.principal.id !== input.authorization.context.principal.id || authority.credential !== undefined) {
+    invalidAgentExecution(input.execution.id, input.runId);
+  }
+  if (input.actorId === undefined) {
     invalidAgentExecution(input.execution.id, input.runId);
   }
-  assertAgentPrincipal(input.agentId, authority.principal);
+  assertAgentPrincipal(input.actorId, authority.principal);
+}
+function assertInheritedAgentAuthority(execution, runId, authorization) {
+  const authority = execution.authorizationRef;
+  if (authorization.type === "disabled") {
+    if (authority.type !== "disabled")
+      invalidAgentExecution(execution.id, runId);
+    return;
+  }
+  const principal = authorization.context.principal;
+  if (authority.type !== "principal" || authority.principal.type !== "user" || principal.type !== "user" || authority.principal.id !== principal.id || authority.credential === undefined || (authority.credential.type === "session" ? authorization.context.sessionId !== authority.credential.id : authorization.context.sessionId !== undefined)) {
+    invalidAgentExecution(execution.id, runId);
+  }
 }
-function assertAgentPrincipal(agentId, principal) {
-  const expectedId = agentServiceAccountId(agentId);
+function assertAgentPrincipal(actorId, principal) {
+  const expectedId = agentServiceAccountId(actorId);
   if (principal.id !== expectedId) {
-    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent '${agentId}' execution authority must reference service account '${expectedId}'.`);
+    throw new ExecutionStorageError("invalid_input", `[Sixb] Agent '${actorId}' execution authority must reference service account '${expectedId}'.`);
   }
 }
 function invalidAgentExecution(executionId, runId) {
   throw new ExecutionStorageError("invalid_input", `[Sixb] Execution '${executionId}' does not authorize Agent run '${runId}'.`);
 }
 
-export { serializeAgentContextForModel, isAgentToolResult, omitUndefinedObjectProperties, fromAiSdk, toUiMessage, toModelMessages, AGENT_API_GATEWAY_PREFIX, AGENT_API_ROUTES, createAgentApiGatewayCapability, isValidAgentApiGatewayCapability, isAllowedAgentApiRequest, AGENT_REASONING_LEVELS, AGENT_RESERVED_TOOL_NAMES, isAgentDefinition, isAgentToolDefinition, validateAndNormalizeAgentToolInput, validateAgentToolsAtStartup, validateAgentGroupReferences, defineAgentTool, defineAgent, AGENT_CONTEXT_ESTIMATOR_VERSION, shouldCompactAgentContext, estimateAgentContextRequestTokens, estimateAgentContextMessagesTokens, selectAgentContextCompactionBoundary, serializeAgentMessagesForSummary, resolveAgentContextParts, agentRunQueueJobId, workflowAgentNodeQueueJobId, dispatchQueuedAgentRuns, createAgentThreadId, createAgentRunId, createAgentMessageId, agentContextCheckpointId, createAgentRunExecutionToken, WorkflowDefinitionError, WorkflowValidationError, assertNonEmpty2 as assertNonEmpty, isStepDefinition, isAgentStepDefinition, isInterventionDefinition, isWorkflowDefinition, validateWorkflowDefinition, validateWorkflowsAtStartup, validateWorkflowInput, validateWorkflowStepInput, validateWorkflowStepOutput, validateWorkflowInterventionInput, validateWorkflowInterventionResponse, validateWorkflowInterventionDefaultResponse, validateWorkflowAgentStepInput, validateWorkflowAgentStepOutput, snapshotWorkflowAgentStepInput, snapshotWorkflowAgentStepOutput, snapshotWorkflowInput, snapshotWorkflowStepInput, snapshotWorkflowStepOutput, snapshotWorkflowInterventionInput, snapshotWorkflowInterventionResponse, snapshotWorkflowInterventionDefaultResponse, snapshotWorkflowActionInput, WorkflowRunDispatcher, requestWorkflowRun, createBoundSixb, isBoundSixb, createAgentExecutionRecord, bindDurableAgentExecution, restoreAgentExecutionScope, assertAgentExecutionRecord, requestAgentRun, retryAgentRun, projectAgentThreadModelContext };
+export { resolveAgentContextParts, agentRunQueueJobId, subagentRunQueueJobId, workflowAgentNodeQueueJobId, dispatchQueuedAgentRuns, dispatchQueuedSubagentRuns, createAgentThreadId, createAgentRunId, createSubagentRunId, createSubagentExecutionId, createAgentMessageId, agentContextCheckpointId, createAgentRunExecutionToken, assertNoAgentDefinitions, WorkflowDefinitionError, WorkflowValidationError, assertNonEmpty, isStepDefinition, isAgentStepDefinition, isInterventionDefinition, isWorkflowDefinition, validateWorkflowDefinition, validateWorkflowsAtStartup, validateWorkflowAgentStepGroupReferences, validateWorkflowInput, validateWorkflowStepInput, validateWorkflowStepOutput, validateWorkflowInterventionInput, validateWorkflowInterventionResponse, validateWorkflowInterventionDefaultResponse, validateWorkflowAgentStepInput, validateWorkflowAgentStepOutput, snapshotWorkflowAgentStepInput, snapshotWorkflowAgentStepOutput, snapshotWorkflowInput, snapshotWorkflowStepInput, snapshotWorkflowStepOutput, snapshotWorkflowInterventionInput, snapshotWorkflowInterventionResponse, snapshotWorkflowInterventionDefaultResponse, snapshotWorkflowActionInput, WorkflowRunDispatcher, requestWorkflowRun, createBoundSixb, isBoundSixb, canInheritAgentRequestAuthorization, createAgentExecutionRecord, createInheritedAgentExecutionRecord, bindDurableAgentExecution, restoreAgentExecutionScope, assertAgentExecutionRecord, requestAgentRun, retryAgentRun };
 
-//# debugId=E5777634D231818464756E2164756E21
+//# debugId=00C5E0281CC5D43264756E2164756E21