@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/prepared-snapshot.js

@@ -0,0 +1,53 @@
+import { isDeepStrictEqual } from "node:util";
+import { normalizeCompletedAdapterExecution } from "../../orchestration/worker-capabilities/execution/adapter-result-normalization.js";
+import { createPreparedWorkerInvocation } from "./prepared-execution.js";
+export function createPreparedRejectionSnapshot(capabilityId, actionFingerprint, acceptedControls, result) {
+    return Object.freeze(structuredClone({
+        kind: "registered_worker_rejection_v1",
+        capabilityId,
+        actionFingerprint,
+        acceptedControls,
+        result,
+    }));
+}
+/** Owning adapter hydration: no normalization, payload author, or external call. */
+export async function restorePreparedWorkerInvocation(params, input, snapshot) {
+    if (!isRecord(snapshot) ||
+        snapshot.capabilityId !== params.descriptor.capabilityId)
+        throw invalid();
+    if (snapshot.kind === "registered_worker_rejection_v1") {
+        if (typeof snapshot.actionFingerprint !== "string" ||
+            !isRecord(snapshot.acceptedControls) ||
+            !isDeepStrictEqual(snapshot.acceptedControls, input.controls) ||
+            !isRecord(snapshot.result))
+            throw invalid();
+        const raw = snapshot.result;
+        const normalized = normalizeCompletedAdapterExecution(raw, params.descriptor.effect);
+        if (!normalized.ok || normalized.execution.result.outcome !== "failed")
+            throw invalid();
+        const result = structuredClone(raw);
+        return Object.freeze({
+            actionFingerprint: snapshot.actionFingerprint,
+            acceptedControls: snapshot.acceptedControls,
+            snapshot: structuredClone(snapshot),
+            execute: async () => result,
+        });
+    }
+    if (snapshot.kind !== "registered_worker_invocation_v1" ||
+        !Array.isArray(snapshot.selectedTargetReferences) ||
+        !snapshot.selectedTargetReferences.every((ref) => isRecord(ref) &&
+            ref.kind === "tool_target" &&
+            typeof ref.target === "string"))
+        throw invalid();
+    const normal = params.executor.restore(snapshot.normal);
+    if (normal.status !== "prepared" ||
+        !isDeepStrictEqual(normal.acceptedControls, input.controls))
+        throw invalid();
+    return createPreparedWorkerInvocation(params, input, normal, snapshot.selectedTargetReferences, { release() { } });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalid() {
+    return new Error("registered_worker_snapshot_incompatible");
+}

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/result-evidence.js

@@ -3,6 +3,7 @@ import { normalizeCapabilityAdapterResult, } from "../../orchestration/capabilit
 import { executionProtocolError } from "./errors.js";
 import { isPlainRecord, nonEmpty } from "./values.js";
 const MUTATION_GROUNDING_MAX_LENGTH = 32_768;
+const OBSERVATION_OUTPUT_PREVIEW_MAX_LENGTH = 512;
 export function summarizeCompletedMutation(completionActions) {
     if (completionActions.length === 0) {
         return boundedSummary("The mutation capability reported a completed change.");
@@ -136,16 +137,18 @@ export function projectObservationOutput(input, directRoot = false) {
     if (normalized.length <= ROLE_CALL_RESULT_MAX_LENGTH) {
         return Object.freeze({ summary: normalized });
     }
-    if (directRoot ||
-        normalized.length > ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH) {
+    if (directRoot) {
         return Object.freeze({
-            summary: directRoot
-                ? "The capability result is available in the canonical direct execution result."
-                : "The capability result is available in the canonical execution result.",
+            summary: "The capability result is available in the canonical direct execution result.",
         });
     }
+    const preview = normalized
+        .slice(0, OBSERVATION_OUTPUT_PREVIEW_MAX_LENGTH)
+        .replace(/[\uD800-\uDBFF]$/u, "");
+    const omittedCharacters = normalized.length - preview.length;
+    const hasBoundedReferenceData = normalized.length <= ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH;
     return Object.freeze({
-        summary: `The observation completed successfully with ${normalized.length} characters of result data; its producing Worker received the complete result.`,
-        referenceData: normalized,
+        summary: `The observation returned ${normalized.length} characters of result data. Output preview (${preview.length} characters; ${omittedCharacters} omitted from this preview):\n${preview}`,
+        ...(hasBoundedReferenceData ? { referenceData: normalized } : {}),
     });
 }

package/dist/src/runtime/adapters/registered-tool-worker-capabilities.js

@@ -101,6 +101,7 @@ export function createRegisteredToolWorkerCapabilityProvider(params) {
                     registrations: narrowedRegistrations,
                     toolRegistry: resolvedCatalog.registry,
                     requestId: params.requestId,
+                    ...(params.toolResources ? { toolResources: params.toolResources } : {}),
                     abortSignal: params.abortSignal,
                     sharedState,
                     toolPermissionMode: params.toolPermissionMode,

package/dist/src/runtime/adapters/scheduler-runtime.js

@@ -17,7 +17,7 @@ export function createRuntimeScheduler(options) {
     function publish(event, sessionId, runGeneration) {
         if (!canPublishRunEvents(runGeneration))
             return;
-        const isDeletedSession = options.isDeleted(sessionId);
+        const isDeletedSession = sessionId !== undefined && options.isDeleted(sessionId);
         const isTerminalEvent = isScheduledTerminalEvent(event);
         if (isDeletedSession && !isTerminalEvent)
             return;
@@ -82,7 +82,7 @@ export function createRuntimeScheduler(options) {
             text: run.prompt,
             agentMode: job.agentMode,
             modelPreference: { profileId: job.modelProfileId, scope: "all" },
-            toolPermissionMode: "full_access",
+            toolPermissionMode: run.toolPermissionMode ?? "full_access",
         };
         try {
             await options.handle(ws, message, withScheduledExecution(options.requestOptions?.(run), run));
@@ -97,9 +97,13 @@ export function createRuntimeScheduler(options) {
     }
     const scheduler = createSchedulerService({
         environmentId: options.config.runtimeId,
-        store: createFileSchedulerStore(join(options.config.paths.runtimeDir, "scheduler")),
+        store: createFileSchedulerStore(join(options.config.paths.runtimeDir, "scheduler"), () => publish({
+            type: "event",
+            name: "scheduler.changed",
+            environment: options.config.runtimeId,
+        }, undefined, generation)),
         executor: {
-            tryReserve: (sessionId) => options.admission.tryReserve(sessionId),
+            tryReserve: (sessionId) => options.admission.tryReserveAvailable(sessionId),
             sessionExists: async (sessionId) => {
                 if (options.isDeleted(sessionId))
                     return false;

package/dist/src/runtime/attachments/request-tool-media-snapshot.d.ts

@@ -0,0 +1,23 @@
+import { type ToolImageEvidence } from "../../capabilities/tool-media.js";
+export declare const REQUEST_TOOL_MEDIA_MAX_BYTES: number;
+export type ToolMediaOwner = Readonly<{
+    callId: string;
+    executionId: string;
+}>;
+export type StoredToolImage = Readonly<{
+    owner: ToolMediaOwner;
+    reference: ToolImageEvidence;
+    bytes: Buffer;
+}>;
+export type RequestToolMediaSnapshot = Readonly<{
+    kind: "request_tool_media_v1";
+    images: readonly Readonly<{
+        owner: ToolMediaOwner;
+        reference: ToolImageEvidence;
+        data: string;
+    }>[];
+}>;
+/** Private request persistence only; these bytes never become session history. */
+export declare function captureToolMediaSnapshot(images: Iterable<StoredToolImage>): RequestToolMediaSnapshot;
+/** Validate every record before installing any image into a live request store. */
+export declare function restoreToolMediaSnapshot(value: unknown): readonly StoredToolImage[];

package/dist/src/runtime/attachments/request-tool-media-snapshot.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+import { isToolImageEvidence, TOOL_RESULT_IMAGE_LIMIT, } from "../../capabilities/tool-media.js";
+import { validateToolImage } from "./tool-image-validation.js";
+export const REQUEST_TOOL_MEDIA_MAX_BYTES = 64 * 1024 * 1024;
+/** Private request persistence only; these bytes never become session history. */
+export function captureToolMediaSnapshot(images) {
+    return Object.freeze({
+        kind: "request_tool_media_v1",
+        images: Object.freeze([...images].map((image) => Object.freeze({
+            owner: Object.freeze({ ...image.owner }),
+            reference: Object.freeze({ ...image.reference }),
+            data: image.bytes.toString("base64"),
+        }))),
+    });
+}
+/** Validate every record before installing any image into a live request store. */
+export function restoreToolMediaSnapshot(value) {
+    if (!isSnapshot(value))
+        throw invalid();
+    const ids = new Set();
+    const executionOwners = new Map();
+    const executionCounts = new Map();
+    let totalBytes = 0;
+    // Reject size/count violations before decoding or retaining large buffers.
+    for (const image of value.images) {
+        if (!isOwner(image?.owner) || !isToolImageEvidence(image?.reference))
+            throw invalid();
+        if (ids.has(image.reference.id))
+            throw invalid();
+        ids.add(image.reference.id);
+        const owner = executionOwners.get(image.owner.executionId);
+        if (owner !== undefined && owner !== image.owner.callId)
+            throw invalid();
+        executionOwners.set(image.owner.executionId, image.owner.callId);
+        const count = (executionCounts.get(image.owner.executionId) ?? 0) + 1;
+        if (count > TOOL_RESULT_IMAGE_LIMIT)
+            throw new Error("tool_media_execution_limit");
+        executionCounts.set(image.owner.executionId, count);
+        totalBytes += image.reference.size;
+        if (totalBytes > REQUEST_TOOL_MEDIA_MAX_BYTES)
+            throw new Error("tool_media_request_limit");
+        if (!hasExactEncodedSize(image.data, image.reference.size))
+            throw invalid();
+    }
+    const images = [];
+    try {
+        for (const image of value.images)
+            images.push(restoreImage(image));
+        return Object.freeze(images);
+    }
+    catch (error) {
+        for (const image of images)
+            image.bytes.fill(0);
+        throw error;
+    }
+}
+function restoreImage(image) {
+    const bytes = Buffer.from(image.data, "base64");
+    try {
+        if (bytes.toString("base64") !== image.data ||
+            bytes.length !== image.reference.size)
+            throw invalid();
+        if (createHash("sha256").update(bytes).digest("hex") !==
+            image.reference.sha256)
+            throw invalid();
+        const metadata = validateToolImage(bytes, image.reference.mimeType);
+        if (metadata.width !== image.reference.width ||
+            metadata.height !== image.reference.height)
+            throw invalid();
+        return Object.freeze({
+            owner: Object.freeze({ ...image.owner }),
+            reference: Object.freeze({ ...image.reference }),
+            bytes,
+        });
+    }
+    catch (error) {
+        bytes.fill(0);
+        throw error;
+    }
+}
+function isSnapshot(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const snapshot = value;
+    return (snapshot.kind === "request_tool_media_v1" && Array.isArray(snapshot.images));
+}
+function isOwner(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const owner = value;
+    return (typeof owner.callId === "string" &&
+        owner.callId.length > 0 &&
+        typeof owner.executionId === "string" &&
+        owner.executionId.length > 0);
+}
+function hasExactEncodedSize(data, bytes) {
+    return typeof data === "string" && data.length === 4 * Math.ceil(bytes / 3);
+}
+function invalid() {
+    return new Error("tool_media_snapshot_invalid");
+}

package/dist/src/runtime/attachments/request-tool-media.d.ts

@@ -0,0 +1,36 @@
+import { type ToolImageEvidence } from "../../capabilities/tool-media.js";
+export type ToolMediaOwner = Readonly<{
+    callId: string;
+    executionId: string;
+}>;
+/** Request-owned binary storage. No paths, history writes, or process registry. */
+export declare class RequestToolMediaStore {
+    private readonly images;
+    private bytes;
+    private disposed;
+    beginExecution(owner: ToolMediaOwner, signal: AbortSignal): Readonly<{
+        writer: Readonly<{
+            writeImage(input: Readonly<{
+                bytes: Uint8Array;
+                mimeType: string;
+            }>): Promise<ToolImageEvidence>;
+        }>;
+        finish: (references?: readonly ToolImageEvidence[]) => void;
+        close: () => void;
+    }>;
+    resolve(owner: ToolMediaOwner, reference: ToolImageEvidence): string;
+    private read;
+    ownerOf(executionId: string, reference: ToolImageEvidence): ToolMediaOwner;
+    snapshot(): Readonly<{
+        kind: "request_tool_media_v1";
+        images: readonly Readonly<{
+            owner: import("./request-tool-media-snapshot.js").ToolMediaOwner;
+            reference: ToolImageEvidence;
+            data: string;
+        }>[];
+    }>;
+    restore(snapshot: unknown): void;
+    dispose(): void;
+    private assertOpen;
+    private remove;
+}

package/dist/src/runtime/attachments/request-tool-media.js

@@ -0,0 +1,119 @@
+import { captureToolMediaSnapshot, restoreToolMediaSnapshot, } from "./request-tool-media-snapshot.js";
+import { createHash, randomUUID } from "node:crypto";
+import { isToolResultMedia, TOOL_RESULT_IMAGE_LIMIT, } from "../../capabilities/tool-media.js";
+import { validateToolImage } from "./tool-image-validation.js";
+const REQUEST_TOOL_MEDIA_MAX_BYTES = 64 * 1024 * 1024;
+/** Request-owned binary storage. No paths, history writes, or process registry. */
+export class RequestToolMediaStore {
+    images = new Map();
+    bytes = 0;
+    disposed = false;
+    beginExecution(owner, signal) {
+        this.assertOpen();
+        const issued = new Set();
+        let closed = false;
+        const writer = Object.freeze({
+            writeImage: async (input) => {
+                this.assertOpen();
+                signal.throwIfAborted();
+                if (closed)
+                    throw new Error("tool_media_execution_closed");
+                if (issued.size >= TOOL_RESULT_IMAGE_LIMIT)
+                    throw new Error("tool_media_execution_limit");
+                if (this.bytes + input.bytes.byteLength > REQUEST_TOOL_MEDIA_MAX_BYTES)
+                    throw new Error("tool_media_request_limit");
+                const metadata = validateToolImage(input.bytes, input.mimeType);
+                const bytes = Buffer.from(input.bytes);
+                const reference = Object.freeze({
+                    kind: "tool_image_v1",
+                    id: `image-${randomUUID()}`,
+                    ...metadata,
+                    size: bytes.length,
+                    sha256: createHash("sha256").update(bytes).digest("hex"),
+                });
+                this.images.set(reference.id, {
+                    owner: Object.freeze({ ...owner }),
+                    reference,
+                    bytes,
+                });
+                this.bytes += bytes.length;
+                issued.add(reference.id);
+                return reference;
+            },
+        });
+        return Object.freeze({
+            writer,
+            finish: (references) => {
+                closed = true;
+                if (!isToolResultMedia(references))
+                    throw new Error("tool_media_reference_invalid");
+                for (const reference of references ?? []) {
+                    if (!issued.has(reference.id))
+                        throw new Error("tool_media_execution_mismatch");
+                    this.read(owner, reference);
+                }
+                const retained = new Set((references ?? []).map(({ id }) => id));
+                for (const id of issued)
+                    if (!retained.has(id))
+                        this.remove(id);
+            },
+            close: () => {
+                closed = true;
+            },
+        });
+    }
+    resolve(owner, reference) {
+        return this.read(owner, reference).bytes.toString("base64");
+    }
+    read(owner, reference) {
+        this.assertOpen();
+        const stored = this.images.get(reference.id);
+        if (!stored)
+            throw new Error("tool_media_reference_unavailable");
+        if (stored.owner.callId !== owner.callId ||
+            stored.owner.executionId !== owner.executionId)
+            throw new Error("tool_media_execution_mismatch");
+        if (!isToolResultMedia([reference]) ||
+            Object.entries(stored.reference).some(([key, value]) => reference[key] !== value))
+            throw new Error("tool_media_reference_invalid");
+        return stored;
+    }
+    ownerOf(executionId, reference) {
+        this.assertOpen();
+        const stored = this.images.get(reference.id);
+        if (!stored || stored.owner.executionId !== executionId)
+            throw new Error("tool_media_execution_mismatch");
+        return stored.owner;
+    }
+    snapshot() {
+        this.assertOpen();
+        return captureToolMediaSnapshot(this.images.values());
+    }
+    restore(snapshot) {
+        this.assertOpen();
+        if (this.images.size)
+            throw new Error("tool_media_restore_not_empty");
+        const images = restoreToolMediaSnapshot(snapshot);
+        for (const image of images) {
+            this.images.set(image.reference.id, image);
+            this.bytes += image.bytes.length;
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        for (const id of this.images.keys())
+            this.remove(id);
+    }
+    assertOpen() {
+        if (this.disposed)
+            throw new Error("tool_media_request_closed");
+    }
+    remove(id) {
+        const image = this.images.get(id);
+        if (!image)
+            return;
+        image.bytes.fill(0);
+        this.bytes -= image.bytes.length;
+        this.images.delete(id);
+    }
+}

package/dist/src/runtime/attachments/tool-image-validation.d.ts

@@ -0,0 +1,6 @@
+/** Validate bounded, non-interlaced 8-bit PNG pixels before exposing evidence. */
+export declare function validateToolImage(bytes: Uint8Array, mimeType: string): Readonly<{
+    width: number;
+    height: number;
+    mimeType: "image/png";
+}>;

package/dist/src/runtime/attachments/tool-image-validation.js

@@ -0,0 +1,83 @@
+import { inflateSync } from "node:zlib";
+import { TOOL_IMAGE_MAX_BYTES } from "../../capabilities/tool-media.js";
+const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const CHANNELS = { 0: 1, 2: 3, 4: 2, 6: 4 };
+/** Validate bounded, non-interlaced 8-bit PNG pixels before exposing evidence. */
+export function validateToolImage(bytes, mimeType) {
+    if (mimeType !== "image/png")
+        throw new Error("tool_image_mime_unsupported");
+    if (bytes.byteLength === 0 || bytes.byteLength > TOOL_IMAGE_MAX_BYTES)
+        throw new Error("tool_image_size_invalid");
+    const image = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (!image.subarray(0, 8).equals(PNG_SIGNATURE))
+        throw new Error("tool_image_png_invalid");
+    let width = 0;
+    let height = 0;
+    let channels = 0;
+    let offset = 8;
+    let ended = false;
+    const pixels = [];
+    while (offset + 12 <= image.length) {
+        const size = image.readUInt32BE(offset);
+        const end = offset + 12 + size;
+        if (end > image.length)
+            throw new Error("tool_image_png_invalid");
+        const type = image.toString("ascii", offset + 4, offset + 8);
+        const data = image.subarray(offset + 8, offset + 8 + size);
+        if (pngCrc(image.subarray(offset + 4, offset + 8 + size)) !== image.readUInt32BE(end - 4))
+            throw new Error("tool_image_png_invalid");
+        if (offset === 8 && type !== "IHDR")
+            throw new Error("tool_image_png_invalid");
+        if (type === "IHDR") {
+            if (offset !== 8 || size !== 13)
+                throw new Error("tool_image_png_invalid");
+            width = data.readUInt32BE(0);
+            height = data.readUInt32BE(4);
+            channels = CHANNELS[data[9]] ?? 0;
+            if (!width || !height || width > 32768 || height > 32768 || width * height > 64 * 1024 * 1024)
+                throw new Error("tool_image_dimensions_invalid");
+            if (data[8] !== 8 || !channels || data[10] !== 0 || data[11] !== 0 || data[12] !== 0)
+                throw new Error("tool_image_png_format_unsupported");
+        }
+        if (type === "IDAT")
+            pixels.push(data);
+        offset = end;
+        if (type !== "IEND")
+            continue;
+        if (size !== 0 || offset !== image.length)
+            throw new Error("tool_image_png_invalid");
+        ended = true;
+        break;
+    }
+    if (!ended || pixels.length === 0)
+        throw new Error("tool_image_png_invalid");
+    const stride = width * channels + 1;
+    let decoded;
+    try {
+        decoded = inflateSync(Buffer.concat(pixels), { maxOutputLength: stride * height });
+    }
+    catch {
+        throw new Error("tool_image_png_invalid");
+    }
+    try {
+        if (decoded.length !== stride * height)
+            throw new Error("tool_image_png_invalid");
+        for (let row = 0; row < height; row++) {
+            if (decoded[row * stride] > 4)
+                throw new Error("tool_image_png_invalid");
+        }
+    }
+    finally {
+        decoded.fill(0);
+    }
+    return Object.freeze({ width, height, mimeType: "image/png" });
+}
+function pngCrc(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}

package/dist/src/runtime/capabilities/configured-tool-registry.js

@@ -1,6 +1,8 @@
+import { bindRequestWorkingDirectory } from "./request-working-directory.js";
 import { createToolRegistry as createToolRegistryInstance } from "../../capabilities/registry.js";
 import { executeToolCall } from "../../capabilities/tool-executor.js";
 import { createRuntimeToolPathResolver } from "./runtime-target-path.js";
+import { prepareRequestToolModules } from "./request-module-preparation.js";
 export function createConfiguredToolRegistry(config, modules) {
     const baseRegistry = createToolRegistryInstance({ modules });
     const getImplementations = () => baseRegistry.getImplementations();
@@ -20,6 +22,11 @@ export function createConfiguredToolRegistry(config, modules) {
         }
         : { ...sharedState };
     return {
+        ...(modules.some((module) => module.prepareRequest)
+            ? {
+                prepareRequest: async (context) => createConfiguredToolRegistry(config, await prepareRequestToolModules(modules, context)),
+            }
+            : {}),
         listDefinitions: () => baseRegistry.getDefinitions(),
         listNormalInvocations: () => baseRegistry.getNormalInvocations(),
         getDefinition: (name) => baseRegistry.getByName(name),
@@ -28,7 +35,8 @@ export function createConfiguredToolRegistry(config, modules) {
         getImplementations,
         prepareSharedState,
         execute: (call, options) => {
-            const sharedState = prepareSharedState(options?.sharedState);
+            const configuredState = prepareSharedState(options?.sharedState);
+            const sharedState = bindRequestWorkingDirectory(configuredState, options?.requestWorkingDirectory);
             return executeToolCall(call, {
                 ...options,
                 sharedState,

package/dist/src/runtime/capabilities/file-output-root-identity.d.ts

@@ -0,0 +1,5 @@
+import { type ToolFileOutputLocation, type ToolFileOutputRootIdentity } from "../../capabilities/file-output-presentation.js";
+/** Host presentation capture only. Creates a marker once; never overwrites it. */
+export declare function captureFileOutputRootId(location: ToolFileOutputLocation, canonicalRoot: string, expectedIdentity?: ToolFileOutputRootIdentity): string;
+/** Preview authorization is read-only: missing or invalid markers stay invalid. */
+export declare function readFileOutputRootId(location: ToolFileOutputLocation, canonicalRoot: string): string;