@sixb/core 0.1.11 → 0.1.12

package/dist/{chunk-gq8vhakp.js → chunk-nzsy3xrp.js}

@@ -20,93 +20,98 @@ import {
   canViewPipelineRun2,
   canViewProjectionRun2,
   canViewProjection2
-} from "./chunk-dz5h08xv.js";
+} from "./chunk-bbaa1fet.js";
 import {
   captureSixbFailure2
-} from "./chunk-f4w3yp4f.js";
+} from "./chunk-hzw7yv5g.js";
 import {
   isRecord2,
   normalizeSchemaValue2,
   coerceSchemaValueToTyped2,
   assertObjectTypeRegistered2
-} from "./chunk-ms2tmn1k.js";
+} from "./chunk-vsg0g7h9.js";
 import {
   isActionDefinition2,
   SYSTEM_PRINCIPAL2,
   principalsEqual2
-} from "./chunk-g00bfdq6.js";
+} from "./chunk-2cxv584m.js";
 import {
   isModelReasoning2,
   modelReasoningSupportIssue2
 } from "./chunk-pqajwytd.js";
 import {
   RuntimeError2,
-  ModelProviderError2,
-  ModelStreamError2,
-  UnsupportedModelFeatureError2,
-  StructuredOutputError2,
+  assertDecisionContent,
+  assertDecisionQuestions,
+  assertDecisionModel,
+  assertDecisionSupport,
+  validateDecisionAnswers,
+  DecisionModelResponseError2,
   estimateModelCall,
   rateModelCall2
-} from "./chunk-jsy70480.js";
+} from "./chunk-2h63nrde.js";
 import {
   AgentStorageError2,
   AGENT_REASONING_LEVELS2
-} from "./chunk-7bs40fe1.js";
+} from "./chunk-69266efg.js";
 import {
   ObjectNotFoundError2
-} from "./chunk-8vj0rjgs.js";
+} from "./chunk-wjffn5m4.js";
 import {
   ExecutionStorageError2
-} from "./chunk-93csa55g.js";
+} from "./chunk-axndsymr.js";
 import {
   WORKFLOW_RUN_FAILURE_CODES2
-} from "./chunk-gqm76kse.js";
+} from "./chunk-ybhz3j9g.js";
 import {
   WorkflowRunError2
-} from "./chunk-pr2h4bv4.js";
+} from "./chunk-tg4g4zh0.js";
 import {
   assertAuthorizedObjectReaderBinding,
   getAuthorizedOntologyView,
   canDelegationAccessActionRun,
   requestAction3,
   requestActionAndWait2
-} from "./chunk-01kj2pbh.js";
+} from "./chunk-g50nxqs5.js";
 import {
   shareSixbErrorReporter2,
   reportRunFailure2
-} from "./chunk-7apz6hg4.js";
+} from "./chunk-bet1rb9h.js";
 import {
   aiLimitSubjectsFromAttribution2,
   applicableAiLimitPolicyStatuses2,
   aiUsageLimitExceededError2,
   aiUsageLimitUnavailableError2
-} from "./chunk-0y39rgsb.js";
+} from "./chunk-5tetw4hn.js";
 import {
   AgentRequestError2,
   normalizeAgentContextEntries2
 } from "./chunk-dmn70ztd.js";
 import {
   publishAgentRunActivity2
-} from "./chunk-92vk7gta.js";
+} from "./chunk-gzt6v1ja.js";
 import {
   registerConnectorConnectionsRuntime
 } from "./chunk-5a4a52tq.js";
 import {
   createConnectorRuntime
-} from "./chunk-v2vcg0w6.js";
+} from "./chunk-xtfryrfb.js";
 import {
   writeDataset2
-} from "./chunk-mrp7k0pw.js";
+} from "./chunk-91kcnbf0.js";
 import {
   shareOntologyMutationRuntime2
 } from "./chunk-85cd7e8c.js";
 import {
   compileShareAccessPlan
-} from "./chunk-awbhdqyc.js";
+} from "./chunk-3ghw2t5q.js";
 import {
   SyncValidationError2,
   requestSyncRun2
-} from "./chunk-cfvakeax.js";
+} from "./chunk-jjwhy3rs.js";
+import {
+  ModelExecutionSession
+} from "./chunk-4ph94nhd.js";
 import {
   getTelemetryHistoryBatch2,
   getLatestTelemetryPoint,
@@ -118,37 +123,48 @@ import {
   upsertObject3,
   upsertObjectBatch3,
   appendTelemetry
-} from "./chunk-z0s4axeh.js";
+} from "./chunk-7qnvhtcd.js";
 import {
   schemaRecordToJsonSchema2
 } from "./chunk-7zgecwy1.js";
 import {
   PipelineError2,
   requestPipelineRun2
-} from "./chunk-g91qxjj0.js";
+} from "./chunk-bg2bs62d.js";
 import {
-  requireAccountingCapabilities,
-  aiModelCallOutputTokenAllowance,
-  createAiModelCallLimitController2,
-  AiModelCallRecorder2,
-  enqueueAiModelCallRecovery2,
   resolveLanguageModel2
-} from "./chunk-d63nnr5b.js";
+} from "./chunk-kept9cdd.js";
+import {
+  AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE,
+  aiModelCallOutputTokenAllowance
+} from "./chunk-e1f1sqba.js";
 import {
   getDatasetPrimaryKeyColumns2
-} from "./chunk-9qsh3p5y.js";
+} from "./chunk-rb143ggb.js";
 import {
   executionRecordInputFromRuntime,
   ensureExecutionRecord2,
   createPrimitiveExecutionRecord
-} from "./chunk-17kfctj6.js";
+} from "./chunk-0mza4xb2.js";
 import {
   ShareGrantStorageError2
 } from "./chunk-br3k6qbf.js";
+import {
+  normalizeParams
+} from "./chunk-y3ev53cq.js";
 import {
   isObjectRefSchema2,
   validateSchemaOrRefValue2
-} from "./chunk-f0rwz2vh.js";
+} from "./chunk-vpxss818.js";
+import {
+  ModelProviderError2,
+  ModelStreamError2,
+  UnsupportedModelFeatureError2,
+  StructuredOutputError2
+} from "./chunk-p1683c0v.js";
+import {
+  OntologyValidationError2
+} from "./chunk-cqr3acm1.js";
 import {
   supportsDirectUpload2,
   supportsRangeRead2
@@ -157,6 +173,8 @@ import {
   isJsonValue2,
   assertJsonValue2,
   assertJsonObject2,
+  cloneJsonValue2,
+  getInvalidJsonValueReason2,
   isPlainRecord
 } from "./chunk-wy0qdqfm.js";
 
@@ -299,6 +317,10 @@ import { createHash, randomUUID } from "crypto";
 function createAgentThreadId2() {
   return `agt_thr_${randomUUID()}`;
 }
+function createAgentThreadSandboxName2(projectId, threadId) {
+  const digest = createHash("sha256").update(JSON.stringify([projectId, threadId, randomUUID()])).digest("hex");
+  return `sixb-sb-${digest}`;
+}
 function createAgentRunId2() {
   return `agt_run_${randomUUID()}`;
 }
@@ -485,6 +507,7 @@ async function requestAgentRun2(runtime, execution, models, input) {
     title: input.title,
     principal
   });
+  assertSandboxExecutionAvailable(thread);
   if (thread.activeRunId !== null) {
     throw new AgentRequestError2("active_run_exists", `[Sixb] Agent thread '${thread.id}' already has an active run '${thread.activeRunId}'.`);
   }
@@ -551,6 +574,7 @@ async function retryAgentRun2(runtime, execution, models, failedRun) {
   if (!thread) {
     throw new AgentRequestError2("thread_not_found", `[Sixb] Agent thread '${failedRun.threadId}' was not found.`);
   }
+  assertSandboxExecutionAvailable(thread);
   const runId = createAgentRunId2();
   const durableExecution = await prepareDurableAgentExecution(runtime, execution, runId);
   await assertAiLimitPreflight(runtime, durableExecution);
@@ -581,6 +605,11 @@ async function retryAgentRun2(runtime, execution, models, failedRun) {
   const jobId = await dispatchAgentRun(runtime, agents, runId);
   return { run, ...jobId ? { jobId } : {}, createdThread: false };
 }
+function assertSandboxExecutionAvailable(thread) {
+  if (thread.sandboxState && !["new", "ready"].includes(thread.sandboxState.status)) {
+    throw new AgentRequestError2("sandbox_execution_unavailable", "[Sixb] Sandbox recovery is required before another run. Reload the thread and explicitly recreate it to start fresh.");
+  }
+}
 async function assertAiLimitPreflight(runtime, execution) {
   const limits = runtime.storage.aiLimits;
   if (!limits)
@@ -687,8 +716,37 @@ function requireAgentStorage(runtime) {
   return agents;
 }
 
+// src/agents/sandbox.ts
+function normalizeSandboxBinding(definition, input, ontology) {
+  if (!definition) {
+    throw new AgentRequestError2("sandbox_not_configured", "[Sixb] This sandbox provider has no compatible thread configuration.");
+  }
+  if (!isPlainRecord(input)) {
+    throw new AgentRequestError2("invalid_sandbox_params", "[Sixb] sandbox must be an object containing the declared parameter values.");
+  }
+  try {
+    const params = normalizeParams(ontology.getValueTypesById(), definition.params, input, {
+      kind: "sandbox",
+      id: "sandboxes",
+      path: "sandbox"
+    });
+    if (getInvalidJsonValueReason2(params)) {
+      throw new OntologyValidationError2("[Sixb] Sandbox params must normalize to JSON values.");
+    }
+    return params;
+  } catch (error) {
+    throw new AgentRequestError2("invalid_sandbox_params", error instanceof OntologyValidationError2 ? error.message : "[Sixb] Sandbox params could not be normalized.");
+  }
+}
+
 // src/agents/execution.ts
-function createAgentRuntime(runtime, execution, models) {
+function publicThread(thread) {
+  if (!thread.sandboxState)
+    return thread;
+  const { name, status, initialized } = thread.sandboxState;
+  return { ...thread, sandboxState: { name, status, initialized } };
+}
+function createAgentRuntime(runtime, execution, models, sandbox) {
   const authority = resolveRuntimeAuthorizationForProject(runtime);
   const principal = authority.type === "principal" ? authority.context.principal : SYSTEM_PRINCIPAL2;
   const allowed = () => isRuntimeAllowed2(runtime, { kind: "agent.run" });
@@ -701,12 +759,12 @@ function createAgentRuntime(runtime, execution, models) {
     }) ?? null;
     if (!thread || !allowed())
       return null;
-    return authority.type === "principal" && !principalsEqual2(principal, thread.ownerPrincipal) ? null : thread;
+    return authority.type === "principal" && !principalsEqual2(principal, thread.ownerPrincipal) ? null : publicThread(thread);
   };
   const getAgent = () => {
     if (authority.type === "denied" || authority.type === "delegated")
       return null;
-    const model = models?.language.default;
+    const model = models?.language?.default;
     if (!model || !allowed())
       return null;
     return {
@@ -733,6 +791,22 @@ function createAgentRuntime(runtime, execution, models) {
   return {
     get: getAgent,
     threads: {
+      recreateSandbox: async (threadId, input) => {
+        const thread = await getVisibleThreadRecord(threadId);
+        if (!thread)
+          throw new AgentRequestError2("thread_not_found", "[Sixb] Agent thread not found.");
+        const storage = runtime.storage.agents;
+        if (!storage)
+          throw new AgentRequestError2("storage_unavailable", "[Sixb] Agent storage is not configured.");
+        const sandboxState = await storage.threads.transitionSandbox({
+          projectId: runtime.projectId,
+          id: threadId,
+          action: "recreate",
+          expectedSandboxName: input.expectedSandboxName,
+          name: createAgentThreadSandboxName2(runtime.projectId, threadId)
+        });
+        return publicThread({ ...thread, sandboxState });
+      },
       create: async (input) => {
         assertNoAgentSelector(input);
         const agent = getAgent();
@@ -743,7 +817,12 @@ function createAgentRuntime(runtime, execution, models) {
         if (!storage) {
           throw new AgentRequestError2("storage_unavailable", "[Sixb] Agent storage is not configured.");
         }
+        if (input.sandbox !== undefined && !sandbox?.supportsPersistence) {
+          throw new AgentRequestError2("sandbox_not_configured", "[Sixb] Thread sandboxes require a provider with persistence support.");
+        }
+        const binding = input.sandbox === undefined ? undefined : normalizeSandboxBinding(sandbox?.definition, input.sandbox, runtime.ontology);
         return storage.threads.create({
+          ...binding === undefined ? {} : { sandboxParams: binding },
           id: input.id ?? createAgentThreadId2(),
           projectId: runtime.projectId,
           ownerPrincipal: principal,
@@ -759,11 +838,12 @@ function createAgentRuntime(runtime, execution, models) {
         const storage = runtime.storage.agents;
         if (!storage || !allowed())
           return { threads: [], hasMore: false, total: 0 };
-        return storage.threads.list({
+        const result = await storage.threads.list({
           ...input,
           projectId: runtime.projectId,
           ownerPrincipal: authority.type === "principal" ? principal : undefined
         });
+        return { ...result, threads: result.threads.map(publicThread) };
       }
     },
     runs: {
@@ -1958,6 +2038,119 @@ function isAbortError(error) {
   return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
 }
 
+// src/models/decision/runtime.ts
+import { randomUUID as randomUUID5 } from "crypto";
+function createDecisionRuntime(runtime, execution, catalog, session) {
+  return {
+    async evaluate(input) {
+      assertProviderAccess2(runtime, execution, "models.decision.evaluate");
+      assertDecisionContent(input.input, "input");
+      assertDecisionQuestions(input.questions);
+      const state = cloneJsonValue2(input.input);
+      assertDecisionContent(state, "input");
+      const questions = structuredClone(input.questions);
+      const signal = session.signal(input.signal);
+      signal.throwIfAborted();
+      const binding = resolveDecisionModel(catalog, input.model);
+      assertDecisionModel(binding);
+      assertDecisionSupport(binding, questions);
+      const accounting = await session.accounting();
+      accounting.assertHealthy();
+      signal.throwIfAborted();
+      const model = binding.resolve ? await binding.resolve() : binding;
+      assertDecisionModel(model);
+      if (model.providerId !== binding.providerId || model.modelId !== binding.modelId) {
+        throw new TypeError("[SixbModels] Resolved decision model identity does not match the selected model.");
+      }
+      assertDecisionSupport(model, questions);
+      signal.throwIfAborted();
+      const request = { input: state, questions, signal };
+      const callId = await admitDecisionCall(accounting, model, request);
+      let result;
+      try {
+        signal.throwIfAborted();
+        result = await model.evaluate(request);
+      } catch (error) {
+        const metadata = error instanceof DecisionModelResponseError2 ? error.metadata : {};
+        await recordDecision(accounting, model, callId, metadata);
+        throw error;
+      }
+      const event = await recordDecision(accounting, model, callId, result ?? {});
+      signal.throwIfAborted();
+      let output;
+      try {
+        output = validateDecisionAnswers(questions, result?.output, model.definition.capabilities.answerDecimalPlaces);
+      } catch (cause) {
+        throw new DecisionModelResponseError2("[SixbModels] Invalid decision response.", model.providerId, model.modelId, result ?? {}, { cause });
+      }
+      return {
+        output,
+        callId,
+        ...event.responseModelId === undefined ? {} : { responseModelId: event.responseModelId },
+        usage: event.usage,
+        cost: event.cost
+      };
+    }
+  };
+}
+function resolveDecisionModel(catalog, requested) {
+  if (!requested) {
+    const model = catalog?.decision?.default.model;
+    if (!model) {
+      throw new Error("[SixbModels] Configure models.decision or supply a model to evaluate().");
+    }
+    return model;
+  }
+  if (!catalog)
+    return requested;
+  const entry = catalog.decision?.getByRef({
+    provider: requested.providerId,
+    modelId: requested.modelId
+  });
+  if (!entry) {
+    throw new Error(`[SixbModels] Model '${requested.providerId}/${requested.modelId}' is not configured in models.decision.`);
+  }
+  return entry.model;
+}
+async function admitDecisionCall(accounting, model, request) {
+  const callId = `call_${randomUUID5()}`;
+  const serialized = JSON.stringify({ input: request.input, questions: request.questions });
+  const tokens = Math.ceil(new TextEncoder().encode(serialized).byteLength / 4);
+  const outputTokenAllowance = AI_MODEL_CALL_OUTPUT_TOKEN_ALLOWANCE;
+  await accounting.admitCall({
+    callId,
+    providerId: model.providerId,
+    modelId: model.modelId,
+    costEstimator: model.costEstimator,
+    inputTokens: { status: "estimated", tokens, method: "utf8BytesDividedByFour" },
+    outputTokenAllowance,
+    estimatedTotalTokens: tokens + outputTokenAllowance
+  });
+  return callId;
+}
+async function recordDecision(accounting, model, callId, metadata) {
+  const usage = metadata.usage ?? {};
+  const estimate = estimateModelCall(model, {
+    usage,
+    route: metadata.route,
+    responseModelId: metadata.responseModelId
+  });
+  const event = {
+    callId,
+    providerId: model.providerId,
+    modelId: model.modelId,
+    responseId: metadata.providerIds?.responseId ?? callId,
+    responseModelId: metadata.responseModelId,
+    providerIds: metadata.providerIds,
+    usage,
+    cost: metadata.reportedCost ? { status: "reported", ...metadata.reportedCost } : estimate,
+    ...metadata.reportedCost ? { estimate } : {},
+    route: metadata.route
+  };
+  await accounting.onModelCallEnd(event);
+  return event;
+}
+
 // src/models/execution/binding.ts
 var bindings = new WeakMap;
 function registerModelExecutionBinding(models, bind) {
@@ -2005,47 +2198,16 @@ function languageModelOutput(shape, valueTypesById) {
 
 // src/models/execution.ts
 function createModelsRuntime(runtime, execution, catalog) {
-  let binding;
-  let recorder;
-  async function createRecorder() {
-    const storage = {
-      ...requireAccountingCapabilities(runtime.storage),
-      transaction: runtime.storage.transaction.bind(runtime.storage)
-    };
-    if (!binding) {
-      throw new Error("[SixbModels] Generation requires a bound request or worker execution attempt.");
-    }
-    const { requesterGroupIds } = await ensureExecutionRecord2(runtime.storage.executions, executionRecordInputFromRuntime({
-      execution,
-      runtimeAuthorization: runtime.runtimeAuthorization
-    }));
-    return new AiModelCallRecorder2({
-      storage,
-      projectId: runtime.projectId,
-      executionId: execution.id,
-      attempt: binding.attempt,
-      requesterGroupIds,
-      limits: createAiModelCallLimitController2({
-        storage,
-        projectId: runtime.projectId,
-        requestedBy: execution.requestedBy,
-        requesterGroupIds
-      }),
-      recoverAiModelCall: (input) => enqueueAiModelCallRecovery2(runtime.queues.agents, input)
-    });
-  }
+  const session = runtime.modelExecution ?? new ModelExecutionSession(runtime, execution);
   async function generate(input) {
     assertProviderAccess2(runtime, execution, "models.language.generate");
     const messages = generationMessages(input);
-    if (!binding) {
-      throw new Error("[SixbModels] Generation requires a bound request or worker execution attempt.");
-    }
-    const signal = input.signal ? AbortSignal.any([binding.signal, input.signal]) : binding.signal;
+    const signal = session.signal(input.signal);
     signal.throwIfAborted();
-    const selected = input.model ? catalog ? catalog.language.getByRef({
+    const selected = input.model ? catalog ? catalog.language?.getByRef({
       provider: input.model.providerId,
       modelId: input.model.modelId
-    })?.model : input.model : catalog?.language.default.model;
+    })?.model : input.model : catalog?.language?.default.model;
     if (!selected) {
       throw new Error(input.model ? `[SixbModels] Model '${input.model.providerId}/${input.model.modelId}' is not configured in models.language.` : "[SixbModels] Configure models.language in createSixb() or supply a model to generate().");
     }
@@ -2061,8 +2223,7 @@ function createModelsRuntime(runtime, execution, catalog) {
     if (typeof input.reasoning === "object" && input.reasoning.budgetTokens >= maxOutputTokens) {
       throw new TypeError("[SixbModels] Output allowance must exceed the reasoning token budget.");
     }
-    recorder ??= createRecorder();
-    const accounting = await recorder;
+    const accounting = await session.accounting();
     accounting.assertHealthy();
     signal.throwIfAborted();
     let event;
@@ -2099,10 +2260,11 @@ function createModelsRuntime(runtime, execution, catalog) {
     };
   }
   const models = {
-    language: { generate }
+    language: { generate },
+    decision: createDecisionRuntime(runtime, execution, catalog, session)
   };
   registerModelExecutionBinding(models, (input) => {
-    binding = { attempt: input.attempt, signal: input.signal };
+    session.bind(input);
   });
   return models;
 }
@@ -2144,6 +2306,7 @@ function createObjectsRuntime(runtime, execution) {
     projectId: runtime.projectId,
     broker: runtime.broker,
     ontology: runtime.ontology,
+    embeddingModels: runtime.embeddingModels,
     actionRegistry: runtime.actionRegistry,
     events: runtime.events,
     storage: runtime.storage,
@@ -2458,7 +2621,7 @@ function createSchedulesRuntime(runtime, schedules) {
 }
 
 // src/shares/execution.ts
-import { createHash as createHash2, randomBytes, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash2, randomBytes, randomUUID as randomUUID6 } from "crypto";
 var MAX_CREATE_ATTEMPTS = 5;
 
 class ShareError2 extends Error {
@@ -2525,7 +2688,7 @@ function createSharesRuntime(runtime, execution, definitions) {
       const secret = randomBytes(32).toString("base64url");
       try {
         const grant = await storage.create({
-          id: `shr_${randomUUID5()}`,
+          id: `shr_${randomUUID6()}`,
           projectId: runtime.projectId,
           definitionId: definition.id,
           target,
@@ -2781,7 +2944,7 @@ class WorkflowValidationError2 extends Error {
 }
 
 // src/workflows/run-dispatch.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { isDeepStrictEqual } from "util";
 
 // src/workflows/validation.ts
@@ -2855,12 +3018,12 @@ function validateWorkflowAgentStepGroupReferences2(workflows, security) {
   }
 }
 function validateWorkflowAgentStepRuntimeReferences(workflowId, step, options) {
-  if (step.model === undefined && options.models === undefined) {
+  if (step.model === undefined && options.models?.language === undefined) {
     throw new WorkflowDefinitionError2(`Workflow "${workflowId}" agent step "${step.id}" needs a model. Configure 'models.language' or pass 'model' to defineAgentStep().`);
   }
   if (step.model !== undefined && options.models !== undefined) {
     const ref = { provider: step.model.providerId, modelId: step.model.modelId };
-    if (options.models.language.getByRef(ref) === null) {
+    if (options.models.language?.getByRef(ref) == null) {
       throw new WorkflowDefinitionError2(`Workflow "${workflowId}" agent step "${step.id}" uses unknown language model "${ref.provider}/${ref.modelId}". Add it to 'models.language' in createSixb().`);
     }
   }
@@ -3471,7 +3634,7 @@ async function persistWorkflowRun(input, request) {
     assertExistingWorkflowRun(existing, input.workflow.id, request.snapshot);
     return { run: existing, created: false };
   }
-  const execution = await input.createExecution(`exec_${randomUUID6()}`, request.runId);
+  const execution = await input.createExecution(`exec_${randomUUID7()}`, request.runId);
   const queuedAt = new Date;
   try {
     return await input.storage.transaction(async (tx) => {
@@ -3584,7 +3747,7 @@ async function failWorkflowRunPublication(input, run, error) {
 }
 function resolveWorkflowRunId(runId) {
   if (runId === undefined)
-    return `run_${randomUUID6()}`;
+    return `run_${randomUUID7()}`;
   if (!runId.trim()) {
     throw new WorkflowValidationError2("[Sixb] Workflow run id must not be empty");
   }
@@ -3891,7 +4054,7 @@ function createExecutionFacades(runtime, execution, dependencies) {
     pipelines: createPipelinesRuntime(runtime, execution, dependencies.definitions.pipelines),
     projections: createProjectionsRuntime(runtime, dependencies.definitions.projections),
     rules: createRulesRuntime(runtime, dependencies.definitions.rules),
-    agent: createAgentRuntime(runtime, execution, dependencies.definitions.models),
+    agent: createAgentRuntime(runtime, execution, dependencies.definitions.models, dependencies.sandbox),
     models: createModelsRuntime(runtime, execution, dependencies.definitions.models),
     aiUsage: createAiUsageRuntime(runtime, dependencies.definitions.security),
     events: createEventsRuntime(runtime),
@@ -4012,6 +4175,6 @@ function invalidAgentExecution(executionId, runId) {
   throw new ExecutionStorageError2("invalid_input", `[Sixb] Execution '${executionId}' does not authorize Agent run '${runId}'.`);
 }
 
-export { resolveAgentContextParts2, agentRunQueueJobId2, subagentRunQueueJobId2, workflowAgentNodeQueueJobId2, dispatchQueuedAgentRuns2, dispatchQueuedSubagentRuns2, createAgentThreadId2, createAgentRunId2, createSubagentRunId2, createSubagentExecutionId2, createAgentMessageId2, agentContextCheckpointId2, createAgentRunExecutionToken2, runModelLoop2, assertNoAgentDefinitions, bindModelExecutionAttempt, ShareError2, WorkflowDefinitionError2, WorkflowValidationError2, assertNonEmpty, isStepDefinition2, isAgentStepDefinition2, isInterventionDefinition2, isWorkflowDefinition2, validateWorkflowDefinition2, validateWorkflowsAtStartup2, validateWorkflowAgentStepGroupReferences2, validateWorkflowInput2, validateWorkflowStepInput2, validateWorkflowStepOutput2, validateWorkflowInterventionInput2, validateWorkflowInterventionResponse2, validateWorkflowInterventionDefaultResponse2, validateWorkflowAgentStepInput2, validateWorkflowAgentStepOutput2, snapshotWorkflowAgentStepInput2, snapshotWorkflowAgentStepOutput2, snapshotWorkflowInput2, snapshotWorkflowStepInput2, snapshotWorkflowStepOutput2, snapshotWorkflowInterventionInput2, snapshotWorkflowInterventionResponse2, snapshotWorkflowInterventionDefaultResponse2, snapshotWorkflowActionInput2, WorkflowRunDispatcher2, requestWorkflowRun2, createBoundSixb, isBoundSixb, canInheritAgentRequestAuthorization2, createAgentExecutionRecord2, createInheritedAgentExecutionRecord2, bindDurableAgentExecution2, restoreAgentExecutionScope2, assertAgentExecutionRecord2, requestAgentRun2, retryAgentRun2 };
+export { resolveAgentContextParts2, agentRunQueueJobId2, subagentRunQueueJobId2, workflowAgentNodeQueueJobId2, dispatchQueuedAgentRuns2, dispatchQueuedSubagentRuns2, createAgentThreadId2, createAgentThreadSandboxName2, createAgentRunId2, createSubagentRunId2, createSubagentExecutionId2, createAgentMessageId2, agentContextCheckpointId2, createAgentRunExecutionToken2, runModelLoop2, assertNoAgentDefinitions, bindModelExecutionAttempt, ShareError2, WorkflowDefinitionError2, WorkflowValidationError2, assertNonEmpty, isStepDefinition2, isAgentStepDefinition2, isInterventionDefinition2, isWorkflowDefinition2, validateWorkflowDefinition2, validateWorkflowsAtStartup2, validateWorkflowAgentStepGroupReferences2, validateWorkflowInput2, validateWorkflowStepInput2, validateWorkflowStepOutput2, validateWorkflowInterventionInput2, validateWorkflowInterventionResponse2, validateWorkflowInterventionDefaultResponse2, validateWorkflowAgentStepInput2, validateWorkflowAgentStepOutput2, snapshotWorkflowAgentStepInput2, snapshotWorkflowAgentStepOutput2, snapshotWorkflowInput2, snapshotWorkflowStepInput2, snapshotWorkflowStepOutput2, snapshotWorkflowInterventionInput2, snapshotWorkflowInterventionResponse2, snapshotWorkflowInterventionDefaultResponse2, snapshotWorkflowActionInput2, WorkflowRunDispatcher2, requestWorkflowRun2, createBoundSixb, isBoundSixb, canInheritAgentRequestAuthorization2, createAgentExecutionRecord2, createInheritedAgentExecutionRecord2, bindDurableAgentExecution2, restoreAgentExecutionScope2, assertAgentExecutionRecord2, requestAgentRun2, retryAgentRun2 };
 
-//# debugId=F73579E689A4184364756E2164756E21
+//# debugId=9EF5DC91DC65724364756E2164756E21