@abot-ai/runtime 1.3.1 → 1.4.0

package/dist/src/runtime/orchestration/role-calls/contracts.d.ts

@@ -6,6 +6,7 @@ import type { RoleCapabilitySelectionSupervisionStage, RoleCapabilitySelectionSu
 import type { RoleCapabilitySelectionReconsiderationCause } from "./reconsideration-cause.js";
 import type { RoleCallResultReceipt } from "./result-receipt.js";
 import type { RoleMemoryRecall, RoleMemoryRecallCommand, RoleMemoryRecallCommitEffect, RoleMemoryRecallTransactions } from "./memory-recall-contract.js";
+import type { AdoptedModelWorkPlan, UpdateModelWorkPlanCommand, ModelWorkPlanCommitEffect, ModelWorkPlanTransactions } from "./work-plan-contracts.js";
 export declare const ROLE_CALL_LEDGER_CONTRACT_VERSION = 18;
 export declare const ROLE_CALL_LEDGER_HEAD_KIND: "runtime_role_call_ledger_v18";
 export declare const ROLE_CALL_OBJECTIVE_MAX_LENGTH = 8192;
@@ -36,6 +37,8 @@ export type ExecutionPolicyAuthoritySnapshot = Readonly<{
     capabilityAuthorities: readonly ExecutionPolicyCapabilityAuthority[];
     /** Omission preserves the legacy normalized terminal-text contract. */
     terminalTextMode?: RoleCallTerminalTextMode;
+    /** Omission denies model-reported plan declarations. */
+    modelWorkPlanAuthority?: "root";
 }>;
 export declare const SUPERVISOR_WORKER_V1_AUTHORITY_SNAPSHOT: ExecutionPolicyAuthoritySnapshot;
 export type RoleCallPolicy = Readonly<{
@@ -90,6 +93,7 @@ export type RoleCallFrame = Readonly<{
     resultRef: string | null;
     /** Omitted unless the immediately preceding activation reconsidered a selection. */
     lastCapabilitySelectionReconsideration?: RoleCapabilitySelectionReconsideration;
+    adoptedWorkPlan?: AdoptedModelWorkPlan;
 }>;
 export type RoleCallResult = Readonly<{
     resultRef: string;
@@ -298,8 +302,8 @@ export type ReconsiderRoleCapabilitySelectionCommand = Readonly<{
     selection: RoleCapabilitySelectionProjection;
     cause: RoleCapabilitySelectionReconsiderationCause;
 }>;
-export type RoleCallLedgerCommand = RoleMemoryRecallCommand | CreateRootRoleCallCommand | CompleteRootResponseCommand | OpenChildRoleCallCommand | ReturnChildRoleCallCommand | BeginRoleCapabilityExecutionCommand | SettleRoleCapabilityExecutionCommand | BeginRoleCapabilityBatchCommand | SettleRoleCapabilityBatchCommand | UpdateRoleCapabilityScopeCommand | EstablishRoleCallWorkingDirectoryCommand | ReconsiderRoleCapabilitySelectionCommand;
-export type RoleCallCommitEffect = RoleMemoryRecallCommitEffect | Readonly<{
+export type RoleCallLedgerCommand = UpdateModelWorkPlanCommand | RoleMemoryRecallCommand | CreateRootRoleCallCommand | CompleteRootResponseCommand | OpenChildRoleCallCommand | ReturnChildRoleCallCommand | BeginRoleCapabilityExecutionCommand | SettleRoleCapabilityExecutionCommand | BeginRoleCapabilityBatchCommand | SettleRoleCapabilityBatchCommand | UpdateRoleCapabilityScopeCommand | EstablishRoleCallWorkingDirectoryCommand | ReconsiderRoleCapabilitySelectionCommand;
+export type RoleCallCommitEffect = ModelWorkPlanCommitEffect | RoleMemoryRecallCommitEffect | Readonly<{
     type: "root_created";
     callId: string;
 }> | Readonly<{
@@ -366,7 +370,7 @@ export type RoleCallValidationIssue = Readonly<{
     code: string;
     path: string;
 }>;
-export type RoleCallTransitionRejectionCode = "invalid_current_state" | "invalid_policy" | "invalid_command" | "root_already_created" | "root_missing" | "caller_not_active" | "root_response_not_allowed" | "supervisor_child_forbidden" | "child_role_not_authorized" | "child_dependency_invalid" | "planner_plan_binding_invalid" | "planner_plan_already_declared" | "planner_plan_missing" | "planner_plan_item_unavailable" | "planner_plan_incomplete" | "depth_limit_exceeded" | "call_limit_exceeded" | "child_return_mismatch" | "capability_caller_invalid" | "capability_invocation_mismatch" | "capability_execution_limit_exceeded" | "capability_execution_mismatch" | "capability_scope_update_invalid" | "working_directory_establishment_invalid" | "capability_selection_reconsideration_invalid" | "capability_selection_supervision_limit_exceeded" | "operation_supervision_limit_exceeded" | "memory_recall_caller_invalid" | "memory_recall_invocation_mismatch" | "memory_recall_settlement_mismatch" | "role_activation_limit_exceeded";
+export type RoleCallTransitionRejectionCode = "invalid_current_state" | "invalid_policy" | "invalid_command" | "root_already_created" | "root_missing" | "caller_not_active" | "root_response_not_allowed" | "supervisor_child_forbidden" | "child_role_not_authorized" | "child_dependency_invalid" | "planner_plan_binding_invalid" | "planner_plan_already_declared" | "planner_plan_missing" | "planner_plan_item_unavailable" | "planner_plan_incomplete" | "depth_limit_exceeded" | "call_limit_exceeded" | "child_return_mismatch" | "capability_caller_invalid" | "capability_invocation_mismatch" | "capability_execution_limit_exceeded" | "capability_execution_mismatch" | "capability_scope_update_invalid" | "working_directory_establishment_invalid" | "model_work_plan_update_invalid" | "capability_selection_reconsideration_invalid" | "capability_selection_supervision_limit_exceeded" | "operation_supervision_limit_exceeded" | "memory_recall_caller_invalid" | "memory_recall_invocation_mismatch" | "memory_recall_settlement_mismatch" | "role_activation_limit_exceeded";
 export type RoleCallTransitionResult = Readonly<{
     ok: true;
     state: RoleCallState;
@@ -435,7 +439,7 @@ export type RoleCallTransactionFailure<TTransitionIssueCode extends string> = Re
     commit: RoleCallLedgerCommitResult;
 }>;
 export type RoleCallTransactionResult<TEffectType extends RoleCallCommitEffect["type"], TTransitionIssueCode extends string> = RoleCallTransactionSuccess<TEffectType> | RoleCallTransactionFailure<TTransitionIssueCode>;
-export type RoleCallTransactions = RoleMemoryRecallTransactions & Readonly<{
+export type RoleCallTransactions = RoleMemoryRecallTransactions & ModelWorkPlanTransactions & Readonly<{
     createRoot(input: Readonly<{
         expectedHead: unknown;
     }>): Promise<RoleCallTransactionResult<"root_created", "root_create_transition_invalid">>;

package/dist/src/runtime/orchestration/role-calls/transactions.js

@@ -1,7 +1,9 @@
 import { createMemoryRecallTransactions } from "./memory-recall-transactions.js";
+import { createModelWorkPlanTransactions } from "./work-plan-transactions.js";
 import { requireEffect, invalidEffect } from "./transaction-effect.js";
 export function createRoleCallTransactions(apply) {
     return Object.freeze({
+        ...createModelWorkPlanTransactions(apply),
         ...createMemoryRecallTransactions(apply),
         async createRoot(input) {
             return requireEffect(await apply({

package/dist/src/runtime/orchestration/role-calls/work-plan-contracts.d.ts

@@ -0,0 +1,48 @@
+import type { RoleCallTransactionInput, RoleCallTransactionResult } from "./contracts.js";
+export declare const MODEL_WORK_PLAN_ITEM_LIMIT = 16;
+export declare const MODEL_WORK_PLAN_TEXT_LIMIT = 8192;
+export declare const MODEL_WORK_PLAN_ID_LIMIT = 128;
+export declare const MODEL_WORK_PLAN_STATUSES: readonly ["pending", "in_progress", "done", "blocked"];
+export type ModelWorkPlanStatus = (typeof MODEL_WORK_PLAN_STATUSES)[number];
+export type ModelWorkPlanItemUpdate = Readonly<{
+    itemId: string;
+    status: ModelWorkPlanStatus;
+}>;
+export type ModelWorkPlanDefinition = Readonly<{
+    summary: string;
+    items: readonly Readonly<{
+        itemId: string;
+        title: string;
+        objective: string;
+    }>[];
+}>;
+/** A root model's report, never execution evidence or terminal authority. */
+export type AdoptedModelWorkPlan = Readonly<{
+    sourceResultRef: string;
+    definition: ModelWorkPlanDefinition;
+    itemStates: readonly ModelWorkPlanItemUpdate[];
+}>;
+export type ModelWorkPlanUpdate = Readonly<{
+    mode: "adopt";
+    sourceResultRef: string;
+    definition: ModelWorkPlanDefinition;
+    itemUpdates: readonly ModelWorkPlanItemUpdate[];
+}> | Readonly<{
+    mode: "progress";
+    sourceResultRef: string;
+    itemUpdates: readonly ModelWorkPlanItemUpdate[];
+}>;
+export type UpdateModelWorkPlanCommand = Readonly<{
+    authority: "active_role";
+    type: "update_model_work_plan";
+    callId: string;
+    invocationAttempt: number;
+    update: ModelWorkPlanUpdate;
+}>;
+export type ModelWorkPlanCommitEffect = Readonly<{
+    type: "model_work_plan_updated";
+    callId: string;
+}>;
+export type ModelWorkPlanTransactions = Readonly<{
+    updateModelWorkPlan(input: RoleCallTransactionInput<UpdateModelWorkPlanCommand>): Promise<RoleCallTransactionResult<"model_work_plan_updated", "model_work_plan_transition_invalid">>;
+}>;

package/dist/src/runtime/orchestration/role-calls/work-plan-contracts.js

@@ -0,0 +1,9 @@
+export const MODEL_WORK_PLAN_ITEM_LIMIT = 16;
+export const MODEL_WORK_PLAN_TEXT_LIMIT = 8_192;
+export const MODEL_WORK_PLAN_ID_LIMIT = 128;
+export const MODEL_WORK_PLAN_STATUSES = [
+    "pending",
+    "in_progress",
+    "done",
+    "blocked",
+];

package/dist/src/runtime/orchestration/role-calls/work-plan-source.d.ts

@@ -0,0 +1,7 @@
+import type { RoleCallFrame, RoleCallPolicy, RoleCallState } from "./contracts.js";
+import type { ModelWorkPlanDefinition } from "./work-plan-contracts.js";
+export declare function ownsModelWorkPlanSource(state: RoleCallState, call: RoleCallFrame, sourceResultRef: string): boolean;
+/** Derive the exact adoptable definition from the sole canonical result ledger. */
+export declare function resolveModelWorkPlanSourceDefinition(state: RoleCallState, call: RoleCallFrame, sourceResultRef: string, policy: RoleCallPolicy): ModelWorkPlanDefinition | undefined;
+/** Object key order is irrelevant; proposed item order and all semantic fields are exact. */
+export declare function areModelWorkPlanDefinitionsEqual(definition: ModelWorkPlanDefinition, source: ModelWorkPlanDefinition): boolean;

package/dist/src/runtime/orchestration/role-calls/work-plan-source.js

@@ -0,0 +1,85 @@
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+import { EXECUTION_AGENT_PLANNER_GRAPH_LIMITS } from "../../steps/planner-graph/contracts.js";
+import { parsePlannerGraphOutput } from "../../steps/planner-graph/parser.js";
+export function ownsModelWorkPlanSource(state, call, sourceResultRef) {
+    const source = state.results.find((result) => result.resultRef === sourceResultRef);
+    if (!source || source.outcome !== "completed")
+        return false;
+    const producer = state.calls.find((candidate) => candidate.callId === source.producerCallId);
+    if (!producer || producer.status !== "completed")
+        return false;
+    if (producer.parentCallId !== call.callId)
+        return false;
+    if (producer.resultRef !== source.resultRef)
+        return false;
+    return call.childCallIds.includes(producer.callId);
+}
+/** Derive the exact adoptable definition from the sole canonical result ledger. */
+export function resolveModelWorkPlanSourceDefinition(state, call, sourceResultRef, policy) {
+    if (policy.authority.modelWorkPlanAuthority !== "root")
+        return undefined;
+    if (state.rootCallId !== call.callId || call.parentCallId !== null)
+        return undefined;
+    if (!ownsModelWorkPlanSource(state, call, sourceResultRef))
+        return undefined;
+    const result = state.results.find((entry) => entry.resultRef === sourceResultRef);
+    if (result.roleId !== "planner")
+        return undefined;
+    let advisory;
+    try {
+        advisory = JSON.parse(result.summary);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isOwnedPlannerProposalAdvisory(advisory, result.producerCallId))
+        return undefined;
+    const parsed = parsePlannerGraphOutput(JSON.stringify({ decision: advisory.proposal }), EXECUTION_AGENT_PLANNER_GRAPH_LIMITS);
+    if (!parsed.ok || parsed.decision.outcome !== "proposal")
+        return undefined;
+    return {
+        summary: parsed.decision.proposal.summary,
+        items: parsed.decision.proposal.nodes.map((node) => ({
+            itemId: node.localId,
+            title: node.title,
+            objective: node.objective,
+        })),
+    };
+}
+function isOwnedPlannerProposalAdvisory(advisory, producerCallId) {
+    if (!isRecord(advisory))
+        return false;
+    if (!exactKeys(advisory, [
+        "kind",
+        "authority",
+        "presenceEffect",
+        "plannerCallId",
+        "outcome",
+        "proposal",
+    ]))
+        return false;
+    if (advisory.kind !== "runtime_execution_agent_planner_advisory_v1")
+        return false;
+    if (advisory.authority !== "model_advisory")
+        return false;
+    if (advisory.presenceEffect !== "passive_result_not_execution_or_completion")
+        return false;
+    if (advisory.plannerCallId !== producerCallId)
+        return false;
+    return advisory.outcome === "proposal";
+}
+/** Object key order is irrelevant; proposed item order and all semantic fields are exact. */
+export function areModelWorkPlanDefinitionsEqual(definition, source) {
+    if (definition.summary !== source.summary)
+        return false;
+    if (definition.items.length !== source.items.length)
+        return false;
+    return definition.items.every((item, index) => isSameModelWorkPlanItemDefinition(item, source.items[index]));
+}
+function isSameModelWorkPlanItemDefinition(item, source) {
+    if (item.itemId !== source.itemId)
+        return false;
+    if (item.title !== source.title)
+        return false;
+    return item.objective === source.objective;
+}

package/dist/src/runtime/orchestration/role-calls/work-plan-transactions.d.ts

@@ -0,0 +1,3 @@
+import type { RoleCallLedger } from "./contracts.js";
+import type { ModelWorkPlanTransactions } from "./work-plan-contracts.js";
+export declare function createModelWorkPlanTransactions(apply: RoleCallLedger["apply"]): ModelWorkPlanTransactions;

package/dist/src/runtime/orchestration/role-calls/work-plan-transactions.js

@@ -0,0 +1,17 @@
+import { requireEffect } from "./transaction-effect.js";
+export function createModelWorkPlanTransactions(apply) {
+    return Object.freeze({
+        async updateModelWorkPlan(input) {
+            return requireEffect(await apply({
+                expectedHead: input.expectedHead,
+                command: {
+                    authority: "active_role",
+                    type: "update_model_work_plan",
+                    callId: input.callId,
+                    invocationAttempt: input.invocationAttempt,
+                    update: input.update,
+                },
+            }), "model_work_plan_updated", "model_work_plan_transition_invalid", (effect) => effect.callId === input.callId);
+        },
+    });
+}

package/dist/src/runtime/orchestration/role-calls/work-plan-validation.d.ts

@@ -0,0 +1,10 @@
+import type { DecodedRoleCallCommand } from "./command-decoder.js";
+import type { RoleCallFrame, RoleCallPolicy, RoleCallState } from "./contracts.js";
+import { type ModelWorkPlanDefinition, type ModelWorkPlanItemUpdate, type ModelWorkPlanUpdate } from "./work-plan-contracts.js";
+export declare function isModelWorkPlanText(value: unknown, limit?: number): value is string;
+export declare function parseModelWorkPlanItemUpdates(value: unknown): readonly ModelWorkPlanItemUpdate[] | undefined;
+export declare function parseModelWorkPlanDefinition(value: unknown): ModelWorkPlanDefinition | undefined;
+export declare function parseModelWorkPlanUpdate(value: unknown): ModelWorkPlanUpdate | undefined;
+export declare function decodeModelWorkPlanCommand(input: Record<string, unknown>): DecodedRoleCallCommand;
+export declare function updatesNameKnownItems(definition: ModelWorkPlanDefinition, updates: readonly ModelWorkPlanItemUpdate[]): boolean;
+export declare function isValidAdoptedModelWorkPlan(state: RoleCallState, call: RoleCallFrame, policy: RoleCallPolicy): boolean;

package/dist/src/runtime/orchestration/role-calls/work-plan-validation.js

@@ -0,0 +1,149 @@
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+import { areModelWorkPlanDefinitionsEqual, resolveModelWorkPlanSourceDefinition, } from "./work-plan-source.js";
+import { MODEL_WORK_PLAN_ID_LIMIT, MODEL_WORK_PLAN_ITEM_LIMIT, MODEL_WORK_PLAN_STATUSES, MODEL_WORK_PLAN_TEXT_LIMIT, } from "./work-plan-contracts.js";
+export function isModelWorkPlanText(value, limit = MODEL_WORK_PLAN_TEXT_LIMIT) {
+    return (typeof value === "string" &&
+        value.trim().length > 0 &&
+        value.length <= limit);
+}
+export function parseModelWorkPlanItemUpdates(value) {
+    if (!Array.isArray(value) || value.length > MODEL_WORK_PLAN_ITEM_LIMIT)
+        return undefined;
+    const updates = [];
+    const ids = new Set();
+    for (const entry of value) {
+        if (!isRecord(entry) || !exactKeys(entry, ["itemId", "status"]))
+            return undefined;
+        if (!isModelWorkPlanText(entry.itemId, MODEL_WORK_PLAN_ID_LIMIT))
+            return undefined;
+        if (!MODEL_WORK_PLAN_STATUSES.includes(entry.status))
+            return undefined;
+        if (ids.has(entry.itemId))
+            return undefined;
+        ids.add(entry.itemId);
+        updates.push({
+            itemId: entry.itemId,
+            status: entry.status,
+        });
+    }
+    return updates;
+}
+export function parseModelWorkPlanDefinition(value) {
+    if (!isRecord(value) || !exactKeys(value, ["summary", "items"]))
+        return undefined;
+    if (!isModelWorkPlanText(value.summary) || !Array.isArray(value.items))
+        return undefined;
+    if (value.items.length === 0 ||
+        value.items.length > MODEL_WORK_PLAN_ITEM_LIMIT)
+        return undefined;
+    const items = [];
+    const ids = new Set();
+    for (const item of value.items) {
+        if (!isRecord(item) || !exactKeys(item, ["itemId", "title", "objective"]))
+            return undefined;
+        if (!isModelWorkPlanText(item.itemId, MODEL_WORK_PLAN_ID_LIMIT))
+            return undefined;
+        if (!isModelWorkPlanText(item.title) ||
+            !isModelWorkPlanText(item.objective))
+            return undefined;
+        if (ids.has(item.itemId))
+            return undefined;
+        ids.add(item.itemId);
+        items.push({
+            itemId: item.itemId,
+            title: item.title,
+            objective: item.objective,
+        });
+    }
+    return { summary: value.summary, items };
+}
+export function parseModelWorkPlanUpdate(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (!isModelWorkPlanText(value.sourceResultRef, 256))
+        return undefined;
+    const itemUpdates = parseModelWorkPlanItemUpdates(value.itemUpdates);
+    if (!itemUpdates)
+        return undefined;
+    if (value.mode === "progress") {
+        if (!exactKeys(value, ["mode", "sourceResultRef", "itemUpdates"]) ||
+            itemUpdates.length === 0)
+            return undefined;
+        return {
+            mode: "progress",
+            sourceResultRef: value.sourceResultRef,
+            itemUpdates,
+        };
+    }
+    if (value.mode !== "adopt")
+        return undefined;
+    if (!exactKeys(value, ["mode", "sourceResultRef", "definition", "itemUpdates"]))
+        return undefined;
+    const definition = parseModelWorkPlanDefinition(value.definition);
+    if (!definition || !updatesNameKnownItems(definition, itemUpdates))
+        return undefined;
+    return {
+        mode: "adopt",
+        sourceResultRef: value.sourceResultRef,
+        definition,
+        itemUpdates,
+    };
+}
+export function decodeModelWorkPlanCommand(input) {
+    const invalid = { ok: false, code: "invalid_command" };
+    if (!exactKeys(input, [
+        "authority",
+        "type",
+        "callId",
+        "invocationAttempt",
+        "update",
+    ]))
+        return invalid;
+    if (input.authority !== "active_role" ||
+        !isModelWorkPlanText(input.callId, 256))
+        return invalid;
+    if (!Number.isSafeInteger(input.invocationAttempt) ||
+        input.invocationAttempt < 1)
+        return invalid;
+    const update = parseModelWorkPlanUpdate(input.update);
+    if (!update)
+        return invalid;
+    return {
+        ok: true,
+        value: {
+            authority: "active_role",
+            type: "update_model_work_plan",
+            callId: input.callId,
+            invocationAttempt: input.invocationAttempt,
+            update,
+        },
+    };
+}
+export function updatesNameKnownItems(definition, updates) {
+    const ids = new Set(definition.items.map((item) => item.itemId));
+    return updates.every((update) => ids.has(update.itemId));
+}
+export function isValidAdoptedModelWorkPlan(state, call, policy) {
+    const plan = call.adoptedWorkPlan;
+    if (plan === undefined)
+        return true;
+    if (policy.authority.modelWorkPlanAuthority !== "root")
+        return false;
+    if (call.callId !== state.rootCallId || call.parentCallId !== null)
+        return false;
+    if (!isRecord(plan) ||
+        !exactKeys(plan, ["sourceResultRef", "definition", "itemStates"]))
+        return false;
+    if (!isModelWorkPlanText(plan.sourceResultRef, 256))
+        return false;
+    const source = resolveModelWorkPlanSourceDefinition(state, call, plan.sourceResultRef, policy);
+    if (!source)
+        return false;
+    const definition = parseModelWorkPlanDefinition(plan.definition);
+    const states = parseModelWorkPlanItemUpdates(plan.itemStates);
+    if (!definition || !states || definition.items.length !== states.length)
+        return false;
+    if (!areModelWorkPlanDefinitionsEqual(definition, source))
+        return false;
+    return updatesNameKnownItems(definition, states);
+}

package/dist/src/runtime/orchestration/worker-capabilities/contracts.d.ts

@@ -7,7 +7,7 @@ export declare const WORKER_CAPABILITY_INTENT_MAX_LENGTH = 500;
 /** Immutable Worker-only assignment for authoring one capability payload. */
 export declare const WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH = 8192;
 export declare const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
-export declare const WORKER_CAPABILITY_COUNT_MAX = 64;
+export declare const WORKER_CAPABILITY_COUNT_MAX = 128;
 export declare const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export declare const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
 export declare const WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH = 4096;

package/dist/src/runtime/orchestration/worker-capabilities/contracts.js

@@ -5,7 +5,7 @@ export const WORKER_CAPABILITY_INTENT_MAX_LENGTH = 500;
 /** Immutable Worker-only assignment for authoring one capability payload. */
 export const WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH = ROLE_CALL_OBJECTIVE_MAX_LENGTH;
 export const WORKER_CAPABILITY_SUMMARY_MAX_LENGTH = 512;
-export const WORKER_CAPABILITY_COUNT_MAX = 64;
+export const WORKER_CAPABILITY_COUNT_MAX = 128;
 export const WORKER_CAPABILITY_CONTROL_COUNT_MAX = 16;
 export const WORKER_CAPABILITY_CONTROL_ID_MAX_LENGTH = 64;
 export const WORKER_CAPABILITY_CONTROL_STRING_MAX_LENGTH = 4_096;

package/dist/src/runtime/plugins/compiled-catalog.d.ts

@@ -1,10 +1,11 @@
-import type { CanonicalToolDefinitionDeclaration, ToolCallAdapter, ToolImplementation } from "../../capabilities/tool-types.js";
+import type { CanonicalToolDefinitionDeclaration, ToolCallAdapter, ToolImplementation, ToolModuleRequestPreparation } from "../../capabilities/tool-types.js";
 import type { ToolNormalInvocationContract } from "../../capabilities/normal-invocation/contracts.js";
 export type CompiledPluginCapability = Readonly<{
     definition: CanonicalToolDefinitionDeclaration;
     normalInvocation: ToolNormalInvocationContract;
     execute: ToolImplementation;
     adapter?: ToolCallAdapter;
+    prepareRequest?: ToolModuleRequestPreparation;
 }>;
 export type CompiledRuntimePlugin = Readonly<{
     id: string;

package/dist/src/runtime/plugins/configured-manifests.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredAgentPluginManifest } from "./discovered-manifest.js";
+import { type AgentPluginManifestDiscoveryOptions } from "./manifest-discovery.js";
+export declare function discoverConfiguredRuntimePluginManifests(consumerRoot: string, options?: AgentPluginManifestDiscoveryOptions): readonly DiscoveredAgentPluginManifest[];

package/dist/src/runtime/plugins/configured-manifests.js

@@ -0,0 +1,37 @@
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { discoverAgentPluginManifests, } from "./manifest-discovery.js";
+import { resolveBundledRuntimeRoot } from "./bundled-root.js";
+function canonicalPluginDiscoveryRoot(rootDir) {
+    const absoluteRoot = resolve(rootDir);
+    try {
+        return realpathSync(absoluteRoot);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+        return absoluteRoot;
+    }
+}
+function assertUniquePluginManifestIds(plugins) {
+    const manifestPathsByPluginId = new Map();
+    for (const plugin of plugins) {
+        const pluginId = plugin.manifest.name;
+        const previousManifestPath = manifestPathsByPluginId.get(pluginId);
+        if (previousManifestPath) {
+            throw new Error(`Duplicate runtime plugin id: ${pluginId}; manifests: ${previousManifestPath}, ${plugin.manifestPath}`);
+        }
+        manifestPathsByPluginId.set(pluginId, plugin.manifestPath);
+    }
+}
+export function discoverConfiguredRuntimePluginManifests(consumerRoot, options = {}) {
+    const bundledRoot = resolveBundledRuntimeRoot();
+    const roots = canonicalPluginDiscoveryRoot(bundledRoot) ===
+        canonicalPluginDiscoveryRoot(consumerRoot)
+        ? [consumerRoot]
+        : [bundledRoot, consumerRoot];
+    const plugins = roots.flatMap((rootDir) => discoverAgentPluginManifests(rootDir, options));
+    assertUniquePluginManifestIds(plugins);
+    return Object.freeze(plugins);
+}

package/dist/src/runtime/plugins/entrypoint-validation.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimePluginEntrypoint } from "../../plugin-contract/entrypoint.js";
+export declare function validateManifestEntrypoint(params: {
+    pluginId: string;
+    expectedCapabilityIds: readonly string[];
+    raw: unknown;
+}): RuntimePluginEntrypoint;

package/dist/src/runtime/plugins/entrypoint-validation.js

@@ -0,0 +1,74 @@
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function validateManifestEntrypoint(params) {
+    if (!isRecord(params.raw) || !isRecord(params.raw.handlers)) {
+        throw new Error(`Runtime plugin ${params.pluginId} entrypoint must export handlers`);
+    }
+    const unsupported = Object.keys(params.raw).find((key) => !["handlers", "adapters", "prepareRequest"].includes(key));
+    if (unsupported) {
+        throw new Error(`Runtime plugin ${params.pluginId} entrypoint contains unsupported field ${unsupported}`);
+    }
+    const handlers = validateEntrypointHandlers(params.pluginId, params.expectedCapabilityIds, params.raw.handlers);
+    const adapters = validateEntrypointAdapters(params.pluginId, params.expectedCapabilityIds, params.raw.adapters);
+    const prepareRequest = params.raw.prepareRequest;
+    if (!isOptionalEntrypointFunction(prepareRequest)) {
+        throw new Error(`Runtime plugin ${params.pluginId} prepareRequest must be a function`);
+    }
+    return {
+        handlers,
+        ...(prepareRequest
+            ? {
+                prepareRequest: prepareRequest,
+            }
+            : {}),
+        ...(Object.keys(adapters).length > 0 ? { adapters } : {}),
+    };
+}
+function validateEntrypointHandlers(pluginId, expectedCapabilityIds, raw) {
+    const handlers = {};
+    for (const [capabilityId, handler] of Object.entries(raw)) {
+        if (typeof handler !== "function") {
+            throw new Error(`Runtime plugin ${pluginId} handler ${capabilityId} must be a function`);
+        }
+        handlers[capabilityId] = handler;
+    }
+    const expected = new Set(expectedCapabilityIds);
+    const missing = expectedCapabilityIds.filter((id) => !handlers[id]);
+    const unexpected = Object.keys(handlers).filter((id) => !expected.has(id));
+    if (missing.length > 0 || unexpected.length > 0) {
+        throw new Error(`Runtime plugin ${pluginId} handler mismatch: missing=${missing.join(",") || "none"}; unexpected=${unexpected.join(",") || "none"}`);
+    }
+    return handlers;
+}
+function validateEntrypointAdapters(pluginId, expectedCapabilityIds, raw) {
+    if (raw === undefined)
+        return {};
+    if (!isRecord(raw)) {
+        throw new Error(`Runtime plugin ${pluginId} entrypoint adapters must be an object`);
+    }
+    const adapters = {};
+    for (const [capabilityId, adapter] of Object.entries(raw)) {
+        if (!expectedCapabilityIds.includes(capabilityId)) {
+            throw new Error(`Runtime plugin ${pluginId} adapter ${capabilityId} has no declared capability`);
+        }
+        adapters[capabilityId] = validateEntrypointAdapter(pluginId, capabilityId, adapter);
+    }
+    return adapters;
+}
+function validateEntrypointAdapter(pluginId, capabilityId, raw) {
+    const label = `Runtime plugin ${pluginId} adapter ${capabilityId}`;
+    if (!isRecord(raw))
+        throw new Error(`${label} must be an object`);
+    const fields = ["normalizeCall", "validateCall", "executionBinding"];
+    const unsupported = Object.keys(raw).find((key) => !fields.includes(key));
+    if (unsupported)
+        throw new Error(`${label} contains unsupported field ${unsupported}`);
+    const invalidFunction = fields.find((key) => !isOptionalEntrypointFunction(raw[key]));
+    if (invalidFunction)
+        throw new Error(`${label}.${invalidFunction} must be a function`);
+    return raw;
+}
+function isOptionalEntrypointFunction(value) {
+    return value === undefined || typeof value === "function";
+}