@linxiraos/pi-agent-core 1.4.0 → 1.4.2

package/CHANGELOG.md

@@ -1,8 +1,8 @@
 ## [Unreleased]
 
-## [1.4.0] - 2026-10-21
+## [1.4.2] - 2026-10-24
 
-- Version line moves to 1.4.0 with the rest of the suite; no user-visible change in this package.
+- Version alignment with the 1.4.2 release line (no behavioral changes).
 
 ## [9.2.2] - 2026-01-31
 
@@ -134,6 +134,14 @@
 
 Initial release under @oh-my-pi scope. See previous releases at [badlogic/pi-mono](https://github.com/badlogic/pi-mono).
 
+## [1.4.1] - 2026-10-23
+
+- Version alignment with the 1.4.1 release line (no behavioral changes).
+
+## [1.4.0] - 2026-10-21
+
+- Version line moves to 1.4.0 with the rest of the suite; no user-visible change in this package.
+
 ## [1.3.2] - 2026-10-19
 
 - Version line moves to 1.3.2 with the rest of the suite; no user-visible change in this package.

package/dist/types/compaction/anthropic.d.ts

@@ -14,6 +14,8 @@ export declare const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
 export interface AnthropicCompactionPreserveData {
     provider: string;
     content: string;
+    /** Opaque signed tool-change records; replayed without normalization. */
+    toolChanges?: Record<string, unknown>[];
     /** Signature attached to an on-demand block; replayed verbatim. */
     signature?: string;
     /** Legacy threshold block state; replay-only. */
@@ -35,9 +37,11 @@ export interface AnthropicCompactionPreserveData {
  * lineage the beta documents); endpoint eligibility is resolved the way the
  * provider routes requests, so a Foundry or `ANTHROPIC_BASE_URL` reroute of a
  * first-party model is excluded unless the route opted in with
- * `remoteCompaction.enabled`.
+ * `remoteCompaction.enabled`. Bedrock Converse models compact through a
+ * Bedrock Runtime side request; their ordinary turns stay on Converse.
  */
-export declare function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages">;
+export declare function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages" | "bedrock-converse-stream">;
+type AnthropicNativeCompactionModel = Model<"anthropic-messages" | "bedrock-converse-stream">;
 export declare function getPreservedAnthropicCompactionData(preserveData: Record<string, unknown> | undefined): AnthropicCompactionPreserveData | undefined;
 /** Set or strip the Anthropic compaction slot; a new compaction never inherits a stale summary. */
 export declare function withAnthropicCompactionPreserveData(preserveData: Record<string, unknown> | undefined, compaction: AnthropicCompactionPreserveData | undefined): Record<string, unknown> | undefined;
@@ -67,6 +71,7 @@ export interface AnthropicNativeCompactionRequest {
 export interface AnthropicNativeCompactionResponse {
     content: string;
     signature: string;
+    toolChanges?: Record<string, unknown>[];
     usage: Usage;
     model: string;
 }
@@ -81,4 +86,5 @@ export interface AnthropicNativeCompactionOptions extends Pick<SimpleStreamOptio
  * without a summary is a native failure, including tool use, refusals and
  * output limits; the configured method order can then choose a fallback.
  */
-export declare function requestAnthropicNativeCompaction(model: Model<"anthropic-messages">, apiKey: ApiKey, request: AnthropicNativeCompactionRequest, signal: AbortSignal | undefined, options: AnthropicNativeCompactionOptions): Promise<AnthropicNativeCompactionResponse>;
+export declare function requestAnthropicNativeCompaction(model: AnthropicNativeCompactionModel, apiKey: ApiKey, request: AnthropicNativeCompactionRequest, signal: AbortSignal | undefined, options: AnthropicNativeCompactionOptions): Promise<AnthropicNativeCompactionResponse>;
+export {};

package/dist/types/tool-arguments.d.ts

@@ -10,9 +10,10 @@ import type { AgentTool } from "./types.js";
 export type ToolArgumentSource = "parsed" | "payload";
 /**
  * Validate a call's arguments against `tool`'s schema, honoring
- * {@link AgentTool.lenientArgValidation}: on a schema mismatch a lenient tool
- * receives its raw arguments minus the internal `__parseError`/`__rawJson`
- * sentinels. Malformed JSON from a provider stream is never lenient.
+ * {@link AgentTool.lenientArgValidation}: a lenient tool keeps unknown root
+ * keys its closed schema would heal away, and on a schema mismatch receives its
+ * raw arguments minus the internal `__parseError`/`__rawJson` sentinels.
+ * Malformed JSON from a provider stream is never lenient.
  *
  * @throws the validation error when the tool is strict or the arguments failed to parse.
  */

package/dist/types/types.d.ts

@@ -1034,7 +1034,7 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
      * before ordinary dispatch commits its result.
      */
     speculation?: ToolSpeculationPolicy;
-    /** If true, schema validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. Malformed argument JSON still returns the parse error. */
+    /** If true, schema validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM, and unknown root keys a closed schema would drop stay on the args. Malformed argument JSON still returns the parse error. */
     lenientArgValidation?: boolean;
     /**
      * Whether the agent loop may abort this tool mid-execution — or skip it
@@ -1090,6 +1090,12 @@ export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any
     approval?: ToolApproval;
     /** Lines appended after the standard approval prompt header. */
     formatApprovalDetails?: (args: unknown) => string | string[] | undefined;
+    /**
+     * Remembered-approval keys for `tools.approvalMode: always-ask-cached`: the files (or URL
+     * targets) this call touches. When every key is already granted the call skips its prompt;
+     * approving the call can record them. Omit it (or return `undefined`) and the call prompts by tier.
+     */
+    approvalCacheTargets?: (args: unknown) => readonly string[] | undefined;
     /** The main execution callback for this tool. */
     execute: AgentToolExecFn<TParameters, TDetails, TTheme>;
     /** Optional custom rendering for tool call display (returns UI component) */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-agent-core",
-	"version": "1.4.0",
+	"version": "1.4.2",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Linxira-OS",
@@ -35,16 +35,16 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-ai": "1.4.0",
-		"@linxiraos/pi-catalog": "1.4.0",
-		"@linxiraos/pi-natives": "1.4.0",
-		"@linxiraos/pi-utils": "1.4.0",
-		"@linxiraos/pi-wire": "1.4.0",
-		"@linxiraos/pi-snapcompact": "1.4.0",
+		"@linxiraos/pi-ai": "1.4.2",
+		"@linxiraos/pi-catalog": "1.4.2",
+		"@linxiraos/pi-natives": "1.4.2",
+		"@linxiraos/pi-utils": "1.4.2",
+		"@linxiraos/pi-wire": "1.4.2",
+		"@linxiraos/pi-snapcompact": "1.4.2",
 		"@opentelemetry/api": "^1.9.1"
 	},
 	"devDependencies": {
-		"@linxiraos/pi-omptype": "1.4.0",
+		"@linxiraos/pi-omptype": "1.4.2",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
 		"@opentelemetry/sdk-trace-base": "^2.9.0",
 		"@types/bun": "1.4.3"

package/src/compaction/anthropic.ts

@@ -19,7 +19,10 @@ import type {
 } from "@linxiraos/pi-ai";
 import * as AIError from "@linxiraos/pi-ai/error";
 import { resolveAnthropicCompactionEffort } from "@linxiraos/pi-ai/providers/anthropic";
-import { supportsAnthropicCompaction } from "@linxiraos/pi-ai/providers/anthropic-compaction";
+import {
+	supportsAnthropicCompaction,
+	supportsBedrockConverseCompaction,
+} from "@linxiraos/pi-ai/providers/anthropic-compaction";
 import { isRecord, prompt } from "@linxiraos/pi-utils";
 import { type InstrumentedChatSpanOptions, instrumentedCompleteSimple } from "../telemetry";
 import type { AgentMessage } from "../types";
@@ -31,6 +34,8 @@ export const ANTHROPIC_COMPACTION_PRESERVE_KEY = "anthropicCompaction";
 export interface AnthropicCompactionPreserveData {
 	provider: string;
 	content: string;
+	/** Opaque signed tool-change records; replayed without normalization. */
+	toolChanges?: Record<string, unknown>[];
 	/** Signature attached to an on-demand block; replayed verbatim. */
 	signature?: string;
 	/** Legacy threshold block state; replay-only. */
@@ -51,18 +56,28 @@ function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messa
 	return model.api === "anthropic-messages";
 }
 
+function isBedrockConverseModel(model: Model): model is Model<"bedrock-converse-stream"> {
+	return model.api === "bedrock-converse-stream";
+}
+
 /**
  * Whether a model compacts through the Anthropic compaction beta. Model
  * eligibility is catalog policy (`compat.supportsServerCompaction`, the
  * lineage the beta documents); endpoint eligibility is resolved the way the
  * provider routes requests, so a Foundry or `ANTHROPIC_BASE_URL` reroute of a
  * first-party model is excluded unless the route opted in with
- * `remoteCompaction.enabled`.
+ * `remoteCompaction.enabled`. Bedrock Converse models compact through a
+ * Bedrock Runtime side request; their ordinary turns stay on Converse.
  */
-export function shouldUseAnthropicNativeCompaction(model: Model): model is Model<"anthropic-messages"> {
-	return isAnthropicMessagesModel(model) && supportsAnthropicCompaction(model);
+export function shouldUseAnthropicNativeCompaction(
+	model: Model,
+): model is Model<"anthropic-messages" | "bedrock-converse-stream"> {
+	if (isAnthropicMessagesModel(model)) return supportsAnthropicCompaction(model);
+	return isBedrockConverseModel(model) && supportsBedrockConverseCompaction(model);
 }
 
+type AnthropicNativeCompactionModel = Model<"anthropic-messages" | "bedrock-converse-stream">;
+
 export function getPreservedAnthropicCompactionData(
 	preserveData: Record<string, unknown> | undefined,
 ): AnthropicCompactionPreserveData | undefined {
@@ -70,6 +85,9 @@ export function getPreservedAnthropicCompactionData(
 	if (!isRecord(candidate)) return undefined;
 	if (typeof candidate.provider !== "string" || candidate.provider.length === 0) return undefined;
 	if (typeof candidate.content !== "string" || candidate.content.length === 0) return undefined;
+	const toolChanges = candidate.toolChanges;
+	// The signature covers `tool_changes`: a block missing or mangling them cannot replay.
+	if (toolChanges !== undefined && (!Array.isArray(toolChanges) || !toolChanges.every(isRecord))) return undefined;
 	return {
 		provider: candidate.provider,
 		content: candidate.content,
@@ -90,6 +108,7 @@ export function getPreservedAnthropicCompactionData(
 					),
 				}
 			: {}),
+		...(toolChanges !== undefined ? { toolChanges } : {}),
 		...(candidate.exactTail === true ? { exactTail: true as const } : {}),
 		...(typeof candidate.model === "string" ? { model: candidate.model } : {}),
 		...(typeof candidate.usedTokens === "number" ? { usedTokens: candidate.usedTokens } : {}),
@@ -124,6 +143,7 @@ export function getAnthropicCompactionPayload(
 		...(preserved.signature ? { signature: preserved.signature } : {}),
 		...(preserved.encryptedContent ? { encryptedContent: preserved.encryptedContent } : {}),
 		...(preserved.filesText ? { filesText: preserved.filesText } : {}),
+		...(preserved.toolChanges ? { toolChanges: preserved.toolChanges } : {}),
 		...(preserved.retainedFiles?.length ? { retainedFiles: preserved.retainedFiles } : {}),
 		...(preserved.exactTail ? { exactTail: true as const } : {}),
 	};
@@ -196,6 +216,7 @@ export interface AnthropicNativeCompactionRequest {
 export interface AnthropicNativeCompactionResponse {
 	content: string;
 	signature: string;
+	toolChanges?: Record<string, unknown>[];
 	usage: Usage;
 	model: string;
 }
@@ -224,7 +245,7 @@ export interface AnthropicNativeCompactionOptions
  * output limits; the configured method order can then choose a fallback.
  */
 export async function requestAnthropicNativeCompaction(
-	model: Model<"anthropic-messages">,
+	model: AnthropicNativeCompactionModel,
 	apiKey: ApiKey,
 	request: AnthropicNativeCompactionRequest,
 	signal: AbortSignal | undefined,
@@ -237,7 +258,9 @@ export async function requestAnthropicNativeCompaction(
 			apiKey,
 			signal,
 			maxTokens: request.maxTokens,
-			reasoning: resolveAnthropicCompactionEffort(model, request.context.messages, request.reasoning),
+			reasoning: isAnthropicMessagesModel(model)
+				? resolveAnthropicCompactionEffort(model, request.context.messages, request.reasoning)
+				: request.reasoning,
 			initiatorOverride: options.initiatorOverride,
 			metadata: options.metadata,
 			fetch: options.fetch,
@@ -279,6 +302,7 @@ export async function requestAnthropicNativeCompaction(
 	return {
 		content: payload.content,
 		signature: payload.signature,
+		...(payload.toolChanges ? { toolChanges: payload.toolChanges } : {}),
 		usage: response.usage,
 		model: response.model,
 	};

package/src/compaction/compaction.ts

@@ -2024,6 +2024,7 @@ export async function compact(
 	let nativeFirstKeptEntryId = firstKeptEntryId;
 	let nativeUsedTokens: number | undefined;
 	let nativeRetainedFiles: AnthropicCompactionFiles[] | undefined;
+	let nativeToolChanges: Record<string, unknown>[] | undefined;
 	if (!usedRemoteCompaction && settings.remoteEnabled !== false && shouldUseAnthropicNativeCompaction(model)) {
 		const previousNative = getPreservedAnthropicCompactionData(previousPreserveData);
 		// Lead with the previous summary as the live context renders it:
@@ -2052,6 +2053,7 @@ export async function compact(
 											: {}),
 										...(previousNative.filesText ? { filesText: previousNative.filesText } : {}),
 										...(previousNative.retainedFiles ? { retainedFiles: previousNative.retainedFiles } : {}),
+										...(previousNative.toolChanges ? { toolChanges: previousNative.toolChanges } : {}),
 										...(previousNative.exactTail ? { exactTail: true as const } : {}),
 									}
 								: undefined,
@@ -2148,6 +2150,7 @@ export async function compact(
 			);
 			nativeSummary = remote.content;
 			nativeSignature = remote.signature;
+			nativeToolChanges = remote.toolChanges;
 			nativeUsedTokens = calculatePromptTokens(remote.usage);
 			usedRemoteCompaction = true;
 		} catch (err) {
@@ -2235,16 +2238,18 @@ export async function compact(
 	const { readFiles, modifiedFiles } = computeFileLists(fileOps);
 	summary = upsertFileOperations(summary, readFiles, modifiedFiles, fileOps.read);
 	if (nativeSummary !== undefined) {
-		// The replayed block stays byte-identical to the API's summary so it
-		// matches its signature. The harness file lists above travel
-		// separately: the converter replaces the summary message with the
-		// block and skips its text, so they would otherwise be invisible to
-		// this provider. Every other provider keeps reading the entry text.
+		// The replayed block (summary and any `tool_changes`) stays
+		// byte-identical to the API's output so it matches its signature. The
+		// harness file lists above travel separately: the converter replaces the
+		// summary message with the block and skips its text, so they would
+		// otherwise be invisible to this provider. Every other provider keeps
+		// reading the entry text.
 		const filesText = upsertFileOperations("", readFiles, modifiedFiles, fileOps.read) || undefined;
 		preserveData = withAnthropicCompactionPreserveData(preserveData, {
 			provider: model.provider,
 			content: nativeSummary,
 			...(nativeSignature ? { signature: nativeSignature } : {}),
+			...(nativeToolChanges ? { toolChanges: nativeToolChanges } : {}),
 			...(filesText ? { filesText } : {}),
 			...(nativeRetainedFiles ? { retainedFiles: nativeRetainedFiles } : {}),
 			exactTail: true,

package/src/tool-arguments.ts

@@ -12,9 +12,10 @@ export type ToolArgumentSource = "parsed" | "payload";
 
 /**
  * Validate a call's arguments against `tool`'s schema, honoring
- * {@link AgentTool.lenientArgValidation}: on a schema mismatch a lenient tool
- * receives its raw arguments minus the internal `__parseError`/`__rawJson`
- * sentinels. Malformed JSON from a provider stream is never lenient.
+ * {@link AgentTool.lenientArgValidation}: a lenient tool keeps unknown root
+ * keys its closed schema would heal away, and on a schema mismatch receives its
+ * raw arguments minus the internal `__parseError`/`__rawJson` sentinels.
+ * Malformed JSON from a provider stream is never lenient.
  *
  * @throws the validation error when the tool is strict or the arguments failed to parse.
  */
@@ -24,7 +25,9 @@ export function validateAgentToolArguments(
 	source: ToolArgumentSource = "parsed",
 ): ToolCall["arguments"] {
 	try {
-		return validateToolArguments(tool, toolCall);
+		const validated = validateToolArguments(tool, toolCall, { keepUnknownRootKeys: tool.lenientArgValidation });
+		// Kept unknown root keys must not smuggle the internal sentinels past validation.
+		return tool.lenientArgValidation ? withoutSentinels(validated) : validated;
 	} catch (error) {
 		const args: unknown = toolCall.arguments;
 		if (!tool.lenientArgValidation) throw error;
@@ -36,3 +39,12 @@ export function validateAgentToolArguments(
 		return fallback;
 	}
 }
+
+function withoutSentinels(args: ToolCall["arguments"]): ToolCall["arguments"] {
+	if (args === null || typeof args !== "object" || Array.isArray(args)) return args;
+	if (!Object.hasOwn(args, "__parseError") && !Object.hasOwn(args, "__rawJson")) return args;
+	const stripped = { ...(args as Record<string, unknown>) };
+	delete stripped.__parseError;
+	delete stripped.__rawJson;
+	return stripped;
+}

package/src/types.ts

@@ -1170,7 +1170,7 @@ export interface AgentTool<
 	 * before ordinary dispatch commits its result.
 	 */
 	speculation?: ToolSpeculationPolicy;
-	/** If true, schema validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM. Malformed argument JSON still returns the parse error. */
+	/** If true, schema validation errors are non-fatal: raw args are passed to execute() instead of returning an error to the LLM, and unknown root keys a closed schema would drop stay on the args. Malformed argument JSON still returns the parse error. */
 	lenientArgValidation?: boolean;
 	/**
 	 * Whether the agent loop may abort this tool mid-execution — or skip it
@@ -1229,6 +1229,13 @@ export interface AgentTool<
 	/** Lines appended after the standard approval prompt header. */
 	formatApprovalDetails?: (args: unknown) => string | string[] | undefined;
 
+	/**
+	 * Remembered-approval keys for `tools.approvalMode: always-ask-cached`: the files (or URL
+	 * targets) this call touches. When every key is already granted the call skips its prompt;
+	 * approving the call can record them. Omit it (or return `undefined`) and the call prompts by tier.
+	 */
+	approvalCacheTargets?: (args: unknown) => readonly string[] | undefined;
+
 	/** The main execution callback for this tool. */
 	execute: AgentToolExecFn<TParameters, TDetails, TTheme>;