@assemblyline-agents/runtime 3.2.0 → 4.0.0

package/dist/index.js

@@ -1,14 +1,16 @@
 import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
 import { builtInToolDefinition } from "./builtin-tools.js";
+import { InMemoryModelCredentialStore } from "./model-credential-stores.js";
 export * from "./public-api.js";
 export { builtInToolDefaults, FILES_MOUNT_TOOL_NAME, FILES_SEARCH_TOOL_NAME, HISTORY_SEARCH_TOOL_NAME, PAIR_TOOL_NAME } from "./builtin-tools.js";
 export { inspectAgentCapabilities } from "./capability-inspection.js";
 export { CONNECTION_PAIRING_UNAVAILABLE_EVENT, executePairTool } from "./builtin-tool-executors.js";
-import { resolveEvalToolStub, validateEvalRunOptions } from "./eval-run-options.js";
+import { evalRunOptionsForRun, resolveEvalToolStub, validateEvalRunOptions } from "./eval-run-options.js";
 import { rememberDefaultOutboundRoute } from "./default-outbound-route.js";
 import { audienceFromRun, audienceUserKey, normalizeAgentAudience } from "./audience.js";
 import { AgentSourceModuleLoader } from "./source-loader.js";
+import { SandboxAuthoredToolExecutor, resolveAuthoredToolExecutionPolicy } from "./sandbox-authored-tool-executor.js";
 import { AgentEventHandlerRegistry } from "./agent-event-handlers.js";
 import { createMainAgentHookController as createMainAgentHookControllerImpl, createSubagentHookController as createSubagentHookControllerImpl } from "./agent-hook-controller-factory.js";
 import { durableAgentSurfaceScope, flattenSubagents, surfaceForPath, surfaceForRun } from "./agent-surface.js";
@@ -64,7 +66,7 @@ import { completeConnectionAuthorizationCallbackImpl, replayImpl, resumeApproval
 import { recordRunReplayStarted, rerunFromSnapshot } from "./run-replay.js";
 export { RunReplayError } from "./run-replay.js";
 import { buildRunAgentResult } from "./run-result.js";
-import { createSubagentRunImpl, executeSubagentRunImpl, finalizeSubagentHandoffImpl, readSubagentImpl, runSubagentImpl, sendSubagentFollowupImpl } from "./subagent-execution.js";
+import { createSubagentRunImpl, executeSubagentRunImpl, finalizeSubagentHandoffImpl, readSubagentImpl, resumeSubagentImpl, runSubagentImpl, sendSubagentFollowupImpl } from "./subagent-execution.js";
 import { acceptBackgroundSubagentHandoff } from "./subagent-handoff.js";
 import { createHarnessContextImpl, DEFAULT_MAX_MODEL_ITERATIONS, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES, executeHarnessTurnImpl, persistHarnessContinuationImpl, resolveAgentHarnessImpl, runHarnessLoopImpl } from "./harness-loop.js";
 import { getAgentControlImpl, requestRunControlImpl, setAgentEnabledImpl, setAgentMaintenanceImpl } from "./operator-controls.js";
@@ -97,6 +99,7 @@ import { inferToolInput } from "./channel-http-util.js";
 import { connectionPrincipalKeyForGrant, durableAgentScopeForManifest, isInstrumentationDefinition, normalizeCapturePolicy, randomHex, timestamp, } from "./runtime-util.js";
 export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     manifest;
+    authoredToolExecution;
     state;
     runEventBus = new RunEventBus();
     eventHandlers;
@@ -115,7 +118,7 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     /** @deprecated See {@link RuntimeOptions.models}. */
     models;
     agentHarnessOverride;
-    modelHarnesses;
+    modelCredentialStore;
     defaultAgentHarness;
     checkpointEveryIteration;
     checkpointRetention;
@@ -173,6 +176,7 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     hostInstrumentationProvided;
     instrumentationConfig;
     sourceLoader;
+    sandboxAuthoredToolExecutor;
     skillBundleIndex;
     skillResourceReader;
     contextPolicyPromise;
@@ -185,6 +189,7 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     constructor(options) {
         super();
         this.manifest = options.manifest;
+        this.authoredToolExecution = resolveAuthoredToolExecutionPolicy(options.authoredToolExecution);
         const normalizedState = normalizeRuntimeState(options.state ?? new InMemoryStateAdapter());
         // Events fan out to live streams; terminal outcomes become log lines at
         // this one choke point (logger read lazily — assigned below).
@@ -213,7 +218,7 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
         this.coreToolPolicy = resolveCoreToolPolicy(options.coreToolPolicy, this.env, this.devMode);
         this.models = options.models;
         this.agentHarnessOverride = options.agentHarness;
-        this.modelHarnesses = options.modelHarnesses ?? {};
+        this.modelCredentialStore = options.modelCredentialStore ?? new InMemoryModelCredentialStore();
         this.checkpointEveryIteration = resolveBooleanEnv(this.env.ASSEMBLY_LINE_CHECKPOINT_EVERY_ITERATION, true);
         this.checkpointRetention = resolveCheckpointRetentionPolicy(options.checkpointRetention, this.env);
         this.checkpointBlobStorageEnabled = options.blob !== undefined && this.checkpointRetention.blobThresholdBytes > 0;
@@ -319,8 +324,12 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
         this.sourceLoader = new AgentSourceModuleLoader({
             manifest: this.manifest,
             sourceBundle: this.sourceBundle,
-            ...(options.artifactRoot ? { cacheRoot: join(resolve(options.artifactRoot), ARTIFACT_DIR_NAME, "module-cache") } : {})
+            ...(options.artifactRoot ? {
+                cacheRoot: join(resolve(options.artifactRoot), ARTIFACT_DIR_NAME, "module-cache"),
+                packageRoot: resolve(options.artifactRoot)
+            } : {})
         });
+        this.sandboxAuthoredToolExecutor = new SandboxAuthoredToolExecutor(this.sourceLoader);
         this.skillBundleIndex = createSkillBundleIndex(this.manifest);
         this.skillResourceReader = createSkillResourceReader({
             manifest: this.manifest,
@@ -1120,8 +1129,8 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
             env: this.env,
             logger: this.logger,
             models: this.models,
+            modelCredentialStore: this.modelCredentialStore,
             agentHarnessOverride: this.agentHarnessOverride,
-            modelHarnesses: this.modelHarnesses,
             checkpointEveryIteration: this.checkpointEveryIteration,
             maxModelIterations: this.maxModelIterations,
             outputValidationMaxRetries: this.outputValidationMaxRetries,
@@ -1145,7 +1154,7 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
             createConnectionRegistryForRun: (run, fallbackChannel, sandboxHandle, selectedConnections) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections),
             missingRequiredConnections: (selected) => this.missingRequiredConnections(selected),
             visibleToolSet: (defaultToolNames, activeSkills) => this.visibleToolSet(defaultToolNames, activeSkills),
-            modelTools: (run, activeToolNames, connectionRegistry, discoveredConnectionTools, options) => this.modelTools(run, activeToolNames, connectionRegistry, discoveredConnectionTools, options),
+            modelTools: (run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options) => this.modelTools(run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options),
             harnessExecuteTool: (call, state) => this.harnessExecuteTool(call, state),
             createCheckpoint: (input) => this.createCheckpoint(input),
             hydrateCheckpointData: (data) => this.hydrateCheckpointData(data),
@@ -1431,6 +1440,9 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     async runSubagent(parentRunId, subagentName, task) {
         return runSubagentImpl(this.subagentExecutionHost(), parentRunId, subagentName, task);
     }
+    async resumeSubagent(parentRunId, childRunId, subagentName, message) {
+        return resumeSubagentImpl(this.subagentExecutionHost(), parentRunId, childRunId, subagentName, message);
+    }
     async queueSubagent(parentRunId, subagentName, task) {
         const child = await createSubagentRunImpl(this.subagentExecutionHost(), parentRunId, subagentName, task, { background: true });
         this.backgroundSubagents.requestDrain();
@@ -1740,8 +1752,8 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     async instructionsForRunTarget(run, target, baseInstructions) {
         return instructionsForRunTargetImpl({ appendEvent: (runId, type, data) => this.state.appendEvent(runId, type, data), skillLoadDetails: (skillName) => this.skillLoadDetails(run, skillName) }, run, target, baseInstructions);
     }
-    async modelTools(run, activeToolNames, connectionRegistry, discoveredConnectionTools = new Map(), options) {
-        return modelToolsImpl(this.toolExecutionHost(), run, activeToolNames, connectionRegistry, discoveredConnectionTools, options);
+    async modelTools(run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools = new Map(), options) {
+        return modelToolsImpl(this.toolExecutionHost(), run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options);
     }
     async harnessExecuteTool(call, state) {
         return harnessExecuteToolImpl(this.toolExecutionHost(), call, state);
@@ -1878,6 +1890,7 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
             connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
             connectionCallbackBaseUrl: this.connectionCallbackBaseUrl,
             toolOutputMaxChars: this.toolOutputMaxChars,
+            authoredToolExecution: this.authoredToolExecution,
             toolTimeoutMs: this.toolTimeoutMs,
             sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
             skillsConfigForRun: (run) => this.skillsConfigForRun(run),
@@ -1896,8 +1909,12 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
             mergedConnections: () => this.mergedConnections(),
             loadConnectionDefinition: (connection) => this.loadConnectionDefinition(connection),
             loadTool: (tool, run) => this.loadTool(tool, run),
+            shouldSandboxAuthoredTool: (tool, run) => this.shouldSandboxAuthoredTool(tool, run),
+            describeSandboxedTool: (tool, sandboxHandle) => this.sandboxAuthoredToolExecutor.describe(tool, sandboxHandle),
+            executeSandboxedTool: (tool, input, context, sandboxHandle, signal) => this.sandboxAuthoredToolExecutor.execute(tool, input, context, sandboxHandle, signal),
             runSubagent: (parentRunId, subagentName, task) => this.runSubagent(parentRunId, subagentName, task),
             queueSubagent: (parentRunId, subagentName, task) => this.queueSubagent(parentRunId, subagentName, task),
+            resumeSubagent: (parentRunId, childRunId, subagentName, message) => this.resumeSubagent(parentRunId, childRunId, subagentName, message),
             listBackgroundWork: (rootRunId, includeTerminal) => this.listBackgroundWork(rootRunId, includeTerminal),
             getBackgroundWork: (rootRunId, childRunId) => this.getBackgroundWork(rootRunId, childRunId),
             cancelBackgroundWork: (rootRunId, childRunId) => this.cancelBackgroundWork(rootRunId, childRunId),
@@ -2083,6 +2100,13 @@ export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
         const module = await this.sourceLoader.load(tool.source);
         return module.default;
     }
+    shouldSandboxAuthoredTool(tool, run) {
+        if (tool.source.path.startsWith("__builtin__"))
+            return false;
+        if (this.toolStubs[tool.name] || evalRunOptionsForRun(run)?.toolStubs?.[tool.name])
+            return false;
+        return this.authoredToolExecution === "sandbox" || tool.execution === "sandbox";
+    }
     async result(run, response, waitingForApproval, waitingForInput, waitingForConnection) {
         return buildRunAgentResult(this.state, run, response, waitingForApproval, waitingForInput, waitingForConnection);
     }