@pencil-agent/nano-pencil 1.14.2 → 1.14.4

package/dist/modes/interactive/interactive-mode.d.ts

@@ -306,6 +306,7 @@ export declare class InteractiveMode {
     private promptAfterRender;
     private updateEditorBorderColor;
     private cycleThinkingLevel;
+    private handleThinkingCommand;
     private handleAgentLoopCommand;
     private cycleModel;
     private toggleToolOutputExpansion;
@@ -398,7 +399,7 @@ export declare class InteractiveMode {
     private getEditorKeyDisplay;
     private handleHotkeysCommand;
     private handleClearCommand;
-    private handleDebugCommand;
+    private handleRenderDebugCommand;
     private handleArminSaysHi;
     private handleShowResourcesCommand;
     private handleDaxnuts;

package/dist/modes/interactive/interactive-mode.js

@@ -13,7 +13,7 @@ import { createCompactionSummaryMessage } from "../../core/messages.js";
 import { listMCPServers, setMCPServerEnabled } from "../../core/mcp/mcp-config.js";
 import { resolveModelScope } from "../../core/model-resolver.js";
 import { SessionManager, } from "../../core/session/session-manager.js";
-import { getLocalizedCommands } from "../../core/slash-commands.js";
+import { getExtensionBackedBuiltinCommandNames, formatSlashCommandDescription, getLocalizedCommands, inferSlashCommandCategory, } from "../../core/slash-commands.js";
 import { t } from "../../core/i18n/index.js";
 import { getActivePersonaId, getPersonaDir, getPersonaMcpConfigPath, getPersonaMemoryDir, getPersonaSoulDir, listPersonas, setActivePersonaId, toAbsolutePath, } from "../../core/persona/persona-manager.js";
 import { NANOPENCIL_ALI_TOKEN_PLAN_ANTHROPIC_PROVIDER, NANOPENCIL_ALI_TOKEN_PLAN_OPENAI_PROVIDER, NANOPENCIL_WHATS_NEW, } from "../../nanopencil-defaults.js";
@@ -58,6 +58,7 @@ import { UserMessageComponent } from "./components/user-message.js";
 import { UserMessageSelectorComponent } from "./components/user-message-selector.js";
 import { RawText } from "./components/raw-text.js";
 import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, initTheme, onThemeChange, setRegisteredThemes, setTheme, setThemeInstance, Theme, theme, } from "./theme/theme.js";
+import { getAgentLoopArgumentCompletions, getLanguageArgumentCompletions, getMcpArgumentCompletions, getPersonaArgumentCompletions, getThinkingArgumentCompletions, } from "./slash-command-arguments.js";
 function isExpandable(obj) {
     return (typeof obj === "object" &&
         obj !== null &&
@@ -230,7 +231,7 @@ export class InteractiveMode {
         const localizedCommands = getLocalizedCommands(t);
         const slashCommands = localizedCommands.map((command) => ({
             name: command.name,
-            description: command.description,
+            description: formatSlashCommandDescription(command.description, command.category, t),
         }));
         const modelCommand = slashCommands.find((command) => command.name === "model");
         if (modelCommand) {
@@ -258,16 +259,53 @@ export class InteractiveMode {
                 }));
             };
         }
+        const thinkingCommand = slashCommands.find((command) => command.name === "thinking");
+        if (thinkingCommand) {
+            thinkingCommand.getArgumentCompletions = (prefix, context) => getThinkingArgumentCompletions(prefix, context, this.session.getAvailableThinkingLevels());
+        }
+        const agentLoopCommand = slashCommands.find((command) => command.name === "agent-loop");
+        if (agentLoopCommand) {
+            agentLoopCommand.getArgumentCompletions = getAgentLoopArgumentCompletions;
+        }
+        const mcpCommand = slashCommands.find((command) => command.name === "mcp");
+        if (mcpCommand) {
+            mcpCommand.getArgumentCompletions = (prefix, context) => getMcpArgumentCompletions(prefix, context, listMCPServers());
+        }
+        const languageCommand = slashCommands.find((command) => command.name === "language");
+        if (languageCommand) {
+            languageCommand.getArgumentCompletions = getLanguageArgumentCompletions;
+        }
+        const personaCommand = slashCommands.find((command) => command.name === "persona");
+        if (personaCommand) {
+            personaCommand.getArgumentCompletions = (prefix, context) => getPersonaArgumentCompletions(prefix, context, listPersonas(), getActivePersonaId());
+        }
         // Convert prompt templates to SlashCommand format for autocomplete
         const templateCommands = this.session.promptTemplates.map((cmd) => ({
             name: cmd.name,
-            description: cmd.description,
+            description: formatSlashCommandDescription(cmd.description, inferSlashCommandCategory(cmd.name, "prompt"), t),
         }));
-        // Convert extension commands to SlashCommand format
+        // Convert extension commands to SlashCommand format. Some discoverable
+        // built-ins are implemented by default extensions; merge their argument
+        // completions into the built-in entry instead of showing duplicates.
         const builtinCommandNames = new Set(slashCommands.map((c) => c.name));
-        const extensionCommands = (this.session.extensionRunner?.getRegisteredCommands(builtinCommandNames) ?? []).map((cmd) => ({
+        const extensionBackedBuiltinNames = getExtensionBackedBuiltinCommandNames();
+        const reservedCommandNames = new Set([...builtinCommandNames].filter((name) => !extensionBackedBuiltinNames.has(name)));
+        const registeredExtensionCommands = this.session.extensionRunner?.getRegisteredCommands(reservedCommandNames) ?? [];
+        const extensionCommandByName = new Map(registeredExtensionCommands.map((command) => [command.name, command]));
+        for (const command of slashCommands) {
+            if (!extensionBackedBuiltinNames.has(command.name))
+                continue;
+            const extensionCommand = extensionCommandByName.get(command.name);
+            if (extensionCommand?.getArgumentCompletions) {
+                command.getArgumentCompletions =
+                    extensionCommand.getArgumentCompletions;
+            }
+        }
+        const extensionCommands = registeredExtensionCommands
+            .filter((cmd) => !builtinCommandNames.has(cmd.name))
+            .map((cmd) => ({
             name: cmd.name,
-            description: cmd.description ?? "(extension command)",
+            description: formatSlashCommandDescription(cmd.description ?? "(extension command)", inferSlashCommandCategory(cmd.name, "extension"), t),
             getArgumentCompletions: cmd.getArgumentCompletions,
         }));
         // Build skill commands from session.skills (if enabled)
@@ -279,7 +317,7 @@ export class InteractiveMode {
                 this.skillCommands.set(commandName, skill.filePath);
                 skillCommandList.push({
                     name: commandName,
-                    description: skill.description,
+                    description: formatSlashCommandDescription(skill.description, inferSlashCommandCategory(skill.name, "skill"), t),
                 });
             }
         }
@@ -1691,7 +1729,7 @@ export class InteractiveMode {
         this.defaultEditor.onAction("cycleModelForward", () => this.cycleModel("forward"));
         this.defaultEditor.onAction("cycleModelBackward", () => this.cycleModel("backward"));
         // Global debug handler on TUI (works regardless of focus)
-        this.ui.onDebug = () => this.handleDebugCommand();
+        this.ui.onDebug = () => this.handleRenderDebugCommand();
         this.defaultEditor.onAction("selectModel", () => this.showProviderThenModelSelector());
         this.defaultEditor.onAction("selectProviderThenModel", () => this.showProviderThenModelSelector());
         this.defaultEditor.onAction("expandTools", () => this.toggleToolOutputExpansion());
@@ -1984,11 +2022,6 @@ export class InteractiveMode {
                 this.editor.setText("");
                 return;
             }
-            if (text === "/debug") {
-                this.handleDebugCommand();
-                this.editor.setText("");
-                return;
-            }
             if (text === "/arminsayshi") {
                 this.handleArminSaysHi();
                 this.editor.setText("");
@@ -2209,6 +2242,11 @@ export class InteractiveMode {
             await this.handleModelCommand(searchTerm);
             return true;
         }
+        if (text === "/thinking" || text.startsWith("/thinking ")) {
+            this.handleThinkingCommand(text);
+            clear();
+            return true;
+        }
         if (text === "/agent-loop" || text.startsWith("/agent-loop ")) {
             this.handleAgentLoopCommand(text);
             clear();
@@ -2337,11 +2375,6 @@ export class InteractiveMode {
             clear();
             return true;
         }
-        if (text === "/debug") {
-            this.handleDebugCommand();
-            clear();
-            return true;
-        }
         if (text === "/arminsayshi") {
             this.handleArminSaysHi();
             clear();
@@ -3165,6 +3198,22 @@ export class InteractiveMode {
             this.showStatus(`Thinking level: ${newLevel}`);
         }
     }
+    handleThinkingCommand(text) {
+        const arg = text.slice("/thinking".length).trim().toLowerCase();
+        const levels = this.session.getAvailableThinkingLevels();
+        if (!arg) {
+            this.showStatus(`Thinking level: ${this.session.thinkingLevel} (available: ${levels.join(", ")})`);
+            return;
+        }
+        if (!levels.includes(arg)) {
+            this.showStatus(`Unknown thinking level: ${arg} (available: ${levels.join(", ")})`);
+            return;
+        }
+        this.session.setThinkingLevel(arg);
+        this.footer.invalidate();
+        this.updateEditorBorderColor();
+        this.showStatus(`Thinking level: ${this.session.thinkingLevel}`);
+    }
     handleAgentLoopCommand(text) {
         const arg = text.slice("/agent-loop".length).trim().toLowerCase();
         const choices = ["standard", "weak-model-compatible"];
@@ -5129,7 +5178,7 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(`${theme.fg("accent", "✓ New session started")}`, 1, 1));
         this.ui.requestRender();
     }
-    handleDebugCommand() {
+    handleRenderDebugCommand() {
         const width = this.ui.terminal.columns;
         const height = this.ui.terminal.rows;
         const allLines = this.ui.render(width);

package/dist/modes/interactive/slash-command-arguments.d.ts

@@ -0,0 +1,16 @@
+/**
+ * [WHO]: getAgentLoopArgumentCompletions(), getThinkingArgumentCompletions(), getMcpArgumentCompletions(), getLanguageArgumentCompletions(), getPersonaArgumentCompletions()
+ * [FROM]: Depends on @pencil-agent/agent-core, @pencil-agent/tui, core/i18n, core/mcp/mcp-client
+ * [TO]: Consumed by modes/interactive/interactive-mode.ts
+ * [HERE]: modes/interactive/slash-command-arguments.ts - pure argument completion helpers for built-in TUI slash commands
+ */
+import type { ThinkingLevel } from "@pencil-agent/agent-core";
+import type { ArgumentCompletionContext, AutocompleteItem } from "@pencil-agent/tui";
+import type { MCPServerConfig } from "../../core/mcp/mcp-client.js";
+type McpCompletionServer = Pick<MCPServerConfig, "id" | "name" | "enabled">;
+export declare function getThinkingArgumentCompletions(argumentPrefix: string, context: Pick<ArgumentCompletionContext, "tokenIndex"> | undefined, levels: readonly ThinkingLevel[]): AutocompleteItem[] | null;
+export declare function getAgentLoopArgumentCompletions(argumentPrefix: string, context?: Pick<ArgumentCompletionContext, "tokenIndex">): AutocompleteItem[] | null;
+export declare function getMcpArgumentCompletions(argumentPrefix: string, context?: Pick<ArgumentCompletionContext, "tokenIndex" | "previousTokens">, servers?: readonly McpCompletionServer[]): AutocompleteItem[] | null;
+export declare function getLanguageArgumentCompletions(argumentPrefix: string, context?: Pick<ArgumentCompletionContext, "tokenIndex">): AutocompleteItem[] | null;
+export declare function getPersonaArgumentCompletions(argumentPrefix: string, context?: Pick<ArgumentCompletionContext, "tokenIndex" | "previousTokens">, personas?: readonly string[], activePersonaId?: string): AutocompleteItem[] | null;
+export {};

package/dist/modes/interactive/slash-command-arguments.js

@@ -0,0 +1,97 @@
+/**
+ * [WHO]: getAgentLoopArgumentCompletions(), getThinkingArgumentCompletions(), getMcpArgumentCompletions(), getLanguageArgumentCompletions(), getPersonaArgumentCompletions()
+ * [FROM]: Depends on @pencil-agent/agent-core, @pencil-agent/tui, core/i18n, core/mcp/mcp-client
+ * [TO]: Consumed by modes/interactive/interactive-mode.ts
+ * [HERE]: modes/interactive/slash-command-arguments.ts - pure argument completion helpers for built-in TUI slash commands
+ */
+import { AVAILABLE_LOCALES, LOCALE_NAMES } from "../../core/i18n/index.js";
+const THINKING_COMPLETIONS = {
+    off: "Skip extra reasoning",
+    minimal: "Very small reasoning budget",
+    low: "Light reasoning for simple tasks",
+    medium: "Balanced reasoning for everyday coding",
+    high: "Deeper reasoning for complex work",
+    xhigh: "Maximum reasoning when the model supports it",
+};
+const AGENT_LOOP_COMPLETIONS = [
+    {
+        value: "standard",
+        label: "standard",
+        description: "Use the normal agent loop",
+    },
+    {
+        value: "weak-model-compatible",
+        label: "weak-model-compatible",
+        description: "Keep working with simpler models",
+    },
+];
+const MCP_ACTION_COMPLETIONS = [
+    { value: "list", label: "list", description: "Show configured MCP servers" },
+    { value: "status", label: "status", description: "Show loaded MCP tools and runtime status" },
+    { value: "tools", label: "tools", description: "Show loaded MCP tools and runtime status" },
+    { value: "enable", label: "enable", description: "Turn on an MCP server" },
+    { value: "disable", label: "disable", description: "Turn off an MCP server" },
+];
+const PERSONA_ACTION_COMPLETIONS = [
+    { value: "list", label: "list", description: "Show available personas" },
+    { value: "use", label: "use", description: "Switch to a persona" },
+];
+function matchCompletions(items, prefix) {
+    const lowerPrefix = prefix.trim().toLowerCase();
+    const matches = items.filter((item) => item.value.toLowerCase().startsWith(lowerPrefix));
+    return matches.length > 0 ? matches.map((item) => ({ ...item })) : null;
+}
+function isFirstToken(context) {
+    return !context || context.tokenIndex === 0;
+}
+export function getThinkingArgumentCompletions(argumentPrefix, context, levels) {
+    if (!isFirstToken(context))
+        return null;
+    return matchCompletions(levels.map((level) => ({
+        value: level,
+        label: level,
+        description: THINKING_COMPLETIONS[level],
+    })), argumentPrefix);
+}
+export function getAgentLoopArgumentCompletions(argumentPrefix, context) {
+    if (!isFirstToken(context))
+        return null;
+    return matchCompletions(AGENT_LOOP_COMPLETIONS, argumentPrefix);
+}
+export function getMcpArgumentCompletions(argumentPrefix, context, servers = []) {
+    if (isFirstToken(context))
+        return matchCompletions(MCP_ACTION_COMPLETIONS, argumentPrefix);
+    if (context?.tokenIndex !== 1)
+        return null;
+    const action = context.previousTokens[0]?.toLowerCase();
+    if (action !== "enable" && action !== "disable")
+        return null;
+    const targetEnabledState = action === "disable";
+    return matchCompletions(servers
+        .filter((server) => (server.enabled !== false) === targetEnabledState)
+        .map((server) => ({
+        value: server.id,
+        label: server.id,
+        description: `${server.name} (${server.enabled === false ? "disabled" : "enabled"})`,
+    })), argumentPrefix);
+}
+export function getLanguageArgumentCompletions(argumentPrefix, context) {
+    if (!isFirstToken(context))
+        return null;
+    return matchCompletions(AVAILABLE_LOCALES.map((locale) => ({
+        value: locale,
+        label: locale,
+        description: LOCALE_NAMES[locale],
+    })), argumentPrefix);
+}
+export function getPersonaArgumentCompletions(argumentPrefix, context, personas = [], activePersonaId) {
+    if (isFirstToken(context))
+        return matchCompletions(PERSONA_ACTION_COMPLETIONS, argumentPrefix);
+    if (context?.tokenIndex !== 1 || context.previousTokens[0]?.toLowerCase() !== "use")
+        return null;
+    return matchCompletions(personas.map((personaId) => ({
+        value: personaId,
+        label: personaId,
+        description: personaId === activePersonaId ? "Current persona" : `Switch to ${personaId}`,
+    })), argumentPrefix);
+}

package/dist/modes/rpc/rpc-mode.d.ts

@@ -1,5 +1,8 @@
 import type { AgentSession } from "../../core/runtime/agent-session.js";
+import type { RpcSlashCommand } from "./rpc-types.js";
 export type { RpcCommand, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcResponse, RpcSessionState, } from "./rpc-types.js";
+type RpcSlashCommandCatalogSession = Pick<AgentSession, "extensionRunner" | "promptTemplates" | "resourceLoader">;
+export declare function buildRpcSlashCommands(session: RpcSlashCommandCatalogSession): RpcSlashCommand[];
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.

package/dist/modes/rpc/rpc-mode.js

@@ -6,7 +6,46 @@
  */
 import * as crypto from "node:crypto";
 import * as readline from "readline";
+import { buildExtensionSlashCommands } from "../../core/runtime/slash-command-catalog.js";
+import { inferSlashCommandCategory } from "../../core/slash-commands.js";
 import { theme } from "../interactive/theme/theme.js";
+function toRpcSlashCommand(command) {
+    return {
+        name: command.name,
+        description: command.description,
+        source: command.source,
+        category: command.category,
+        location: command.location,
+        path: command.path,
+    };
+}
+export function buildRpcSlashCommands(session) {
+    if (session.extensionRunner) {
+        return buildExtensionSlashCommands({
+            promptTemplates: session.promptTemplates,
+            resourceLoader: session.resourceLoader,
+            extensionRunner: session.extensionRunner,
+        }).map(toRpcSlashCommand);
+    }
+    return [
+        ...session.promptTemplates.map((template) => ({
+            name: template.name,
+            description: template.description,
+            source: "prompt",
+            category: inferSlashCommandCategory(template.name, "prompt"),
+            location: template.source,
+            path: template.filePath,
+        })),
+        ...session.resourceLoader.getSkills().skills.map((skill) => ({
+            name: `skill:${skill.name}`,
+            description: skill.description,
+            source: "skill",
+            category: inferSlashCommandCategory(skill.name, "skill"),
+            location: skill.source,
+            path: skill.filePath,
+        })),
+    ];
+}
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.
@@ -436,37 +475,7 @@ export async function runRpcMode(session) {
             // Commands (available for invocation via prompt)
             // =================================================================
             case "get_commands": {
-                const commands = [];
-                // Extension commands
-                for (const { command, extensionPath } of session.extensionRunner?.getRegisteredCommandsWithPaths() ?? []) {
-                    commands.push({
-                        name: command.name,
-                        description: command.description,
-                        source: "extension",
-                        path: extensionPath,
-                    });
-                }
-                // Prompt templates (source is always "user" | "project" | "path" in coding-agent)
-                for (const template of session.promptTemplates) {
-                    commands.push({
-                        name: template.name,
-                        description: template.description,
-                        source: "prompt",
-                        location: template.source,
-                        path: template.filePath,
-                    });
-                }
-                // Skills (source is always "user" | "project" | "path" in coding-agent)
-                for (const skill of session.resourceLoader.getSkills().skills) {
-                    commands.push({
-                        name: `skill:${skill.name}`,
-                        description: skill.description,
-                        source: "skill",
-                        location: skill.source,
-                        path: skill.filePath,
-                    });
-                }
-                return success(id, "get_commands", { commands });
+                return success(id, "get_commands", { commands: buildRpcSlashCommands(session) });
             }
             default: {
                 const unknownCommand = command;

package/dist/modes/rpc/rpc-types.d.ts

@@ -9,6 +9,7 @@ import type { ImageContent, Model } from "@pencil-agent/ai";
 import type { SessionStats } from "../../core/runtime/agent-session.js";
 import type { BashResult } from "../../core/bash-executor.js";
 import type { CompactionResult } from "../../core/session/compaction/index.js";
+import type { SlashCommandCategory } from "../../core/slash-commands.js";
 type AgentLoopFrameworkInput = AgentLoopFramework | "high-intelligence" | "low-intelligence" | "structured-adaptive";
 export type RpcCommand = {
     id?: string;
@@ -128,6 +129,8 @@ export interface RpcSlashCommand {
     description?: string;
     /** What kind of command this is */
     source: "extension" | "prompt" | "skill";
+    /** Human-facing command category for grouping and filtering */
+    category?: SlashCommandCategory;
     /** Where the command was loaded from (undefined for extensions) */
     location?: "user" | "project" | "path";
     /** File path to the command source */

package/dist/node_modules/@pencil-agent/agent-core/agent.d.ts

@@ -3,7 +3,7 @@
  * No transport abstraction - calls streamSimple via the loop.
  */
 /**
- * [WHO]: AgentOptions, Agent
+ * [WHO]: AgentOptions, Agent, in-loop model error recovery and loop budget option plumbing
  * [FROM]: Depends on ./agent-loop.js and ./structured-adaptive-agent-loop.js
  * [TO]: Consumed by packages/agent-core/src/index.ts
  * [HERE]: packages/agent-core/src/agent.ts -
@@ -68,6 +68,16 @@ export interface AgentOptions {
      * Optional tool permission gate used by weak-model-compatible loop execution.
      */
     canUseTool?: AgentLoopConfig["canUseTool"];
+    /**
+     * Optional aggregate tool-result batch budget used by weak-model-compatible loop execution.
+     */
+    maxToolResultBatchSizeChars?: AgentLoopConfig["maxToolResultBatchSizeChars"];
+    /**
+     * Optional in-loop model error recovery hook used by weak-model-compatible loop execution.
+     */
+    recoverModelError?: AgentLoopConfig["recoverModelError"];
+    /** Maximum in-loop model error recoveries per prompt. */
+    maxModelErrorRecoveryAttempts?: number;
 }
 export declare class Agent {
     private _state;
@@ -89,6 +99,9 @@ export declare class Agent {
     private _maxRetryDelayMs?;
     private _agentLoopFramework?;
     private canUseTool?;
+    private maxToolResultBatchSizeChars?;
+    private recoverModelError?;
+    private maxModelErrorRecoveryAttempts?;
     constructor(opts?: AgentOptions);
     /**
      * Get the current session ID used for provider caching.
@@ -136,6 +149,7 @@ export declare class Agent {
     setFollowUpMode(mode: "all" | "one-at-a-time"): void;
     getFollowUpMode(): "all" | "one-at-a-time";
     setTools(t: AgentTool<any>[]): void;
+    setModelErrorRecovery(recoverModelError: AgentLoopConfig["recoverModelError"] | undefined): void;
     replaceMessages(ms: AgentMessage[]): void;
     appendMessage(m: AgentMessage): void;
     /**

package/dist/node_modules/@pencil-agent/agent-core/agent.js

@@ -3,7 +3,7 @@
  * No transport abstraction - calls streamSimple via the loop.
  */
 /**
- * [WHO]: AgentOptions, Agent
+ * [WHO]: AgentOptions, Agent, in-loop model error recovery and loop budget option plumbing
  * [FROM]: Depends on ./agent-loop.js and ./structured-adaptive-agent-loop.js
  * [TO]: Consumed by packages/agent-core/src/index.ts
  * [HERE]: packages/agent-core/src/agent.ts -
@@ -48,6 +48,9 @@ export class Agent {
     _maxRetryDelayMs;
     _agentLoopFramework;
     canUseTool;
+    maxToolResultBatchSizeChars;
+    recoverModelError;
+    maxModelErrorRecoveryAttempts;
     constructor(opts = {}) {
         this._state = { ...this._state, ...opts.initialState };
         this.convertToLlm = opts.convertToLlm || defaultConvertToLlm;
@@ -62,6 +65,9 @@ export class Agent {
         this._maxRetryDelayMs = opts.maxRetryDelayMs;
         this._agentLoopFramework = normalizeAgentLoopFramework(opts.agentLoopFramework);
         this.canUseTool = opts.canUseTool;
+        this.maxToolResultBatchSizeChars = opts.maxToolResultBatchSizeChars;
+        this.recoverModelError = opts.recoverModelError;
+        this.maxModelErrorRecoveryAttempts = opts.maxModelErrorRecoveryAttempts;
     }
     /**
      * Get the current session ID used for provider caching.
@@ -151,6 +157,9 @@ export class Agent {
     setTools(t) {
         this._state.tools = t;
     }
+    setModelErrorRecovery(recoverModelError) {
+        this.recoverModelError = recoverModelError;
+    }
     replaceMessages(ms) {
         this._state.messages = ms.slice();
     }
@@ -318,6 +327,9 @@ export class Agent {
             transformContext: this.transformContext,
             getApiKey: this.getApiKey,
             canUseTool: this.canUseTool,
+            maxToolResultBatchSizeChars: this.maxToolResultBatchSizeChars,
+            recoverModelError: this.recoverModelError,
+            maxModelErrorRecoveryAttempts: this.maxModelErrorRecoveryAttempts,
             getSteeringMessages: async () => {
                 if (skipInitialSteeringPoll) {
                     skipInitialSteeringPoll = false;

package/dist/node_modules/@pencil-agent/agent-core/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * [WHO]: agent-core barrel exports
- * [FROM]: Depends on agent.js, agent-loop.js, structured-adaptive-agent-loop.js, structured-adaptive-tool-orchestration.js, proxy.js, types.js
+ * [FROM]: Depends on agent.js, agent-loop.js, structured-adaptive-agent-loop.js, structured-adaptive-tool-orchestration.js, structured-adaptive-streaming-tool-executor.js, proxy.js, types.js
  * [TO]: Consumed by @pencil-agent/agent-core package consumers
  * [HERE]: packages/agent-core/src/index.ts - agent-core entry point
  */
@@ -8,6 +8,7 @@ export * from "./agent.js";
 export * from "./agent-loop.js";
 export * from "./structured-adaptive-agent-loop.js";
 export * from "./structured-adaptive-tool-orchestration.js";
+export * from "./structured-adaptive-streaming-tool-executor.js";
 export * from "./proxy.js";
 export * from "./types.js";
 export * from "./errors.js";

package/dist/node_modules/@pencil-agent/agent-core/index.js

@@ -1,6 +1,6 @@
 /**
  * [WHO]: agent-core barrel exports
- * [FROM]: Depends on agent.js, agent-loop.js, structured-adaptive-agent-loop.js, structured-adaptive-tool-orchestration.js, proxy.js, types.js
+ * [FROM]: Depends on agent.js, agent-loop.js, structured-adaptive-agent-loop.js, structured-adaptive-tool-orchestration.js, structured-adaptive-streaming-tool-executor.js, proxy.js, types.js
  * [TO]: Consumed by @pencil-agent/agent-core package consumers
  * [HERE]: packages/agent-core/src/index.ts - agent-core entry point
  */
@@ -10,6 +10,7 @@ export * from "./agent.js";
 export * from "./agent-loop.js";
 export * from "./structured-adaptive-agent-loop.js";
 export * from "./structured-adaptive-tool-orchestration.js";
+export * from "./structured-adaptive-streaming-tool-executor.js";
 // Proxy utilities
 export * from "./proxy.js";
 // Types

package/dist/node_modules/@pencil-agent/agent-core/structured-adaptive-agent-loop.d.ts

@@ -5,7 +5,7 @@
  */
 /**
  * [WHO]: structuredAdaptiveAgentLoop, structuredAdaptiveAgentLoopContinue
- * [FROM]: Depends on @pencil-agent/ai, ./types, ./errors, ./structured-adaptive-tool-orchestration
+ * [FROM]: Depends on @pencil-agent/ai, ./types, ./errors, ./structured-adaptive-tool-orchestration, ./structured-adaptive-streaming-tool-executor
  * [TO]: Consumed by packages/agent-core/src/agent.ts and index.ts
  * [HERE]: packages/agent-core/src/structured-adaptive-agent-loop.ts - selectable structured-adaptive query loop framework
  */