@noxsoft/anima 2.0.0

package/dist/plugin-sdk/agents/model-fallback.d.ts

@@ -0,0 +1,40 @@
+import type { AnimaConfig } from "../config/config.js";
+import type { FailoverReason } from "./pi-embedded-helpers.js";
+type FallbackAttempt = {
+    provider: string;
+    model: string;
+    error: string;
+    reason?: FailoverReason;
+    status?: number;
+    code?: string;
+};
+type ModelFallbackErrorHandler = (attempt: {
+    provider: string;
+    model: string;
+    error: unknown;
+    attempt: number;
+    total: number;
+}) => void | Promise<void>;
+type ModelFallbackRunResult<T> = {
+    result: T;
+    provider: string;
+    model: string;
+    attempts: FallbackAttempt[];
+};
+export declare function runWithModelFallback<T>(params: {
+    cfg: AnimaConfig | undefined;
+    provider: string;
+    model: string;
+    agentDir?: string;
+    /** Optional explicit fallbacks list; when provided (even empty), replaces agents.defaults.model.fallbacks. */
+    fallbacksOverride?: string[];
+    run: (provider: string, model: string) => Promise<T>;
+    onError?: ModelFallbackErrorHandler;
+}): Promise<ModelFallbackRunResult<T>>;
+export declare function runWithImageModelFallback<T>(params: {
+    cfg: AnimaConfig | undefined;
+    modelOverride?: string;
+    run: (provider: string, model: string) => Promise<T>;
+    onError?: ModelFallbackErrorHandler;
+}): Promise<ModelFallbackRunResult<T>>;
+export {};

package/dist/plugin-sdk/agents/model-selection.d.ts

@@ -0,0 +1,94 @@
+import type { AnimaConfig } from "../config/config.js";
+import type { ModelCatalogEntry } from "./model-catalog.js";
+export type ModelRef = {
+    provider: string;
+    model: string;
+};
+export type ThinkLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+export type ModelAliasIndex = {
+    byAlias: Map<string, {
+        alias: string;
+        ref: ModelRef;
+    }>;
+    byKey: Map<string, string[]>;
+};
+export declare function modelKey(provider: string, model: string): string;
+export declare function normalizeProviderId(provider: string): string;
+export declare function isCliProvider(provider: string, cfg?: AnimaConfig): boolean;
+export declare function normalizeModelRef(provider: string, model: string): ModelRef;
+export declare function parseModelRef(raw: string, defaultProvider: string): ModelRef | null;
+export declare function resolveAllowlistModelKey(raw: string, defaultProvider: string): string | null;
+export declare function buildConfiguredAllowlistKeys(params: {
+    cfg: AnimaConfig | undefined;
+    defaultProvider: string;
+}): Set<string> | null;
+export declare function buildModelAliasIndex(params: {
+    cfg: AnimaConfig;
+    defaultProvider: string;
+}): ModelAliasIndex;
+export declare function resolveModelRefFromString(params: {
+    raw: string;
+    defaultProvider: string;
+    aliasIndex?: ModelAliasIndex;
+}): {
+    ref: ModelRef;
+    alias?: string;
+} | null;
+export declare function resolveConfiguredModelRef(params: {
+    cfg: AnimaConfig;
+    defaultProvider: string;
+    defaultModel: string;
+}): ModelRef;
+export declare function resolveDefaultModelForAgent(params: {
+    cfg: AnimaConfig;
+    agentId?: string;
+}): ModelRef;
+export declare function buildAllowedModelSet(params: {
+    cfg: AnimaConfig;
+    catalog: ModelCatalogEntry[];
+    defaultProvider: string;
+    defaultModel?: string;
+}): {
+    allowAny: boolean;
+    allowedCatalog: ModelCatalogEntry[];
+    allowedKeys: Set<string>;
+};
+export type ModelRefStatus = {
+    key: string;
+    inCatalog: boolean;
+    allowAny: boolean;
+    allowed: boolean;
+};
+export declare function getModelRefStatus(params: {
+    cfg: AnimaConfig;
+    catalog: ModelCatalogEntry[];
+    ref: ModelRef;
+    defaultProvider: string;
+    defaultModel?: string;
+}): ModelRefStatus;
+export declare function resolveAllowedModelRef(params: {
+    cfg: AnimaConfig;
+    catalog: ModelCatalogEntry[];
+    raw: string;
+    defaultProvider: string;
+    defaultModel?: string;
+}): {
+    ref: ModelRef;
+    key: string;
+} | {
+    error: string;
+};
+export declare function resolveThinkingDefault(params: {
+    cfg: AnimaConfig;
+    provider: string;
+    model: string;
+    catalog?: ModelCatalogEntry[];
+}): ThinkLevel;
+/**
+ * Resolve the model configured for Gmail hook processing.
+ * Returns null if hooks.gmail.model is not set.
+ */
+export declare function resolveHooksGmailModel(params: {
+    cfg: AnimaConfig;
+    defaultProvider: string;
+}): ModelRef | null;

package/dist/plugin-sdk/agents/models-config.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Models configuration — SIMPLIFIED
+ *
+ * The multi-provider LLM abstraction (pi-ai) has been removed.
+ * ANIMA uses Claude Code CLI exclusively. This file retains only
+ * the minimal interface needed by the rest of the codebase.
+ * Full replacement comes in Phase 2.
+ */
+import { type AnimaConfig } from "../config/config.js";
+export declare function ensureAnimaModelsJson(config?: AnimaConfig, agentDirOverride?: string): Promise<{
+    agentDir: string;
+    wrote: boolean;
+}>;

package/dist/plugin-sdk/agents/models-config.providers.d.ts

@@ -0,0 +1,37 @@
+import type { AnimaConfig } from "../config/config.js";
+type ModelsConfig = NonNullable<AnimaConfig["models"]>;
+export type ProviderConfig = NonNullable<ModelsConfig["providers"]>[string];
+export declare const XIAOMI_DEFAULT_MODEL_ID = "mimo-v2-flash";
+export declare const QIANFAN_BASE_URL = "https://qianfan.baidubce.com/v2";
+export declare const QIANFAN_DEFAULT_MODEL_ID = "deepseek-v3.2";
+/**
+ * Derive the Ollama native API base URL from a configured base URL.
+ *
+ * Users typically configure `baseUrl` with a `/v1` suffix (e.g.
+ * `http://192.168.20.14:11434/v1`) for the OpenAI-compatible endpoint.
+ * The native Ollama API lives at the root (e.g. `/api/tags`), so we
+ * strip the `/v1` suffix when present.
+ */
+export declare function resolveOllamaApiBase(configuredBaseUrl?: string): string;
+export declare function normalizeGoogleModelId(id: string): string;
+export declare function normalizeProviders(params: {
+    providers: ModelsConfig["providers"];
+    agentDir: string;
+}): ModelsConfig["providers"];
+export declare function buildXiaomiProvider(): ProviderConfig;
+export declare function buildQianfanProvider(): ProviderConfig;
+export declare function buildNvidiaProvider(): ProviderConfig;
+export declare function resolveImplicitProviders(params: {
+    agentDir: string;
+    explicitProviders?: Record<string, ProviderConfig> | null;
+}): Promise<ModelsConfig["providers"]>;
+export declare function resolveImplicitCopilotProvider(params: {
+    agentDir: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ProviderConfig | null>;
+export declare function resolveImplicitBedrockProvider(params: {
+    agentDir: string;
+    config?: AnimaConfig;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ProviderConfig | null>;
+export {};

package/dist/plugin-sdk/agents/ollama-stream.d.ts

@@ -0,0 +1,45 @@
+import type { StreamFn } from "@mariozechner/pi-agent-core";
+import type { AssistantMessage } from "@mariozechner/pi-ai";
+export declare const OLLAMA_NATIVE_BASE_URL = "http://127.0.0.1:11434";
+interface OllamaChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    images?: string[];
+    tool_calls?: OllamaToolCall[];
+    tool_name?: string;
+}
+interface OllamaToolCall {
+    function: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+}
+interface OllamaChatResponse {
+    model: string;
+    created_at: string;
+    message: {
+        role: "assistant";
+        content: string;
+        tool_calls?: OllamaToolCall[];
+    };
+    done: boolean;
+    done_reason?: string;
+    total_duration?: number;
+    load_duration?: number;
+    prompt_eval_count?: number;
+    prompt_eval_duration?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+export declare function convertToOllamaMessages(messages: Array<{
+    role: string;
+    content: unknown;
+}>, system?: string): OllamaChatMessage[];
+export declare function buildAssistantMessage(response: OllamaChatResponse, modelInfo: {
+    api: string;
+    provider: string;
+    id: string;
+}): AssistantMessage;
+export declare function parseNdjsonStream(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<OllamaChatResponse>;
+export declare function createOllamaStreamFn(baseUrl: string): StreamFn;
+export {};

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

@@ -0,0 +1,46 @@
+import type { AnimaConfig } from "../config/config.js";
+import type { GatewayMessageChannel } from "../utils/message-channel.js";
+import type { SandboxFsBridge } from "./sandbox/fs-bridge.js";
+import type { AnyAgentTool } from "./tools/common.js";
+export declare function createAnimaTools(options?: {
+    sandboxBrowserBridgeUrl?: string;
+    allowHostBrowserControl?: boolean;
+    agentSessionKey?: string;
+    agentChannel?: GatewayMessageChannel;
+    agentAccountId?: string;
+    /** Delivery target (e.g. telegram:group:123:topic:456) for topic/thread routing. */
+    agentTo?: string;
+    /** Thread/topic identifier for routing replies to the originating thread. */
+    agentThreadId?: string | number;
+    /** Group id for channel-level tool policy inheritance. */
+    agentGroupId?: string | null;
+    /** Group channel label for channel-level tool policy inheritance. */
+    agentGroupChannel?: string | null;
+    /** Group space label for channel-level tool policy inheritance. */
+    agentGroupSpace?: string | null;
+    agentDir?: string;
+    sandboxRoot?: string;
+    sandboxFsBridge?: SandboxFsBridge;
+    workspaceDir?: string;
+    sandboxed?: boolean;
+    config?: AnimaConfig;
+    pluginToolAllowlist?: string[];
+    /** Current channel ID for auto-threading (Slack). */
+    currentChannelId?: string;
+    /** Current thread timestamp for auto-threading (Slack). */
+    currentThreadTs?: string;
+    /** 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;
+    /** Explicit agent ID override for cron/hook sessions. */
+    requesterAgentIdOverride?: string;
+    /** Require explicit message targets (no implicit last-route sends). */
+    requireExplicitMessageTarget?: boolean;
+    /** If true, omit the message tool from the tool list. */
+    disableMessageTool?: boolean;
+}): AnyAgentTool[];

package/dist/plugin-sdk/agents/pi-auth-json.d.ts

@@ -0,0 +1,14 @@
+/**
+ * pi-coding-agent's ModelRegistry/AuthStorage expects OAuth credentials in auth.json.
+ *
+ * Anima stores OAuth credentials in auth-profiles.json instead. This helper
+ * bridges a subset of credentials into agentDir/auth.json so pi-coding-agent can
+ * (a) consider the provider authenticated and (b) include built-in models in its
+ * registry/catalog output.
+ *
+ * Currently used for openai-codex.
+ */
+export declare function ensurePiAuthJsonFromAuthProfiles(agentDir: string): Promise<{
+    wrote: boolean;
+    authPath: string;
+}>;

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

@@ -0,0 +1,7 @@
+export {};
+/**
+ * STUBBED — the original pi-embedded provider removed.
+ * ANIMA uses Claude Code CLI as its sole interface to Claude.
+ * This file is kept as a stub to prevent import breakage during Phase 1.
+ * Full replacement comes in Phase 2 (Task 7: Claude Code CLI Spawner).
+ */

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

@@ -0,0 +1 @@
+export declare function resolveModel(..._args: unknown[]): string;

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

@@ -0,0 +1,5 @@
+export type ClientToolDefinition = {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Pi-embedded runner — STUBBED
+ *
+ * The the original pi-embedded LLM provider abstraction has been removed.
+ * ANIMA uses Claude Code CLI as its sole interface to Claude.
+ * These exports are kept as stubs to prevent import breakage during Phase 1.
+ */
+export type { EmbeddedPiAgentMeta, EmbeddedPiCompactResult, EmbeddedPiRunMeta, EmbeddedPiRunResult, } from "./pi-embedded.js";
+export { runEmbeddedPiAgent, compactEmbeddedPiSession, abortEmbeddedPiRun, isEmbeddedPiRunActive, isEmbeddedPiRunStreaming, queueEmbeddedPiMessage, resolveEmbeddedSessionLane, waitForEmbeddedPiRunEnd, } from "./pi-embedded.js";
+export type MessagingToolSend = {
+    to: string;
+    text: string;
+};
+export declare function applyExtraParamsToAgent(): void;
+export declare function resolveExtraParams(): Record<string, unknown>;
+export declare function applyGoogleTurnOrderingFix(): void;
+export declare function getDmHistoryLimitFromSessionKey(): number | undefined;
+export declare function getHistoryLimitFromSessionKey(): number | undefined;
+export declare function limitHistoryTurns(): void;
+export declare function buildEmbeddedSandboxInfo(): Record<string, unknown>;
+export declare function createSystemPromptOverride(): string | undefined;
+export declare function splitSdkTools(): {
+    local: unknown[];
+    remote: unknown[];
+};

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

@@ -0,0 +1,7 @@
+export {};
+/**
+ * STUBBED — the original pi-embedded provider removed.
+ * ANIMA uses Claude Code CLI as its sole interface to Claude.
+ * This file is kept as a stub to prevent import breakage during Phase 1.
+ * Full replacement comes in Phase 2 (Task 7: Claude Code CLI Spawner).
+ */

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

@@ -0,0 +1,25 @@
+/**
+ * Pi-embedded agent — STUBBED
+ *
+ * The the original pi-embedded LLM provider abstraction has been removed.
+ * ANIMA uses Claude Code CLI as its sole interface to Claude.
+ * These exports are kept as stubs to prevent import breakage during Phase 1.
+ * Full replacement comes in Phase 2 (Task 7: Claude Code CLI Spawner).
+ */
+export type EmbeddedPiAgentMeta = Record<string, unknown>;
+export type EmbeddedPiCompactResult = {
+    ok: boolean;
+};
+export type EmbeddedPiRunMeta = Record<string, unknown>;
+export type EmbeddedPiRunResult = {
+    status: "completed" | "failed" | "timeout";
+    output?: string;
+};
+export declare function runEmbeddedPiAgent(): Promise<EmbeddedPiRunResult>;
+export declare function compactEmbeddedPiSession(): Promise<EmbeddedPiCompactResult>;
+export declare function abortEmbeddedPiRun(): void;
+export declare function isEmbeddedPiRunActive(): boolean;
+export declare function isEmbeddedPiRunStreaming(): boolean;
+export declare function queueEmbeddedPiMessage(): void;
+export declare function resolveEmbeddedSessionLane(): string;
+export declare function waitForEmbeddedPiRunEnd(): Promise<void>;

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,19 @@
+import type { AnimaConfig } from "../config/config.js";
+export declare const DEFAULT_PI_COMPACTION_RESERVE_TOKENS_FLOOR = 20000;
+type PiSettingsManagerLike = {
+    getCompactionReserveTokens: () => number;
+    applyOverrides: (overrides: {
+        compaction: {
+            reserveTokens: number;
+        };
+    }) => void;
+};
+export declare function ensurePiCompactionReserveTokens(params: {
+    settingsManager: PiSettingsManagerLike;
+    minReserveTokens?: number;
+}): {
+    didOverride: boolean;
+    reserveTokens: number;
+};
+export declare function resolveCompactionReserveTokensFloor(cfg?: AnimaConfig): number;
+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,29 @@
+import type { AnyAgentTool } from "./tools/common.js";
+import { isPlainObject } from "../utils.js";
+type HookContext = {
+    agentId?: string;
+    sessionKey?: string;
+};
+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,69 @@
+import type { AnimaConfig } from "../config/config.js";
+import type { ModelAuthMode } from "./model-auth.js";
+import type { AnyAgentTool } from "./pi-tools.types.js";
+import type { SandboxContext } from "./sandbox.js";
+import { type ExecToolDefaults, type ProcessToolDefaults } from "./bash-tools.js";
+import { assertRequiredParams, normalizeToolParams, patchToolSchemaForClaudeCompatibility, wrapToolParamNormalization } from "./pi-tools.read.js";
+import { cleanToolSchemaForGemini } from "./pi-tools.schema.js";
+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 createAnimaCodingTools(options?: {
+    exec?: ExecToolDefaults & ProcessToolDefaults;
+    messageProvider?: string;
+    agentAccountId?: string;
+    messageTo?: string;
+    messageThreadId?: string | number;
+    sandbox?: SandboxContext | null;
+    sessionKey?: string;
+    agentDir?: string;
+    workspaceDir?: string;
+    config?: AnimaConfig;
+    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;
+    /**
+     * 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 { AnimaConfig } from "../config/config.js";
+import type { AnyAgentTool } from "./pi-tools.types.js";
+import type { SandboxToolPolicy } from "./sandbox.js";
+export declare function resolveSubagentToolPolicy(cfg?: AnimaConfig, depth?: number): SandboxToolPolicy;
+export declare function isToolAllowedByPolicyName(name: string, policy?: SandboxToolPolicy): boolean;
+export declare function filterToolsByPolicy(tools: AnyAgentTool[], policy?: SandboxToolPolicy): AgentTool<any, unknown>[];
+export declare function resolveEffectiveToolPolicy(params: {
+    config?: AnimaConfig;
+    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?: AnimaConfig;
+    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;

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

@@ -0,0 +1,44 @@
+import type { AnyAgentTool } from "./pi-tools.types.js";
+import type { SandboxFsBridge } from "./sandbox/fs-bridge.js";
+type RequiredParamGroup = {
+    keys: readonly string[];
+    allowEmpty?: boolean;
+    label?: string;
+};
+export declare const CLAUDE_PARAM_GROUPS: {
+    readonly read: readonly [{
+        readonly keys: readonly ["path", "file_path"];
+        readonly label: "path (path or file_path)";
+    }];
+    readonly write: readonly [{
+        readonly keys: readonly ["path", "file_path"];
+        readonly label: "path (path or file_path)";
+    }, {
+        readonly keys: readonly ["content"];
+        readonly label: "content";
+    }];
+    readonly edit: readonly [{
+        readonly keys: readonly ["path", "file_path"];
+        readonly label: "path (path or file_path)";
+    }, {
+        readonly keys: readonly ["oldText", "old_string"];
+        readonly label: "oldText (oldText or old_string)";
+    }, {
+        readonly keys: readonly ["newText", "new_string"];
+        readonly label: "newText (newText or new_string)";
+    }];
+};
+export declare function normalizeToolParams(params: unknown): Record<string, unknown> | undefined;
+export declare function patchToolSchemaForClaudeCompatibility(tool: AnyAgentTool): AnyAgentTool;
+export declare function assertRequiredParams(record: Record<string, unknown> | undefined, groups: readonly RequiredParamGroup[], toolName: string): void;
+export declare function wrapToolParamNormalization(tool: AnyAgentTool, requiredParamGroups?: readonly RequiredParamGroup[]): AnyAgentTool;
+export declare function wrapToolWorkspaceRootGuard(tool: AnyAgentTool, root: string): AnyAgentTool;
+type SandboxToolParams = {
+    root: string;
+    bridge: SandboxFsBridge;
+};
+export declare function createSandboxedReadTool(params: SandboxToolParams): AgentTool<any, unknown>;
+export declare function createSandboxedWriteTool(params: SandboxToolParams): AgentTool<any, unknown>;
+export declare function createSandboxedEditTool(params: SandboxToolParams): AgentTool<any, unknown>;
+export declare function createAnimaReadTool(base: AnyAgentTool): AnyAgentTool;
+export {};

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

@@ -0,0 +1,3 @@
+import type { AnyAgentTool } from "./pi-tools.types.js";
+export declare function normalizeToolParameters(tool: AnyAgentTool): AnyAgentTool;
+export declare function cleanToolSchemaForGemini(schema: Record<string, unknown>): unknown;

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

@@ -0,0 +1,2 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+export type AnyAgentTool = AgentTool<any, unknown>;

package/dist/plugin-sdk/agents/pty-dsr.d.ts

@@ -0,0 +1,5 @@
+export declare function stripDsrRequests(input: string): {
+    cleaned: string;
+    requests: number;
+};
+export declare function buildCursorPositionResponse(row?: number, col?: number): string;

package/dist/plugin-sdk/agents/pty-keys.d.ts

@@ -0,0 +1,13 @@
+export declare const BRACKETED_PASTE_START = "\u001B[200~";
+export declare const BRACKETED_PASTE_END = "\u001B[201~";
+export type KeyEncodingRequest = {
+    keys?: string[];
+    hex?: string[];
+    literal?: string;
+};
+export type KeyEncodingResult = {
+    data: string;
+    warnings: string[];
+};
+export declare function encodeKeySequence(request: KeyEncodingRequest): KeyEncodingResult;
+export declare function encodePaste(text: string, bracketed?: boolean): string;

package/dist/plugin-sdk/agents/sandbox/browser-bridges.d.ts

@@ -0,0 +1,7 @@
+import type { BrowserBridge } from "../../browser/bridge-server.js";
+export declare const BROWSER_BRIDGES: Map<string, {
+    bridge: BrowserBridge;
+    containerName: string;
+    authToken?: string;
+    authPassword?: string;
+}>;

package/dist/plugin-sdk/agents/sandbox/browser.d.ts

@@ -0,0 +1,12 @@
+import type { SandboxBrowserContext, SandboxConfig } from "./types.js";
+export declare function ensureSandboxBrowser(params: {
+    scopeKey: string;
+    workspaceDir: string;
+    agentWorkspaceDir: string;
+    cfg: SandboxConfig;
+    evaluateEnabled?: boolean;
+    bridgeAuth?: {
+        token?: string;
+        password?: string;
+    };
+}): Promise<SandboxBrowserContext | null>;

package/dist/plugin-sdk/agents/sandbox/config-hash.d.ts

@@ -0,0 +1,17 @@
+import type { SandboxBrowserConfig, SandboxDockerConfig, SandboxWorkspaceAccess } from "./types.js";
+type SandboxHashInput = {
+    docker: SandboxDockerConfig;
+    workspaceAccess: SandboxWorkspaceAccess;
+    workspaceDir: string;
+    agentWorkspaceDir: string;
+};
+type SandboxBrowserHashInput = {
+    docker: SandboxDockerConfig;
+    browser: Pick<SandboxBrowserConfig, "cdpPort" | "vncPort" | "noVncPort" | "headless" | "enableNoVnc">;
+    workspaceAccess: SandboxWorkspaceAccess;
+    workspaceDir: string;
+    agentWorkspaceDir: string;
+};
+export declare function computeSandboxConfigHash(input: SandboxHashInput): string;
+export declare function computeSandboxBrowserConfigHash(input: SandboxBrowserHashInput): string;
+export {};