@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/adapters/in-memory-session-store.js

@@ -1,13 +1,17 @@
 import { randomUUID } from "node:crypto";
 import { assertSessionProjectUnchanged, copySessionProject, } from "../../sessions/project-binding.js";
 import { assertValidSessionArtifactPathInputs, upsertSessionArtifactPaths, } from "../../sessions/artifact-paths.js";
-import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, toSnapshotMessage, toSnapshotRequest, } from "../../sessions/record/projection.js";
+import { compactRequestEvents, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, } from "../../sessions/record/projection.js";
+import { projectSessionSnapshot } from "../../sessions/snapshot.js";
 import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "../../sessions/record/rules.js";
 import { resolveSessionMemoryCheckpointCommit } from "../../sessions/memory/rules.js";
+import { assertSessionKindUnchanged, sessionKindCreationFields } from "../../sessions/spark-session.js";
+import { appendSparkInitiativeRecord } from "../../sessions/assistant-initiative-append.js";
 export function createInMemorySessionStore(options = {}) {
     const store = new InMemorySessionStore(options);
     return {
         getOrCreateSession: store.getOrCreateSession.bind(store),
+        appendAssistantInitiative: store.appendAssistantInitiative.bind(store),
         getAllSessions: store.getAllSessions.bind(store),
         listSessions: store.listSessions.bind(store),
         getSessionById: store.getSessionById.bind(store),
@@ -47,6 +51,7 @@ class InMemorySessionStore {
         const existing = this.sessions.get(sessionId);
         if (existing) {
             assertSessionProjectUnchanged(existing, options.project);
+            assertSessionKindUnchanged(existing, options.kind);
             return cloneSession(existing);
         }
         const timestamp = toIso(this.now);
@@ -55,7 +60,7 @@ class InMemorySessionStore {
             ...(options.project
                 ? { project: copySessionProject(options.project) }
                 : {}),
-            title: sessionId,
+            ...sessionKindCreationFields(sessionId, options),
             createdAt: timestamp,
             updatedAt: timestamp,
             lastAgentMode: "reasoning",
@@ -70,6 +75,14 @@ class InMemorySessionStore {
             .map(cloneSession)
             .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
+    async appendAssistantInitiative(sessionId, input) {
+        return this.runSessionMutation(sessionId, async () => {
+            const record = appendSparkInitiativeRecord(this.sessions.get(sessionId) ?? null, sessionId, input, this.now());
+            input.assertCurrent?.();
+            this.saveSession(record);
+            return cloneSession(record);
+        });
+    }
     async listSessions(params = {}) {
         const limit = normalizeLimit(params.limit);
         const offset = normalizeCursor(params.cursor);
@@ -87,20 +100,10 @@ class InMemorySessionStore {
         return session ? cloneSession(session) : null;
     }
     async getSessionSnapshot(sessionId, options = {}) {
-        const session = await this.getSessionById(sessionId);
-        if (!session) {
-            return null;
-        }
-        return {
-            sessionId,
-            ...(session.project ? { project: session.project } : {}),
-            title: session.title,
-            messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),
-            requests: options.includeRequests === false
-                ? []
-                : (session.requests ?? []).map(toSnapshotRequest),
-            nextCursor: null,
-        };
+        assertValidSessionId(sessionId);
+        const session = this.sessions.get(sessionId);
+        // Copy only the projection; identities-only reads never clone history bodies/events.
+        return session ? structuredClone(projectSessionSnapshot(session, options)) : null;
     }
     async getRequestReplayById(requestId, afterSeq = 0) {
         assertValidRequestId(requestId);

package/dist/src/runtime/adapters/long-term-memory/onboarding-service.d.ts

@@ -1,8 +1,9 @@
 import { type ModelProviderAdapterRegistry } from "../../../model-gateway/index.js";
-import type { LongTermMemoryOnboardingService } from "../../long-term-memory/onboarding/contracts.js";
+import type { LongTermMemoryOnboardingConfigRepository, LongTermMemoryOnboardingService } from "../../long-term-memory/onboarding/contracts.js";
 export declare function createLocalLongTermMemoryOnboardingService(params: {
     rootDir: string;
     providerAdapters: ModelProviderAdapterRegistry;
     configPath?: string;
     fetchImpl?: typeof fetch;
+    repository?: LongTermMemoryOnboardingConfigRepository;
 }): LongTermMemoryOnboardingService;

package/dist/src/runtime/adapters/long-term-memory/onboarding-service.js

@@ -3,10 +3,11 @@ import { createLongTermMemoryOnboardingService } from "../../long-term-memory/on
 import { createFileLongTermMemoryOnboardingConfigRepository } from "./onboarding-config-repository.js";
 const EMBEDDING_PROBE_TEXT = "ABot long-term memory embedding capability probe.";
 export function createLocalLongTermMemoryOnboardingService(params) {
-    const repository = createFileLongTermMemoryOnboardingConfigRepository({
-        rootDir: params.rootDir,
-        ...(params.configPath ? { configPath: params.configPath } : {}),
-    });
+    const repository = params.repository ??
+        createFileLongTermMemoryOnboardingConfigRepository({
+            rootDir: params.rootDir,
+            ...(params.configPath ? { configPath: params.configPath } : {}),
+        });
     return createLongTermMemoryOnboardingService({
         repository,
         probe: async (input) => {

package/dist/src/runtime/adapters/passive-learning-runtime.d.ts

@@ -1,11 +1,13 @@
 import type { RuntimeConfig, ModelGatewayClient, SessionStore } from "../ports.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
 /** The environment owns learning; the paired desktop owns native collection. */
 export declare function createRuntimePassiveLearning(params: {
     config: RuntimeConfig;
     models: ModelGatewayClient;
     memory: LongTermMemoryService;
     sessions?: SessionStore;
+    deliveryAdmission?: Pick<SessionRequestAdmission, "run">;
 }): Readonly<{
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -21,7 +23,6 @@ export declare function createRuntimePassiveLearning(params: {
     flush(): Promise<void>;
     beginInteractive(): () => void;
     subscribe(listener: (event?: import("../passive-learning/contracts.js").LearningChangedEvent) => void): () => void;
-    dismissProposal?(id: string): Promise<void>;
     sessionDeleted?(sessionId: string): Promise<void>;
     notifyKnowledgeChanged?(): void;
     candidates?(): Promise<readonly Omit<import("../long-term-memory/maturation/contracts.js").LearningCandidateRecord, "embedding">[]>;

package/dist/src/runtime/adapters/passive-learning-runtime.js

@@ -17,7 +17,7 @@ export function createRuntimePassiveLearning(params) {
         model: createRuntimePassiveLearningModel({ config, models }),
         backgroundDependencies: (context) => createCoWorkerResourceDependencies({
             config, models, memory, context, ownerId, directory: join(config.paths.runtimeDir, "passive-learning"),
-            sessions: params.sessions,
+            sessions: params.sessions, deliveryAdmission: params.deliveryAdmission,
         }),
         connect: (input) => connectHostObservations({
             ...input,

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/prepared-execution.js

@@ -1,6 +1,9 @@
+import { createRegisteredToolResultBudget, assertRegisteredToolResultMetadataFits, } from "./result-budget.js";
+import { randomUUID } from "node:crypto";
 import { requiresToolActionApproval } from "../../../../capabilities/tool-permission-mode.js";
 import { buildToolCompletedEventActions, buildToolCompletedEventMetadata, buildToolLifecycleEventCopy, } from "../../../../capabilities/tool-event-metadata.js";
 import { buildToolExecutorEventMetadata, } from "../shared/event-metadata.js";
+import { rejectNormalInvocation } from "../shared/rejection.js";
 import { requestNormalInvocationApproval } from "./approval.js";
 import { createPreparedInvocationRejectionEmitter } from "./rejection-event.js";
 import { createFileOutputPresentation } from "./file-output-presentation.js";
@@ -61,8 +64,9 @@ export function createPreparedNormalInvocation(params) {
             eventMeta: params.eventMeta,
             onEvent: params.executor.onEvent,
         }),
-        execute: (executionId, executorIdentity) => executePreparedNormalInvocation({
+        execute: (executionId, executorIdentity, selectedReferences) => executePreparedNormalInvocation({
             ...params,
+            selectedReferences,
             ...(approvalRequest ? { approvalRequest } : {}),
             ...(decision ? { decision, decisionRecorded } : {}),
             ...(executionId ? { executionId } : {}),
@@ -71,6 +75,12 @@ export function createPreparedNormalInvocation(params) {
     });
 }
 async function executePreparedNormalInvocation(params) {
+    const resultBudget = createRegisteredToolResultBudget({
+        call: params.call,
+        definition: params.target.registration.definition,
+        selectedReferences: params.selectedReferences,
+    });
+    assertRegisteredToolResultMetadataFits(resultBudget);
     const approval = await requestNormalInvocationApproval({
         ...(params.approvalRequest
             ? { preparedRequest: params.approvalRequest }
@@ -98,6 +108,27 @@ async function executePreparedNormalInvocation(params) {
     if (!approval.ok)
         return approval.rejection;
     params.executor.abortSignal.throwIfAborted();
+    const effectExecutionId = params.executionId ?? randomUUID();
+    const identity = (binding) => ({
+        toolName: binding.registration.toolName,
+        operationId: binding.operation.operationId,
+        contractVersion: binding.registration.contract.version,
+    });
+    const effectAdmission = await params.executor.effectPersistence?.beforeEffect({
+        executionId: effectExecutionId,
+        actionFingerprint: params.actionFingerprint,
+        source: identity(params.source),
+        target: identity(params.target),
+        effect: params.target.operation.effect,
+    });
+    const abortedBeforeDispatch = params.executor.abortSignal.aborted;
+    if (abortedBeforeDispatch) {
+        await params.executor.effectPersistence?.afterEffect({
+            executionId: effectExecutionId,
+            outcome: rejectNormalInvocation("request_aborted", "The operation was stopped before it began."),
+        });
+    }
+    params.executor.abortSignal.throwIfAborted();
     const startedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, "started");
     params.executor.onEvent?.("tool.started", {
         ...buildToolExecutorEventMetadata(params.executorIdentity),
@@ -108,32 +139,57 @@ async function executePreparedNormalInvocation(params) {
         ...(startedCopy ?? {}),
     });
     const fileOutputPresentation = createFileOutputPresentation(params.executor.sharedState?.runtimePaths);
-    const result = await executeWithToolResources({
-        registry: params.executor.toolRegistry,
-        call: params.call,
-        resources: params.executor.toolResources,
-        ...(params.executionId && params.executorIdentity
-            ? {
-                owner: {
-                    executionId: params.executionId,
-                    callId: params.executorIdentity.callId,
-                },
-            }
-            : {}),
-        options: {
-            abortSignal: params.executor.abortSignal,
-            reportFileOutput: fileOutputPresentation.report,
-            ...(params.executor.sharedState
-                ? { sharedState: params.executor.sharedState }
+    let result;
+    try {
+        result = await executeWithToolResources({
+            registry: params.executor.toolRegistry,
+            call: params.call,
+            resources: params.executor.toolResources,
+            ...(params.executionId && params.executorIdentity
+                ? {
+                    owner: {
+                        executionId: params.executionId,
+                        callId: params.executorIdentity.callId,
+                    },
+                }
                 : {}),
-        },
-    });
+            options: {
+                abortSignal: params.executor.abortSignal,
+                resultBudget,
+                ...(effectAdmission ? { trustedEffectAdmission: effectAdmission } : {}),
+                reportFileOutput: fileOutputPresentation.report,
+                ...(params.executor.sharedState
+                    ? { sharedState: params.executor.sharedState }
+                    : {}),
+            },
+        });
+    }
+    catch (error) {
+        await params.executor.effectPersistence?.afterEffect({
+            executionId: effectExecutionId,
+            outcome: {
+                status: "uncertain",
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw error;
+    }
     const completionActions = Object.freeze(buildToolCompletedEventActions(params.call, result, params.target.registration.definition).map((action) => Object.freeze({ ...action })));
     const completedMeta = fileOutputPresentation.finish(result, buildToolCompletedEventMetadata(params.call, result, params.target.registration.definition), params.target.operation.effect);
     const completedCopy = buildToolLifecycleEventCopy(params.target.registration.definition, result.ok ? "completed" : "failed");
     const completedEventMeta = params.executionMetadata
         ? { ...completedMeta, ...params.executionMetadata }
         : completedMeta;
+    const settled = Object.freeze({
+        status: "executed",
+        effect: params.target.operation.effect,
+        result,
+        completionActions,
+    });
+    await params.executor.effectPersistence?.afterEffect({
+        executionId: effectExecutionId,
+        outcome: settled,
+    });
     params.executor.onEvent?.("tool.completed", {
         ...buildToolExecutorEventMetadata(params.executorIdentity),
         ...(params.executionId ? { executionId: params.executionId } : {}),
@@ -143,10 +199,5 @@ async function executePreparedNormalInvocation(params) {
         ...(completedEventMeta ? { meta: completedEventMeta } : {}),
         ...(completedCopy ?? {}),
     });
-    return Object.freeze({
-        status: "executed",
-        effect: params.target.operation.effect,
-        result,
-        completionActions,
-    });
+    return settled;
 }

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/result-budget.d.ts

@@ -0,0 +1,11 @@
+import { type ToolResultBudget } from "../../../../capabilities/result-budget.js";
+import type { ToolCall, ToolDefinition } from "../../../../capabilities/tool-types.js";
+import type { CapabilityResultReference } from "../../../orchestration/capability-adapters/result.js";
+/** Invocation-owned delivery contract; it grants no model context or execution authority. */
+export declare function createRegisteredToolResultBudget(input: {
+    call: ToolCall;
+    definition: ToolDefinition;
+    selectedReferences?: readonly CapabilityResultReference[];
+}): ToolResultBudget;
+/** Metadata known before dispatch must leave space for even an empty result. */
+export declare function assertRegisteredToolResultMetadataFits(budget: ToolResultBudget): void;

package/dist/src/runtime/adapters/registered-tool-normal-invocations/execution/result-budget.js

@@ -0,0 +1,30 @@
+import { assessResultEnvelopeBytes, } from "../../../../capabilities/result-budget.js";
+import { buildToolCompletedEventActions } from "../../../../capabilities/tool-event-metadata.js";
+import { measureToolContextTextBytes } from "../../../../capabilities/tool-context-text.js";
+import { projectToolExecutionResult } from "../../../../capabilities/tool-result-normalization.js";
+import { projectRegisteredToolResultEnvelope } from "../../registered-tool-worker-capabilities/result-envelope.js";
+/** Invocation-owned delivery contract; it grants no model context or execution authority. */
+export function createRegisteredToolResultBudget(input) {
+    const selectedReferences = Object.freeze([
+        ...(input.selectedReferences ?? []),
+    ]);
+    return Object.freeze({
+        acceptsContextText: true,
+        assess(output) {
+            const result = projectToolExecutionResult(input.call.tool, output);
+            const actions = buildToolCompletedEventActions(input.call, result, input.definition);
+            return assessResultEnvelopeBytes(projectRegisteredToolResultEnvelope(result, actions, selectedReferences), measureToolContextTextBytes(result));
+        },
+    });
+}
+/** Metadata known before dispatch must leave space for even an empty result. */
+export function assertRegisteredToolResultMetadataFits(budget) {
+    const assessment = budget.assess({
+        ok: true,
+        output: "",
+        producedNewInformation: false,
+    });
+    if (assessment.fits)
+        return;
+    throw new Error("registered_tool_result_metadata_exceeds_budget");
+}

package/dist/src/runtime/adapters/registered-tool-normal-invocations/shared/contracts.d.ts

@@ -1,3 +1,4 @@
+import type { CapabilityResultReference } from "../../../orchestration/capability-adapters/result.js";
 import type { BoundApprovalDecision } from "../../../orchestration/worker-capabilities/approval-contracts.js";
 import type { ToolEventExecutorIdentity } from "./event-metadata.js";
 import type { RequestToolResources } from "../../../capabilities/request-tool-resources.js";
@@ -50,7 +51,7 @@ export type RegisteredToolPreparedNormalInvocation = Readonly<{
         errorCode: string;
     }>): void;
     /** Canonical execution identity for client lifecycle events only. */
-    execute(executionId?: string, executorIdentity?: ToolEventExecutorIdentity): Promise<RegisteredToolNormalInvocationResult>;
+    execute(executionId?: string, executorIdentity?: ToolEventExecutorIdentity, selectedReferences?: readonly CapabilityResultReference[]): Promise<RegisteredToolNormalInvocationResult>;
 }>;
 export type RegisteredToolNormalInvocationPreparation = RegisteredToolPreparedNormalInvocation | RegisteredToolNormalInvocationRejection;
 export type RegisteredToolNormalInvocationPayloadLifecyclePhase = "started" | "completed" | "failed";
@@ -135,6 +136,31 @@ export type BoundOperation = Readonly<{
     payloadContextPlan?: RegisteredToolPayloadContextPlan;
     stagedPayloadPlan?: RegisteredToolStagedPayloadPlan;
 }>;
+/** Opt-in durable effect boundary used by non-interactive automation runs. */
+export type RegisteredToolEffectPersistence = Readonly<{
+    beforeEffect(input: Readonly<{
+        executionId: string;
+        actionFingerprint: string;
+        source: Readonly<{
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+        }>;
+        target: Readonly<{
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+        }>;
+        effect: ToolNormalInvocationEffect;
+    }>): Promise<object | void>;
+    afterEffect(input: Readonly<{
+        executionId: string;
+        outcome: RegisteredToolNormalInvocationResult | Readonly<{
+            status: "uncertain";
+            error: string;
+        }>;
+    }>): Promise<void>;
+}>;
 export type RegisteredToolNormalInvocationExecutorParams = Readonly<{
     toolResources?: RequestToolResources;
     registrations: readonly RegisteredToolNormalInvocation[];
@@ -146,6 +172,7 @@ export type RegisteredToolNormalInvocationExecutorParams = Readonly<{
     toolApprovalController?: ToolApprovalController;
     nextApprovalId(): string;
     onEvent?(name: string, payload: Record<string, unknown>): void;
+    effectPersistence?: RegisteredToolEffectPersistence;
 }>;
 export type RegisteredToolNormalInvocationPayloadLifecycleInput = Parameters<RegisteredToolNormalInvocationExecutor["emitPayloadLifecycle"]>[0];
 export type RegisteredToolNormalInvocationExecutionInput = Parameters<RegisteredToolNormalInvocationExecutor["execute"]>[0];

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

@@ -40,9 +40,9 @@ export type RegisteredToolPayloadTargetContext = Readonly<{
 }>;
 export declare function deriveRegisteredToolPayloadContextPlan(definition: ToolDefinition, operation: ToolNormalInvocationOperation): RegisteredToolPayloadContextPlan | undefined;
 /**
- * Bridges only explicitly staged tool metadata into the ordinary invocation
- * contract. Single-stage operations deliberately remain on their established
- * raw-payload path.
+ * Bridges explicitly declared payload stages into ordinary invocation.
+ * One declared stage retains its response format; operations with no declared
+ * stages keep their established raw-payload path.
  */
 export declare function deriveRegisteredToolStagedPayloadPlan(definition: ToolDefinition, operation: ToolNormalInvocationOperation): RegisteredToolStagedPayloadPlan | undefined;
 export type RegisteredToolPayloadStageLiteralResolution = Readonly<{

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

@@ -14,13 +14,13 @@ export function deriveRegisteredToolPayloadContextPlan(definition, operation) {
     });
 }
 /**
- * Bridges only explicitly staged tool metadata into the ordinary invocation
- * contract. Single-stage operations deliberately remain on their established
- * raw-payload path.
+ * Bridges explicitly declared payload stages into ordinary invocation.
+ * One declared stage retains its response format; operations with no declared
+ * stages keep their established raw-payload path.
  */
 export function deriveRegisteredToolStagedPayloadPlan(definition, operation) {
     const spec = definition.payloadChannelSpec;
-    if (!spec?.stages || spec.stages.length < 2) {
+    if (!spec?.stages || spec.stages.length === 0) {
         return undefined;
     }
     if (!operation.payload ||

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

@@ -3,6 +3,7 @@ import type { RegisteredToolNormalInvocation, ToolExecutionRequestContext, ToolN
 import type { WorkerCapabilityDescriptor, WorkerCapabilityPayloadAuthor } from "../../orchestration/worker-capabilities/index.js";
 import type { ToolApprovalController, ToolPermissionMode, ToolRegistry } from "../../ports.js";
 import type { RegisteredToolStagedPayloadPlan } from "../registered-tool-payload-plan.js";
+import type { RegisteredToolEffectPersistence } from "../registered-tool-normal-invocations/shared/contracts.js";
 export type RegisteredToolWorkerCapabilityProviderParams = Readonly<{
     toolResources?: RequestToolResources;
     /**
@@ -21,6 +22,7 @@ export type RegisteredToolWorkerCapabilityProviderParams = Readonly<{
     loadActionSkillContext?(toolName: string): Promise<string>;
     nextApprovalId(): string;
     onEvent?(name: string, payload: Record<string, unknown>): void;
+    effectPersistence?: RegisteredToolEffectPersistence;
 }>;
 export type SelectedOperation = Readonly<{
     registration: RegisteredToolNormalInvocation;

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

@@ -1,4 +1,4 @@
-import { validateJsonSchemaValue } from "../../model/json-schema-value.js";
+import { normalizePayloadBody } from "../../orchestration/worker-capabilities/payload-body-normalization.js";
 import { isPlainRecord } from "./values.js";
 export function normalizePayloadAuthoringResult(input, minBytes, maxBytes, responseFormat) {
     if (!isPlainRecord(input) || Object.keys(input).length !== 2) {
@@ -8,13 +8,14 @@ export function normalizePayloadAuthoringResult(input, minBytes, maxBytes, respo
         });
     }
     if (input.status === "authored" && typeof input.body === "string") {
-        const body = normalizeAdapterAuthoredBody(input.body, responseFormat);
-        if (body === undefined) {
+        const normalized = normalizePayloadBody(input.body, responseFormat);
+        if (!normalized.ok) {
             return Object.freeze({
                 status: "failed",
                 code: "payload_model_output_invalid",
             });
         }
+        const body = normalized.body;
         const payloadBytes = Buffer.byteLength(body, "utf8");
         if (payloadBytes < minBytes) {
             return Object.freeze({
@@ -34,21 +35,6 @@ export function normalizePayloadAuthoringResult(input, minBytes, maxBytes, respo
         code: "payload_author_result_invalid",
     });
 }
-function normalizeAdapterAuthoredBody(body, responseFormat) {
-    if (!responseFormat)
-        return body;
-    try {
-        const parsed = JSON.parse(body);
-        if (responseFormat !== "json" &&
-            validateJsonSchemaValue(responseFormat, parsed)) {
-            return undefined;
-        }
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return undefined;
-    }
-}
 function isPayloadAuthorFailureCode(input) {
     return (input === "payload_context_invalid" ||
         input === "payload_context_budget_exceeded" ||

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

@@ -34,9 +34,9 @@ export function createPreparedWorkerInvocation(params, input, normalPreparation,
                         exactResult: rejectedExecution.exactResult,
                     }, selectedTargetReferences);
                 }
-                const externalResult = await normalPreparation.execute(executionId, input.call);
-                const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null);
-                const observedResult = attachTargetReferences(observed.result, selectedTargetReferences);
+                const externalResult = await normalPreparation.execute(executionId, input.call, selectedTargetReferences);
+                const observed = observeExternalResult(externalResult, params.projection.operation.effect, input.call.parentCallId === null, selectedTargetReferences);
+                const observedResult = observed.result;
                 traceRegisteredToolWorkerCapabilityExecutionCompleted(params.diagnostic, operationId, input.call, executionId, observedResult, externalResult.status, {
                     ...(observed.sourceIssueCode
                         ? { sourceIssueCode: observed.sourceIssueCode }

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

@@ -0,0 +1,13 @@
+import type { ToolActionSummary, ToolExecutionResult } from "../../../capabilities/tool-types.js";
+import type { CapabilityResultReference } from "../../orchestration/capability-adapters/result.js";
+/** This exact envelope is both measured for the producer and captured for settlement. */
+export declare function projectRegisteredToolResultEnvelope(result: ToolExecutionResult, completionActions: readonly ToolActionSummary[], selectedReferences?: readonly CapabilityResultReference[]): Readonly<{
+    references?: readonly Readonly<{
+        kind: "tool_target";
+        target: string;
+    }>[] | undefined;
+    kind: "registered_tool_execution_result_v1";
+    authority: "registered_plugin";
+    status: "executed";
+    result: ToolExecutionResult;
+}>;

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

@@ -0,0 +1,15 @@
+import { projectTargetReferences } from "./result-references.js";
+/** This exact envelope is both measured for the producer and captured for settlement. */
+export function projectRegisteredToolResultEnvelope(result, completionActions, selectedReferences = []) {
+    const references = projectTargetReferences([
+        ...selectedReferences.map(({ target }) => target),
+        ...completionActions.map(({ target }) => target),
+    ]);
+    return Object.freeze({
+        kind: "registered_tool_execution_result_v1",
+        authority: "registered_plugin",
+        status: "executed",
+        result,
+        ...(references.length ? { references } : {}),
+    });
+}

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

@@ -2,16 +2,12 @@ import type { ToolActionSummary } from "../../../capabilities/tool-types.js";
 import { type RoleCapabilityResultReference } from "../../orchestration/role-calls/index.js";
 import { type CapabilityAdapterResult } from "../../orchestration/capability-adapters/index.js";
 import type { WorkerCapabilityAdapterResult } from "../../orchestration/worker-capabilities/index.js";
-import type { RegisteredToolNormalInvocationProjection, RegisteredToolNormalInvocationResult } from "../registered-tool-normal-invocations.js";
+import type { RegisteredToolNormalInvocationResult } from "../registered-tool-normal-invocations.js";
+export { projectSelectedTargetReferences, projectToolTargetReferences, } from "./result-references.js";
 export declare function summarizeCompletedMutation(completionActions: readonly ToolActionSummary[]): string;
 export declare function projectMutationGrounding(input: unknown, directRoot?: boolean): string | undefined;
-export declare function projectToolTargetReferences(completionActions: readonly ToolActionSummary[]): readonly Readonly<{
-    kind: "tool_target";
-    target: string;
-}>[];
-export declare function projectSelectedTargetReferences(projection: RegisteredToolNormalInvocationProjection, controls: Readonly<Record<string, unknown>>, directRootSelectionControlIds?: readonly string[]): readonly RoleCapabilityResultReference[];
 export declare function attachTargetReferences(result: WorkerCapabilityAdapterResult, selected: readonly RoleCapabilityResultReference[]): WorkerCapabilityAdapterResult;
-export declare function captureRegisteredToolResult(input: RegisteredToolNormalInvocationResult): CapabilityAdapterResult;
+export declare function captureRegisteredToolResult(input: RegisteredToolNormalInvocationResult, selectedReferences?: readonly RoleCapabilityResultReference[]): CapabilityAdapterResult;
 export declare function requireCapabilityAdapterResult(input: unknown): CapabilityAdapterResult;
 export declare function validateToolExecutionResult(input: unknown): void;
 export declare function boundedSummary(input: string, directRoot?: boolean): string;

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

@@ -1,5 +1,8 @@
-import { ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
 import { normalizeCapabilityAdapterResult, } from "../../orchestration/capability-adapters/index.js";
+import { projectTargetReferences } from "./result-references.js";
+export { projectSelectedTargetReferences, projectToolTargetReferences, } from "./result-references.js";
+import { projectRegisteredToolResultEnvelope } from "./result-envelope.js";
 import { executionProtocolError } from "./errors.js";
 import { isPlainRecord, nonEmpty } from "./values.js";
 const MUTATION_GROUNDING_MAX_LENGTH = 32_768;
@@ -26,17 +29,6 @@ export function projectMutationGrounding(input, directRoot = false) {
         ? normalized
         : `${normalized.slice(0, MUTATION_GROUNDING_MAX_LENGTH - 1)}…`;
 }
-export function projectToolTargetReferences(completionActions) {
-    return projectTargetReferences(completionActions.map(({ target }) => target));
-}
-export function projectSelectedTargetReferences(projection, controls, directRootSelectionControlIds) {
-    const targetParam = projection.stagedPayloadPlan?.targetParam ??
-        projection.payloadContextPlan?.targetParam;
-    const targetParams = targetParam
-        ? [targetParam]
-        : (directRootSelectionControlIds ?? []);
-    return projectTargetReferences(targetParams.map((param) => controls[param]));
-}
 export function attachTargetReferences(result, selected) {
     if (selected.length === 0)
         return result;
@@ -60,7 +52,7 @@ export function attachTargetReferences(result, selected) {
             : {}),
     });
 }
-export function captureRegisteredToolResult(input) {
+export function captureRegisteredToolResult(input, selectedReferences = []) {
     if (input.status === "rejected") {
         return requireCapabilityAdapterResult({
             kind: "runtime_capability_rejection_v1",
@@ -71,14 +63,7 @@ export function captureRegisteredToolResult(input) {
             message: input.message,
         });
     }
-    const references = projectToolTargetReferences(input.completionActions);
-    return requireCapabilityAdapterResult({
-        kind: "registered_tool_execution_result_v1",
-        authority: "registered_plugin",
-        status: "executed",
-        result: input.result,
-        ...(references.length > 0 ? { references } : {}),
-    });
+    return requireCapabilityAdapterResult(projectRegisteredToolResultEnvelope(input.result, input.completionActions, selectedReferences));
 }
 export function requireCapabilityAdapterResult(input) {
     const normalized = normalizeCapabilityAdapterResult(input);
@@ -87,23 +72,6 @@ export function requireCapabilityAdapterResult(input) {
     }
     return normalized.value;
 }
-function projectTargetReferences(values) {
-    const targets = new Set();
-    const references = [];
-    for (const value of values) {
-        const target = typeof value === "string" ? value.trim() : "";
-        if (!target ||
-            target.length > ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH ||
-            targets.has(target)) {
-            continue;
-        }
-        targets.add(target);
-        references.push(Object.freeze({ kind: "tool_target", target }));
-        if (references.length >= ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX)
-            break;
-    }
-    return Object.freeze(references);
-}
 export function validateToolExecutionResult(input) {
     if (!isPlainRecord(input) ||
         typeof input.ok !== "boolean" ||

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

@@ -1,8 +1,9 @@
+import type { RoleCapabilityResultReference } from "../../orchestration/role-calls/index.js";
 import type { WorkerCapabilityAdapterResult } from "../../orchestration/worker-capabilities/index.js";
 import type { RegisteredToolNormalInvocationResult } from "../registered-tool-normal-invocations.js";
 type ObservedExternalResult = Readonly<{
     result: WorkerCapabilityAdapterResult;
     sourceIssueCode?: string;
 }>;
-export declare function observeExternalResult(input: RegisteredToolNormalInvocationResult, expectedEffect: "read_only" | "mutating" | "mixed", directRoot: boolean): ObservedExternalResult;
+export declare function observeExternalResult(input: RegisteredToolNormalInvocationResult, expectedEffect: "read_only" | "mutating" | "mixed", directRoot: boolean, selectedReferences?: readonly RoleCapabilityResultReference[]): ObservedExternalResult;
 export { attachTargetReferences, boundedSummary, projectSelectedTargetReferences, requireCapabilityAdapterResult, } from "./result-evidence.js";