@thinkwell/acp 0.5.4 → 0.5.6

package/dist/session.js

@@ -1,165 +1,119 @@
-/**
- * Active session with an agent
- */
 export class ActiveSession {
-    sessionId;
-    _connection;
-    _mcpHandler;
-    _pendingUpdates = [];
-    _updateResolvers = [];
-    _closed = false;
-    constructor(sessionId, connection, mcpHandler) {
-        this.sessionId = sessionId;
-        this._connection = connection;
-        this._mcpHandler = mcpHandler;
-        this._mcpHandler.setSessionId(sessionId);
-    }
-    /**
-     * Send a prompt to the agent
-     */
-    async sendPrompt(content) {
-        const response = await this._connection.sendPrompt(this.sessionId, content);
-        // Push a stop update when the prompt completes
-        if (response.stopReason) {
-            this.pushUpdate({ type: "stop", reason: response.stopReason });
-        }
-    }
-    /**
-     * Push an update received from the agent
-     */
-    pushUpdate(update) {
-        if (this._updateResolvers.length > 0) {
-            const resolver = this._updateResolvers.shift();
-            resolver(update);
-        }
-        else {
-            this._pendingUpdates.push(update);
-        }
-    }
-    /**
-     * Read the next update from the agent
-     */
-    async readUpdate() {
-        if (this._pendingUpdates.length > 0) {
-            return this._pendingUpdates.shift();
-        }
-        if (this._closed) {
-            return { type: "stop", reason: "session_closed" };
-        }
-        return new Promise((resolve) => {
-            this._updateResolvers.push(resolve);
-        });
-    }
-    /**
-     * Read all updates until completion, returning concatenated text
-     */
-    async readToString() {
-        const parts = [];
-        while (true) {
-            const update = await this.readUpdate();
-            if (update.type === "text") {
-                parts.push(update.content);
-            }
-            else if (update.type === "stop") {
-                break;
-            }
-            // tool_use updates are handled by the connection layer
-        }
-        return parts.join("");
-    }
-    /**
-     * Mark the session as closed
-     */
-    close() {
-        this._closed = true;
-        // Resolve any pending readers
-        for (const resolver of this._updateResolvers) {
-            resolver({ type: "stop", reason: "session_closed" });
-        }
-        this._updateResolvers = [];
+  sessionId;
+  _connection;
+  _mcpHandler;
+  _pendingUpdates = [];
+  _updateResolvers = [];
+  _closed = !1;
+  constructor(sessionId, connection, mcpHandler) {
+    this.sessionId = sessionId, this._connection = connection, this._mcpHandler = mcpHandler, this._mcpHandler.setSessionId(sessionId);
+  }
+  /**
+   * Send a prompt to the agent
+   */
+  async sendPrompt(content) {
+    const response = await this._connection.sendPrompt(this.sessionId, content);
+    response.stopReason && this.pushUpdate({ type: "stop", reason: response.stopReason });
+  }
+  /**
+   * Push an update received from the agent
+   */
+  pushUpdate(update) {
+    this._updateResolvers.length > 0 ? this._updateResolvers.shift()(update) : this._pendingUpdates.push(update);
+  }
+  /**
+   * Read the next update from the agent
+   */
+  async readUpdate() {
+    return this._pendingUpdates.length > 0 ? this._pendingUpdates.shift() : this._closed ? { type: "stop", reason: "session_closed" } : new Promise((resolve) => {
+      this._updateResolvers.push(resolve);
+    });
+  }
+  /**
+   * Read all updates until completion, returning concatenated text
+   */
+  async readToString() {
+    const parts = [];
+    for (; ; ) {
+      const update = await this.readUpdate();
+      if (update.type === "text")
+        parts.push(update.content);
+      else if (update.type === "stop")
+        break;
     }
+    return parts.join("");
+  }
+  /**
+   * Mark the session as closed
+   */
+  close() {
+    this._closed = !0;
+    for (const resolver of this._updateResolvers)
+      resolver({ type: "stop", reason: "session_closed" });
+    this._updateResolvers = [];
+  }
 }
-/**
- * Builder for creating ACP sessions with MCP servers
- */
 export class SessionBuilder {
-    _connection;
-    _mcpHandler;
-    _mcpServers = [];
-    _cwd;
-    _systemPrompt;
-    _mcpReadyOptions = {};
-    constructor(connection, mcpHandler) {
-        this._connection = connection;
-        this._mcpHandler = mcpHandler;
-    }
-    /**
-     * Attach an MCP server to this session
-     */
-    withMcpServer(server) {
-        this._mcpServers.push(server);
-        this._mcpHandler.register(server);
-        return this;
-    }
-    /**
-     * Set the working directory for the session
-     */
-    cwd(path) {
-        this._cwd = path;
-        return this;
-    }
-    /**
-     * Set the system prompt for the session
-     */
-    systemPrompt(prompt) {
-        this._systemPrompt = prompt;
-        return this;
-    }
-    /**
-     * Configure waiting for MCP tools discovery.
-     *
-     * By default, when MCP servers are attached, the session will wait for
-     * the agent to call tools/list before invoking the callback. This prevents
-     * a race condition where the prompt is sent before the agent knows about
-     * available tools.
-     *
-     * @param options - Options for MCP readiness waiting
-     */
-    waitForMcpReady(options = {}) {
-        this._mcpReadyOptions = options;
-        return this;
-    }
-    /**
-     * Start the session and run a callback
-     */
-    async run(callback) {
-        // Create the session
-        const sessionId = await this._connection.createSession({
-            cwd: this._cwd,
-            systemPrompt: this._systemPrompt,
-            mcpServers: this._mcpServers.map((s) => s.toSessionConfig()),
-        });
-        const session = new ActiveSession(sessionId, this._connection, this._mcpHandler);
-        // Set up the message pump for this session
-        this._connection.setSessionHandler(sessionId, session);
-        try {
-            // Wait for MCP tools discovery if we have MCP servers attached
-            const shouldWait = this._mcpServers.length > 0 &&
-                (this._mcpReadyOptions.enabled !== false);
-            if (shouldWait) {
-                const timeout = this._mcpReadyOptions.timeout ?? 2000;
-                await this._mcpHandler.waitForToolsDiscovery(sessionId, timeout);
-            }
-            return await callback(session);
-        }
-        finally {
-            session.close();
-            this._connection.removeSessionHandler(sessionId);
-            // Unregister MCP servers
-            for (const server of this._mcpServers) {
-                this._mcpHandler.unregister(server);
-            }
-        }
+  _connection;
+  _mcpHandler;
+  _mcpServers = [];
+  _cwd;
+  _systemPrompt;
+  _mcpReadyOptions = {};
+  constructor(connection, mcpHandler) {
+    this._connection = connection, this._mcpHandler = mcpHandler;
+  }
+  /**
+   * Attach an MCP server to this session
+   */
+  withMcpServer(server) {
+    return this._mcpServers.push(server), this._mcpHandler.register(server), this;
+  }
+  /**
+   * Set the working directory for the session
+   */
+  cwd(path) {
+    return this._cwd = path, this;
+  }
+  /**
+   * Set the system prompt for the session
+   */
+  systemPrompt(prompt) {
+    return this._systemPrompt = prompt, this;
+  }
+  /**
+   * Configure waiting for MCP tools discovery.
+   *
+   * By default, when MCP servers are attached, the session will wait for
+   * the agent to call tools/list before invoking the callback. This prevents
+   * a race condition where the prompt is sent before the agent knows about
+   * available tools.
+   *
+   * @param options - Options for MCP readiness waiting
+   */
+  waitForMcpReady(options = {}) {
+    return this._mcpReadyOptions = options, this;
+  }
+  /**
+   * Start the session and run a callback
+   */
+  async run(callback) {
+    const sessionId = await this._connection.createSession({
+      cwd: this._cwd,
+      systemPrompt: this._systemPrompt,
+      mcpServers: this._mcpServers.map((s) => s.toSessionConfig())
+    }), session = new ActiveSession(sessionId, this._connection, this._mcpHandler);
+    this._connection.setSessionHandler(sessionId, session);
+    try {
+      if (this._mcpServers.length > 0 && this._mcpReadyOptions.enabled !== !1) {
+        const timeout = this._mcpReadyOptions.timeout ?? 2e3;
+        await this._mcpHandler.waitForToolsDiscovery(sessionId, timeout);
+      }
+      return await callback(session);
+    } finally {
+      session.close(), this._connection.removeSessionHandler(sessionId);
+      for (const server of this._mcpServers)
+        this._mcpHandler.unregister(server);
     }
+  }
 }
-//# sourceMappingURL=session.js.map

package/dist/skill-server.js

@@ -1,96 +1,61 @@
-/**
- * Skill MCP server builder.
- *
- * Creates an MCP server that exposes three tools for skill interaction:
- * - activate_skill: returns a skill's instruction body
- * - call_skill_tool: dispatches to a virtual skill's tool handler
- * - read_skill_file: reads a file from a stored skill's basePath
- *
- * These tools are registered as standard MCP tools but are intended to be
- * hidden from the prompt (via Plan's defineTool pattern).
- */
 import { readFile } from "node:fs/promises";
 import { resolve, relative, isAbsolute } from "node:path";
 import { mcpServer } from "./mcp-server.js";
-/** Type guard for StoredSkill (has basePath). */
 function isStoredSkill(skill) {
-    return "basePath" in skill && typeof skill.basePath === "string";
+  return "basePath" in skill && typeof skill.basePath == "string";
 }
-/**
- * Build an MCP server that provides skill tools.
- *
- * @param skills - resolved skills (virtual or stored) to make available
- * @returns an McpServer with activate_skill, call_skill_tool, and read_skill_file tools
- */
 export function createSkillServer(skills) {
-    const skillsByName = new Map();
-    for (const skill of skills) {
-        skillsByName.set(skill.name, skill);
-    }
-    return mcpServer("skills")
-        .tool("activate_skill", "Activate a skill by name, returning its full instructions.", {
-        type: "object",
-        properties: {
-            skill_name: { type: "string", description: "The name of the skill to activate" },
-        },
-        required: ["skill_name"],
-    }, { type: "string" }, async (input) => {
-        const skill = skillsByName.get(input.skill_name);
-        if (!skill) {
-            throw new Error(`Unknown skill: "${input.skill_name}"`);
-        }
-        return skill.body;
-    })
-        .tool("call_skill_tool", "Call a tool provided by a skill.", {
-        type: "object",
-        properties: {
-            skill_name: { type: "string", description: "The name of the skill that provides the tool" },
-            tool_name: { type: "string", description: "The name of the tool to call" },
-            input: { description: "Input to pass to the tool handler" },
-        },
-        required: ["skill_name", "tool_name"],
-    }, {}, async (input) => {
-        const skill = skillsByName.get(input.skill_name);
-        if (!skill) {
-            throw new Error(`Unknown skill: "${input.skill_name}"`);
-        }
-        const tools = skill.tools;
-        if (!tools || tools.length === 0) {
-            throw new Error(`Skill "${input.skill_name}" has no tools`);
-        }
-        const tool = tools.find((t) => t.name === input.tool_name);
-        if (!tool) {
-            throw new Error(`Unknown tool "${input.tool_name}" for skill "${input.skill_name}"`);
-        }
-        return tool.handler(input.input);
-    })
-        .tool("read_skill_file", "Read a file from a stored skill's directory.", {
-        type: "object",
-        properties: {
-            skill_name: { type: "string", description: "The name of the skill" },
-            path: { type: "string", description: "Relative path to the file within the skill directory" },
-        },
-        required: ["skill_name", "path"],
-    }, { type: "string" }, async (input) => {
-        const skill = skillsByName.get(input.skill_name);
-        if (!skill) {
-            throw new Error(`Unknown skill: "${input.skill_name}"`);
-        }
-        if (!isStoredSkill(skill)) {
-            throw new Error(`Skill "${input.skill_name}" is not a stored skill (no basePath)`);
-        }
-        // Reject absolute paths outright
-        if (isAbsolute(input.path)) {
-            throw new Error("Path must be relative");
-        }
-        const resolved = resolve(skill.basePath, input.path);
-        // Path traversal check: resolved path must be within basePath
-        const rel = relative(skill.basePath, resolved);
-        if (rel.startsWith("..") || isAbsolute(rel)) {
-            throw new Error("Path traversal is not allowed");
-        }
-        return readFile(resolved, "utf-8");
-    })
-        .build();
+  const skillsByName = /* @__PURE__ */ new Map();
+  for (const skill of skills)
+    skillsByName.set(skill.name, skill);
+  return mcpServer("skills").tool("activate_skill", "Activate a skill by name, returning its full instructions.", {
+    type: "object",
+    properties: {
+      skill_name: { type: "string", description: "The name of the skill to activate" }
+    },
+    required: ["skill_name"]
+  }, { type: "string" }, async (input) => {
+    const skill = skillsByName.get(input.skill_name);
+    if (!skill)
+      throw new Error(`Unknown skill: "${input.skill_name}"`);
+    return skill.body;
+  }).tool("call_skill_tool", "Call a tool provided by a skill.", {
+    type: "object",
+    properties: {
+      skill_name: { type: "string", description: "The name of the skill that provides the tool" },
+      tool_name: { type: "string", description: "The name of the tool to call" },
+      input: { description: "Input to pass to the tool handler" }
+    },
+    required: ["skill_name", "tool_name"]
+  }, {}, async (input) => {
+    const skill = skillsByName.get(input.skill_name);
+    if (!skill)
+      throw new Error(`Unknown skill: "${input.skill_name}"`);
+    const tools = skill.tools;
+    if (!tools || tools.length === 0)
+      throw new Error(`Skill "${input.skill_name}" has no tools`);
+    const tool = tools.find((t) => t.name === input.tool_name);
+    if (!tool)
+      throw new Error(`Unknown tool "${input.tool_name}" for skill "${input.skill_name}"`);
+    return tool.handler(input.input);
+  }).tool("read_skill_file", "Read a file from a stored skill's directory.", {
+    type: "object",
+    properties: {
+      skill_name: { type: "string", description: "The name of the skill" },
+      path: { type: "string", description: "Relative path to the file within the skill directory" }
+    },
+    required: ["skill_name", "path"]
+  }, { type: "string" }, async (input) => {
+    const skill = skillsByName.get(input.skill_name);
+    if (!skill)
+      throw new Error(`Unknown skill: "${input.skill_name}"`);
+    if (!isStoredSkill(skill))
+      throw new Error(`Skill "${input.skill_name}" is not a stored skill (no basePath)`);
+    if (isAbsolute(input.path))
+      throw new Error("Path must be relative");
+    const resolved = resolve(skill.basePath, input.path), rel = relative(skill.basePath, resolved);
+    if (rel.startsWith("..") || isAbsolute(rel))
+      throw new Error("Path traversal is not allowed");
+    return readFile(resolved, "utf-8");
+  }).build();
 }
-//# sourceMappingURL=skill-server.js.map

package/dist/skill.js

@@ -1,117 +1,51 @@
-/**
- * Skill types and SKILL.md parser for the Agent Skills standard.
- *
- * This module defines the core skill types and provides a parser for
- * SKILL.md files (YAML frontmatter + Markdown body).
- */
-/** Validation pattern for skill names: lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens. */
-const SKILL_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9]))*$/;
-/** Maximum length for skill names. */
-const MAX_NAME_LENGTH = 64;
-/** Maximum length for skill descriptions. */
-const MAX_DESCRIPTION_LENGTH = 1024;
-/**
- * Validate a skill name per the Agent Skills spec.
- * - 1-64 characters
- * - Lowercase alphanumeric + hyphens
- * - No leading, trailing, or consecutive hyphens
- */
+const SKILL_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9]))*$/, MAX_NAME_LENGTH = 64, MAX_DESCRIPTION_LENGTH = 1024;
 export function validateSkillName(name) {
-    if (typeof name !== "string" || name.length === 0) {
-        throw new Error("Skill name is required");
-    }
-    if (name.length > MAX_NAME_LENGTH) {
-        throw new Error(`Skill name must be at most ${MAX_NAME_LENGTH} characters, got ${name.length}`);
-    }
-    if (!SKILL_NAME_PATTERN.test(name)) {
-        throw new Error(`Invalid skill name "${name}": must be lowercase alphanumeric with hyphens, no leading/trailing/consecutive hyphens`);
-    }
+  if (typeof name != "string" || name.length === 0)
+    throw new Error("Skill name is required");
+  if (name.length > 64)
+    throw new Error(`Skill name must be at most 64 characters, got ${name.length}`);
+  if (!SKILL_NAME_PATTERN.test(name))
+    throw new Error(`Invalid skill name "${name}": must be lowercase alphanumeric with hyphens, no leading/trailing/consecutive hyphens`);
 }
-/**
- * Validate a skill description per the Agent Skills spec.
- * - 1-1024 characters
- * - Non-empty (after trimming)
- */
 export function validateSkillDescription(description) {
-    if (typeof description !== "string" || description.trim().length === 0) {
-        throw new Error("Skill description is required");
-    }
-    if (description.length > MAX_DESCRIPTION_LENGTH) {
-        throw new Error(`Skill description must be at most ${MAX_DESCRIPTION_LENGTH} characters, got ${description.length}`);
-    }
+  if (typeof description != "string" || description.trim().length === 0)
+    throw new Error("Skill description is required");
+  if (description.length > 1024)
+    throw new Error(`Skill description must be at most 1024 characters, got ${description.length}`);
 }
-/**
- * Parse a SKILL.md file content into a Skill.
- *
- * Extracts YAML frontmatter (delimited by `---`), validates required fields
- * (name, description), and returns the parsed skill with the Markdown body.
- *
- * Optional frontmatter fields (license, compatibility, metadata) are preserved
- * in the returned object but not acted upon.
- *
- * @throws Error if frontmatter is missing, malformed, or required fields are invalid
- */
 export function parseSkillMd(content) {
-    const { frontmatter, body } = extractFrontmatter(content);
-    const fields = parseYamlFrontmatter(frontmatter);
-    validateSkillName(fields.name);
-    validateSkillDescription(fields.description);
-    return {
-        ...fields,
-        name: fields.name,
-        description: fields.description,
-        body,
-    };
+  const { frontmatter, body } = extractFrontmatter(content), fields = parseYamlFrontmatter(frontmatter);
+  return validateSkillName(fields.name), validateSkillDescription(fields.description), {
+    ...fields,
+    name: fields.name,
+    description: fields.description,
+    body
+  };
 }
-/**
- * Extract YAML frontmatter and body from a SKILL.md string.
- * Frontmatter is delimited by opening and closing `---` lines.
- */
 function extractFrontmatter(content) {
-    const trimmed = content.trimStart();
-    if (!trimmed.startsWith("---")) {
-        throw new Error("SKILL.md must begin with YAML frontmatter (---)");
-    }
-    // Find the closing `---` after the opening one
-    const endIndex = trimmed.indexOf("\n---", 3);
-    if (endIndex === -1) {
-        throw new Error("SKILL.md frontmatter is missing closing ---");
-    }
-    const frontmatter = trimmed.slice(3, endIndex).trim();
-    // Body starts after the closing `---` and its newline
-    const afterClosing = endIndex + 4; // "\n---".length
-    // Strip the line ending after the closing --- and any single blank line
-    const body = trimmed.slice(afterClosing).replace(/^(\r?\n){1,2}/, "");
-    return { frontmatter, body };
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---"))
+    throw new Error("SKILL.md must begin with YAML frontmatter (---)");
+  const endIndex = trimmed.indexOf(`
+---`, 3);
+  if (endIndex === -1)
+    throw new Error("SKILL.md frontmatter is missing closing ---");
+  const frontmatter = trimmed.slice(3, endIndex).trim(), afterClosing = endIndex + 4, body = trimmed.slice(afterClosing).replace(/^(\r?\n){1,2}/, "");
+  return { frontmatter, body };
 }
-/**
- * Minimal YAML parser for SKILL.md frontmatter.
- *
- * Supports only the flat key-value structure needed for skill metadata:
- * simple string values (quoted or unquoted). This is intentionally limited --
- * we don't need nested objects, arrays, or other YAML features.
- */
 function parseYamlFrontmatter(yaml) {
-    const result = {};
-    for (const line of yaml.split("\n")) {
-        const trimmed = line.trim();
-        if (trimmed === "" || trimmed.startsWith("#"))
-            continue;
-        const colonIndex = trimmed.indexOf(":");
-        if (colonIndex === -1) {
-            throw new Error(`Invalid frontmatter line: ${trimmed}`);
-        }
-        const key = trimmed.slice(0, colonIndex).trim();
-        let value = trimmed.slice(colonIndex + 1).trim();
-        // Strip surrounding quotes (single or double)
-        if (typeof value === "string") {
-            if ((value.startsWith('"') && value.endsWith('"')) ||
-                (value.startsWith("'") && value.endsWith("'"))) {
-                value = value.slice(1, -1);
-            }
-        }
-        result[key] = value;
-    }
-    return result;
+  const result = {};
+  for (const line of yaml.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#"))
+      continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1)
+      throw new Error(`Invalid frontmatter line: ${trimmed}`);
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    typeof value == "string" && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) && (value = value.slice(1, -1)), result[key] = value;
+  }
+  return result;
 }
-//# sourceMappingURL=skill.js.map

package/dist/types.js

@@ -1,8 +1 @@
-/**
- * Types for ACP protocol messages
- *
- * This module re-exports shared types from @thinkwell/protocol and
- * defines ACP-specific types that are not shared with other packages.
- */
 export {};
-//# sourceMappingURL=types.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thinkwell/acp",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "TypeScript implementation of ACP (Agent Client Protocol) extensions for Thinkwell",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,10 +25,10 @@
   "author": "David Herman",
   "license": "MIT",
   "dependencies": {
-    "@agentclientprotocol/sdk": "^0.4.0",
+    "@agentclientprotocol/sdk": "^0.16.1",
     "uuid": "^11.0.3",
-    "@thinkwell/conductor": "0.5.4",
-    "@thinkwell/protocol": "0.5.4"
+    "@thinkwell/conductor": "0.5.6",
+    "@thinkwell/protocol": "0.5.6"
   },
   "devDependencies": {
     "@types/node": "^24.10.4",
@@ -37,7 +37,8 @@
     "typescript": "^5.7.2"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsx ../../scripts/strip-features.ts --mode=release",
+    "build:debug": "tsc",
     "clean": "rm -rf dist",
     "test": "node --test --import tsx src/**/*.test.ts"
   }