@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,167 @@
+import { executionProtocolError } from "./errors.js";
+import { boundedSummary, captureRegisteredToolResult, projectMutationGrounding, projectObservationOutput, projectToolTargetReferences, summarizeCompletedMutation, validateToolExecutionResult, } from "./result-evidence.js";
+import { isPlainRecord, nonEmpty, safeIssueCode } from "./values.js";
+export function observeExternalResult(input, expectedEffect, directRoot) {
+    const observed = observeExternalResultLegacy(input, expectedEffect, directRoot);
+    return Object.freeze({
+        ...observed,
+        result: Object.freeze({
+            ...observed.result,
+            exactResult: captureRegisteredToolResult(input),
+        }),
+    });
+}
+function observeExternalResultLegacy(input, expectedEffect, directRoot) {
+    if (!isPlainRecord(input)) {
+        throw executionProtocolError("result_not_object");
+    }
+    if (input.status === "rejected") {
+        const sourceIssueCode = safeIssueCode(input.code);
+        if (!sourceIssueCode || !nonEmpty(input.message)) {
+            throw executionProtocolError("rejection_invalid");
+        }
+        return Object.freeze({
+            result: Object.freeze({
+                outcome: "failed",
+                observedEffect: "none",
+                summary: boundedSummary(input.message, directRoot),
+            }),
+            sourceIssueCode,
+        });
+    }
+    if (input.status !== "executed" || input.effect !== expectedEffect) {
+        throw executionProtocolError("effect_or_status_invalid");
+    }
+    const result = input.result;
+    validateToolExecutionResult(result);
+    const execution = result;
+    if (expectedEffect === "mixed") {
+        return observeMixedResult(execution, input.completionActions, directRoot);
+    }
+    if (expectedEffect === "mutating") {
+        return observeMutationResult(execution, input.completionActions, directRoot);
+    }
+    if (execution.ok) {
+        const output = nonEmpty(execution.output);
+        if (!output) {
+            return Object.freeze({
+                result: Object.freeze({
+                    outcome: "failed",
+                    observedEffect: "none",
+                    summary: "The observation capability returned no usable result.",
+                }),
+                sourceIssueCode: "observation_output_missing",
+            });
+        }
+        const references = projectToolTargetReferences(input.completionActions);
+        const observation = projectObservationOutput(output, directRoot);
+        return Object.freeze({
+            result: Object.freeze({
+                outcome: "succeeded",
+                observedEffect: "observation",
+                ...observation,
+                ...(references.length > 0 ? { references } : {}),
+            }),
+        });
+    }
+    return Object.freeze({
+        result: Object.freeze({
+            outcome: "failed",
+            observedEffect: execution.data?.currentStateEvidence === true ? "observation" : "none",
+            summary: boundedSummary(nonEmpty(execution.error) ??
+                nonEmpty(execution.output) ??
+                "The observation capability reported an execution failure.", directRoot),
+        }),
+        sourceIssueCode: safeIssueCode(execution.errorCode) ?? "tool_execution_failed",
+    });
+}
+function observeMixedResult(execution, completionActions, directRoot) {
+    const output = nonEmpty(execution.output);
+    if (execution.ok && execution.data?.mutationEvidence === true) {
+        const references = projectToolTargetReferences(completionActions);
+        const referenceData = projectMutationGrounding(execution.data?.mutationGrounding, directRoot);
+        return Object.freeze({
+            result: Object.freeze({
+                outcome: "succeeded",
+                observedEffect: "mutation",
+                summary: summarizeCompletedMutation(completionActions),
+                ...(referenceData ? { referenceData } : {}),
+                ...(references.length > 0 ? { references } : {}),
+            }),
+        });
+    }
+    if (execution.ok &&
+        (output ||
+            execution.data?.currentStateEvidence === true ||
+            execution.data?.stateAlreadySatisfied === true)) {
+        const observation = output
+            ? projectObservationOutput(output, directRoot)
+            : {
+                summary: "The capability confirmed the requested external state without a mutation.",
+            };
+        return Object.freeze({
+            result: Object.freeze({
+                outcome: "succeeded",
+                observedEffect: "observation",
+                ...observation,
+            }),
+        });
+    }
+    const observedEffect = execution.data?.mutationEvidence === true
+        ? "mutation"
+        : execution.data?.currentStateEvidence === true ||
+            execution.data?.stateAlreadySatisfied === true
+            ? "observation"
+            : "none";
+    return Object.freeze({
+        result: Object.freeze({
+            outcome: "failed",
+            observedEffect,
+            summary: boundedSummary(nonEmpty(execution.error) ??
+                output ??
+                (execution.ok
+                    ? "The mixed capability returned no usable observation or mutation evidence."
+                    : "The mixed capability reported an execution failure."), directRoot),
+        }),
+        sourceIssueCode: safeIssueCode(execution.errorCode) ??
+            (execution.ok
+                ? "mixed_effect_evidence_missing"
+                : "tool_execution_failed"),
+    });
+}
+function observeMutationResult(execution, completionActions, directRoot) {
+    const output = nonEmpty(execution.output);
+    if (execution.ok && execution.data?.mutationEvidence === true) {
+        const references = projectToolTargetReferences(completionActions);
+        const referenceData = projectMutationGrounding(execution.data?.mutationGrounding, directRoot);
+        return Object.freeze({
+            result: Object.freeze({
+                outcome: "succeeded",
+                observedEffect: "mutation",
+                summary: summarizeCompletedMutation(completionActions),
+                ...(referenceData ? { referenceData } : {}),
+                ...(references.length > 0 ? { references } : {}),
+            }),
+        });
+    }
+    const observedEffect = execution.data?.mutationEvidence === true
+        ? "mutation"
+        : execution.data?.currentStateEvidence === true ||
+            execution.data?.stateAlreadySatisfied === true
+            ? "observation"
+            : "none";
+    return Object.freeze({
+        result: Object.freeze({
+            outcome: "failed",
+            observedEffect,
+            summary: boundedSummary(nonEmpty(execution.error) ??
+                output ??
+                (execution.ok
+                    ? "The capability returned no explicit mutation evidence."
+                    : "The mutation capability reported an execution failure."), directRoot),
+        }),
+        sourceIssueCode: safeIssueCode(execution.errorCode) ??
+            (execution.ok ? "mutation_evidence_missing" : "tool_execution_failed"),
+    });
+}
+export { attachTargetReferences, boundedSummary, projectSelectedTargetReferences, requireCapabilityAdapterResult, } from "./result-evidence.js";

package/dist/src/runtime/adapters/registered-tool-worker-capabilities/runtime-path-controls.d.ts

@@ -0,0 +1,12 @@
+import type { ToolExecutionSharedState } from "../../../capabilities/tool-types.js";
+import { type WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+export declare function resolveEffectiveOperationTargetControls(params: Readonly<{
+    descriptor: WorkerCapabilityDescriptor;
+    controls: Readonly<Record<string, unknown>>;
+    runtimePathBindings: readonly Readonly<{
+        param: string;
+        default?: ".";
+    }>[];
+    workingDirectory?: string;
+    sharedState: ToolExecutionSharedState;
+}>): Readonly<Record<string, unknown>>;

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

@@ -0,0 +1,39 @@
+import { scopeRuntimeTargetPath } from "../../capabilities/runtime-target-path.js";
+import { validateWorkerCapabilityControls, } from "../../orchestration/worker-capabilities/index.js";
+import { executionProtocolError } from "./errors.js";
+import { safeIssueCode } from "./values.js";
+export function resolveEffectiveOperationTargetControls(params) {
+    if (params.runtimePathBindings.length === 0) {
+        return params.controls;
+    }
+    const effectiveEntries = params.runtimePathBindings.map((binding) => {
+        const rawTarget = params.controls[binding.param] ?? binding.default;
+        if (typeof rawTarget !== "string") {
+            throw executionProtocolError("operation_target_control_invalid");
+        }
+        try {
+            return [
+                binding.param,
+                scopeRuntimeTargetPath({
+                    rawPath: rawTarget,
+                    ...(params.workingDirectory
+                        ? { workingDirectory: params.workingDirectory }
+                        : {}),
+                    sharedState: params.sharedState,
+                }),
+            ];
+        }
+        catch (error) {
+            const issueCode = error instanceof TypeError ? safeIssueCode(error.message) : undefined;
+            throw executionProtocolError(issueCode ?? "operation_target_path_invalid");
+        }
+    });
+    const controls = validateWorkerCapabilityControls(params.descriptor.controls, Object.freeze({
+        ...params.controls,
+        ...Object.fromEntries(effectiveEntries),
+    }));
+    if (!controls.ok) {
+        throw executionProtocolError(`effective_${controls.issueCode}`);
+    }
+    return controls.value;
+}

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

@@ -0,0 +1,3 @@
+export declare function nonEmpty(input: unknown): string | undefined;
+export declare function safeIssueCode(input: unknown): string | undefined;
+export declare function isPlainRecord(input: unknown): input is Record<string, unknown>;

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

@@ -0,0 +1,21 @@
+export function nonEmpty(input) {
+    return typeof input === "string" && input.trim().length > 0
+        ? input.trim()
+        : undefined;
+}
+export function safeIssueCode(input) {
+    if (typeof input !== "string" ||
+        input.length === 0 ||
+        input.length > 128 ||
+        !/^[a-z][a-z0-9._:-]*$/u.test(input)) {
+        return undefined;
+    }
+    return input;
+}
+export function isPlainRecord(input) {
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(input);
+    return prototype === Object.prototype || prototype === null;
+}

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

@@ -0,0 +1,8 @@
+import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
+import type { RegisteredToolWorkerCapabilityProviderParams } from "./registered-tool-worker-capabilities/contracts.js";
+export type { RegisteredToolWorkerCapabilityProviderParams } from "./registered-tool-worker-capabilities/contracts.js";
+/**
+ * Lazily projects a closed request ToolRegistry snapshot into neutral Worker
+ * adapters. It contains no profile or request-routing policy.
+ */
+export declare function createRegisteredToolWorkerCapabilityProvider<TContext>(params: RegisteredToolWorkerCapabilityProviderParams): WorkerCapabilityAdapterProvider<TContext>;

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

@@ -0,0 +1,147 @@
+import { isRoleCapabilityId } from "../orchestration/role-calls/index.js";
+import { createRegisteredToolNormalInvocationExecutor } from "./registered-tool-normal-invocations.js";
+import { traceRegisteredToolWorkerCapabilityCatalogResolutionCompleted, traceRegisteredToolWorkerCapabilityCatalogResolutionRejected, traceRegisteredToolWorkerCapabilityCatalogResolutionStarted, traceRegisteredToolWorkerCapabilityGuidanceCompleted, traceRegisteredToolWorkerCapabilityGuidanceFailed, traceRegisteredToolWorkerCapabilityGuidanceStarted, traceRegisteredToolWorkerCapabilityResolutionCompleted, traceRegisteredToolWorkerCapabilityResolutionRejected, traceRegisteredToolWorkerCapabilityResolutionStarted, } from "./registered-tool-worker-capability-diagnostics.js";
+import { narrowRegistrations, prepareSharedState, resolveRegisteredToolCapabilityCatalog, } from "./registered-tool-worker-capabilities/catalog.js";
+import { RegisteredToolWorkerCapabilityCompositionError, normalizeResolutionError, } from "./registered-tool-worker-capabilities/errors.js";
+import { projectWorkerAdapters } from "./registered-tool-worker-capabilities/execution.js";
+/**
+ * Lazily projects a closed request ToolRegistry snapshot into neutral Worker
+ * adapters. It contains no profile or request-routing policy.
+ */
+export function createRegisteredToolWorkerCapabilityProvider(params) {
+    let diagnostic = Object.freeze({
+        requestId: params.requestId,
+        operationIds: Object.freeze([]),
+    });
+    let catalog;
+    let catalogFailure;
+    let catalogFailureCause;
+    let adapters;
+    let adapterFailure;
+    function resolveCatalog() {
+        if (catalog)
+            return catalog;
+        if (catalogFailure)
+            throw catalogFailure;
+        traceRegisteredToolWorkerCapabilityCatalogResolutionStarted(diagnostic);
+        try {
+            const registry = params.getRequestToolRegistry();
+            catalog = resolveRegisteredToolCapabilityCatalog(registry, params.payloadAuthor !== undefined);
+            diagnostic = Object.freeze({
+                requestId: params.requestId,
+                operationIds: catalog.operationIds,
+            });
+            traceRegisteredToolWorkerCapabilityCatalogResolutionCompleted(diagnostic, catalog.descriptors.length);
+            return catalog;
+        }
+        catch (error) {
+            catalogFailureCause = error;
+            catalogFailure = normalizeResolutionError(error);
+            traceRegisteredToolWorkerCapabilityCatalogResolutionRejected(diagnostic, {
+                issueCode: catalogFailure instanceof
+                    RegisteredToolWorkerCapabilityCompositionError
+                    ? catalogFailure.issueCode
+                    : "resolution_failed",
+                ...(catalogFailure instanceof
+                    RegisteredToolWorkerCapabilityCompositionError &&
+                    catalogFailure.operationId &&
+                    isRoleCapabilityId(catalogFailure.operationId)
+                    ? { operationId: catalogFailure.operationId }
+                    : {}),
+                error,
+            });
+            throw catalogFailure;
+        }
+    }
+    return Object.freeze({
+        getDescriptors() {
+            return resolveCatalog().descriptors;
+        },
+        async getExecutionGuidance(capabilityId) {
+            if (!isRoleCapabilityId(capabilityId)) {
+                throw new RegisteredToolWorkerCapabilityCompositionError("guidance_capability_id_invalid");
+            }
+            const selected = resolveCatalog().selected.find(({ operation }) => operation.operationId === capabilityId);
+            if (!selected) {
+                throw new RegisteredToolWorkerCapabilityCompositionError("guidance_capability_unavailable", capabilityId);
+            }
+            const toolName = selected.registration.toolName;
+            traceRegisteredToolWorkerCapabilityGuidanceStarted(diagnostic, capabilityId, toolName);
+            if (!params.loadActionSkillContext) {
+                traceRegisteredToolWorkerCapabilityGuidanceCompleted(diagnostic, capabilityId, toolName, 0);
+                return "";
+            }
+            try {
+                const context = await params.loadActionSkillContext(toolName);
+                const normalized = typeof context === "string" ? context.trim() : "";
+                traceRegisteredToolWorkerCapabilityGuidanceCompleted(diagnostic, capabilityId, toolName, normalized.length);
+                return normalized;
+            }
+            catch (error) {
+                traceRegisteredToolWorkerCapabilityGuidanceFailed(diagnostic, capabilityId, toolName, error);
+                throw error;
+            }
+        },
+        getAdapters() {
+            if (adapters)
+                return adapters;
+            if (adapterFailure)
+                throw adapterFailure;
+            traceRegisteredToolWorkerCapabilityResolutionStarted(diagnostic);
+            try {
+                const resolvedCatalog = resolveCatalog();
+                if (resolvedCatalog.selected.length === 0) {
+                    adapters = Object.freeze([]);
+                    traceRegisteredToolWorkerCapabilityResolutionCompleted(diagnostic, 0);
+                    return adapters;
+                }
+                const narrowedRegistrations = narrowRegistrations(resolvedCatalog.selected);
+                const sharedState = prepareSharedState(resolvedCatalog.registry, params.sessionId, params.requestContext);
+                const executor = createRegisteredToolNormalInvocationExecutor({
+                    registrations: narrowedRegistrations,
+                    toolRegistry: resolvedCatalog.registry,
+                    requestId: params.requestId,
+                    abortSignal: params.abortSignal,
+                    sharedState,
+                    toolPermissionMode: params.toolPermissionMode,
+                    ...(params.toolApprovalController
+                        ? { toolApprovalController: params.toolApprovalController }
+                        : {}),
+                    nextApprovalId: params.nextApprovalId,
+                    ...(params.onEvent ? { onEvent: params.onEvent } : {}),
+                });
+                adapters = projectWorkerAdapters({
+                    operationIds: resolvedCatalog.operationIds,
+                    descriptors: resolvedCatalog.descriptors,
+                    executor,
+                    sharedState,
+                    diagnostic,
+                    ...(params.payloadAuthor
+                        ? { payloadAuthor: params.payloadAuthor }
+                        : {}),
+                });
+                traceRegisteredToolWorkerCapabilityResolutionCompleted(diagnostic, adapters.length);
+                return adapters;
+            }
+            catch (error) {
+                adapterFailure = normalizeResolutionError(error);
+                traceRegisteredToolWorkerCapabilityResolutionRejected(diagnostic, {
+                    issueCode: adapterFailure instanceof
+                        RegisteredToolWorkerCapabilityCompositionError
+                        ? adapterFailure.issueCode
+                        : "resolution_failed",
+                    ...(adapterFailure instanceof
+                        RegisteredToolWorkerCapabilityCompositionError &&
+                        adapterFailure.operationId &&
+                        isRoleCapabilityId(adapterFailure.operationId)
+                        ? { operationId: adapterFailure.operationId }
+                        : {}),
+                    error: error === catalogFailure && catalogFailureCause !== undefined
+                        ? catalogFailureCause
+                        : error,
+                });
+                throw adapterFailure;
+            }
+        },
+    });
+}

package/dist/src/runtime/adapters/registered-tool-worker-capability-diagnostics.d.ts

@@ -0,0 +1,37 @@
+import type { RoleCallFrame } from "../orchestration/role-calls/index.js";
+import type { WorkerCapabilityAdapterResult } from "../orchestration/worker-capabilities/index.js";
+import type { ToolActionSummary } from "../../capabilities/tool-types.js";
+export type RegisteredToolWorkerCapabilityProviderDiagnostic = Readonly<{
+    requestId: string;
+    operationIds: readonly string[];
+}>;
+export declare function traceRegisteredToolWorkerCapabilityCatalogResolutionStarted(context: RegisteredToolWorkerCapabilityProviderDiagnostic): void;
+export declare function traceRegisteredToolWorkerCapabilityCatalogResolutionCompleted(context: RegisteredToolWorkerCapabilityProviderDiagnostic, descriptorCount: number): void;
+export declare function traceRegisteredToolWorkerCapabilityCatalogResolutionRejected(context: RegisteredToolWorkerCapabilityProviderDiagnostic, params: Readonly<{
+    issueCode: string;
+    operationId?: string;
+    error?: unknown;
+}>): void;
+export declare function traceRegisteredToolWorkerCapabilityResolutionStarted(context: RegisteredToolWorkerCapabilityProviderDiagnostic): void;
+export declare function traceRegisteredToolWorkerCapabilityResolutionCompleted(context: RegisteredToolWorkerCapabilityProviderDiagnostic, adapterCount: number): void;
+export declare function traceRegisteredToolWorkerCapabilityResolutionRejected(context: RegisteredToolWorkerCapabilityProviderDiagnostic, params: Readonly<{
+    issueCode: string;
+    operationId?: string;
+    error?: unknown;
+}>): void;
+export declare function traceRegisteredToolWorkerCapabilityGuidanceStarted(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, toolName: string): void;
+export declare function traceRegisteredToolWorkerCapabilityGuidanceCompleted(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, toolName: string, contextLength: number): void;
+export declare function traceRegisteredToolWorkerCapabilityGuidanceFailed(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, toolName: string, error: unknown): void;
+export declare function traceRegisteredToolWorkerCapabilityExecutionStarted(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, call: RoleCallFrame, executionId: string, intentLength: number, controlCount: number): void;
+export declare function traceRegisteredToolWorkerCapabilityPayloadStageMaterialized(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, call: RoleCallFrame, executionId: string, details: Readonly<{
+    payloadStage: number;
+    payloadStageCount: number;
+    source: "manifest_literal";
+    byteCount: number;
+}>): void;
+export declare function traceRegisteredToolWorkerCapabilityExecutionCompleted(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, call: RoleCallFrame, executionId: string, result: WorkerCapabilityAdapterResult, sourceStatus: "executed" | "rejected", details: Readonly<{
+    sourceIssueCode?: string;
+    summaryProjection: "logical_completion_actions" | "mutation_evidence_only" | "bounded_external_result" | "runtime_rejection";
+    completionActions: readonly ToolActionSummary[];
+}>): void;
+export declare function traceRegisteredToolWorkerCapabilityExecutionFailed(context: RegisteredToolWorkerCapabilityProviderDiagnostic, operationId: string, call: RoleCallFrame, executionId: string, error: unknown, protocolIssueCode: string): void;

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

@@ -0,0 +1,133 @@
+import { traceDebug } from "../observability/debug-logger.js";
+import { classifyRuntimeErrorType } from "../observability/error-type.js";
+const LOG_SCOPE = "runtime.registered_tool_worker_capabilities";
+export function traceRegisteredToolWorkerCapabilityCatalogResolutionStarted(context) {
+    traceDebug(LOG_SCOPE, "provider.catalog_resolution_started", {
+        ...projectProvider(context),
+    });
+}
+export function traceRegisteredToolWorkerCapabilityCatalogResolutionCompleted(context, descriptorCount) {
+    traceDebug(LOG_SCOPE, "provider.catalog_resolution_completed", {
+        ...projectProvider(context),
+        descriptorCount,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityCatalogResolutionRejected(context, params) {
+    traceDebug(LOG_SCOPE, "provider.catalog_resolution_rejected", {
+        ...projectProvider(context),
+        issueCode: params.issueCode,
+        ...(params.operationId ? { operationId: params.operationId } : {}),
+        ...(params.error === undefined
+            ? {}
+            : { errorType: classifyRuntimeErrorType(params.error) }),
+    });
+}
+export function traceRegisteredToolWorkerCapabilityResolutionStarted(context) {
+    traceDebug(LOG_SCOPE, "provider.resolution_started", {
+        ...projectProvider(context),
+    });
+}
+export function traceRegisteredToolWorkerCapabilityResolutionCompleted(context, adapterCount) {
+    traceDebug(LOG_SCOPE, "provider.resolution_completed", {
+        ...projectProvider(context),
+        adapterCount,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityResolutionRejected(context, params) {
+    traceDebug(LOG_SCOPE, "provider.resolution_rejected", {
+        ...projectProvider(context),
+        issueCode: params.issueCode,
+        ...(params.operationId ? { operationId: params.operationId } : {}),
+        ...(params.error === undefined
+            ? {}
+            : { errorType: classifyRuntimeErrorType(params.error) }),
+    });
+}
+export function traceRegisteredToolWorkerCapabilityGuidanceStarted(context, operationId, toolName) {
+    traceDebug(LOG_SCOPE, "guidance.resolution_started", {
+        ...projectProvider(context),
+        operationId,
+        capabilityId: operationId,
+        toolName,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityGuidanceCompleted(context, operationId, toolName, contextLength) {
+    traceDebug(LOG_SCOPE, "guidance.resolution_completed", {
+        ...projectProvider(context),
+        operationId,
+        capabilityId: operationId,
+        toolName,
+        contextLength,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityGuidanceFailed(context, operationId, toolName, error) {
+    traceDebug(LOG_SCOPE, "guidance.resolution_failed", {
+        ...projectProvider(context),
+        operationId,
+        capabilityId: operationId,
+        toolName,
+        errorType: classifyRuntimeErrorType(error),
+    });
+}
+export function traceRegisteredToolWorkerCapabilityExecutionStarted(context, operationId, call, executionId, intentLength, controlCount) {
+    traceDebug(LOG_SCOPE, "adapter.execution_started", {
+        ...projectExecution(context, operationId, call, executionId),
+        intentLength,
+        controlCount,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityPayloadStageMaterialized(context, operationId, call, executionId, details) {
+    traceDebug(LOG_SCOPE, "adapter.payload_stage_materialized", {
+        ...projectExecution(context, operationId, call, executionId),
+        payloadStage: details.payloadStage,
+        payloadStageCount: details.payloadStageCount,
+        source: details.source,
+        byteCount: details.byteCount,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityExecutionCompleted(context, operationId, call, executionId, result, sourceStatus, details) {
+    const logicalTargetLengths = details.completionActions.flatMap((action) => action.target ? [action.target.length] : []);
+    traceDebug(LOG_SCOPE, "adapter.execution_completed", {
+        ...projectExecution(context, operationId, call, executionId),
+        sourceStatus,
+        ...(details.sourceIssueCode
+            ? { sourceIssueCode: details.sourceIssueCode }
+            : {}),
+        outcome: result.outcome,
+        observedEffect: result.observedEffect,
+        summaryLength: result.summary.length,
+        referenceDataLength: result.referenceData?.length ?? 0,
+        summaryProjection: details.summaryProjection,
+        completionActionCount: details.completionActions.length,
+        completionActionTypes: details.completionActions.map((action) => action.type),
+        logicalTargetCount: logicalTargetLengths.length,
+        logicalTargetLengths,
+    });
+}
+export function traceRegisteredToolWorkerCapabilityExecutionFailed(context, operationId, call, executionId, error, protocolIssueCode) {
+    traceDebug(LOG_SCOPE, "adapter.execution_failed", {
+        ...projectExecution(context, operationId, call, executionId),
+        protocolIssueCode,
+        errorType: classifyRuntimeErrorType(error),
+    });
+}
+function projectProvider(context) {
+    return {
+        requestId: context.requestId,
+        configuredOperationCount: context.operationIds.length,
+        operationIds: context.operationIds,
+    };
+}
+function projectExecution(context, operationId, call, executionId) {
+    return {
+        ...projectProvider(context),
+        operationId,
+        capabilityId: operationId,
+        callId: call.callId,
+        parentCallId: call.parentCallId,
+        roleId: call.roleId,
+        depth: call.depth,
+        invocationAttempt: call.activationCount,
+        executionId,
+    };
+}

package/dist/src/runtime/adapters/request-tool-model-invoker.d.ts

@@ -0,0 +1,4 @@
+import type { ToolModelInvoker } from "../../capabilities/tool-types.js";
+import type { BoundRequestModelInvocationContext } from "../request/contracts.js";
+/** Binds model-assisted tools to the current request's configured model boundary. */
+export declare function createRequestToolModelInvoker(request: BoundRequestModelInvocationContext): ToolModelInvoker;

package/dist/src/runtime/adapters/request-tool-model-invoker.js

@@ -0,0 +1,20 @@
+import { invokeRawModelStep } from "../model/invoke-raw-step.js";
+/** Binds model-assisted tools to the current request's configured model boundary. */
+export function createRequestToolModelInvoker(request) {
+    return Object.freeze({
+        invokeText(input) {
+            return invokeRawModelStep({
+                request,
+                modelStep: input.modelStep,
+                messages: [
+                    ...(input.instructions
+                        ? [{ role: "system", content: input.instructions }]
+                        : []),
+                    { role: "user", content: input.prompt },
+                ],
+                timeoutReason: input.timeoutReason,
+                ...(input.format ? { format: input.format } : {}),
+            });
+        },
+    });
+}

package/dist/src/runtime/adapters/source-workspace-provider.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceProvider } from "../ports.js";
+export type SourceWorkspaceProviderOptions = {
+    workspaceDir?: string;
+};
+export declare function createSourceWorkspaceProvider(options?: SourceWorkspaceProviderOptions): WorkspaceProvider;

package/dist/src/runtime/adapters/source-workspace-provider.js

@@ -0,0 +1,14 @@
+import { buildDeterministicWorkspaceConcat, readWorkspaceMarkdownFiles, } from "../../workspace/files.js";
+import { getDefaultWorkspaceSourceDir } from "../config/layout.js";
+export function createSourceWorkspaceProvider(options = {}) {
+    const workspaceDir = options.workspaceDir ?? getDefaultWorkspaceSourceDir(process.cwd());
+    async function loadWorkspaceSystemSummary() {
+        const files = await readWorkspaceMarkdownFiles(workspaceDir);
+        return buildDeterministicWorkspaceConcat(files).trim();
+    }
+    return {
+        getSystemSummary() {
+            return loadWorkspaceSystemSummary();
+        },
+    };
+}