@abot-ai/runtime 1.1.0 → 1.2.0

package/README.md

@@ -219,9 +219,12 @@ from core-owned passive long-term memory.
 The Web plugin exposes two distinct capabilities:
 
 - `web_fetch` retrieves a specific public HTTP(S) page without a search API key.
-- `web_search` uses the Brave Search API and requires
-  `BRAVE_SEARCH_API_KEY`. Without it, the capability returns a clear local
-  configuration error before making a search request.
+- `web_search` uses Brave Search when `BRAVE_SEARCH_API_KEY` is configured.
+  Without a key, it uses Light search: bounded discovery and ranking within a
+  catalog of public Hebrew and English sources, without an external search
+  engine. Light has limited coverage; an empty result does not mean the
+  information is absent from the web. A configured Brave key that fails does
+  not trigger an automatic switch to Light.
 
 Some plugins have platform-specific requirements. See [Plugins](docs/plugins.md)
 for their contracts, limits, and configuration.

package/dist/src/capabilities/tool-types.d.ts

@@ -115,7 +115,7 @@ export type ToolRequestAttachment = Readonly<{
     name?: string;
     size?: number;
 }>;
-/** Minimal config-filtered tool fact projected to plugin execution only. */
+/** Minimal config-filtered tool fact; consumers project it for their own context. */
 export type ToolAvailabilityEntry = Readonly<{
     toolName: string;
     operationId: string;

package/dist/src/model-gateway/providers/ollama/generation-options.d.ts

@@ -1,4 +1,4 @@
-import type { ModelGatewayFormat, ResolvedModelInvocation } from "../../types.js";
+import type { ResolvedModelInvocation } from "../../types.js";
 export declare function readOptionalPositiveIntEnv(name: string): number | undefined;
 export declare function buildOllamaOptions(params: {
     baseOptions: Record<string, unknown>;
@@ -13,8 +13,6 @@ export declare function buildOllamaOptions(params: {
 export declare function deriveOllamaNumPredict(params: {
     payload: Readonly<Record<string, unknown>>;
     invocation: ResolvedModelInvocation;
-    effectiveFormat?: ModelGatewayFormat;
-    useStructuredOutputCeiling: boolean;
     outputTokenLimit?: number;
 }): number;
 export declare function resolveOllamaKeepAlive(invocation: ResolvedModelInvocation): string;

package/dist/src/model-gateway/providers/ollama/generation-options.js

@@ -1,4 +1,3 @@
-import { estimateStrictStructuredOutputTokenCeiling } from "../../structured-output/budget.js";
 import { estimateProviderEnvelopeInputTokens } from "../envelope-budget.js";
 const DEFAULT_OLLAMA_KEEP_ALIVE = "3m";
 export function readOptionalPositiveIntEnv(name) {
@@ -38,10 +37,7 @@ export function buildOllamaOptions(params) {
 export function deriveOllamaNumPredict(params) {
     const estimatedInputTokens = estimateProviderEnvelopeInputTokens(params.payload, params.invocation.profile.context.tokenEstimation);
     const physicalRemainingTokens = Math.max(1, params.invocation.profile.contextWindowTokens - estimatedInputTokens);
-    const structuredOutputCeiling = params.useStructuredOutputCeiling
-        ? estimateStrictStructuredOutputTokenCeiling(params.effectiveFormat, params.invocation.profile.context.tokenEstimation)
-        : undefined;
-    return Math.max(1, Math.min(physicalRemainingTokens, structuredOutputCeiling ?? physicalRemainingTokens, params.outputTokenLimit ?? physicalRemainingTokens));
+    return Math.max(1, Math.min(physicalRemainingTokens, params.outputTokenLimit ?? physicalRemainingTokens));
 }
 export function resolveOllamaKeepAlive(invocation) {
     const configured = invocation.profile.providerConfig?.keepAlive?.trim();

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

@@ -28,10 +28,6 @@ function applyGenerationOptions(params) {
         derivedNumPredict: deriveOllamaNumPredict({
             payload: params.payload,
             invocation: params.invocation,
-            ...(params.effectiveFormat
-                ? { effectiveFormat: params.effectiveFormat }
-                : {}),
-            useStructuredOutputCeiling: params.useStructuredOutputCeiling,
             ...(params.outputTokenLimit !== undefined
                 ? { outputTokenLimit: params.outputTokenLimit }
                 : {}),
@@ -71,8 +67,6 @@ export function buildOllamaPayload(requestBody, payloadOptions = {}) {
     applyGenerationOptions({
         payload,
         invocation,
-        ...(effectiveFormat ? { effectiveFormat } : {}),
-        useStructuredOutputCeiling: !invocation.profile.supportsThinking || invocation.think === "none",
         ...(outputTokenLimit !== undefined ? { outputTokenLimit } : {}),
     });
     return payload;
@@ -103,8 +97,6 @@ export function buildOllamaRawPayload(requestBody, payloadOptions = {}) {
     applyGenerationOptions({
         payload,
         invocation,
-        ...(effectiveFormat ? { effectiveFormat } : {}),
-        useStructuredOutputCeiling: false,
         ...(outputTokenLimit !== undefined ? { outputTokenLimit } : {}),
     });
     return payload;

package/dist/src/model-gateway/server/request-body.js

@@ -1,4 +1,5 @@
 export async function readJsonBody(request) {
+    request.setEncoding("utf8");
     let raw = "";
     for await (const chunk of request) {
         raw += chunk;

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

@@ -4,4 +4,6 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./tool-availability-brief.js";
+export * from "./tool-availability-overview.js";
 export * from "../plugin-contract/index.js";

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

@@ -4,4 +4,6 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./tool-availability-brief.js";
+export * from "./tool-availability-overview.js";
 export * from "../plugin-contract/index.js";

package/dist/src/plugin-sdk/tool-availability-brief.d.ts

@@ -0,0 +1,9 @@
+import type { ToolAvailabilityEntry } from "../plugin-contract/entrypoint.js";
+import { type BoundedCollectionMetadata, type BoundedTextMetadata } from "./bounds.js";
+export type ToolAvailabilityBrief = Readonly<{
+    text: string;
+    collection: BoundedCollectionMetadata;
+    output: BoundedTextMetadata;
+}>;
+/** Formats the existing bounded, on-demand tool brief without executing tools. */
+export declare function buildToolAvailabilityBrief(entries: readonly ToolAvailabilityEntry[]): ToolAvailabilityBrief;

package/dist/src/plugin-sdk/tool-availability-brief.js

@@ -0,0 +1,48 @@
+import { boundCollection, boundText, } from "./bounds.js";
+const TOOL_COUNT_MAX = 64;
+const OUTPUT_CHARACTER_MAX = 16_000;
+/** Formats the existing bounded, on-demand tool brief without executing tools. */
+export function buildToolAvailabilityBrief(entries) {
+    const orderedTools = [...entries].sort(compareAvailableTools);
+    const boundedTools = boundCollection(orderedTools, {
+        maxItems: TOOL_COUNT_MAX,
+    });
+    const rawOutput = [
+        `Available tool operations: ${entries.length}`,
+        ...boundedTools.items.map(formatAvailableTool),
+        ...(boundedTools.metadata.truncated
+            ? [
+                `[${boundedTools.metadata.omittedItems} additional tool operations omitted]`,
+            ]
+            : []),
+    ].join("\n");
+    const boundedOutput = boundText(rawOutput, {
+        maxChars: OUTPUT_CHARACTER_MAX,
+        marker: "\n[available tool brief truncated]",
+    });
+    return Object.freeze({
+        text: boundedOutput.text,
+        collection: boundedTools.metadata,
+        output: boundedOutput.metadata,
+    });
+}
+function formatAvailableTool(tool) {
+    return [
+        `- ${tool.operationId}`,
+        `(tool=${tool.toolName}; effect=${tool.effect}; groups=${tool.catalogGroups.join(",")})`,
+        tool.summary,
+    ].join(" ");
+}
+function compareAvailableTools(left, right) {
+    const byOperation = compareAscii(left.operationId, right.operationId);
+    if (byOperation !== 0)
+        return byOperation;
+    return compareAscii(left.toolName, right.toolName);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/plugin-sdk/tool-availability-overview.d.ts

@@ -0,0 +1,9 @@
+import type { ToolAvailabilityEntry } from "../plugin-contract/entrypoint.js";
+export type ToolAvailabilityOverviewLevel = "detailed" | "titles" | "groups";
+export type ToolAvailabilityOverviewGroup = Readonly<{
+    groupId: string;
+    memberCount: number;
+    effects: readonly string[];
+}>;
+/** Complete informational candidates; callers own admission and context budget. */
+export declare function buildToolAvailabilityOverview(entries: readonly ToolAvailabilityEntry[], groups: readonly ToolAvailabilityOverviewGroup[], level: ToolAvailabilityOverviewLevel): string;

package/dist/src/plugin-sdk/tool-availability-overview.js

@@ -0,0 +1,62 @@
+/** Complete informational candidates; callers own admission and context budget. */
+export function buildToolAvailabilityOverview(entries, groups, level) {
+    if (level === "detailed")
+        return describeAvailableTools(entries);
+    const orderedGroups = [...groups].sort((left, right) => compareAscii(left.groupId, right.groupId));
+    if (level === "titles")
+        return describeGroupTools(entries, orderedGroups);
+    return orderedGroups.map(describeGroupMetadata).join("\n");
+}
+function describeAvailableTools(entries) {
+    const tools = new Map();
+    for (const entry of entries) {
+        const tool = tools.get(entry.toolName) ?? {
+            operationIds: new Set(),
+            catalogGroups: new Set(),
+        };
+        tool.operationIds.add(entry.operationId);
+        for (const groupId of entry.catalogGroups)
+            tool.catalogGroups.add(groupId);
+        tools.set(entry.toolName, tool);
+    }
+    return [...tools.entries()]
+        .sort(([left], [right]) => compareAscii(left, right))
+        .map(([toolName, tool]) => `- ${formatOverviewIdentifier(toolName)} — ${sortedValues(tool.operationIds)} [${sortedValues(tool.catalogGroups)}]`)
+        .join("\n");
+}
+function describeGroupTools(entries, groups) {
+    return groups
+        .map((group) => {
+        const toolNames = new Set(entries
+            .filter((entry) => entry.catalogGroups.includes(group.groupId))
+            .map((entry) => entry.toolName));
+        return `- ${group.groupId}: ${sortedValues(toolNames)}`;
+    })
+        .join("\n");
+}
+function describeGroupMetadata(group) {
+    return `- ${group.groupId} (memberCount=${group.memberCount}; effects=${sortedValues(group.effects)})`;
+}
+function sortedValues(values) {
+    return [...values]
+        .sort(compareAscii)
+        .map(formatOverviewIdentifier)
+        .join(", ");
+}
+function formatOverviewIdentifier(value) {
+    if (isPlainOverviewIdentifier(value))
+        return value;
+    return JSON.stringify(value)
+        .replace(/\u2028/gu, "\\u2028")
+        .replace(/\u2029/gu, "\\u2029");
+}
+function isPlainOverviewIdentifier(value) {
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(value);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/runtime/adapters/registered-tool-payload-plan.d.ts

@@ -1,6 +1,4 @@
 import type { ToolDefinition, ToolExecutionSharedState, ToolNormalInvocationInput, ToolNormalInvocationOperation, ToolPayloadChannelSpec, ToolPayloadChannelStageSpec } from "../../capabilities/tool-types.js";
-import { type WorkerCapabilityPayloadRelatedArtifactContext } from "../orchestration/worker-capabilities/payload-contracts.js";
-import type { WorkerSettledCapabilityResult } from "../orchestration/worker-capabilities/contracts.js";
 export type RegisteredToolPayloadStage = Readonly<{
     outputParam: string;
     instructions: string;
@@ -72,13 +70,6 @@ export declare function resolveRegisteredToolPayloadTargetContext(params: {
     sharedState: ToolExecutionSharedState;
     materializedParams?: Readonly<Record<string, string>>;
 }): Promise<RegisteredToolPayloadTargetContext | undefined>;
-export declare function resolveRegisteredToolPayloadRelatedArtifactContexts(params: {
-    contextScope?: ToolPayloadChannelSpec["contextScope"];
-    targetParam?: string;
-    controls: Readonly<Record<string, unknown>>;
-    sharedState: ToolExecutionSharedState;
-    settledCapabilityResults: readonly WorkerSettledCapabilityResult[];
-}): Promise<readonly WorkerCapabilityPayloadRelatedArtifactContext[]>;
 export declare function materializeRegisteredToolPayloadStageResponseFormat(params: {
     stage: RegisteredToolPayloadStage;
     targetContext?: RegisteredToolPayloadTargetContext;

package/dist/src/runtime/adapters/registered-tool-payload-plan.js

@@ -1,7 +1,6 @@
 import { readFile, stat } from "node:fs/promises";
 import { TOOL_PAYLOAD_STAGE_LITERAL_OUTPUT_MAX_BYTES } from "../../capabilities/tool-types.js";
 import { resolveRuntimeTargetPath } from "../capabilities/runtime-target-path.js";
-import { WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, } from "../orchestration/worker-capabilities/payload-contracts.js";
 export function deriveRegisteredToolPayloadContextPlan(definition, operation) {
     const spec = definition.payloadChannelSpec;
     if (!operation.payload ||
@@ -227,72 +226,6 @@ export async function resolveRegisteredToolPayloadTargetContext(params) {
         content,
     });
 }
-export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params) {
-    if (params.contextScope !== "target_with_artifacts") {
-        return Object.freeze([]);
-    }
-    const currentTarget = resolveCurrentTarget(params);
-    const resolvedTargets = new Set();
-    const artifacts = [];
-    let totalCharacters = 0;
-    for (const result of params.settledCapabilityResults) {
-        if (result.outcome !== "succeeded")
-            continue;
-        for (const reference of result.references ?? []) {
-            let resolvedTarget;
-            try {
-                resolvedTarget = resolveRuntimeTargetPath(reference.target, params.sharedState);
-            }
-            catch {
-                continue;
-            }
-            if (resolvedTarget === currentTarget ||
-                resolvedTargets.has(resolvedTarget)) {
-                continue;
-            }
-            resolvedTargets.add(resolvedTarget);
-            try {
-                const targetStat = await stat(resolvedTarget);
-                if (!targetStat.isFile())
-                    continue;
-                const content = await readFile(resolvedTarget, "utf8");
-                if (content.length + totalCharacters >
-                    WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS) {
-                    continue;
-                }
-                artifacts.push(Object.freeze({
-                    sourceExecutionId: result.executionId,
-                    targetPath: reference.target,
-                    presentation: "full",
-                    content,
-                }));
-                totalCharacters += content.length;
-                if (artifacts.length >=
-                    WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT) {
-                    return Object.freeze(artifacts);
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return Object.freeze(artifacts);
-}
-function resolveCurrentTarget(params) {
-    const rawTarget = params.targetParam
-        ? params.controls[params.targetParam]
-        : undefined;
-    if (typeof rawTarget !== "string" || rawTarget.trim().length === 0) {
-        return undefined;
-    }
-    try {
-        return resolveRuntimeTargetPath(rawTarget.trim(), params.sharedState);
-    }
-    catch {
-        return undefined;
-    }
-}
 function resolveBoundedTargetContext(params) {
     const stageIndex = params.plan.stages.indexOf(params.stage);
     const priorStages = params.plan.stages

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.d.ts

@@ -0,0 +1,13 @@
+import type { ToolExecutionSharedState, ToolPayloadChannelSpec } from "../../capabilities/tool-types.js";
+import type { WorkerCapabilityPayloadSourceProvenance, WorkerSettledCapabilityResult } from "../orchestration/worker-capabilities/contracts.js";
+import { type WorkerCapabilityPayloadRelatedArtifactContext } from "../orchestration/worker-capabilities/payload-contracts.js";
+import type { RoleCallFrame } from "../orchestration/role-calls/contracts.js";
+export declare function resolveRegisteredToolPayloadRelatedArtifactContexts(params: {
+    contextScope?: ToolPayloadChannelSpec["contextScope"];
+    targetParam?: string;
+    controls: Readonly<Record<string, unknown>>;
+    sharedState: ToolExecutionSharedState;
+    call: RoleCallFrame;
+    assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
+    settledCapabilityResults: readonly WorkerSettledCapabilityResult[];
+}): Promise<readonly WorkerCapabilityPayloadRelatedArtifactContext[]>;

package/dist/src/runtime/adapters/registered-tool-payload-related-artifacts.js

@@ -0,0 +1,84 @@
+import { readFile, stat } from "node:fs/promises";
+import { resolveRuntimeTargetPath } from "../capabilities/runtime-target-path.js";
+import { projectWorkerCapabilityDependencyArtifactReceipts, } from "../orchestration/worker-capabilities/assignment-provenance.js";
+import { projectWorkerPayloadPlannerItemProvenance } from "../orchestration/worker-capabilities/payload-source-provenance.js";
+import { WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS, WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT, } from "../orchestration/worker-capabilities/payload-contracts.js";
+export async function resolveRegisteredToolPayloadRelatedArtifactContexts(params) {
+    if (params.contextScope !== "target_with_artifacts") {
+        return Object.freeze([]);
+    }
+    const dependencyReceipts = projectWorkerCapabilityDependencyArtifactReceipts(projectWorkerPayloadPlannerItemProvenance(params.assignmentProvenance, params.call), params.call);
+    const receipts = [
+        ...projectSameCallArtifactReceipts(params.settledCapabilityResults),
+        ...dependencyReceipts,
+    ];
+    return loadRelatedArtifactContexts(params, receipts);
+}
+function projectSameCallArtifactReceipts(results) {
+    return results.flatMap((result) => {
+        if (result.outcome !== "succeeded")
+            return [];
+        return (result.references ?? []).map((reference) => Object.freeze({
+            sourceExecutionId: result.executionId,
+            targetPath: reference.target,
+        }));
+    });
+}
+async function loadRelatedArtifactContexts(params, receipts) {
+    const currentTarget = resolveCurrentTarget(params);
+    const resolvedTargets = new Set();
+    const artifacts = [];
+    let totalCharacters = 0;
+    for (const receipt of receipts) {
+        let resolvedTarget;
+        try {
+            resolvedTarget = resolveRuntimeTargetPath(receipt.targetPath, params.sharedState);
+        }
+        catch {
+            continue;
+        }
+        if (resolvedTarget === currentTarget ||
+            resolvedTargets.has(resolvedTarget)) {
+            continue;
+        }
+        resolvedTargets.add(resolvedTarget);
+        try {
+            const targetStat = await stat(resolvedTarget);
+            if (!targetStat.isFile())
+                continue;
+            const content = await readFile(resolvedTarget, "utf8");
+            if (content.length + totalCharacters >
+                WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS) {
+                continue;
+            }
+            artifacts.push(Object.freeze({
+                sourceExecutionId: receipt.sourceExecutionId,
+                targetPath: receipt.targetPath,
+                presentation: "full",
+                content,
+            }));
+            totalCharacters += content.length;
+            if (artifacts.length >= WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_COUNT) {
+                return Object.freeze(artifacts);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return Object.freeze(artifacts);
+}
+function resolveCurrentTarget(params) {
+    const rawTarget = params.targetParam
+        ? params.controls[params.targetParam]
+        : undefined;
+    if (typeof rawTarget !== "string" || rawTarget.trim().length === 0) {
+        return undefined;
+    }
+    try {
+        return resolveRuntimeTargetPath(rawTarget.trim(), params.sharedState);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -112,6 +112,10 @@ function projectWorkerDescriptor(definition, operation, stagedPayloadPlan) {
             ? { requiresPayloadAuthoringObjective: true }
             : {}),
         catalogGroups,
+        routingCapability: definition.routingCapability,
+        ...(definition.developmentRoles
+            ? { developmentRoles: Object.freeze([...definition.developmentRoles]) }
+            : {}),
     });
 }
 function projectRuntimePathControlIds(definition, operation, controls) {

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

@@ -113,6 +113,9 @@ async function prepareRegisteredToolWorkerCapability(params, input, payloadObser
         sharedState: params.sharedState,
         ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
         call: input.call,
+        ...(input.assignmentProvenance
+            ? { assignmentProvenance: input.assignmentProvenance }
+            : {}),
         // The payload contract still names this correlation executionId. During
         // prepare it is deliberately non-canonical and never enters the ledger.
         executionId: input.preparationId,

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-lifecycle.d.ts

@@ -9,6 +9,7 @@ export declare function prepareOperationPayload(params: Readonly<{
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
+    assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;
     descriptor: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["descriptor"];
     intent: string;

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

@@ -1,4 +1,4 @@
-import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-plan.js";
+import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-related-artifacts.js";
 import { normalizePayloadAuthoringResult } from "./payload-authoring-result.js";
 import { executionFreshnessRejection, payloadRejection, rejectPayloadLifecycle, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "./payload-rejection.js";
 import { prepareStagedOperationPayload } from "./payload-stages.js";
@@ -11,6 +11,9 @@ export async function prepareOperationPayload(params) {
             sharedState: params.sharedState,
             ...(params.payloadAuthor ? { payloadAuthor: params.payloadAuthor } : {}),
             call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             executionId: params.executionId,
             descriptor: params.descriptor,
             intent: params.intent,
@@ -55,10 +58,17 @@ export async function prepareOperationPayload(params) {
             targetParam: params.projection.payloadContextPlan?.targetParam,
             controls: params.controls,
             sharedState: params.sharedState,
+            call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             settledCapabilityResults: params.settledCapabilityResults,
         });
         rawAuthored = await params.payloadAuthor.author({
             call: params.call,
+            ...(params.assignmentProvenance
+                ? { assignmentProvenance: params.assignmentProvenance }
+                : {}),
             executionId: params.executionId,
             descriptor: params.descriptor,
             ...(params.authoringObjective

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/payload-stages.d.ts

@@ -11,6 +11,7 @@ export type StagedOperationPayloadParams = Readonly<{
     sharedState: ToolExecutionSharedState;
     payloadAuthor?: WorkerCapabilityPayloadAuthor;
     call: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["call"];
+    assignmentProvenance?: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["assignmentProvenance"];
     executionId: string;
     descriptor: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0]["descriptor"];
     intent: string;

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

@@ -1,4 +1,5 @@
-import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadRelatedArtifactContexts, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
+import { resolveRegisteredToolPayloadRelatedArtifactContexts } from "../registered-tool-payload-related-artifacts.js";
+import { materializeRegisteredToolPayloadStageResponseFormat, resolveRegisteredToolPayloadStageLiteralOutput, resolveRegisteredToolPayloadStageMinBytes, resolveRegisteredToolPayloadTargetContext, validateRegisteredToolPayloadStageTargetLineBounds, } from "../registered-tool-payload-plan.js";
 import { normalizePayloadAuthoringResult } from "./payload-authoring-result.js";
 import { executionFreshnessRejection, payloadRejection, rejectPayloadLifecycle, STEERING_SUPERSEDED_BEFORE_EXTERNAL_EXECUTION, STEERING_SUPERSEDED_SUMMARY, } from "./payload-rejection.js";
 export async function prepareStagedOperationPayload(params) {
@@ -172,10 +173,17 @@ class PayloadStageRunner {
                     targetParam: this.params.plan.targetParam,
                     controls: this.params.controls,
                     sharedState: this.params.sharedState,
+                    call: this.params.call,
+                    ...(this.params.assignmentProvenance
+                        ? { assignmentProvenance: this.params.assignmentProvenance }
+                        : {}),
                     settledCapabilityResults: this.params.settledCapabilityResults,
                 });
                 rawAuthored = await payloadAuthor.author({
                     call: this.params.call,
+                    ...(this.params.assignmentProvenance
+                        ? { assignmentProvenance: this.params.assignmentProvenance }
+                        : {}),
                     executionId: this.params.executionId,
                     descriptor: this.params.descriptor,
                     ...(this.params.authoringObjective

package/dist/src/runtime/capabilities/request-bound-tool-registry.js

@@ -1,3 +1,4 @@
+import { projectAvailableTools } from "./tool-availability.js";
 /**
  * Adds trusted request services to an already config-filtered Tool Registry.
  * Tools remain opaque to the request flow.
@@ -54,27 +55,3 @@ export function bindRequestToolRegistry(params) {
         }),
     });
 }
-function projectAvailableTools(registrations) {
-    if (registrations === undefined)
-        return undefined;
-    const entries = registrations.flatMap((registration) => registration.contract.operations.map((operation) => Object.freeze({
-        toolName: registration.toolName,
-        operationId: operation.operationId,
-        summary: operation.summary,
-        catalogGroups: Object.freeze([
-            ...(registration.definition.catalogGroups ?? ["other"]),
-        ]),
-        effect: operation.effect,
-    })));
-    entries.sort(compareAvailableTools);
-    return Object.freeze(entries);
-}
-function compareAvailableTools(left, right) {
-    const byOperation = compareAscii(left.operationId, right.operationId);
-    return byOperation !== 0
-        ? byOperation
-        : compareAscii(left.toolName, right.toolName);
-}
-function compareAscii(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/src/runtime/capabilities/tool-availability.d.ts

@@ -0,0 +1,6 @@
+import type { RegisteredToolNormalInvocation, ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
+/** Passive request-effective tool facts, independent of execution services. */
+export interface ToolAvailabilitySource {
+    getAvailableTools(): readonly ToolAvailabilityEntry[] | undefined;
+}
+export declare function projectAvailableTools(registrations: readonly RegisteredToolNormalInvocation[] | undefined): readonly ToolAvailabilityEntry[] | undefined;

package/dist/src/runtime/capabilities/tool-availability.js

@@ -0,0 +1,28 @@
+export function projectAvailableTools(registrations) {
+    if (registrations === undefined)
+        return undefined;
+    const entries = registrations.flatMap((registration) => registration.contract.operations.map((operation) => Object.freeze({
+        toolName: registration.toolName,
+        operationId: operation.operationId,
+        summary: operation.summary,
+        catalogGroups: Object.freeze([
+            ...(registration.definition.catalogGroups ?? ["other"]),
+        ]),
+        effect: operation.effect,
+    })));
+    entries.sort(compareAvailableTools);
+    return Object.freeze(entries);
+}
+function compareAvailableTools(left, right) {
+    const byOperation = compareAscii(left.operationId, right.operationId);
+    return byOperation !== 0
+        ? byOperation
+        : compareAscii(left.toolName, right.toolName);
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/src/runtime/context/capability-brief.d.ts

@@ -0,0 +1,25 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
+import { type ToolAvailabilityOverviewGroup, type ToolAvailabilityOverviewLevel } from "../../plugin-sdk/tool-availability-overview.js";
+import type { projectRequestContext } from "./request-context.js";
+export declare const CAPABILITY_BRIEF_KIND = "runtime_capability_brief_v1";
+export declare const CAPABILITY_BRIEF_MAX_TOKENS = 512;
+export type CapabilityBriefLevel = ToolAvailabilityOverviewLevel | "none";
+export type CapabilityBriefProjection = Readonly<{
+    level: CapabilityBriefLevel;
+    message?: ChatMessage;
+    estimatedTokens: number;
+    budgetTokens: number;
+    reason: "complete_catalog" | "empty_catalog" | "insufficient_budget";
+}>;
+type ContextInput = Parameters<typeof projectRequestContext>[0];
+/** Optional availability metadata admitted against the full context estimate. */
+export declare function projectCapabilityBrief(params: Readonly<{
+    entries?: readonly ToolAvailabilityEntry[];
+    groups: readonly ToolAvailabilityOverviewGroup[];
+    context: ContextInput;
+    additionalBudgetMessages?: readonly ChatMessage[];
+}>): CapabilityBriefProjection;
+/** Consumers explicitly remove this optional reference at narrower phases. */
+export declare function isCapabilityBriefMessage(message: ChatMessage): boolean;
+export {};