@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/computer-access/process-runner.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 const STREAM_MAX_CHARS = 16_000;
 /** Bounded process observation; exit zero proves command completion, not effects. */
-export function runSystemProcess(input) {
+export function runSystemProcess(input, capture) {
     if (input.abortSignal?.aborted)
         return Promise.resolve({
             exitCode: null,
@@ -29,6 +29,7 @@ export function runSystemProcess(input) {
             if (stopGrace)
                 clearTimeout(stopGrace);
             input.abortSignal?.removeEventListener("abort", abort);
+            capture?.end();
             resolve(Object.freeze({
                 exitCode,
                 stdout,
@@ -76,18 +77,25 @@ export function runSystemProcess(input) {
             stopGrace.unref();
         };
         const abort = () => stop("aborted");
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
-        child.stdout.on("data", (chunk) => {
-            const remaining = streamMaxChars - stdout.length;
-            truncated ||= chunk.length > remaining;
-            stdout += chunk.slice(0, remaining);
-        });
-        child.stderr.on("data", (chunk) => {
-            const remaining = streamMaxChars - stderr.length;
-            truncated ||= chunk.length > remaining;
-            stderr += chunk.slice(0, remaining);
-        });
+        const attachOutput = () => {
+            if (capture) {
+                capture.attach(child.stdout, child.stderr, () => stop("output_failed"));
+                return;
+            }
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                const remaining = streamMaxChars - stdout.length;
+                truncated ||= chunk.length > remaining;
+                stdout += chunk.slice(0, remaining);
+            });
+            child.stderr.on("data", (chunk) => {
+                const remaining = streamMaxChars - stderr.length;
+                truncated ||= chunk.length > remaining;
+                stderr += chunk.slice(0, remaining);
+            });
+        };
+        attachOutput();
         child.once("error", (error) => {
             status = "spawn_failed";
             stderr = error.message.slice(0, STREAM_MAX_CHARS);

package/dist/src/model-gateway/policy/invocation-policy.js

@@ -171,8 +171,17 @@ export function resolveModelInvocation(requestBody) {
         ...(selectedInvocationProfile?.format
             ? { format: selectedInvocationProfile.format }
             : {}),
-        ...(calibration.instructions
+        ...(calibration.instructions && !omitsCalibrationInstructions(requestBody.format)
             ? { instructions: calibration.instructions }
             : {}),
     };
 }
+/** A caller-owned text contract may isolate itself from the selected slot's prose. */
+function omitsCalibrationInstructions(format) {
+    if (!format || typeof format !== "object" || Array.isArray(format))
+        return false;
+    const requested = format;
+    if (requested.type !== "text")
+        return false;
+    return requested.calibrationInstructions === "omit";
+}

package/dist/src/model-gateway/providers/openai/payload.js

@@ -70,6 +70,9 @@ function readFiniteNumber(value) {
         ? value
         : undefined;
 }
+function hasExplicitlyDisabledOpenAIReasoning(invocation) {
+    return invocation.profile.supportsThinking === true && invocation.think === "none";
+}
 export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     validateModelGatewayMessages(requestBody.messages);
     const invocation = resolveModelInvocation(requestBody);
@@ -103,6 +106,11 @@ export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     if (formatProjection.format) {
         payload.text = { format: formatProjection.format };
     }
+    // Without an explicit provider disable, hidden reasoning may consume output.
+    // A missing or false control declaration does not disable provider defaults.
+    if (!hasExplicitlyDisabledOpenAIReasoning(invocation)) {
+        return payload;
+    }
     const outputTokenLimit = resolveModelStepOutputTokenLimit(requestBody.modelStep);
     if (outputTokenLimit === undefined) {
         return payload;

package/dist/src/model-gateway/server/configuration.d.ts

@@ -1,4 +1,6 @@
 import type { ModelGatewayPolicyConfig } from "../types.js";
 import type { ModelGatewayHandlerOptions } from "./contracts.js";
 export declare function resolveModelGatewayPort(environment?: NodeJS.ProcessEnv): number;
+/** Captures gateway inputs without changing its loggers or retaining credentials. */
+export declare function captureModelGatewayConfiguration(options: ModelGatewayHandlerOptions): string | null;
 export declare function configureModelGateway(options: ModelGatewayHandlerOptions): ModelGatewayPolicyConfig;

package/dist/src/model-gateway/server/configuration.js

@@ -1,10 +1,11 @@
+import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { loadRuntimeConfig } from "../../runtime/config.js";
 import { RUNTIME_LOGS_DIR_NAME } from "../../runtime/config/layout.js";
 import { loadRequestRunnerConfig } from "../../runtime/config/runner/loader.js";
 import { createRequestModelPolicy } from "../../runtime/config/runner/model-policy.js";
 import { configureDebugLogger } from "../../runtime/observability/debug-logger.js";
-import { DEFAULT_MODEL_GATEWAY_URL } from "../../shared/constants.js";
+import { DEFAULT_MODEL_GATEWAY_URL, DEFAULT_OLLAMA_URL, } from "../../shared/constants.js";
 import { configureModelIoTrace } from "../model-io-trace.js";
 const MODEL_GATEWAY_TRACE_FILE_SEGMENTS = ["model-gateway.jsonl"];
 const MODEL_IO_TRACE_FILE_SEGMENTS = ["model-io.jsonl"];
@@ -26,7 +27,7 @@ export function resolveModelGatewayPort(environment = process.env) {
     const parsedUrl = new URL(configuredUrl);
     return Number(parsedUrl.port || "80");
 }
-export function configureModelGateway(options) {
+function resolveModelGatewayConfiguration(options) {
     const runtimeConfig = loadRuntimeConfig({
         rootDir: options.rootDir ?? process.cwd(),
         configPath: options.configPath,
@@ -38,23 +39,74 @@ export function configureModelGateway(options) {
                 configPath: runtimeConfig.requestRunner.configPath,
             }),
         });
-    configureDebugLogger({
-        traceFile: resolveTraceFile({
-            configuredPath: resolveConfiguredTraceFile("MODEL_GATEWAY_TRACE_FILE"),
-            sharedDir: runtimeConfig.paths.sharedDir,
-            segments: MODEL_GATEWAY_TRACE_FILE_SEGMENTS,
-        }),
-        enabled: runtimeConfig.logging?.enabled,
-        rotation: runtimeConfig.logging?.rotation,
-    });
-    configureModelIoTrace({
-        traceFile: resolveTraceFile({
-            configuredPath: resolveConfiguredTraceFile("MODEL_GATEWAY_MODEL_IO_TRACE_FILE"),
-            sharedDir: runtimeConfig.paths.sharedDir,
-            segments: MODEL_IO_TRACE_FILE_SEGMENTS,
-        }),
-        enabled: runtimeConfig.logging?.enabled,
-        rotation: runtimeConfig.logging?.rotation,
-    });
-    return modelPolicy;
+    return {
+        modelGatewayUrl: runtimeConfig.modelGatewayUrl,
+        modelPolicy,
+        debugLogging: {
+            traceFile: resolveTraceFile({
+                configuredPath: resolveConfiguredTraceFile("MODEL_GATEWAY_TRACE_FILE"),
+                sharedDir: runtimeConfig.paths.sharedDir,
+                segments: MODEL_GATEWAY_TRACE_FILE_SEGMENTS,
+            }),
+            enabled: runtimeConfig.logging?.enabled,
+            rotation: runtimeConfig.logging?.rotation,
+        },
+        modelIoLogging: {
+            traceFile: resolveTraceFile({
+                configuredPath: resolveConfiguredTraceFile("MODEL_GATEWAY_MODEL_IO_TRACE_FILE"),
+                sharedDir: runtimeConfig.paths.sharedDir,
+                segments: MODEL_IO_TRACE_FILE_SEGMENTS,
+            }),
+            enabled: runtimeConfig.logging?.enabled,
+            rotation: runtimeConfig.logging?.rotation,
+        },
+    };
+}
+function canonicalConfiguration(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalConfiguration);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, canonicalConfiguration(entry)]));
+    return value;
+}
+function providerEnvironment(options, policy) {
+    const credentialNames = new Set(["OPENAI_API_KEY"]);
+    for (const provider of Object.values(policy.providers ?? {})) {
+        if (provider.type !== "openai")
+            continue;
+        const configuredName = provider.apiKeyEnv?.trim();
+        if (configuredName && /^[A-Za-z_][A-Za-z0-9_]*$/.test(configuredName))
+            credentialNames.add(configuredName);
+    }
+    const numPredict = Number(process.env.OLLAMA_NUM_PREDICT);
+    return {
+        ollamaUrl: options.ollamaUrl ?? (process.env.OLLAMA_URL || DEFAULT_OLLAMA_URL),
+        openAIBaseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com/v1",
+        ollamaNumPredict: Number.isFinite(numPredict) && numPredict > 0
+            ? Math.trunc(numPredict)
+            : null,
+        credentials: Object.fromEntries([...credentialNames].map((name) => [name, process.env[name] || null])),
+    };
+}
+/** Captures gateway inputs without changing its loggers or retaining credentials. */
+export function captureModelGatewayConfiguration(options) {
+    if (options.providerAdapters || options.additionalProviderAdapters?.length)
+        return null;
+    const configuration = resolveModelGatewayConfiguration(options);
+    const snapshot = {
+        ...configuration,
+        modelGatewayUrl: new URL(configuration.modelGatewayUrl).href,
+        providerEnvironment: providerEnvironment(options, configuration.modelPolicy),
+    };
+    return createHash("sha256")
+        .update(JSON.stringify(canonicalConfiguration(snapshot)))
+        .digest("hex");
+}
+export function configureModelGateway(options) {
+    const configuration = resolveModelGatewayConfiguration(options);
+    configureDebugLogger(configuration.debugLogging);
+    configureModelIoTrace(configuration.modelIoLogging);
+    return configuration.modelPolicy;
 }

package/dist/src/model-gateway/structured-output/ollama-format.js

@@ -112,6 +112,11 @@ export function projectOllamaFormat(format) {
     if (!isPlainObject(format)) {
         return { format: undefined, diagnostics: [] };
     }
+    const requestsPlainTextOutput = format.type === "text";
+    if (requestsPlainTextOutput) {
+        rejectMisplacedProjectionMetadata(format);
+        return { format: undefined, diagnostics: [] };
+    }
     if (isModelGatewayJsonSchemaFormat(format)) {
         return projectWrappedJsonSchema(format);
     }

package/dist/src/model-gateway/structured-output/openai-format.js

@@ -51,6 +51,11 @@ export function projectOpenAIResponsesFormat(format) {
     if (!isPlainObject(format)) {
         return emptyProjection(undefined);
     }
+    const requestsPlainTextOutput = format.type === "text";
+    if (requestsPlainTextOutput) {
+        rejectMisplacedProjectionMetadata(format);
+        return emptyProjection(undefined);
+    }
     if (isModelGatewayJsonSchemaFormat(format)) {
         return hasUnsupportedRootUnion(format.schema)
             ? rootUnionFallback(format.name, format.schema)

package/dist/src/model-gateway/types.d.ts

@@ -56,6 +56,7 @@ export type ModelGatewayJsonSchemaFormat = {
         path: string;
     }>[];
 };
+/** Text requests may set calibrationInstructions: "omit" to retain only caller-owned instructions. */
 export type ModelGatewayFormat = "json" | ModelGatewayJsonSchemaFormat | Record<string, unknown>;
 export type ModelPreferenceScope = "main" | "all";
 export type ModelPreference = {
@@ -69,6 +70,7 @@ export type ModelGatewayProfileConfig = {
     model: string;
     /** Declared physical context capacity. Required after profile materialization. */
     contextWindowTokens?: number;
+    /** Explicit reasoning-control support, not a request to enable or disable thinking. */
     supportsThinking?: boolean;
     capabilities?: ModelGatewayProfileCapabilities;
     options?: Record<string, unknown>;
@@ -218,6 +220,7 @@ export type ModelProfile = {
     providerConfig?: ModelGatewayProviderConfig;
     model: string;
     contextWindowTokens: number;
+    /** Declared control support; false does not disable provider-default reasoning. */
     supportsThinking: boolean;
     capabilities: Required<ModelGatewayProfileCapabilities>;
     options: Record<string, unknown>;

package/dist/src/plugin-contract/install-source.d.ts

@@ -0,0 +1,13 @@
+/** Portable installation intent. A source never grants execution authority. */
+export type PluginInstallSource = Readonly<{
+    repository: string;
+    ref?: string;
+    path?: string;
+}>;
+export declare class PluginInstallError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    constructor(code: string, message: string, statusCode?: number);
+}
+export declare function parsePluginInstallSource(input: unknown): PluginInstallSource;
+export declare function parsePluginInstallLink(value: string): PluginInstallSource;

package/dist/src/plugin-contract/install-source.js

@@ -0,0 +1,99 @@
+export class PluginInstallError extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode = 400) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+    }
+}
+function invalidSource(message) {
+    throw new PluginInstallError("plugin_source_invalid", message);
+}
+function hasPublicGitHubOrigin(url) {
+    if (url.protocol !== "https:")
+        return false;
+    if (url.hostname !== "github.com")
+        return false;
+    if (url.port || url.username || url.password)
+        return false;
+    return !url.search && !url.hash;
+}
+function isPluginInstallEndpoint(url) {
+    if (url.protocol !== "abot:")
+        return false;
+    if (url.hostname !== "install")
+        return false;
+    if (!["", "/"].includes(url.pathname))
+        return false;
+    if (url.username || url.password || url.port)
+        return false;
+    return !url.hash;
+}
+function isRepositoryFolderComponent(part) {
+    if (part === "." || part === "..")
+        return false;
+    return /^[A-Za-z0-9_.-]+$/u.test(part);
+}
+export function parsePluginInstallSource(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return invalidSource("Enter a public GitHub repository URL.");
+    const value = input;
+    if (typeof value.repository !== "string" || value.repository.length > 512)
+        return invalidSource("Enter a public GitHub repository URL.");
+    let url;
+    try {
+        url = new URL(value.repository.trim());
+    }
+    catch {
+        return invalidSource("Enter a public GitHub repository URL.");
+    }
+    if (!hasPublicGitHubOrigin(url))
+        return invalidSource("Use an HTTPS repository URL on github.com.");
+    const match = /^\/([A-Za-z0-9][A-Za-z0-9-]{0,38})\/([A-Za-z0-9_.-]{1,100})\/?$/u.exec(url.pathname);
+    if (!match)
+        return invalidSource("Use the repository URL; enter its revision and folder separately.");
+    const repo = match[2].replace(/\.git$/u, "");
+    if (repo === "." || repo === ".." || !repo)
+        return invalidSource("Invalid repository name.");
+    const ref = value.ref === undefined ? "" : value.ref;
+    if (typeof ref !== "string" ||
+        ref.length > 200 ||
+        /[\u0000-\u0020\u007f\\?#]/u.test(ref))
+        return invalidSource("Enter a commit, tag or branch without spaces.");
+    const path = value.path === undefined ? "" : value.path;
+    if (typeof path !== "string" || path.length > 512)
+        return invalidSource("Enter a folder relative to the repository root.");
+    if (path && !path.split("/").every(isRepositoryFolderComponent))
+        return invalidSource("The plugin folder must be a relative path without traversal.");
+    return {
+        repository: `https://github.com/${match[1]}/${repo}`,
+        ...(ref ? { ref } : {}),
+        ...(path ? { path } : {}),
+    };
+}
+export function parsePluginInstallLink(value) {
+    if (value.length > 2048)
+        return invalidSource("The installation link is too long.");
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return invalidSource("Invalid ABot installation link.");
+    }
+    if (!isPluginInstallEndpoint(url))
+        return invalidSource("Unsupported ABot installation link.");
+    const allowed = ["kind", "repo", "ref", "path"];
+    for (const key of url.searchParams.keys()) {
+        if (!allowed.includes(key) || url.searchParams.getAll(key).length !== 1)
+            return invalidSource("Unsupported installation link fields.");
+    }
+    if (url.searchParams.get("kind") !== "plugin")
+        return invalidSource("This installation link must select a plugin.");
+    return parsePluginInstallSource({
+        repository: url.searchParams.get("repo"),
+        ref: url.searchParams.get("ref") ?? "",
+        path: url.searchParams.get("path") ?? "",
+    });
+}

package/dist/src/plugin-contract/manifest.d.ts

@@ -1,15 +1,17 @@
-import type { ToolCatalogGroup, ToolDevelopmentRole, ToolEventPresentation, ToolNormalInvocationApproval, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationPayload, ToolPayloadChannelSpec, ToolRoutingCapability, ToolRuntimePathBinding } from "../capabilities/tool-types.js";
+import type { ToolCatalogGroup, ToolDevelopmentRole, ToolEventPresentation, ToolNormalInvocationApproval, ToolNormalInvocationAttachmentInput, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationPayload, ToolNormalInvocationOutputChannels, ToolPayloadChannelSpec, ToolRoutingCapability, ToolRuntimePathBinding } from "../capabilities/tool-types.js";
 export declare const AGENT_PLUGIN_MANIFEST_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
 export declare const ABOT_RUNTIME_EXTENSION = "ai.abot.runtime";
 export declare const ABOT_RUNTIME_EXTENSION_VERSION: 1;
 export type AgentPluginOperationManifest = Readonly<{
     summary: string;
+    outputChannels?: ToolNormalInvocationOutputChannels;
     input: ToolNormalInvocationInput;
     selectionControlIds?: readonly string[];
     effect: ToolNormalInvocationEffect;
     approval: ToolNormalInvocationApproval;
     fixedParams?: Readonly<Record<string, ToolNormalInvocationFixedValue>>;
     payload?: ToolNormalInvocationPayload;
+    attachmentInput?: ToolNormalInvocationAttachmentInput;
 }>;
 export type AgentPluginCapabilityManifest = Readonly<{
     requiredPermissionMode?: import("../capabilities/tool-permission-mode.js").ToolRequiredPermissionMode;

package/dist/src/plugin-sdk/computer-access.d.ts

@@ -11,3 +11,11 @@ export { SystemOperationError, type SystemTarget, type SystemTargetId, } from ".
 export { createSystemHandlers } from "../computer-access/handlers.js";
 export { type SystemTargetObservation, observeSystemTargets, } from "../computer-access/target-observation.js";
 export type { ComputerAccessConnection, CompanionTarget, } from "../computer-access/client.js";
+export { runSystemProcess } from "../computer-access/process-runner.js";
+export { buildSystemProcessResult } from "../computer-access/process-result.js";
+export type { SystemCommandOutputFactory } from "../computer-access/command-output.js";
+export type { SystemProcessCapture } from "../computer-access/process-capture.js";
+export type { SystemProcessResult } from "../computer-access/contracts.js";
+export { createSystemOutputCapture, type SystemOutputReceipt } from "../computer-access/command-output-capture.js";
+export { DEFAULT_SYSTEM_OUTPUT_RETENTION_MS, scheduleSystemOutputCleanup } from "../computer-access/command-output-retention.js";
+export { SYSTEM_OUTPUT_CAPABILITY, SYSTEM_OUTPUT_CHUNK_BYTES, readSystemOutputTransfer } from "../computer-access/companion/command-output-protocol.js";

package/dist/src/plugin-sdk/computer-access.js

@@ -9,3 +9,8 @@ export { COMPUTER_CAPABILITY, readNativeComputerResult, } from "../computer-acce
 export { SystemOperationError, } from "../computer-access/contracts.js";
 export { createSystemHandlers } from "../computer-access/handlers.js";
 export { observeSystemTargets, } from "../computer-access/target-observation.js";
+export { runSystemProcess } from "../computer-access/process-runner.js";
+export { buildSystemProcessResult } from "../computer-access/process-result.js";
+export { createSystemOutputCapture } from "../computer-access/command-output-capture.js";
+export { DEFAULT_SYSTEM_OUTPUT_RETENTION_MS, scheduleSystemOutputCleanup } from "../computer-access/command-output-retention.js";
+export { SYSTEM_OUTPUT_CAPABILITY, SYSTEM_OUTPUT_CHUNK_BYTES, readSystemOutputTransfer } from "../computer-access/companion/command-output-protocol.js";

package/dist/src/plugin-sdk/context-text-result.d.ts

@@ -0,0 +1,10 @@
+import type { ToolImplementationOutput } from "../plugin-contract/entrypoint.js";
+import type { ToolResultBudget } from "../capabilities/result-budget.js";
+import type { ToolContextTextField } from "../capabilities/tool-context-text.js";
+export type { ToolContextTextField } from "../capabilities/tool-context-text.js";
+/**
+ * Keeps ordinary results unchanged. An opted-in host can receive oversized
+ * exact text in the same fields, with metadata still bounded. This is delivery
+ * to runtime evidence, not permission to exceed the model's context window.
+ */
+export declare function deliverPluginTextResult(result: ToolImplementationOutput, fields: readonly ToolContextTextField[], budget?: ToolResultBudget): ToolImplementationOutput;

package/dist/src/plugin-sdk/context-text-result.js

@@ -0,0 +1,19 @@
+import { enforcePluginResultByteBudget } from "./results.js";
+/**
+ * Keeps ordinary results unchanged. An opted-in host can receive oversized
+ * exact text in the same fields, with metadata still bounded. This is delivery
+ * to runtime evidence, not permission to exceed the model's context window.
+ */
+export function deliverPluginTextResult(result, fields, budget) {
+    const assessed = enforcePluginResultByteBudget(result, budget);
+    if (!canHandOffContextText(result, assessed, budget))
+        return assessed;
+    return enforcePluginResultByteBudget({ ...result, contextTextFields: Object.freeze([...fields]) }, budget);
+}
+function canHandOffContextText(original, assessed, budget) {
+    if (budget?.acceptsContextText !== true)
+        return false;
+    if (assessed === original)
+        return false;
+    return assessed.errorCode === "plugin_result_too_large";
+}

package/dist/src/plugin-sdk/index.d.ts

@@ -4,6 +4,7 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./context-text-result.js";
 export * from "../capabilities/tool-media.js";
 export * from "./tool-availability-brief.js";
 export * from "./tool-availability-overview.js";

package/dist/src/plugin-sdk/index.js

@@ -4,6 +4,7 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./context-text-result.js";
 export * from "../capabilities/tool-media.js";
 export * from "./tool-availability-brief.js";
 export * from "./tool-availability-overview.js";

package/dist/src/plugin-sdk/results.d.ts

@@ -1,21 +1,24 @@
 import type { ToolImplementationOutput } from "../plugin-contract/entrypoint.js";
+import { type ToolResultBudget } from "../capabilities/result-budget.js";
+export type { ToolResultBudget, ToolResultBudgetAssessment, } from "../capabilities/result-budget.js";
 type ResultCommon = Pick<ToolImplementationOutput, "actions" | "data" | "exitCode" | "progress" | "stderr" | "stdout" | "media">;
+/** Legacy standalone SDK bound; invocation-aware producers also pass the host assessor. */
 export declare const PLUGIN_RESULT_SERIALIZED_MAX_BYTES: number;
-export declare function enforcePluginResultByteBudget(result: ToolImplementationOutput): ToolImplementationOutput;
+export declare function enforcePluginResultByteBudget(result: ToolImplementationOutput, resultBudget?: ToolResultBudget): ToolImplementationOutput;
 export type SuccessResultInput = ResultCommon & Readonly<{
     output: string;
     producedNewInformation?: boolean;
 }>;
-export declare function successResult(input: SuccessResultInput): ToolImplementationOutput;
+export declare function successResult(input: SuccessResultInput, resultBudget?: ToolResultBudget): ToolImplementationOutput;
 export type FailureResultInput = ResultCommon & Readonly<{
+    interruption?: ToolImplementationOutput["interruption"];
     errorCode: string;
     message: string;
     output?: string;
 }>;
-export declare function failureResult(input: FailureResultInput): ToolImplementationOutput;
+export declare function failureResult(input: FailureResultInput, resultBudget?: ToolResultBudget): ToolImplementationOutput;
 export declare function failureFromError(error: unknown, options: Readonly<{
     fallbackCode: string;
     fallbackMessage: string;
     operation?: string;
 }>): ToolImplementationOutput;
-export {};

package/dist/src/plugin-sdk/results.js

@@ -1,6 +1,9 @@
+import { hasValidToolContextText } from "../capabilities/tool-context-text.js";
+import { CAPABILITY_RESULT_ENVELOPE_MAX_BYTES, } from "../capabilities/result-budget.js";
 import { isPluginParameterError, } from "./parameters.js";
 import { runtimeToolPathErrorCode } from "./paths.js";
-export const PLUGIN_RESULT_SERIALIZED_MAX_BYTES = 128 * 1024;
+/** Legacy standalone SDK bound; invocation-aware producers also pass the host assessor. */
+export const PLUGIN_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 function resultBoundsFailure(code, message) {
     return {
         ok: false,
@@ -10,24 +13,45 @@ function resultBoundsFailure(code, message) {
         errorCode: code,
     };
 }
-export function enforcePluginResultByteBudget(result) {
-    let serialized;
+export function enforcePluginResultByteBudget(result, resultBudget) {
+    let requiresContextTextHost = false;
+    let serializedBytes;
+    let envelopeBytes;
+    let maxBytes = PLUGIN_RESULT_SERIALIZED_MAX_BYTES;
+    let fitsDeclaredBudget = true;
     try {
+        if (!hasValidToolContextText(result)) {
+            return resultBoundsFailure("plugin_context_text_invalid", "The plugin declared invalid context text fields.");
+        }
+        requiresContextTextHost = result.contextTextFields !== undefined;
+        const lacksContextTextHost = requiresContextTextHost && resultBudget?.acceptsContextText !== true;
+        if (lacksContextTextHost) {
+            return resultBoundsFailure("plugin_context_text_unavailable", "The host does not support context-managed tool text.");
+        }
         const candidate = JSON.stringify(result);
         if (candidate === undefined) {
             return resultBoundsFailure("plugin_result_not_json_safe", "The plugin produced a result that is not JSON-safe.");
         }
-        serialized = candidate;
+        const assessment = resultBudget?.assess(result);
+        serializedBytes =
+            assessment?.serializedBytes ?? Buffer.byteLength(candidate, "utf8");
+        envelopeBytes = assessment?.envelopeBytes ?? serializedBytes;
+        maxBytes = Math.min(assessment?.maxBytes ?? maxBytes, maxBytes);
+        fitsDeclaredBudget = assessment?.fits ?? true;
     }
     catch {
         return resultBoundsFailure("plugin_result_not_json_safe", "The plugin produced a result that is not JSON-safe.");
     }
-    if (Buffer.byteLength(serialized, "utf8") > PLUGIN_RESULT_SERIALIZED_MAX_BYTES) {
-        return resultBoundsFailure("plugin_result_too_large", `The plugin result exceeds the ${PLUGIN_RESULT_SERIALIZED_MAX_BYTES}-byte safety limit.`);
+    const hasResultDeliveryHeadroom = fitsDeclaredBudget && envelopeBytes <= maxBytes;
+    if (!hasResultDeliveryHeadroom) {
+        const message = requiresContextTextHost
+            ? `The plugin result envelope is ${envelopeBytes} bytes (${serializedBytes} total bytes) and exceeds the ${maxBytes}-byte delivery limit.`
+            : `The plugin result is ${serializedBytes} bytes and exceeds the ${maxBytes}-byte delivery limit.`;
+        return resultBoundsFailure("plugin_result_too_large", message);
     }
     return result;
 }
-export function successResult(input) {
+export function successResult(input, resultBudget) {
     return enforcePluginResultByteBudget({
         ok: true,
         ...(input.media !== undefined ? { media: input.media } : {}),
@@ -39,11 +63,12 @@ export function successResult(input) {
         ...(input.stdout !== undefined ? { stdout: input.stdout } : {}),
         ...(input.stderr !== undefined ? { stderr: input.stderr } : {}),
         ...(input.data !== undefined ? { data: input.data } : {}),
-    });
+    }, resultBudget);
 }
-export function failureResult(input) {
+export function failureResult(input, resultBudget) {
     return enforcePluginResultByteBudget({
         ok: false,
+        ...(input.interruption ? { interruption: input.interruption } : {}),
         ...(input.media !== undefined ? { media: input.media } : {}),
         output: input.output ?? input.message,
         producedNewInformation: false,
@@ -55,7 +80,7 @@ export function failureResult(input) {
         ...(input.data !== undefined ? { data: input.data } : {}),
         error: input.message,
         errorCode: input.errorCode,
-    });
+    }, resultBudget);
 }
 export function failureFromError(error, options) {
     const pathCode = runtimeToolPathErrorCode(error);

package/dist/src/runtime/adapters/co-worker-resources.d.ts

@@ -1,6 +1,7 @@
 import type { RuntimeConfig, ModelGatewayClient, SessionStore } from "../ports.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
 import type { LearningBackgroundContext, LearningBackgroundDependencies } from "../passive-learning/background-dependencies.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
 /** The environment shares one budget; foreground chat keeps its original clients. */
 export declare function createCoWorkerResourceDependencies(options: {
     config: RuntimeConfig;
@@ -10,4 +11,5 @@ export declare function createCoWorkerResourceDependencies(options: {
     ownerId: string;
     context: LearningBackgroundContext;
     sessions?: SessionStore;
+    deliveryAdmission?: Pick<SessionRequestAdmission, "run">;
 }): LearningBackgroundDependencies;

package/dist/src/runtime/adapters/co-worker-resources.js

@@ -61,8 +61,8 @@ export function createCoWorkerResourceDependencies(options) {
         supportsParallel: () => original.supportsParallelBatches?.(context.preferences().proactiveModelProfileId ?? context.preferences().modelProfileId ?? "") ?? false,
     });
     const proactive = learning && options.sessions ? new CoWorkerProactiveAgent({ directory: options.directory,
-        context, memory: learning, sessions: options.sessions, budget,
-        model: createRuntimeProactiveModel({ config: options.config, models: proactiveGateway }) }) : undefined;
+        context, memory: learning, sessions: options.sessions, budget, deliveryAdmission: options.deliveryAdmission,
+        model: createRuntimeProactiveModel({ config: options.config, models: proactiveGateway, sessions: options.sessions }) }) : undefined;
     const model = createRuntimePassiveLearningModel({ ...options, models: gateway });
     const reassessment = memory.learning ? new ScheduledLearningReassessment({ directory: options.directory,
         environmentId: options.ownerId, context, memory: memory.learning, model,

package/dist/src/runtime/adapters/file-session-store.js

@@ -3,7 +3,13 @@ export function createFileSessionStore(options = {}) {
     const service = new SessionService(options);
     return {
         requestLifecycle: service.requestLifecycle,
+        assertInteractiveSession: service.assertInteractiveSession.bind(service),
+        createAutomationSession: service.createAutomationSession.bind(service),
+        runAsAutomationSession: service.runAsAutomationSession.bind(service),
+        releaseAutomationSession: service.releaseAutomationSession.bind(service),
+        reconcileAutomationSessions: service.reconcileAutomationSessions.bind(service),
         createAssistantConversation: service.createAssistantConversation.bind(service),
+        appendAssistantInitiative: service.appendAssistantInitiative.bind(service),
         getOrCreateSession: service.getOrCreateSession.bind(service),
         getAllSessions: service.getAllSessions.bind(service),
         listSessions: service.listSessions.bind(service),