@abot-ai/runtime 1.0.0 → 1.1.0

package/dist/src/capabilities/tool-definition-validator/event-presentation.d.ts

@@ -0,0 +1,2 @@
+import type { ToolEventPresentation } from "../tool-types.js";
+export declare function parseEventPresentation(toolName: string, raw: unknown): ToolEventPresentation | undefined;

package/dist/src/capabilities/tool-definition-validator/event-presentation.js

@@ -0,0 +1,97 @@
+import { isToolDefinitionRecordValue } from "./definition-shape.js";
+const EVENT_PROJECTION_KINDS = [
+    "string",
+    "number",
+    "string_array",
+    "length",
+];
+export function parseEventPresentation(toolName, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw invalidEventPresentation(toolName);
+    }
+    if (!isToolDefinitionRecordValue(raw.metadata)) {
+        throw invalidEventPresentation(toolName);
+    }
+    const metadata = Object.fromEntries(Object.entries(raw.metadata).map(([key, projection]) => parseEventMetadataProjection(toolName, key, projection)));
+    const lifecycle = parseEventLifecycle(toolName, raw.lifecycle);
+    return {
+        metadata,
+        ...(lifecycle ? { lifecycle } : {}),
+    };
+}
+function parseEventMetadataProjection(toolName, key, raw) {
+    if (!key.trim() || !isToolDefinitionRecordValue(raw)) {
+        throw invalidEventMetadataProjection(toolName, key);
+    }
+    const param = raw.param;
+    const kind = raw.kind;
+    const fallback = raw.default;
+    if (typeof param !== "string" || !param.trim()) {
+        throw invalidEventMetadataProjection(toolName, key);
+    }
+    if (!isEventProjectionKind(kind)) {
+        throw invalidEventMetadataProjection(toolName, key);
+    }
+    if (!hasSupportedEventProjectionDefault(fallback)) {
+        throw invalidEventMetadataProjection(toolName, key);
+    }
+    return [
+        key,
+        {
+            param: param.trim(),
+            kind,
+            ...(fallback !== undefined ? { default: fallback } : {}),
+        },
+    ];
+}
+function isEventProjectionKind(value) {
+    return EVENT_PROJECTION_KINDS.includes(value);
+}
+function hasSupportedEventProjectionDefault(value) {
+    if (value === undefined)
+        return true;
+    if (typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return true;
+    return typeof value === "boolean";
+}
+function parseEventLifecycle(toolName, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw new Error(`Invalid tool definition for ${toolName} (eventPresentation.lifecycle)`);
+    }
+    const entries = ["started", "completed", "failed"].flatMap((phase) => {
+        const copy = parseEventLifecyclePhase(toolName, phase, raw[phase]);
+        return copy ? [[phase, copy]] : [];
+    });
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries);
+}
+function parseEventLifecyclePhase(toolName, phase, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw invalidEventLifecyclePhase(toolName, phase);
+    }
+    if (typeof raw.status !== "string" || raw.status.trim().length === 0) {
+        throw invalidEventLifecyclePhase(toolName, phase);
+    }
+    if (typeof raw.message !== "string" || raw.message.trim().length === 0) {
+        throw invalidEventLifecyclePhase(toolName, phase);
+    }
+    return { status: raw.status.trim(), message: raw.message.trim() };
+}
+function invalidEventPresentation(toolName) {
+    return new Error(`Invalid tool definition for ${toolName} (eventPresentation)`);
+}
+function invalidEventMetadataProjection(toolName, key) {
+    return new Error(`Invalid tool definition for ${toolName} (eventPresentation.metadata.${key})`);
+}
+function invalidEventLifecyclePhase(toolName, phase) {
+    return new Error(`Invalid tool definition for ${toolName} (eventPresentation.lifecycle.${phase})`);
+}

package/dist/src/capabilities/tool-definition-validator/module-registry.d.ts

@@ -0,0 +1,3 @@
+import type { ToolModule, ToolModuleDeclaration } from "../tool-types.js";
+export declare function buildToolRegistry(modules: readonly ToolModuleDeclaration[]): ToolModule[];
+export declare function validateToolModuleDeclarations(modules: readonly ToolModuleDeclaration[]): ToolModuleDeclaration[];

package/dist/src/capabilities/tool-definition-validator/module-registry.js

@@ -0,0 +1,99 @@
+import { projectNormalInvocationDefinition } from "../normal-invocation/definition-projection.js";
+import { parseToolNormalInvocationContract, parseToolNormalInvocationForDefinition, } from "../normal-invocation/validator.js";
+import { parseToolDefinition } from "./definition-parser.js";
+import { isToolDefinitionRecordValue, readToolDefinitionName, } from "./definition-shape.js";
+export function buildToolRegistry(modules) {
+    if (!Array.isArray(modules)) {
+        throw new Error("Tool registry modules must be an array");
+    }
+    const seenNames = new Set();
+    return modules.map((module, index) => {
+        if (!module || typeof module !== "object") {
+            throw new Error(`Invalid tool module entry at index ${index}`);
+        }
+        const rawDefinition = module.definition;
+        const toolName = readToolDefinitionName(rawDefinition);
+        const parsedNormalInvocation = parseToolNormalInvocationContract(toolName, module.normalInvocation);
+        if (!parsedNormalInvocation) {
+            throw new Error(`Invalid tool module for ${toolName} (normalInvocation is required)`);
+        }
+        const definition = parseToolDefinition(projectCanonicalDefinition({
+            toolName,
+            rawDefinition,
+            normalInvocation: parsedNormalInvocation,
+        }));
+        if (seenNames.has(definition.name)) {
+            throw new Error(`Duplicate tool definition: ${definition.name}`);
+        }
+        seenNames.add(definition.name);
+        if (typeof module.implementation !== "function") {
+            throw new Error(`Invalid tool module for ${definition.name} (implementation)`);
+        }
+        const adapter = parseToolAdapter(definition.name, module.adapter);
+        const normalInvocation = parseToolNormalInvocationForDefinition(definition, parsedNormalInvocation);
+        return {
+            definition,
+            implementation: module.implementation,
+            ...(adapter ? { adapter } : {}),
+            normalInvocation: normalInvocation,
+        };
+    });
+}
+export function validateToolModuleDeclarations(modules) {
+    const resolved = buildToolRegistry(modules);
+    return resolved.map((tool, index) => {
+        const source = modules[index];
+        const { params: _projectedParams, executionEffect: _projectedEffect, ...definition } = tool.definition;
+        void _projectedParams;
+        void _projectedEffect;
+        return {
+            definition,
+            implementation: tool.implementation,
+            ...(tool.adapter ? { adapter: tool.adapter } : {}),
+            normalInvocation: tool.normalInvocation,
+        };
+    });
+}
+function parseToolAdapter(toolName, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw new Error(`Invalid tool module for ${toolName} (adapter)`);
+    }
+    const normalizeCall = raw.normalizeCall;
+    const validateCall = raw.validateCall;
+    if (normalizeCall !== undefined && typeof normalizeCall !== "function") {
+        throw new Error(`Invalid tool module for ${toolName} (adapter.normalizeCall)`);
+    }
+    if (validateCall !== undefined && typeof validateCall !== "function") {
+        throw new Error(`Invalid tool module for ${toolName} (adapter.validateCall)`);
+    }
+    const adapter = {};
+    if (typeof normalizeCall === "function") {
+        adapter.normalizeCall = normalizeCall;
+    }
+    if (typeof validateCall === "function") {
+        adapter.validateCall = validateCall;
+    }
+    return adapter;
+}
+function projectCanonicalDefinition(params) {
+    if (!isToolDefinitionRecordValue(params.rawDefinition)) {
+        throw new Error("Invalid tool definition entry (not an object)");
+    }
+    if (params.rawDefinition.params !== undefined) {
+        throw new Error(`Invalid tool definition for ${params.toolName} (params must be omitted when normalInvocation is canonical)`);
+    }
+    if (params.rawDefinition.executionEffect !== undefined) {
+        throw new Error(`Invalid tool definition for ${params.toolName} (executionEffect must be omitted when normalInvocation is canonical)`);
+    }
+    const projection = projectNormalInvocationDefinition({
+        toolName: params.toolName,
+        contract: params.normalInvocation,
+    });
+    return {
+        ...params.rawDefinition,
+        params: { ...projection.params },
+        executionEffect: projection.executionEffect,
+    };
+}

package/dist/src/capabilities/tool-definition-validator/payload-channel-spec.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDefinition } from "../tool-types.js";
+export declare function parsePayloadChannelSpec(toolName: string, params: Record<string, string>, raw: unknown): ToolDefinition["payloadChannelSpec"];

package/dist/src/capabilities/tool-definition-validator/payload-channel-spec.js

@@ -0,0 +1,190 @@
+import { createInvalidToolDefinitionError as invalidPayloadChannelSpec, isPayloadContextScope, isPayloadResponseFormat, isPayloadTargetContext, isToolDefinitionRecordValue, } from "./definition-shape.js";
+import { parsePayloadChannelStages } from "./payload-channel-stage.js";
+export function parsePayloadChannelSpec(toolName, params, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec");
+    }
+    const payloadParams = raw.params;
+    const outputParam = raw.outputParam;
+    const generationMode = raw.generationMode;
+    const targetParam = raw.targetParam;
+    const targetRole = raw.targetRole;
+    const contextScope = raw.contextScope;
+    const targetContext = raw.targetContext;
+    const responseFormat = raw.responseFormat;
+    const promptHint = raw.promptHint;
+    const stages = raw.stages;
+    const groundingWindow = raw.groundingWindow;
+    const requiresCurrentTargetObservation = raw.requiresCurrentTargetObservation;
+    if (!hasSupportedPayloadParameters(payloadParams)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.params");
+    }
+    if (typeof outputParam !== "string" || outputParam.trim().length === 0) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.outputParam");
+    }
+    if (generationMode !== "raw_text") {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.generationMode");
+    }
+    const payloadTargetParam = parsePayloadTargetParam(toolName, targetParam);
+    if (targetRole !== undefined && !isPayloadTargetRole(targetRole)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.targetRole");
+    }
+    if (contextScope !== undefined && !isPayloadContextScope(contextScope)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.contextScope");
+    }
+    if (targetContext !== undefined && !isPayloadTargetContext(targetContext)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.targetContext");
+    }
+    if (responseFormat !== undefined &&
+        !isPayloadResponseFormat(responseFormat)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.responseFormat");
+    }
+    if (promptHint !== undefined && typeof promptHint !== "string") {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.promptHint");
+    }
+    if (stages !== undefined && (!Array.isArray(stages) || stages.length === 0)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.stages");
+    }
+    if (!isSupportedGroundingWindow(groundingWindow)) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.groundingWindow");
+    }
+    const currentTargetObservation = parseCurrentTargetObservation(toolName, requiresCurrentTargetObservation);
+    const parsedStages = Array.isArray(stages)
+        ? parsePayloadChannelStages({
+            toolName,
+            toolParams: params,
+            payloadParams,
+            finalOutputParam: outputParam,
+            stages,
+            inheritedResponseFormat: responseFormat,
+        })
+        : undefined;
+    const unknownParam = payloadParams.find((paramName) => !(paramName in params));
+    if (unknownParam) {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec unknown param ${unknownParam}`);
+    }
+    if (!(outputParam in params)) {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec outputParam ${outputParam}`);
+    }
+    if (params[outputParam] !== "string") {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec outputParam ${outputParam} must be string`);
+    }
+    if (payloadTargetParam !== undefined && !(payloadTargetParam in params)) {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec unknown targetParam ${payloadTargetParam}`);
+    }
+    if (payloadTargetParam !== undefined &&
+        payloadParams.includes(payloadTargetParam)) {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec targetParam ${payloadTargetParam} must be a visible control param`);
+    }
+    if (targetContext !== undefined && payloadTargetParam === undefined) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.targetContext requires targetParam");
+    }
+    if (parsedStages?.some((stage) => stage.targetContext !== undefined) &&
+        payloadTargetParam === undefined) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec stage targetContext requires targetParam");
+    }
+    if (parsedStages &&
+        parsedStages[parsedStages.length - 1]?.outputParam !== outputParam) {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec final stage must materialize outputParam ${outputParam}`);
+    }
+    if (currentTargetObservation !== undefined &&
+        !(currentTargetObservation.targetParam in params)) {
+        throw invalidPayloadChannelSpec(toolName, `payloadChannelSpec requiresCurrentTargetObservation unknown targetParam ${currentTargetObservation.targetParam}`);
+    }
+    const parsed = {
+        params: [...payloadParams],
+        outputParam,
+        generationMode,
+    };
+    if (payloadTargetParam) {
+        parsed.targetParam = payloadTargetParam;
+    }
+    if (isPayloadTargetRole(targetRole)) {
+        parsed.targetRole = targetRole;
+    }
+    if (isPayloadContextScope(contextScope)) {
+        parsed.contextScope = contextScope;
+    }
+    if (isPayloadTargetContext(targetContext)) {
+        parsed.targetContext = targetContext;
+    }
+    if (isPayloadResponseFormat(responseFormat)) {
+        parsed.responseFormat = responseFormat;
+    }
+    if (typeof promptHint === "string") {
+        parsed.promptHint = promptHint;
+    }
+    if (parsedStages) {
+        parsed.stages = parsedStages;
+    }
+    if (typeof groundingWindow === "number") {
+        parsed.groundingWindow = groundingWindow;
+    }
+    if (currentTargetObservation) {
+        parsed.requiresCurrentTargetObservation = currentTargetObservation;
+    }
+    return parsed;
+}
+function hasSupportedPayloadParameters(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (value.length === 0)
+        return false;
+    return value.every((paramName) => typeof paramName === "string" && paramName.trim().length > 0);
+}
+function parsePayloadTargetParam(toolName, value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw invalidPayloadChannelSpec(toolName, "payloadChannelSpec.targetParam");
+    }
+    return value.trim();
+}
+function isPayloadTargetRole(value) {
+    if (value === "payload_body")
+        return true;
+    return value === "operation_target";
+}
+function isSupportedGroundingWindow(value) {
+    if (value === undefined)
+        return true;
+    if (typeof value !== "number")
+        return false;
+    if (!Number.isInteger(value))
+        return false;
+    return value >= 0;
+}
+function parseCurrentTargetObservation(toolName, raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw invalidCurrentTargetObservation(toolName);
+    }
+    if (typeof raw.targetParam !== "string") {
+        throw invalidCurrentTargetObservation(toolName);
+    }
+    if (raw.targetParam.trim().length === 0) {
+        throw invalidCurrentTargetObservation(toolName);
+    }
+    if (!isCurrentTargetContentRequirement(raw.contentRequirement)) {
+        throw invalidCurrentTargetObservation(toolName);
+    }
+    return {
+        targetParam: raw.targetParam,
+        ...(raw.contentRequirement
+            ? { contentRequirement: raw.contentRequirement }
+            : {}),
+    };
+}
+function isCurrentTargetContentRequirement(value) {
+    if (value === undefined)
+        return true;
+    if (value === "any")
+        return true;
+    return value === "full";
+}
+function invalidCurrentTargetObservation(toolName) {
+    return invalidPayloadChannelSpec(toolName, "payloadChannelSpec.requiresCurrentTargetObservation");
+}

package/dist/src/capabilities/tool-definition-validator/payload-channel-stage.d.ts

@@ -0,0 +1,11 @@
+import type { ToolPayloadChannelStageSpec } from "../tool-types.js";
+type PayloadChannelStageParsingContext = Readonly<{
+    toolName: string;
+    toolParams: Readonly<Record<string, string>>;
+    payloadParams: readonly string[];
+    finalOutputParam: string;
+    stages: readonly unknown[];
+    inheritedResponseFormat: unknown;
+}>;
+export declare function parsePayloadChannelStages(context: PayloadChannelStageParsingContext): ToolPayloadChannelStageSpec[];
+export {};

package/dist/src/capabilities/tool-definition-validator/payload-channel-stage.js

@@ -0,0 +1,155 @@
+import { createInvalidToolDefinitionError as invalidPayloadChannelStage, isPayloadContextScope, isPayloadResponseFormat, isPayloadTargetContext, isToolDefinitionRecordValue, } from "./definition-shape.js";
+import { isPayloadStageMinimumWithinInvocationBounds, parsePayloadStageLiteralOutput, parsePayloadStageMinBytesOverride, } from "./payload-stage-conditions.js";
+export function parsePayloadChannelStages(context) {
+    return context.stages.map((stage, index) => parsePayloadChannelStage(context, stage, index));
+}
+function parsePayloadChannelStage(context, raw, stageIndex) {
+    const path = `payloadChannelSpec.stages.${stageIndex}`;
+    if (!isToolDefinitionRecordValue(raw)) {
+        throw invalidPayloadChannelStage(context.toolName, path);
+    }
+    const outputParam = raw.outputParam;
+    const contextScope = raw.contextScope;
+    const targetContext = raw.targetContext;
+    const responseFormat = raw.responseFormat;
+    const targetLineBoundProperties = raw.targetLineBoundProperties;
+    const promptHint = raw.promptHint;
+    const includeMaterializedParams = raw.includeMaterializedParams;
+    const minBytes = raw.minBytes;
+    const minBytesOverride = raw.minBytesOverride;
+    const literalOutput = raw.literalOutput;
+    if (!hasSupportedPayloadStageOutput(context, outputParam)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.outputParam`);
+    }
+    if (contextScope !== undefined && !isPayloadContextScope(contextScope)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.contextScope`);
+    }
+    if (targetContext !== undefined && !isPayloadTargetContext(targetContext)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.targetContext`);
+    }
+    if (responseFormat !== undefined &&
+        !isPayloadResponseFormat(responseFormat)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.responseFormat`);
+    }
+    if (!hasSupportedTargetLineBoundProperties(targetLineBoundProperties)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.targetLineBoundProperties`);
+    }
+    if (promptHint !== undefined && typeof promptHint !== "string") {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.promptHint`);
+    }
+    if (!hasSupportedMaterializedStageInputs(includeMaterializedParams, context.payloadParams)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.includeMaterializedParams`);
+    }
+    if (!hasSupportedPayloadStageMinimum(minBytes)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path}.minBytes`);
+    }
+    const normalizedOutputParam = outputParam.trim();
+    if (hasPayloadStageByteMinimum(minBytes, minBytesOverride) &&
+        normalizedOutputParam !== context.finalOutputParam) {
+        throw invalidPayloadChannelStage(context.toolName, `${path} byte minimum must belong to the final payload stage`);
+    }
+    if (!referencesAvailableMaterializedStageInputs(context.stages, stageIndex, includeMaterializedParams)) {
+        throw invalidPayloadChannelStage(context.toolName, `${path} references unavailable materialized params`);
+    }
+    let parsedMinBytesOverride;
+    if (minBytesOverride !== undefined) {
+        parsedMinBytesOverride = parsePayloadStageMinBytesOverride({
+            toolName: context.toolName,
+            stageIndex,
+            input: minBytesOverride,
+            baseMinBytes: minBytes,
+            includeMaterializedParams,
+            stages: context.stages,
+            inheritedResponseFormat: context.inheritedResponseFormat,
+        });
+    }
+    const parsedLiteralOutput = parsePayloadStageLiteralOutput({
+        toolName: context.toolName,
+        stageIndex,
+        input: literalOutput,
+        stageOutputParam: normalizedOutputParam,
+        finalOutputParam: context.finalOutputParam,
+        stageResponseFormat: responseFormat,
+        inheritedResponseFormat: context.inheritedResponseFormat,
+        stageTargetLineBoundProperties: targetLineBoundProperties,
+        stageMinBytesOverride: minBytesOverride,
+        includeMaterializedParams,
+        stages: context.stages,
+    });
+    const parsed = {
+        outputParam: normalizedOutputParam,
+    };
+    if (isPayloadContextScope(contextScope)) {
+        parsed.contextScope = contextScope;
+    }
+    if (isPayloadTargetContext(targetContext)) {
+        parsed.targetContext = targetContext;
+    }
+    if (isPayloadResponseFormat(responseFormat)) {
+        parsed.responseFormat = responseFormat;
+    }
+    if (Array.isArray(targetLineBoundProperties)) {
+        parsed.targetLineBoundProperties = [...targetLineBoundProperties];
+    }
+    if (typeof promptHint === "string") {
+        parsed.promptHint = promptHint;
+    }
+    if (Array.isArray(includeMaterializedParams)) {
+        parsed.includeMaterializedParams = [...includeMaterializedParams];
+    }
+    if (typeof minBytes === "number") {
+        parsed.minBytes = minBytes;
+    }
+    if (parsedMinBytesOverride) {
+        parsed.minBytesOverride = parsedMinBytesOverride;
+    }
+    if (parsedLiteralOutput) {
+        parsed.literalOutput = parsedLiteralOutput;
+    }
+    return parsed;
+}
+function hasSupportedPayloadStageOutput(context, value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim().length === 0)
+        return false;
+    if (!context.payloadParams.includes(value))
+        return false;
+    return context.toolParams[value] === "string";
+}
+function hasSupportedTargetLineBoundProperties(value) {
+    if (value === undefined)
+        return true;
+    if (!Array.isArray(value))
+        return false;
+    if (value.length === 0)
+        return false;
+    if (new Set(value).size !== value.length)
+        return false;
+    return value.every((property) => typeof property === "string" && property.trim().length > 0);
+}
+function hasSupportedMaterializedStageInputs(value, payloadParams) {
+    if (value === undefined)
+        return true;
+    if (!Array.isArray(value))
+        return false;
+    return value.every((paramName) => typeof paramName === "string" && payloadParams.includes(paramName));
+}
+function hasSupportedPayloadStageMinimum(value) {
+    if (value === undefined)
+        return true;
+    return isPayloadStageMinimumWithinInvocationBounds(value);
+}
+function hasPayloadStageByteMinimum(minBytes, minBytesOverride) {
+    return minBytes !== undefined || minBytesOverride !== undefined;
+}
+function referencesAvailableMaterializedStageInputs(stages, stageIndex, includeMaterializedParams) {
+    if (!Array.isArray(includeMaterializedParams))
+        return true;
+    const priorStageOutputs = new Set(stages
+        .slice(0, stageIndex)
+        .filter(isToolDefinitionRecordValue)
+        .map((stage) => stage.outputParam)
+        .filter((paramName) => typeof paramName === "string"));
+    return includeMaterializedParams.every((paramName) => priorStageOutputs.has(paramName));
+}

package/dist/src/capabilities/tool-definition-validator/payload-stage-conditions.d.ts

@@ -0,0 +1,24 @@
+import type { ToolPayloadChannelStageSpec } from "../tool-types.js";
+export declare function parsePayloadStageMinBytesOverride(params: Readonly<{
+    toolName: string;
+    stageIndex: number;
+    input: unknown;
+    baseMinBytes: unknown;
+    includeMaterializedParams: unknown;
+    stages: readonly unknown[];
+    inheritedResponseFormat: unknown;
+}>): NonNullable<ToolPayloadChannelStageSpec["minBytesOverride"]>;
+export declare function parsePayloadStageLiteralOutput(params: Readonly<{
+    toolName: string;
+    stageIndex: number;
+    input: unknown;
+    stageOutputParam: string;
+    finalOutputParam: unknown;
+    stageResponseFormat: unknown;
+    inheritedResponseFormat: unknown;
+    stageTargetLineBoundProperties: unknown;
+    stageMinBytesOverride: unknown;
+    includeMaterializedParams: unknown;
+    stages: readonly unknown[];
+}>): NonNullable<ToolPayloadChannelStageSpec["literalOutput"]> | undefined;
+export declare function isPayloadStageMinimumWithinInvocationBounds(value: unknown): value is number;