@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/@noble/hashes/webcrypto.d.ts

@@ -0,0 +1,121 @@
+import { type Pbkdf2Opt } from './pbkdf2.ts';
+import { type KDFInput, type TArg, type TRet } from './utils.ts';
+/** Callable WebCrypto hash function descriptor. */
+export type WebHash = {
+    /**
+     * Hashes one message with the selected WebCrypto digest.
+     * @param msg - message bytes to hash
+     * @returns Promise resolving to digest bytes.
+     */
+    (msg: TArg<Uint8Array>): Promise<TRet<Uint8Array>>;
+    /** WebCrypto algorithm name passed to `crypto.subtle`. */
+    webCryptoName: string;
+    /** Digest size in bytes. */
+    outputLen: number;
+    /** Input block size in bytes. */
+    blockLen: number;
+};
+/** WebCrypto SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+/**
+ * WebCrypto SHA2-256 hash function from RFC 6234.
+ * @param msg - message bytes to hash
+ * @returns Promise resolving to digest bytes.
+ * @example
+ * Hash a message with WebCrypto SHA2-256.
+ * ```ts
+ * await sha256(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export declare const sha256: TRet<WebHash>;
+/**
+ * WebCrypto SHA2-384 hash function from RFC 6234.
+ * @param msg - message bytes to hash
+ * @returns Promise resolving to digest bytes.
+ * @example
+ * Hash a message with WebCrypto SHA2-384.
+ * ```ts
+ * await sha384(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export declare const sha384: TRet<WebHash>;
+/**
+ * WebCrypto SHA2-512 hash function from RFC 6234.
+ * @param msg - message bytes to hash
+ * @returns Promise resolving to digest bytes.
+ * @example
+ * Hash a message with WebCrypto SHA2-512.
+ * ```ts
+ * await sha512(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export declare const sha512: TRet<WebHash>;
+/** WebCrypto HMAC function type. See {@link hmac} for usage. */
+type WebHmacFn = {
+    (hash: TArg<WebHash>, key: TArg<Uint8Array>, message: TArg<Uint8Array>): Promise<TRet<Uint8Array>>;
+    create(hash: TArg<WebHash>, key: TArg<Uint8Array>): any;
+};
+/**
+ * WebCrypto HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256. Webcrypto version.
+ * @param key - authentication key bytes
+ * @param message - message bytes to authenticate
+ * @returns Promise resolving to authentication tag bytes.
+ * `.create()` exists only to mirror the synchronous API surface
+ * and always throws `not implemented`.
+ * @example
+ * Compute an RFC 2104 HMAC with WebCrypto.
+ * ```ts
+ * import { hmac, sha256 } from '@noble/hashes/webcrypto.js';
+ * const key = new Uint8Array([1, 2, 3]);
+ * const message = new Uint8Array([4, 5, 6]);
+ * const mac = await hmac(sha256, key, message);
+ * ```
+ */
+export declare const hmac: TRet<WebHmacFn>;
+/**
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256). Webcrypto version.
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information bytes
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` requests an empty OKM.
+ * @returns Promise resolving to derived key bytes.
+ * The RFC `L <= 255 * HashLen` bound is enforced before calling WebCrypto.
+ * @throws If the current runtime does not provide `crypto.subtle`. {@link Error}
+ * @example
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * ```ts
+ * import { hkdf, sha256 } from '@noble/hashes/webcrypto.js';
+ * import { randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = utf8ToBytes('application-key');
+ * const okm = await hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export declare function hkdf(hash: TArg<WebHash>, ikm: TArg<Uint8Array>, salt: TArg<Uint8Array | undefined>, info: TArg<Uint8Array | undefined>, length: number): Promise<TRet<Uint8Array>>;
+/**
+ * WebCrypto PBKDF2-HMAC: RFC 8018 key derivation function.
+ * @param hash - hash function that would be used e.g. sha256. Webcrypto version.
+ * @param password - password from which a derived key is generated; string
+ *   inputs are normalized through `kdfInputToBytes()`, i.e. UTF-8
+ * @param salt - cryptographic salt; string inputs are normalized through
+ *   `kdfInputToBytes()`, i.e. UTF-8
+ * @param opts - PBKDF2 work factor and output settings. `dkLen`, if provided,
+ *   must be `>= 1` per RFC 8018 §5.2. See {@link Pbkdf2Opt}.
+ * @returns Promise resolving to derived key bytes.
+ * Positive-iteration enforcement is currently delegated to backend
+ * `deriveBits()` rejection (for example `c = 0`), not a dedicated
+ * library-side guard. Values above the signed 32-bit backend range are rejected locally.
+ * @throws If the current runtime does not provide `crypto.subtle`. {@link Error}
+ * @example
+ * WebCrypto PBKDF2-HMAC: RFC 2898 key derivation function.
+ * ```ts
+ * import { pbkdf2, sha256 } from '@noble/hashes/webcrypto.js';
+ * const key = await pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ * ```
+ */
+export declare function pbkdf2(hash: TArg<WebHash>, password: TArg<KDFInput>, salt: TArg<KDFInput>, opts: Pbkdf2Opt): Promise<TRet<Uint8Array>>;
+export {};

package/node_modules/toolcraft/node_modules/@noble/hashes/webcrypto.js

@@ -0,0 +1,228 @@
+import {} from "./pbkdf2.js";
+import { abytes, ahash, anumber, checkOpts, clean, copyBytes, kdfInputToBytes, } from "./utils.js";
+function _subtle() {
+    const cr = typeof globalThis === 'object' ? globalThis.crypto : null;
+    const sb = cr?.subtle;
+    if (typeof sb === 'object' && sb != null)
+        return sb;
+    throw new Error('crypto.subtle must be defined');
+}
+function createWebHash(name, blockLen, outputLen) {
+    const hashC = async (msg) => {
+        abytes(msg);
+        const crypto = _subtle();
+        return new Uint8Array(await crypto.digest(name, msg));
+    };
+    hashC.webCryptoName = name; // make sure it won't interfere with function name
+    hashC.outputLen = outputLen;
+    hashC.blockLen = blockLen;
+    hashC.create = () => {
+        // Present only so this async wrapper satisfies the shared
+        // hash-wrapper shape checked by `ahashWeb()`.
+        throw new Error('not implemented');
+    };
+    // Later WebCrypto HMAC/HKDF/PBKDF2 calls read descriptor metadata directly, so freezing prevents
+    // callers from retargeting a `sha256` wrapper into a different backend digest by mutation.
+    return Object.freeze(hashC);
+}
+function ahashWeb(hash) {
+    ahash(hash);
+    const name = hash.webCryptoName;
+    if (typeof name !== 'string')
+        throw new Error('non-web hash');
+    return name;
+}
+/** WebCrypto SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+// export const sha1: WebHash = createHash('SHA-1', 64, 20);
+/**
+ * WebCrypto SHA2-256 hash function from RFC 6234.
+ * @param msg - message bytes to hash
+ * @returns Promise resolving to digest bytes.
+ * @example
+ * Hash a message with WebCrypto SHA2-256.
+ * ```ts
+ * await sha256(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export const sha256 = /* @__PURE__ */ createWebHash('SHA-256', 64, 32);
+/**
+ * WebCrypto SHA2-384 hash function from RFC 6234.
+ * @param msg - message bytes to hash
+ * @returns Promise resolving to digest bytes.
+ * @example
+ * Hash a message with WebCrypto SHA2-384.
+ * ```ts
+ * await sha384(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export const sha384 = /* @__PURE__ */ createWebHash('SHA-384', 128, 48);
+/**
+ * WebCrypto SHA2-512 hash function from RFC 6234.
+ * @param msg - message bytes to hash
+ * @returns Promise resolving to digest bytes.
+ * @example
+ * Hash a message with WebCrypto SHA2-512.
+ * ```ts
+ * await sha512(new Uint8Array([97, 98, 99]));
+ * ```
+ */
+export const sha512 = /* @__PURE__ */ createWebHash('SHA-512', 128, 64);
+/**
+ * WebCrypto HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256. Webcrypto version.
+ * @param key - authentication key bytes
+ * @param message - message bytes to authenticate
+ * @returns Promise resolving to authentication tag bytes.
+ * `.create()` exists only to mirror the synchronous API surface
+ * and always throws `not implemented`.
+ * @example
+ * Compute an RFC 2104 HMAC with WebCrypto.
+ * ```ts
+ * import { hmac, sha256 } from '@noble/hashes/webcrypto.js';
+ * const key = new Uint8Array([1, 2, 3]);
+ * const message = new Uint8Array([4, 5, 6]);
+ * const mac = await hmac(sha256, key, message);
+ * ```
+ */
+export const hmac = /* @__PURE__ */ (() => {
+    const hmac_ = async (hash, key, message) => {
+        const crypto = _subtle();
+        abytes(key, undefined, 'key');
+        abytes(message, undefined, 'message');
+        const hashName = ahashWeb(hash);
+        // importKey() snapshots key synchronously, but message is not passed to sign() until after
+        // importKey() resolves. Keep the wrapper's inputs stable across that await.
+        const _message = copyBytes(message);
+        try {
+            // WebCrypto keys can't be zeroized
+            // prettier-ignore
+            const wkey = await crypto.importKey('raw', key, { name: 'HMAC', hash: hashName }, false, ['sign']);
+            return new Uint8Array(await crypto.sign('HMAC', wkey, _message));
+        }
+        finally {
+            clean(_message);
+        }
+    };
+    hmac_.create = (_hash, _key) => {
+        throw new Error('not implemented');
+    };
+    return hmac_;
+})();
+/**
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256). Webcrypto version.
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information bytes
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` requests an empty OKM.
+ * @returns Promise resolving to derived key bytes.
+ * The RFC `L <= 255 * HashLen` bound is enforced before calling WebCrypto.
+ * @throws If the current runtime does not provide `crypto.subtle`. {@link Error}
+ * @example
+ * WebCrypto HKDF (RFC 5869): derive keys from an initial input.
+ * ```ts
+ * import { hkdf, sha256 } from '@noble/hashes/webcrypto.js';
+ * import { randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = utf8ToBytes('application-key');
+ * const okm = await hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+export async function hkdf(hash, ikm, salt, info, length) {
+    const crypto = _subtle();
+    const hashName = ahashWeb(hash);
+    const hashOutputLen = hash.outputLen;
+    abytes(ikm, undefined, 'ikm');
+    anumber(length, 'length');
+    if (length > 255 * hashOutputLen)
+        throw new Error('Length must be <= 255*HashLen');
+    if (salt !== undefined)
+        abytes(salt, undefined, 'salt');
+    if (info !== undefined)
+        abytes(info, undefined, 'info');
+    // salt and info reach deriveBits() only after importKey() resolves, so snapshot them now.
+    const _salt = salt === undefined ? new Uint8Array(0) : copyBytes(salt);
+    const _info = info === undefined ? new Uint8Array(0) : copyBytes(info);
+    try {
+        const wkey = await crypto.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
+        const opts = { name: 'HKDF', hash: hashName, salt: _salt, info: _info };
+        const out = new Uint8Array(await crypto.deriveBits(opts, wkey, 8 * length));
+        if (out.length !== length) {
+            clean(out);
+            throw new Error('WebCrypto returned an invalid derived key length');
+        }
+        return out;
+    }
+    finally {
+        clean(_salt, _info);
+    }
+}
+/**
+ * WebCrypto PBKDF2-HMAC: RFC 8018 key derivation function.
+ * @param hash - hash function that would be used e.g. sha256. Webcrypto version.
+ * @param password - password from which a derived key is generated; string
+ *   inputs are normalized through `kdfInputToBytes()`, i.e. UTF-8
+ * @param salt - cryptographic salt; string inputs are normalized through
+ *   `kdfInputToBytes()`, i.e. UTF-8
+ * @param opts - PBKDF2 work factor and output settings. `dkLen`, if provided,
+ *   must be `>= 1` per RFC 8018 §5.2. See {@link Pbkdf2Opt}.
+ * @returns Promise resolving to derived key bytes.
+ * Positive-iteration enforcement is currently delegated to backend
+ * `deriveBits()` rejection (for example `c = 0`), not a dedicated
+ * library-side guard. Values above the signed 32-bit backend range are rejected locally.
+ * @throws If the current runtime does not provide `crypto.subtle`. {@link Error}
+ * @example
+ * WebCrypto PBKDF2-HMAC: RFC 2898 key derivation function.
+ * ```ts
+ * import { pbkdf2, sha256 } from '@noble/hashes/webcrypto.js';
+ * const key = await pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
+ * ```
+ */
+export async function pbkdf2(hash, password, salt, opts) {
+    const crypto = _subtle();
+    const hashName = ahashWeb(hash);
+    const _opts = checkOpts({ dkLen: 32 }, opts);
+    const { c, dkLen } = _opts;
+    anumber(c, 'c');
+    anumber(dkLen, 'dkLen');
+    // Node's native WebCrypto PBKDF2 binding accepts only a signed 32-bit iteration count and aborts
+    // the process on larger values instead of returning a rejected promise.
+    if (c > 0x7fffffff)
+        throw new Error('"c" exceeds WebCrypto backend limit');
+    // RFC 8018 §5.2 defines dkLen as a positive integer.
+    if (dkLen < 1)
+        throw new Error('"dkLen" must be >= 1');
+    // SubtleCrypto.deriveBits() accepts an unsigned-long bit count. Byte lengths at or above
+    // 2^29 would wrap after multiplication by eight instead of requesting the intended length.
+    if (dkLen >= 2 ** 29)
+        throw new Error('derived key too long');
+    const _password = kdfInputToBytes(password, 'password');
+    try {
+        const saltBytes = kdfInputToBytes(salt, 'salt');
+        // String conversion already returns an owned array. Caller-owned byte salts need a snapshot
+        // because deriveBits() does not receive them until after importKey() resolves.
+        const _salt = typeof salt === 'string' ? saltBytes : copyBytes(saltBytes);
+        try {
+            const key = await crypto.importKey('raw', _password, 'PBKDF2', false, [
+                'deriveBits',
+            ]);
+            const deriveOpts = { name: 'PBKDF2', salt: _salt, iterations: c, hash: hashName };
+            const out = new Uint8Array(await crypto.deriveBits(deriveOpts, key, 8 * dkLen));
+            if (out.length !== dkLen) {
+                clean(out);
+                throw new Error('WebCrypto returned an invalid derived key length');
+            }
+            return out;
+        }
+        finally {
+            clean(_salt);
+        }
+    }
+    finally {
+        if (typeof password === 'string')
+            clean(_password);
+    }
+}

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/README.md

@@ -4,7 +4,8 @@ Shared catalog of supported coding-agent definitions.
 
 This package owns the declarative agent metadata used by CLI, SDK, spawn,
 configuration, and UI surfaces: stable ids, labels, aliases, config paths,
-binary names, API-shape support, OTEL capture wiring, and brand colors.
+binary names, API-shape support, OTEL capture wiring, brand colors, and the
+capability matrix that says which commands accept each agent.
 
 ## Usage
 
@@ -23,7 +24,19 @@ const codex = allAgents.find((agent) => agent.id === "codex");
 - `parseAgentSpecifier(input)`: parses `agent` or `agent:model` input.
 - `formatAgentSpecifier(specifier)`: formats an agent specifier.
 - `normalizeAgentId(input)`: normalizes the agent part through the registry.
-- Agent definition exports such as `codexAgent`, `claudeCodeAgent`, and `geminiCliAgent`.
+- Agent definition exports such as `codexAgent`, `claudeCodeAgent`, `geminiCliAgent`, and `piAgent`.
+- `listAgentsWithCapability(capability, options?)`: ids supporting a capability, optionally including aliases.
+- `agentSupportsCapability(input, capability)`: resolves aliases, then checks the matrix.
+- `formatAgentCapabilityError({ agent, capability })`: the shared message for a rejected agent argument.
+
+## Capability Matrix
+
+Each `AgentDefinition` declares its `capabilities` (`spawn`, `configure`,
+`install`, `test`, `skill`, `mcp`). This is the single published source for every
+command's allow-list, so `spawn`/`configure`/`install`/`test`/`skill` cannot
+drift apart. `src/cli/commands/agent-capability-matrix.test.ts` pins each
+capability to the registry that implements it, and fails if a registry gains or
+loses an agent without the matrix being updated.
 
 ## Config Options
 

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/claude-code.js

@@ -2,7 +2,7 @@ export const claudeCodeAgent = {
     id: "claude-code",
     name: "claude-code",
     label: "Claude Code",
-    summary: "Configure Claude Code to route through Poe.",
+    summary: "Anthropic's agentic coding tool for the terminal.",
     aliases: ["claude"],
     binaryName: "claude",
     apiShapes: ["anthropic-messages"],
@@ -12,6 +12,7 @@ export const claudeCodeAgent = {
         }
     },
     configPath: "~/.claude.json",
+    capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
     branding: {
         colors: {
             dark: "#C15F3C",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/claude-desktop.js

@@ -9,6 +9,7 @@ export const claudeDesktopAgent = {
         linux: "~/.config/Claude/claude_desktop_config.json",
         win32: "~/AppData/Roaming/Claude/claude_desktop_config.json"
     },
+    capabilities: ["mcp"],
     branding: {
         colors: {
             dark: "#D97757",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/codex.js

@@ -2,7 +2,7 @@ export const codexAgent = {
     id: "codex",
     name: "codex",
     label: "Codex",
-    summary: "Configure Codex to use Poe as the model provider.",
+    summary: "OpenAI's coding agent for the terminal.",
     binaryName: "codex",
     apiShapes: ["openai-responses"],
     otelCapture: {
@@ -16,6 +16,7 @@ export const codexAgent = {
         ]
     },
     configPath: "~/.codex/config.toml",
+    capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
     branding: {
         colors: {
             dark: "#D5D9DF",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/cursor.js

@@ -6,6 +6,7 @@ export const cursorAgent = {
     summary: "Cursor's CLI coding agent.",
     binaryName: "cursor-agent",
     configPath: "~/.cursor/mcp.json",
+    capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
     branding: {
         colors: {
             dark: "#FFFFFF",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/gemini-cli.js

@@ -3,10 +3,11 @@ export const geminiCliAgent = {
     name: "gemini-cli",
     aliases: ["gemini"],
     label: "Gemini CLI",
-    summary: "Configure Google's Gemini CLI to use a compatible Google generations API.",
+    summary: "Google's open-source AI agent for the terminal.",
     binaryName: "gemini",
     configPath: "~/.gemini/settings.json",
     apiShapes: ["google-generations"],
+    capabilities: ["spawn", "configure", "install", "test", "skill"],
     branding: {
         colors: {
             dark: "#8AB4F8",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/goose.js

@@ -7,6 +7,7 @@ export const gooseAgent = {
     apiShapes: ["openai-chat-completions"],
     otelCapture: {},
     configPath: "~/.config/goose/config.yaml",
+    capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
     branding: {
         colors: {
             dark: "#FF6B35",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/index.d.ts

@@ -4,6 +4,6 @@ export { codexAgent } from "./codex.js";
 export { cursorAgent } from "./cursor.js";
 export { geminiCliAgent } from "./gemini-cli.js";
 export { openCodeAgent } from "./opencode.js";
-export { kimiAgent } from "./kimi.js";
 export { gooseAgent } from "./goose.js";
+export { piAgent } from "./pi.js";
 export { poeAgentAgent } from "./poe-agent.js";

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/index.js

@@ -4,6 +4,6 @@ export { codexAgent } from "./codex.js";
 export { cursorAgent } from "./cursor.js";
 export { geminiCliAgent } from "./gemini-cli.js";
 export { openCodeAgent } from "./opencode.js";
-export { kimiAgent } from "./kimi.js";
 export { gooseAgent } from "./goose.js";
+export { piAgent } from "./pi.js";
 export { poeAgentAgent } from "./poe-agent.js";

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/opencode.js

@@ -2,7 +2,7 @@ export const openCodeAgent = {
     id: "opencode",
     name: "opencode",
     label: "OpenCode CLI",
-    summary: "Configure OpenCode CLI to use the Poe API.",
+    summary: "Open-source AI coding agent for the terminal.",
     binaryName: "opencode",
     apiShapes: ["openai-chat-completions"],
     otelCapture: {
@@ -11,6 +11,7 @@ export const openCodeAgent = {
         }
     },
     configPath: "~/.config/opencode/opencode.json",
+    capabilities: ["spawn", "configure", "install", "test", "skill", "mcp"],
     branding: {
         colors: {
             dark: "#4A4F55",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/{kimi.d.ts → pi.d.ts}

@@ -1,2 +1,2 @@
 import type { AgentDefinition } from "../types.js";
-export declare const kimiAgent: AgentDefinition;
+export declare const piAgent: AgentDefinition;

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/pi.js

@@ -0,0 +1,15 @@
+export const piAgent = {
+    id: "pi",
+    name: "pi",
+    aliases: ["pi-agent"],
+    label: "Pi",
+    summary: "Minimal AI coding agent for the terminal.",
+    binaryName: "pi",
+    capabilities: ["spawn"],
+    branding: {
+        colors: {
+            dark: "#F2F2F2",
+            light: "#242424"
+        }
+    }
+};

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/agents/poe-agent.js

@@ -5,6 +5,7 @@ export const poeAgentAgent = {
     summary: "Run one-shot prompts with the built-in Poe agent runtime.",
     apiShapes: ["openai-responses", "openai-chat-completions"],
     configPath: "~/.poe-code/config.json",
+    capabilities: ["configure"],
     branding: {
         colors: {
             dark: "#A465F7",

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/capabilities.d.ts

@@ -0,0 +1,14 @@
+import type { AgentCapability } from "./types.js";
+export declare function listAgentsWithCapability(capability: AgentCapability, options?: {
+    includeAliases?: boolean;
+}): readonly string[];
+export declare function agentSupportsCapability(input: string, capability: AgentCapability): boolean;
+/**
+ * The single message for every agent argument that misses. It distinguishes a
+ * typo (unknown id, plus a did-you-mean) from a real capability gap ("pi
+ * supports: spawn"), and always names the agents the command does accept.
+ */
+export declare function formatAgentCapabilityError(input: {
+    agent: string;
+    capability: AgentCapability;
+}): string;

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/capabilities.js

@@ -0,0 +1,63 @@
+import { allAgents, resolveAgentId } from "./registry.js";
+export function listAgentsWithCapability(capability, options) {
+    const names = [];
+    for (const agent of allAgents) {
+        if (!agent.capabilities?.includes(capability)) {
+            continue;
+        }
+        names.push(agent.id);
+        if (options?.includeAliases) {
+            names.push(...(agent.aliases ?? []));
+        }
+    }
+    return names;
+}
+export function agentSupportsCapability(input, capability) {
+    const id = resolveAgentId(input);
+    return id !== undefined && listAgentsWithCapability(capability).includes(id);
+}
+const MAX_SUGGESTION_DISTANCE = 3;
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_unused, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j += 1) {
+            const substitution = previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+            current[j] = Math.min(substitution, previous[j] + 1, current[j - 1] + 1);
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/** Every candidate tied for the smallest edit distance, when one is close enough. */
+function suggest(input, candidates) {
+    const needle = input.trim().toLowerCase();
+    const scored = candidates
+        .map((candidate) => ({ candidate, score: editDistance(needle, candidate.toLowerCase()) }))
+        .filter((entry) => entry.score <= MAX_SUGGESTION_DISTANCE);
+    if (scored.length === 0) {
+        return [];
+    }
+    const best = Math.min(...scored.map((entry) => entry.score));
+    return scored.filter((entry) => entry.score === best).map((entry) => entry.candidate);
+}
+/**
+ * The single message for every agent argument that misses. It distinguishes a
+ * typo (unknown id, plus a did-you-mean) from a real capability gap ("pi
+ * supports: spawn"), and always names the agents the command does accept.
+ */
+export function formatAgentCapabilityError(input) {
+    const allowed = listAgentsWithCapability(input.capability, { includeAliases: true });
+    const allowList = `Agents supporting ${input.capability}: ${allowed.length > 0 ? allowed.join(", ") : "none"}.`;
+    const id = resolveAgentId(input.agent);
+    if (!id) {
+        const near = suggest(input.agent, allowed);
+        const hint = near.length > 0 ? ` Did you mean: ${near.join(", ")}?` : "";
+        return `Unknown agent "${input.agent}".${hint} ${allowList}`;
+    }
+    const supported = ["spawn", "configure", "install", "test", "skill", "mcp"].filter((capability) => listAgentsWithCapability(capability).includes(id));
+    const supports = supported.length > 0
+        ? `${id} supports: ${supported.join(", ")}.`
+        : `${id} is not supported by poe-code agent commands.`;
+    return `Agent "${id}" does not support ${input.capability}. ${supports} ${allowList}`;
+}

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/index.d.ts

@@ -1,5 +1,6 @@
-export type { AgentDefinition, ApiShapeId, OtelCaptureDefinition } from "./types.js";
+export type { AgentCapability, AgentDefinition, ApiShapeId, OtelCaptureDefinition } from "./types.js";
 export type { AgentSpecifier } from "./specifier.js";
-export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
+export { agentSupportsCapability, formatAgentCapabilityError, listAgentsWithCapability } from "./capabilities.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";

package/node_modules/toolcraft/node_modules/@poe-code/agent-defs/dist/index.js

@@ -1,3 +1,4 @@
-export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, kimiAgent, gooseAgent, poeAgentAgent } from "./agents/index.js";
+export { claudeCodeAgent, claudeDesktopAgent, codexAgent, cursorAgent, geminiCliAgent, openCodeAgent, gooseAgent, piAgent, poeAgentAgent } from "./agents/index.js";
 export { allAgents, resolveAgentId } from "./registry.js";
+export { agentSupportsCapability, formatAgentCapabilityError, listAgentsWithCapability } from "./capabilities.js";
 export { parseAgentSpecifier, formatAgentSpecifier, normalizeAgentId } from "./specifier.js";