@codex-infinity/pi-infinity 0.61.2 → 0.62.1

package/dist/core/agent-session.js

@@ -27,9 +27,10 @@ import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
-import { BUILTIN_SLASH_COMMANDS } from "./slash-commands.js";
+import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
-import { createAllTools } from "./tools/index.js";
+import { createAllToolDefinitions } from "./tools/index.js";
+import { createToolDefinitionFromAgentTool, wrapToolDefinition } from "./tools/tool-definition-wrapper.js";
 /**
  * Parse a skill block from message text.
  * Returns null if the text doesn't contain a skill block.
@@ -85,9 +86,10 @@ export class AgentSession {
         // Extension system
         this._extensionRunner = undefined;
         this._turnIndex = 0;
-        this._baseToolRegistry = new Map();
+        this._baseToolDefinitions = new Map();
         // Tool registry for extension getTools/setTools
         this._toolRegistry = new Map();
+        this._toolDefinitions = new Map();
         this._toolPromptSnippets = new Map();
         this._toolPromptGuidelines = new Map();
         // Base system prompt (without extension appends) - used to apply fresh appends each turn
@@ -481,15 +483,19 @@ export class AgentSession {
         return this.agent.state.tools.map((t) => t.name);
     }
     /**
-     * Get all configured tools with name, description, and parameter schema.
+     * Get all configured tools with name, description, parameter schema, and source metadata.
      */
     getAllTools() {
-        return Array.from(this._toolRegistry.values()).map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
+        return Array.from(this._toolDefinitions.values()).map(({ definition, sourceInfo }) => ({
+            name: definition.name,
+            description: definition.description,
+            parameters: definition.parameters,
+            sourceInfo,
         }));
     }
+    getToolDefinition(name) {
+        return this._toolDefinitions.get(name)?.definition;
+    }
     /**
      * Set active tools by name.
      * Only tools in the registry can be enabled. Unknown tool names are ignored.
@@ -1644,36 +1650,24 @@ export class AgentSession {
         this.agent.setModel(refreshedModel);
     }
     _bindExtensionCore(runner) {
-        const normalizeLocation = (source) => {
-            if (source === "user" || source === "project" || source === "path") {
-                return source;
-            }
-            return undefined;
-        };
-        const reservedBuiltins = new Set(BUILTIN_SLASH_COMMANDS.map((command) => command.name));
         const getCommands = () => {
-            const extensionCommands = runner
-                .getRegisteredCommandsWithPaths()
-                .filter(({ command }) => !reservedBuiltins.has(command.name))
-                .map(({ command, extensionPath }) => ({
-                name: command.name,
+            const extensionCommands = runner.getRegisteredCommands().map((command) => ({
+                name: command.invocationName,
                 description: command.description,
                 source: "extension",
-                path: extensionPath,
+                sourceInfo: command.sourceInfo,
             }));
             const templates = this.promptTemplates.map((template) => ({
                 name: template.name,
                 description: template.description,
                 source: "prompt",
-                location: normalizeLocation(template.source),
-                path: template.filePath,
+                sourceInfo: template.sourceInfo,
             }));
             const skills = this._resourceLoader.getSkills().skills.map((skill) => ({
                 name: `skill:${skill.name}`,
                 description: skill.description,
                 source: "skill",
-                location: normalizeLocation(skill.source),
-                path: skill.filePath,
+                sourceInfo: skill.sourceInfo,
             }));
             return [...extensionCommands, ...templates, ...skills];
         };
@@ -1761,24 +1755,44 @@ export class AgentSession {
         const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
         const allCustomTools = [
             ...registeredTools,
-            ...this._customTools.map((def) => ({ definition: def, extensionPath: "<sdk>" })),
+            ...this._customTools.map((definition) => ({
+                definition,
+                sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" }),
+            })),
         ];
-        this._toolPromptSnippets = new Map(allCustomTools
-            .map((registeredTool) => {
-            const snippet = this._normalizePromptSnippet(registeredTool.definition.promptSnippet);
-            return snippet ? [registeredTool.definition.name, snippet] : undefined;
+        const definitionRegistry = new Map(Array.from(this._baseToolDefinitions.entries()).map(([name, definition]) => [
+            name,
+            {
+                definition,
+                sourceInfo: createSyntheticSourceInfo(`<builtin:${name}>`, { source: "builtin" }),
+            },
+        ]));
+        for (const tool of allCustomTools) {
+            definitionRegistry.set(tool.definition.name, {
+                definition: tool.definition,
+                sourceInfo: tool.sourceInfo,
+            });
+        }
+        this._toolDefinitions = definitionRegistry;
+        this._toolPromptSnippets = new Map(Array.from(definitionRegistry.values())
+            .map(({ definition }) => {
+            const snippet = this._normalizePromptSnippet(definition.promptSnippet);
+            return snippet ? [definition.name, snippet] : undefined;
         })
             .filter((entry) => entry !== undefined));
-        this._toolPromptGuidelines = new Map(allCustomTools
-            .map((registeredTool) => {
-            const guidelines = this._normalizePromptGuidelines(registeredTool.definition.promptGuidelines);
-            return guidelines.length > 0 ? [registeredTool.definition.name, guidelines] : undefined;
+        this._toolPromptGuidelines = new Map(Array.from(definitionRegistry.values())
+            .map(({ definition }) => {
+            const guidelines = this._normalizePromptGuidelines(definition.promptGuidelines);
+            return guidelines.length > 0 ? [definition.name, guidelines] : undefined;
         })
             .filter((entry) => entry !== undefined));
         const wrappedExtensionTools = this._extensionRunner
             ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
             : [];
-        const toolRegistry = new Map(this._baseToolRegistry);
+        const toolRegistry = new Map(Array.from(this._baseToolDefinitions.values()).map((definition) => [
+            definition.name,
+            wrapToolDefinition(definition),
+        ]));
         for (const tool of wrappedExtensionTools) {
             toolRegistry.set(tool.name, tool);
         }
@@ -1803,13 +1817,16 @@ export class AgentSession {
     _buildRuntime(options) {
         const autoResizeImages = this.settingsManager.getImageAutoResize();
         const shellCommandPrefix = this.settingsManager.getShellCommandPrefix();
-        const baseTools = this._baseToolsOverride
-            ? this._baseToolsOverride
-            : createAllTools(this._cwd, {
+        const baseToolDefinitions = this._baseToolsOverride
+            ? Object.fromEntries(Object.entries(this._baseToolsOverride).map(([name, tool]) => [
+                name,
+                createToolDefinitionFromAgentTool(tool),
+            ]))
+            : createAllToolDefinitions(this._cwd, {
                 read: { autoResizeImages },
                 bash: { commandPrefix: shellCommandPrefix },
             });
-        this._baseToolRegistry = new Map(Object.entries(baseTools).map(([name, tool]) => [name, tool]));
+        this._baseToolDefinitions = new Map(Object.entries(baseToolDefinitions).map(([name, tool]) => [name, tool]));
         const extensionsResult = this._resourceLoader.getExtensions();
         if (options.flagValues) {
             for (const [name, value] of options.flagValues) {
@@ -2526,13 +2543,10 @@ export class AgentSession {
     async exportToHtml(outputPath) {
         const themeName = this.settingsManager.getTheme();
         // Create tool renderer if we have an extension runner (for custom tool HTML rendering)
-        let toolRenderer;
-        if (this._extensionRunner) {
-            toolRenderer = createToolHtmlRenderer({
-                getToolDefinition: (name) => this._extensionRunner.getToolDefinition(name),
-                theme,
-            });
-        }
+        const toolRenderer = createToolHtmlRenderer({
+            getToolDefinition: (name) => this.getToolDefinition(name),
+            theme,
+        });
         return await exportSessionToHtml(this.sessionManager, this.state, {
             outputPath,
             themeName,