gsd-pi 2.39.0 → 2.40.0-dev.4a93031

package/packages/pi-coding-agent/dist/core/agent-session.js

@@ -15,6 +15,7 @@
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { modelsAreEqual, resetApiProviders, supportsXhigh } from "@gsd/pi-ai";
+import { Type } from "@sinclair/typebox";
 import { getDocsPath } from "../config.js";
 import { getErrorMessage } from "../utils/error.js";
 import { theme } from "../modes/interactive/theme/theme.js";
@@ -494,9 +495,10 @@ export class AgentSession {
      * Changes take effect on the next agent turn.
      */
     setActiveToolsByName(toolNames) {
+        const requestedToolNames = [...new Set([...toolNames, ...this._getBuiltinToolNames()])];
         const tools = [];
         const validToolNames = [];
-        for (const name of toolNames) {
+        for (const name of requestedToolNames) {
             const tool = this._toolRegistry.get(name);
             if (tool) {
                 tools.push(tool);
@@ -602,6 +604,42 @@ export class AgentSession {
         }
         return Array.from(unique);
     }
+    _findSkillByName(skillName) {
+        return this.resourceLoader.getSkills().skills.find((skill) => skill.name === skillName);
+    }
+    _formatMissingSkillMessage(skillName) {
+        const availableSkills = this.resourceLoader.getSkills().skills.map((skill) => skill.name).join(", ") || "(none)";
+        return `Skill "${skillName}" not found. Available skills: ${availableSkills}`;
+    }
+    _emitSkillExpansionError(skillFilePath, err) {
+        this._extensionRunner?.emitError({
+            extensionPath: skillFilePath,
+            event: "skill_expansion",
+            error: getErrorMessage(err),
+        });
+    }
+    _renderSkillInvocation(skill, args) {
+        const content = readFileSync(skill.filePath, "utf-8");
+        const body = stripFrontmatter(content).trim();
+        const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
+        return args && args.trim() ? `${skillBlock}\n\n${args.trim()}` : skillBlock;
+    }
+    _expandSkillByName(skillName, args) {
+        const skill = this._findSkillByName(skillName);
+        if (!skill) {
+            throw new Error(this._formatMissingSkillMessage(skillName));
+        }
+        try {
+            return this._renderSkillInvocation(skill, args);
+        }
+        catch (err) {
+            this._emitSkillExpansionError(skill.filePath, err);
+            throw err;
+        }
+    }
+    _formatSkillInvocation(skillName, args) {
+        return this._expandSkillByName(skillName, args);
+    }
     _rebuildSystemPrompt(toolNames) {
         const validToolNames = toolNames.filter((name) => this._toolRegistry.has(name));
         const toolSnippets = {};
@@ -809,25 +847,69 @@ export class AgentSession {
         const spaceIndex = text.indexOf(" ");
         const skillName = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
         const args = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1).trim();
-        const skill = this.resourceLoader.getSkills().skills.find((s) => s.name === skillName);
-        if (!skill)
-            return text; // Unknown skill, pass through
+        if (!this._findSkillByName(skillName))
+            return text;
         try {
-            const content = readFileSync(skill.filePath, "utf-8");
-            const body = stripFrontmatter(content).trim();
-            const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${skill.baseDir}.\n\n${body}\n</skill>`;
-            return args ? `${skillBlock}\n\n${args}` : skillBlock;
+            return this._formatSkillInvocation(skillName, args);
         }
-        catch (err) {
-            // Emit error like extension commands do
-            this._extensionRunner?.emitError({
-                extensionPath: skill.filePath,
-                event: "skill_expansion",
-                error: getErrorMessage(err),
-            });
-            return text; // Return original on error
+        catch {
+            return text;
         }
     }
+    _createBuiltInSkillTool() {
+        const skillSchema = Type.Object({
+            skill: Type.String({ description: "The skill name. E.g., 'commit', 'review-pr', or 'pdf'" }),
+            args: Type.Optional(Type.String({ description: "Optional arguments for the skill" })),
+        });
+        return {
+            name: "Skill",
+            label: "Skill",
+            description: "Execute a skill within the main conversation. Use this tool when users ask for a slash command or reference a skill by name. Returns the expanded skill block and appends args after it.",
+            parameters: skillSchema,
+            execute: async (_toolCallId, params) => {
+                const input = params;
+                try {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: this._expandSkillByName(input.skill, input.args),
+                            },
+                        ],
+                        details: undefined,
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: "text", text: getErrorMessage(err) }],
+                        details: undefined,
+                    };
+                }
+            },
+        };
+    }
+    _getBuiltinToolNames() {
+        return this._getBuiltinTools().map((tool) => tool.name);
+    }
+    _getBuiltinTools() {
+        return [this._createBuiltInSkillTool()];
+    }
+    _getRegisteredToolDefinitions() {
+        const registeredTools = this._extensionRunner?.getAllRegisteredTools() ?? [];
+        return registeredTools.map((tool) => tool.definition);
+    }
+    _getBuiltinToolDefinitions() {
+        return this._getBuiltinTools().map((tool) => ({
+            name: tool.name,
+            label: tool.label,
+            description: tool.description,
+            parameters: tool.parameters,
+            execute: async () => ({ content: [], details: undefined }),
+        }));
+    }
+    getRenderableToolDefinition(toolName) {
+        return [...this._getBuiltinToolDefinitions(), ...this._getRegisteredToolDefinitions()].find((tool) => tool.name === toolName);
+    }
     /**
      * Queue a steering message to interrupt the agent mid-run.
      * Delivered after current tool execution, skips remaining tools.
@@ -1553,7 +1635,11 @@ export class AgentSession {
         const wrappedExtensionTools = this._extensionRunner
             ? wrapRegisteredTools(allCustomTools, this._extensionRunner)
             : [];
+        const builtinTools = this._getBuiltinTools();
         const toolRegistry = new Map(this._baseToolRegistry);
+        for (const tool of builtinTools) {
+            toolRegistry.set(tool.name, tool);
+        }
         for (const tool of wrappedExtensionTools) {
             toolRegistry.set(tool.name, tool);
         }
@@ -2171,14 +2257,11 @@ 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,
-            });
-        }
+        // Create tool renderer for extension and built-in tool HTML rendering
+        const toolRenderer = createToolHtmlRenderer({
+            getToolDefinition: (name) => this.getRenderableToolDefinition(name),
+            theme,
+        });
         return await exportSessionToHtml(this.sessionManager, this.state, {
             outputPath,
             themeName,