openclaw-cortex 3.4.0 → 3.5.0

package/dist/plugin-sdk/agents/pi-embedded-subscribe.handlers.d.ts

@@ -0,0 +1,2 @@
+import type { EmbeddedPiSubscribeContext, EmbeddedPiSubscribeEvent } from "./pi-embedded-subscribe.handlers.types.js";
+export declare function createEmbeddedPiSessionEventHandler(ctx: EmbeddedPiSubscribeContext): (evt: EmbeddedPiSubscribeEvent) => void;

package/dist/plugin-sdk/agents/pi-embedded-subscribe.handlers.lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { EmbeddedPiSubscribeContext } from "./pi-embedded-subscribe.handlers.types.js";
+export { handleAutoCompactionEnd, handleAutoCompactionStart, } from "./pi-embedded-subscribe.handlers.compaction.js";
+export declare function handleAgentStart(ctx: EmbeddedPiSubscribeContext): void;
+export declare function handleAgentEnd(ctx: EmbeddedPiSubscribeContext): void;

package/dist/plugin-sdk/agents/pi-embedded-subscribe.handlers.messages.d.ts

@@ -0,0 +1,16 @@
+import type { AgentEvent, AgentMessage } from "@mariozechner/pi-agent-core";
+import type { EmbeddedPiSubscribeContext } from "./pi-embedded-subscribe.handlers.types.js";
+export declare function resolveSilentReplyFallbackText(params: {
+    text: string;
+    messagingToolSentTexts: string[];
+}): string;
+export declare function handleMessageStart(ctx: EmbeddedPiSubscribeContext, evt: AgentEvent & {
+    message: AgentMessage;
+}): void;
+export declare function handleMessageUpdate(ctx: EmbeddedPiSubscribeContext, evt: AgentEvent & {
+    message: AgentMessage;
+    assistantMessageEvent?: unknown;
+}): void;
+export declare function handleMessageEnd(ctx: EmbeddedPiSubscribeContext, evt: AgentEvent & {
+    message: AgentMessage;
+}): void;

package/dist/plugin-sdk/agents/pi-embedded-subscribe.handlers.tools.d.ts

@@ -0,0 +1,18 @@
+import type { AgentEvent } from "@mariozechner/pi-agent-core";
+import type { ToolHandlerContext } from "./pi-embedded-subscribe.handlers.types.js";
+export declare function handleToolExecutionStart(ctx: ToolHandlerContext, evt: AgentEvent & {
+    toolName: string;
+    toolCallId: string;
+    args: unknown;
+}): Promise<void>;
+export declare function handleToolExecutionUpdate(ctx: ToolHandlerContext, evt: AgentEvent & {
+    toolName: string;
+    toolCallId: string;
+    partialResult?: unknown;
+}): void;
+export declare function handleToolExecutionEnd(ctx: ToolHandlerContext, evt: AgentEvent & {
+    toolName: string;
+    toolCallId: string;
+    isError: boolean;
+    result?: unknown;
+}): Promise<void>;

package/dist/plugin-sdk/agents/pi-embedded-subscribe.handlers.types.d.ts

@@ -0,0 +1,149 @@
+import type { AgentEvent, AgentMessage } from "@mariozechner/pi-agent-core";
+import type { ReplyDirectiveParseResult } from "../auto-reply/reply/reply-directives.js";
+import type { ReasoningLevel } from "../auto-reply/thinking.js";
+import type { InlineCodeState } from "../markdown/code-spans.js";
+import type { HookRunner } from "../plugins/hooks.js";
+import type { EmbeddedBlockChunker } from "./pi-embedded-block-chunker.js";
+import type { MessagingToolSend } from "./pi-embedded-messaging.js";
+import type { BlockReplyChunking, SubscribeEmbeddedPiSessionParams } from "./pi-embedded-subscribe.types.js";
+import type { NormalizedUsage } from "./usage.js";
+export type EmbeddedSubscribeLogger = {
+    debug: (message: string) => void;
+    warn: (message: string) => void;
+};
+export type ToolErrorSummary = {
+    toolName: string;
+    meta?: string;
+    error?: string;
+    mutatingAction?: boolean;
+    actionFingerprint?: string;
+};
+export type ToolCallSummary = {
+    meta?: string;
+    mutatingAction: boolean;
+    actionFingerprint?: string;
+};
+export type EmbeddedPiSubscribeState = {
+    assistantTexts: string[];
+    toolMetas: Array<{
+        toolName?: string;
+        meta?: string;
+    }>;
+    toolMetaById: Map<string, ToolCallSummary>;
+    toolSummaryById: Set<string>;
+    lastToolError?: ToolErrorSummary;
+    blockReplyBreak: "text_end" | "message_end";
+    reasoningMode: ReasoningLevel;
+    includeReasoning: boolean;
+    shouldEmitPartialReplies: boolean;
+    streamReasoning: boolean;
+    deltaBuffer: string;
+    blockBuffer: string;
+    blockState: {
+        thinking: boolean;
+        final: boolean;
+        inlineCode: InlineCodeState;
+    };
+    partialBlockState: {
+        thinking: boolean;
+        final: boolean;
+        inlineCode: InlineCodeState;
+    };
+    lastStreamedAssistant?: string;
+    lastStreamedAssistantCleaned?: string;
+    emittedAssistantUpdate: boolean;
+    lastStreamedReasoning?: string;
+    lastBlockReplyText?: string;
+    reasoningStreamOpen: boolean;
+    assistantMessageIndex: number;
+    lastAssistantTextMessageIndex: number;
+    lastAssistantTextNormalized?: string;
+    lastAssistantTextTrimmed?: string;
+    assistantTextBaseline: number;
+    suppressBlockChunks: boolean;
+    lastReasoningSent?: string;
+    compactionInFlight: boolean;
+    pendingCompactionRetry: number;
+    compactionRetryResolve?: () => void;
+    compactionRetryReject?: (reason?: unknown) => void;
+    compactionRetryPromise: Promise<void> | null;
+    unsubscribed: boolean;
+    messagingToolSentTexts: string[];
+    messagingToolSentTextsNormalized: string[];
+    messagingToolSentTargets: MessagingToolSend[];
+    messagingToolSentMediaUrls: string[];
+    pendingMessagingTexts: Map<string, string>;
+    pendingMessagingTargets: Map<string, MessagingToolSend>;
+    successfulCronAdds: number;
+    pendingMessagingMediaUrls: Map<string, string[]>;
+    lastAssistant?: AgentMessage;
+};
+export type EmbeddedPiSubscribeContext = {
+    params: SubscribeEmbeddedPiSessionParams;
+    state: EmbeddedPiSubscribeState;
+    log: EmbeddedSubscribeLogger;
+    blockChunking?: BlockReplyChunking;
+    blockChunker: EmbeddedBlockChunker | null;
+    hookRunner?: HookRunner;
+    noteLastAssistant: (msg: AgentMessage) => void;
+    shouldEmitToolResult: () => boolean;
+    shouldEmitToolOutput: () => boolean;
+    emitToolSummary: (toolName?: string, meta?: string) => void;
+    emitToolOutput: (toolName?: string, meta?: string, output?: string) => void;
+    stripBlockTags: (text: string, state: {
+        thinking: boolean;
+        final: boolean;
+        inlineCode?: InlineCodeState;
+    }) => string;
+    emitBlockChunk: (text: string) => void;
+    flushBlockReplyBuffer: () => void;
+    emitReasoningStream: (text: string) => void;
+    consumeReplyDirectives: (text: string, options?: {
+        final?: boolean;
+    }) => ReplyDirectiveParseResult | null;
+    consumePartialReplyDirectives: (text: string, options?: {
+        final?: boolean;
+    }) => ReplyDirectiveParseResult | null;
+    resetAssistantMessageState: (nextAssistantTextBaseline: number) => void;
+    resetForCompactionRetry: () => void;
+    finalizeAssistantTexts: (args: {
+        text: string;
+        addedDuringMessage: boolean;
+        chunkerHasBuffered: boolean;
+    }) => void;
+    trimMessagingToolSent: () => void;
+    ensureCompactionPromise: () => void;
+    noteCompactionRetry: () => void;
+    resolveCompactionRetry: () => void;
+    maybeResolveCompactionWait: () => void;
+    recordAssistantUsage: (usage: unknown) => void;
+    incrementCompactionCount: () => void;
+    getUsageTotals: () => NormalizedUsage | undefined;
+    getCompactionCount: () => number;
+};
+/**
+ * Minimal context type for tool execution handlers. Allows
+ * tests provide only the fields they exercise
+ * without needing the full `EmbeddedPiSubscribeContext`.
+ */
+export type ToolHandlerParams = Pick<SubscribeEmbeddedPiSessionParams, "runId" | "onBlockReplyFlush" | "onAgentEvent" | "onToolResult">;
+export type ToolHandlerState = Pick<EmbeddedPiSubscribeState, "toolMetaById" | "toolMetas" | "toolSummaryById" | "lastToolError" | "pendingMessagingTargets" | "pendingMessagingTexts" | "pendingMessagingMediaUrls" | "messagingToolSentTexts" | "messagingToolSentTextsNormalized" | "messagingToolSentMediaUrls" | "messagingToolSentTargets" | "successfulCronAdds">;
+export type ToolHandlerContext = {
+    params: ToolHandlerParams;
+    state: ToolHandlerState;
+    log: EmbeddedSubscribeLogger;
+    hookRunner?: HookRunner;
+    flushBlockReplyBuffer: () => void;
+    shouldEmitToolResult: () => boolean;
+    shouldEmitToolOutput: () => boolean;
+    emitToolSummary: (toolName?: string, meta?: string) => void;
+    emitToolOutput: (toolName?: string, meta?: string, output?: string) => void;
+    trimMessagingToolSent: () => void;
+};
+export type EmbeddedPiSubscribeEvent = AgentEvent | {
+    type: string;
+    [k: string]: unknown;
+} | {
+    type: "message_start";
+    message: AgentMessage;
+};

package/dist/plugin-sdk/agents/pi-embedded-subscribe.raw-stream.d.ts

@@ -0,0 +1 @@
+export declare function appendRawStream(payload: Record<string, unknown>): void;

package/dist/plugin-sdk/agents/pi-embedded-subscribe.tools.d.ts

@@ -0,0 +1,20 @@
+import { type MessagingToolSend } from "./pi-embedded-messaging.js";
+export declare function sanitizeToolResult(result: unknown): unknown;
+export declare function extractToolResultText(result: unknown): string | undefined;
+export declare function isToolResultMediaTrusted(toolName?: string): boolean;
+export declare function filterToolResultMediaUrls(toolName: string | undefined, mediaUrls: string[]): string[];
+/**
+ * Extract media file paths from a tool result.
+ *
+ * Strategy (first match wins):
+ * 1. Parse `MEDIA:` tokens from text content blocks (all OpenClaw tools).
+ * 2. Fall back to `details.path` when image content exists (OpenClaw imageResult).
+ *
+ * Returns an empty array when no media is found (e.g. Pi SDK `read` tool
+ * returns base64 image data but no file path; those need a different delivery
+ * path like saving to a temp file).
+ */
+export declare function extractToolResultMediaPaths(result: unknown): string[];
+export declare function isToolResultError(result: unknown): boolean;
+export declare function extractToolErrorMessage(result: unknown): string | undefined;
+export declare function extractMessagingToolSend(toolName: string, args: Record<string, unknown>): MessagingToolSend | undefined;

package/dist/plugin-sdk/agents/pi-embedded-subscribe.types.d.ts

@@ -0,0 +1,45 @@
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { ReasoningLevel, VerboseLevel } from "../auto-reply/thinking.js";
+import type { OpenClawConfig } from "../config/types.openclaw.js";
+import type { HookRunner } from "../plugins/hooks.js";
+import type { BlockReplyChunking } from "./pi-embedded-block-chunker.js";
+import type { BlockReplyPayload } from "./pi-embedded-payloads.js";
+export type ToolResultFormat = "markdown" | "plain";
+export type SubscribeEmbeddedPiSessionParams = {
+    session: AgentSession;
+    runId: string;
+    hookRunner?: HookRunner;
+    verboseLevel?: VerboseLevel;
+    reasoningMode?: ReasoningLevel;
+    toolResultFormat?: ToolResultFormat;
+    shouldEmitToolResult?: () => boolean;
+    shouldEmitToolOutput?: () => boolean;
+    onToolResult?: (payload: {
+        text?: string;
+        mediaUrls?: string[];
+    }) => void | Promise<void>;
+    onReasoningStream?: (payload: {
+        text?: string;
+        mediaUrls?: string[];
+    }) => void | Promise<void>;
+    /** Called when a thinking/reasoning block ends (</think> tag processed). */
+    onReasoningEnd?: () => void | Promise<void>;
+    onBlockReply?: (payload: BlockReplyPayload) => void | Promise<void>;
+    /** Flush pending block replies (e.g., before tool execution to preserve message boundaries). */
+    onBlockReplyFlush?: () => void | Promise<void>;
+    blockReplyBreak?: "text_end" | "message_end";
+    blockReplyChunking?: BlockReplyChunking;
+    onPartialReply?: (payload: {
+        text?: string;
+        mediaUrls?: string[];
+    }) => void | Promise<void>;
+    onAssistantMessageStart?: () => void | Promise<void>;
+    onAgentEvent?: (evt: {
+        stream: string;
+        data: Record<string, unknown>;
+    }) => void | Promise<void>;
+    enforceFinalTag?: boolean;
+    config?: OpenClawConfig;
+    sessionKey?: string;
+};
+export type { BlockReplyChunking } from "./pi-embedded-block-chunker.js";

package/dist/plugin-sdk/agents/pi-embedded-utils.d.ts

@@ -0,0 +1,40 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+export declare function isAssistantMessage(msg: AgentMessage | undefined): msg is AssistantMessage;
+/**
+ * Strip malformed Minimax tool invocations that leak into text content.
+ * Minimax sometimes embeds tool calls as XML in text blocks instead of
+ * proper structured tool calls. This removes:
+ * - <invoke name="...">...</invoke> blocks
+ * - </minimax:tool_call> closing tags
+ */
+export declare function stripMinimaxToolCallXml(text: string): string;
+/**
+ * Strip downgraded tool call text representations that leak into text content.
+ * When replaying history to Gemini, tool calls without `thought_signature` are
+ * downgraded to text blocks like `[Tool Call: name (ID: ...)]`. These should
+ * not be shown to users.
+ */
+export declare function stripDowngradedToolCallText(text: string): string;
+/**
+ * Strip thinking tags and their content from text.
+ * This is a safety net for cases where the model outputs <think> tags
+ * that slip through other filtering mechanisms.
+ */
+export declare function stripThinkingTagsFromText(text: string): string;
+export declare function extractAssistantText(msg: AssistantMessage): string;
+export declare function extractAssistantThinking(msg: AssistantMessage): string;
+export declare function formatReasoningMessage(text: string): string;
+type ThinkTaggedSplitBlock = {
+    type: "thinking";
+    thinking: string;
+} | {
+    type: "text";
+    text: string;
+};
+export declare function splitThinkingTaggedText(text: string): ThinkTaggedSplitBlock[] | null;
+export declare function promoteThinkingTagsToBlocks(message: AssistantMessage): void;
+export declare function extractThinkingFromTaggedText(text: string): string;
+export declare function extractThinkingFromTaggedStream(text: string): string;
+export declare function inferToolMetaFromArgs(toolName: string, args: unknown): string | undefined;
+export {};

package/dist/plugin-sdk/agents/pi-embedded.d.ts

@@ -0,0 +1,2 @@
+export type { EmbeddedPiAgentMeta, EmbeddedPiCompactResult, EmbeddedPiRunMeta, EmbeddedPiRunResult, } from "./pi-embedded-runner.js";
+export { abortEmbeddedPiRun, compactEmbeddedPiSession, isEmbeddedPiRunActive, isEmbeddedPiRunStreaming, queueEmbeddedPiMessage, resolveEmbeddedSessionLane, runEmbeddedPiAgent, waitForEmbeddedPiRunEnd, } from "./pi-embedded-runner.js";

package/dist/plugin-sdk/agents/pi-extensions/compaction-safeguard-runtime.d.ts

@@ -0,0 +1,6 @@
+export type CompactionSafeguardRuntimeValue = {
+    maxHistoryShare?: number;
+    contextWindowTokens?: number;
+};
+export declare const setCompactionSafeguardRuntime: (sessionManager: unknown, value: CompactionSafeguardRuntimeValue | null) => void;
+export declare const getCompactionSafeguardRuntime: (sessionManager: unknown) => CompactionSafeguardRuntimeValue | null;

package/dist/plugin-sdk/agents/pi-extensions/compaction-safeguard.d.ts

@@ -0,0 +1,22 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { computeAdaptiveChunkRatio, isOversizedForSummary } from "../compaction.js";
+type ToolFailure = {
+    toolCallId: string;
+    toolName: string;
+    summary: string;
+    meta?: string;
+};
+declare function collectToolFailures(messages: AgentMessage[]): ToolFailure[];
+declare function formatToolFailuresSection(failures: ToolFailure[]): string;
+export default function compactionSafeguardExtension(api: ExtensionAPI): void;
+export declare const __testing: {
+    readonly collectToolFailures: typeof collectToolFailures;
+    readonly formatToolFailuresSection: typeof formatToolFailuresSection;
+    readonly computeAdaptiveChunkRatio: typeof computeAdaptiveChunkRatio;
+    readonly isOversizedForSummary: typeof isOversizedForSummary;
+    readonly BASE_CHUNK_RATIO: 0.4;
+    readonly MIN_CHUNK_RATIO: 0.15;
+    readonly SAFETY_MARGIN: 1.2;
+};
+export {};

package/dist/plugin-sdk/agents/pi-extensions/context-pruning/extension.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+export default function contextPruningExtension(api: ExtensionAPI): void;

package/dist/plugin-sdk/agents/pi-extensions/context-pruning/pruner.d.ts

@@ -0,0 +1,10 @@
+import type { AgentMessage } from "@mariozechner/pi-agent-core";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { EffectiveContextPruningSettings } from "./settings.js";
+export declare function pruneContextMessages(params: {
+    messages: AgentMessage[];
+    settings: EffectiveContextPruningSettings;
+    ctx: Pick<ExtensionContext, "model">;
+    isToolPrunable?: (toolName: string) => boolean;
+    contextWindowTokensOverride?: number;
+}): AgentMessage[];

package/dist/plugin-sdk/agents/pi-extensions/context-pruning/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { EffectiveContextPruningSettings } from "./settings.js";
+export type ContextPruningRuntimeValue = {
+    settings: EffectiveContextPruningSettings;
+    contextWindowTokens?: number | null;
+    isToolPrunable: (toolName: string) => boolean;
+    lastCacheTouchAt?: number | null;
+};
+export declare const setContextPruningRuntime: (sessionManager: unknown, value: ContextPruningRuntimeValue | null) => void;
+export declare const getContextPruningRuntime: (sessionManager: unknown) => ContextPruningRuntimeValue | null;

package/dist/plugin-sdk/agents/pi-extensions/context-pruning/settings.d.ts

@@ -0,0 +1,44 @@
+export type ContextPruningToolMatch = {
+    allow?: string[];
+    deny?: string[];
+};
+export type ContextPruningMode = "off" | "cache-ttl";
+export type ContextPruningConfig = {
+    mode?: ContextPruningMode;
+    /** TTL to consider cache expired (duration string, default unit: minutes). */
+    ttl?: string;
+    keepLastAssistants?: number;
+    softTrimRatio?: number;
+    hardClearRatio?: number;
+    minPrunableToolChars?: number;
+    tools?: ContextPruningToolMatch;
+    softTrim?: {
+        maxChars?: number;
+        headChars?: number;
+        tailChars?: number;
+    };
+    hardClear?: {
+        enabled?: boolean;
+        placeholder?: string;
+    };
+};
+export type EffectiveContextPruningSettings = {
+    mode: Exclude<ContextPruningMode, "off">;
+    ttlMs: number;
+    keepLastAssistants: number;
+    softTrimRatio: number;
+    hardClearRatio: number;
+    minPrunableToolChars: number;
+    tools: ContextPruningToolMatch;
+    softTrim: {
+        maxChars: number;
+        headChars: number;
+        tailChars: number;
+    };
+    hardClear: {
+        enabled: boolean;
+        placeholder: string;
+    };
+};
+export declare const DEFAULT_CONTEXT_PRUNING_SETTINGS: EffectiveContextPruningSettings;
+export declare function computeEffectiveSettings(raw: unknown): EffectiveContextPruningSettings | null;

package/dist/plugin-sdk/agents/pi-extensions/context-pruning/tools.d.ts

@@ -0,0 +1,2 @@
+import type { ContextPruningToolMatch } from "./settings.js";
+export declare function makeToolPrunablePredicate(match: ContextPruningToolMatch): (toolName: string) => boolean;

package/dist/plugin-sdk/agents/pi-extensions/context-pruning.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Opt-in context pruning (“microcompact”-style) for Pi sessions.
+ *
+ * This only affects the in-memory context for the current request; it does not rewrite session
+ * history persisted on disk.
+ */
+export { default } from "./context-pruning/extension.js";
+export { pruneContextMessages } from "./context-pruning/pruner.js";
+export type { ContextPruningConfig, ContextPruningToolMatch, EffectiveContextPruningSettings, } from "./context-pruning/settings.js";
+export { computeEffectiveSettings, DEFAULT_CONTEXT_PRUNING_SETTINGS, } from "./context-pruning/settings.js";

package/dist/plugin-sdk/agents/pi-extensions/session-manager-runtime-registry.d.ts

@@ -0,0 +1,4 @@
+export declare function createSessionManagerRuntimeRegistry<TValue>(): {
+    set: (sessionManager: unknown, value: TValue | null) => void;
+    get: (sessionManager: unknown) => TValue | null;
+};

package/dist/plugin-sdk/agents/pi-model-discovery.d.ts

@@ -0,0 +1,4 @@
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+export { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+export declare function discoverAuthStorage(agentDir: string): AuthStorage;
+export declare function discoverModels(authStorage: AuthStorage, agentDir: string): ModelRegistry;

package/dist/plugin-sdk/agents/pi-settings.d.ts

@@ -0,0 +1,31 @@
+import type { OpenClawConfig } from "../config/config.js";
+export declare const DEFAULT_PI_COMPACTION_RESERVE_TOKENS_FLOOR = 20000;
+type PiSettingsManagerLike = {
+    getCompactionReserveTokens: () => number;
+    getCompactionKeepRecentTokens: () => number;
+    applyOverrides: (overrides: {
+        compaction: {
+            reserveTokens?: number;
+            keepRecentTokens?: number;
+        };
+    }) => void;
+};
+export declare function ensurePiCompactionReserveTokens(params: {
+    settingsManager: PiSettingsManagerLike;
+    minReserveTokens?: number;
+}): {
+    didOverride: boolean;
+    reserveTokens: number;
+};
+export declare function resolveCompactionReserveTokensFloor(cfg?: OpenClawConfig): number;
+export declare function applyPiCompactionSettingsFromConfig(params: {
+    settingsManager: PiSettingsManagerLike;
+    cfg?: OpenClawConfig;
+}): {
+    didOverride: boolean;
+    compaction: {
+        reserveTokens: number;
+        keepRecentTokens: number;
+    };
+};
+export {};

package/dist/plugin-sdk/agents/pi-tool-definition-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { ClientToolDefinition } from "./pi-embedded-runner/run/params.js";
+import type { HookContext } from "./pi-tools.before-tool-call.js";
+type AnyAgentTool = AgentTool;
+export declare function toToolDefinitions(tools: AnyAgentTool[]): ToolDefinition[];
+export declare function toClientToolDefinitions(tools: ClientToolDefinition[], onClientToolCall?: (toolName: string, params: Record<string, unknown>) => void, hookContext?: HookContext): ToolDefinition[];
+export {};

package/dist/plugin-sdk/agents/pi-tools.abort.d.ts

@@ -0,0 +1,2 @@
+import type { AnyAgentTool } from "./pi-tools.types.js";
+export declare function wrapToolWithAbortSignal(tool: AnyAgentTool, abortSignal?: AbortSignal): AnyAgentTool;

package/dist/plugin-sdk/agents/pi-tools.before-tool-call.d.ts

@@ -0,0 +1,31 @@
+import type { ToolLoopDetectionConfig } from "../config/types.tools.js";
+import { isPlainObject } from "../utils.js";
+import type { AnyAgentTool } from "./tools/common.js";
+export type HookContext = {
+    agentId?: string;
+    sessionKey?: string;
+    loopDetection?: ToolLoopDetectionConfig;
+};
+type HookOutcome = {
+    blocked: true;
+    reason: string;
+} | {
+    blocked: false;
+    params: unknown;
+};
+export declare function runBeforeToolCallHook(args: {
+    toolName: string;
+    params: unknown;
+    toolCallId?: string;
+    ctx?: HookContext;
+}): Promise<HookOutcome>;
+export declare function wrapToolWithBeforeToolCallHook(tool: AnyAgentTool, ctx?: HookContext): AnyAgentTool;
+export declare function isToolWrappedWithBeforeToolCallHook(tool: AnyAgentTool): boolean;
+export declare function consumeAdjustedParamsForToolCall(toolCallId: string): unknown;
+export declare const __testing: {
+    BEFORE_TOOL_CALL_WRAPPED: symbol;
+    adjustedParamsByToolCallId: Map<string, unknown>;
+    runBeforeToolCallHook: typeof runBeforeToolCallHook;
+    isPlainObject: typeof isPlainObject;
+};
+export {};

package/dist/plugin-sdk/agents/pi-tools.d.ts

@@ -0,0 +1,76 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { ToolLoopDetectionConfig } from "../config/types.tools.js";
+import { type ExecToolDefaults, type ProcessToolDefaults } from "./bash-tools.js";
+import type { ModelAuthMode } from "./model-auth.js";
+import { assertRequiredParams, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization } from "./pi-tools.read.js";
+import { cleanToolSchemaForGemini } from "./pi-tools.schema.js";
+import type { AnyAgentTool } from "./pi-tools.types.js";
+import type { SandboxContext } from "./sandbox.js";
+export declare function resolveToolLoopDetectionConfig(params: {
+    cfg?: OpenClawConfig;
+    agentId?: string;
+}): ToolLoopDetectionConfig | undefined;
+export declare const __testing: {
+    readonly cleanToolSchemaForGemini: typeof cleanToolSchemaForGemini;
+    readonly normalizeToolParams: typeof normalizeToolParams;
+    readonly patchToolSchemaForClaudeCompatibility: typeof patchToolSchemaForClaudeCompatibility;
+    readonly wrapToolParamNormalization: typeof wrapToolParamNormalization;
+    readonly assertRequiredParams: typeof assertRequiredParams;
+};
+export declare function createOpenClawCodingTools(options?: {
+    exec?: ExecToolDefaults & ProcessToolDefaults;
+    messageProvider?: string;
+    agentAccountId?: string;
+    messageTo?: string;
+    messageThreadId?: string | number;
+    sandbox?: SandboxContext | null;
+    sessionKey?: string;
+    agentDir?: string;
+    workspaceDir?: string;
+    config?: OpenClawConfig;
+    abortSignal?: AbortSignal;
+    /**
+     * Provider of the currently selected model (used for provider-specific tool quirks).
+     * Example: "anthropic", "openai", "google", "openai-codex".
+     */
+    modelProvider?: string;
+    /** Model id for the current provider (used for model-specific tool gating). */
+    modelId?: string;
+    /** Model context window in tokens (used to scale read-tool output budget). */
+    modelContextWindowTokens?: number;
+    /**
+     * Auth mode for the current provider. We only need this for Anthropic OAuth
+     * tool-name blocking quirks.
+     */
+    modelAuthMode?: ModelAuthMode;
+    /** Current channel ID for auto-threading (Slack). */
+    currentChannelId?: string;
+    /** Current thread timestamp for auto-threading (Slack). */
+    currentThreadTs?: string;
+    /** Group id for channel-level tool policy resolution. */
+    groupId?: string | null;
+    /** Group channel label (e.g. #general) for channel-level tool policy resolution. */
+    groupChannel?: string | null;
+    /** Group space label (e.g. guild/team id) for channel-level tool policy resolution. */
+    groupSpace?: string | null;
+    /** Parent session key for subagent group policy inheritance. */
+    spawnedBy?: string | null;
+    senderId?: string | null;
+    senderName?: string | null;
+    senderUsername?: string | null;
+    senderE164?: string | null;
+    /** Reply-to mode for Slack auto-threading. */
+    replyToMode?: "off" | "first" | "all";
+    /** Mutable ref to track if a reply was sent (for "first" mode). */
+    hasRepliedRef?: {
+        value: boolean;
+    };
+    /** If true, the model has native vision capability */
+    modelHasVision?: boolean;
+    /** Require explicit message targets (no implicit last-route sends). */
+    requireExplicitMessageTarget?: boolean;
+    /** If true, omit the message tool from the tool list. */
+    disableMessageTool?: boolean;
+    /** Whether the sender is an owner (required for owner-only tools). */
+    senderIsOwner?: boolean;
+}): AnyAgentTool[];

package/dist/plugin-sdk/agents/pi-tools.policy.d.ts

@@ -0,0 +1,37 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { AnyAgentTool } from "./pi-tools.types.js";
+import type { SandboxToolPolicy } from "./sandbox.js";
+export declare function resolveSubagentToolPolicy(cfg?: OpenClawConfig, depth?: number): SandboxToolPolicy;
+export declare function isToolAllowedByPolicyName(name: string, policy?: SandboxToolPolicy): boolean;
+export declare function filterToolsByPolicy(tools: AnyAgentTool[], policy?: SandboxToolPolicy): AnyAgentTool[];
+export declare function resolveEffectiveToolPolicy(params: {
+    config?: OpenClawConfig;
+    sessionKey?: string;
+    modelProvider?: string;
+    modelId?: string;
+}): {
+    agentId: string | undefined;
+    globalPolicy: SandboxToolPolicy | undefined;
+    globalProviderPolicy: SandboxToolPolicy | undefined;
+    agentPolicy: SandboxToolPolicy | undefined;
+    agentProviderPolicy: SandboxToolPolicy | undefined;
+    profile: import("../config/types.tools.ts").ToolProfileId | undefined;
+    providerProfile: string | undefined;
+    profileAlsoAllow: string[] | undefined;
+    providerProfileAlsoAllow: string[] | undefined;
+};
+export declare function resolveGroupToolPolicy(params: {
+    config?: OpenClawConfig;
+    sessionKey?: string;
+    spawnedBy?: string | null;
+    messageProvider?: string;
+    groupId?: string | null;
+    groupChannel?: string | null;
+    groupSpace?: string | null;
+    accountId?: string | null;
+    senderId?: string | null;
+    senderName?: string | null;
+    senderUsername?: string | null;
+    senderE164?: string | null;
+}): SandboxToolPolicy | undefined;
+export declare function isToolAllowedByPolicies(name: string, policies: Array<SandboxToolPolicy | undefined>): boolean;