toolcraft 0.0.2 → 0.0.3

package/dist/sdk.d.ts

@@ -1,11 +1,16 @@
 import type { ObjectSchema, Static } from "toolcraft-schema";
 import type { Group, Scope } from "./index.js";
+import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
 type ScopeInput = readonly Scope[] | undefined;
+type HumanInLoopMode = "sync" | "async";
+type HumanInLoopModeInput = HumanInLoopMode | null | undefined;
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 type EmptyRecord = Record<never, never>;
 type EffectiveCommandScope<TOwnScope extends ScopeInput, TInheritedScope extends ScopeInput> = TOwnScope extends readonly Scope[] ? TOwnScope : TInheritedScope extends readonly Scope[] ? TInheritedScope : readonly ["cli", "sdk"];
 type EffectiveGroupScope<TOwnScope extends ScopeInput, TInheritedScope extends ScopeInput> = TOwnScope extends readonly Scope[] ? TOwnScope : TInheritedScope extends readonly Scope[] ? TInheritedScope : undefined;
 type IncludesSDK<TScope> = TScope extends readonly Scope[] ? "sdk" extends TScope[number] ? true : false : false;
+type EffectiveCommandHumanInLoopMode<TOwnHumanInLoopMode extends HumanInLoopModeInput, TInheritedHumanInLoopMode extends HumanInLoopMode | undefined> = TOwnHumanInLoopMode extends HumanInLoopMode ? TOwnHumanInLoopMode : TOwnHumanInLoopMode extends null ? undefined : TInheritedHumanInLoopMode;
+type EffectiveGroupHumanInLoopMode<TOwnHumanInLoopMode extends HumanInLoopModeInput, TInheritedHumanInLoopMode extends HumanInLoopMode | undefined> = TOwnHumanInLoopMode extends HumanInLoopMode ? TOwnHumanInLoopMode : TOwnHumanInLoopMode extends null ? undefined : TInheritedHumanInLoopMode;
 type Separator = "-" | "_" | " " | ".";
 type IsUppercase<TValue extends string> = TValue extends Uppercase<TValue> ? TValue extends Lowercase<TValue> ? false : true : false;
 type IsLowercase<TValue extends string> = TValue extends Lowercase<TValue> ? TValue extends Uppercase<TValue> ? false : true : false;
@@ -24,40 +29,44 @@ type CamelCase<TValue extends string> = JoinCamelWords<SplitCamelWords<TValue>>;
 type Camelize<TValue> = TValue extends Primitive ? TValue : TValue extends readonly (infer TItem)[] ? Array<Camelize<TItem>> : TValue extends object ? {
     [TKey in keyof TValue as TKey extends string ? CamelCase<TKey> : TKey]: Camelize<TValue[TKey]>;
 } : TValue;
+type SDKResult<TResult, THumanInLoopMode extends HumanInLoopMode | undefined> = THumanInLoopMode extends "async" ? HumanInLoopPending : TResult;
 type SDKMethod<TParamsSchema extends ObjectSchema<any>, TResult> = (params: Camelize<Static<TParamsSchema>>) => Promise<TResult>;
 type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer TResult) => void ? TResult : never;
 type Simplify<TValue> = {
     [TKey in keyof TValue]: TValue[TKey];
 };
 type RawChildrenValue<TChildren> = TChildren extends readonly unknown[] ? TChildren[number] : never;
-type SDKNodeShape<TNode, TInheritedScope extends ScopeInput> = TNode extends {
+type SDKNodeShape<TNode, TInheritedScope extends ScopeInput, TInheritedHumanInLoopMode extends HumanInLoopMode | undefined> = TNode extends {
     kind: "command";
     readonly __agentKitCommandTypeInfo: {
         name: infer TName extends string;
         params: infer TParamsSchema extends ObjectSchema<any>;
         result: infer TResult;
         ownScope: infer TOwnScope extends ScopeInput;
+        ownHumanInLoopMode: infer TOwnHumanInLoopMode extends HumanInLoopModeInput;
     };
 } ? IncludesSDK<EffectiveCommandScope<TOwnScope, TInheritedScope>> extends true ? {
-    [TKey in CamelCase<TName>]: SDKMethod<TParamsSchema, TResult>;
+    [TKey in CamelCase<TName>]: SDKMethod<TParamsSchema, SDKResult<TResult, EffectiveCommandHumanInLoopMode<TOwnHumanInLoopMode, TInheritedHumanInLoopMode>>>;
 } : EmptyRecord : TNode extends {
     kind: "group";
     readonly __agentKitGroupTypeInfo: {
         name: infer TName extends string;
         children: infer TChildren extends readonly unknown[];
         ownScope: infer TOwnScope extends ScopeInput;
+        ownHumanInLoopMode: infer TOwnHumanInLoopMode extends HumanInLoopModeInput;
     };
-} ? SDKChildrenShape<TChildren, EffectiveGroupScope<TOwnScope, TInheritedScope>> extends infer TChildShape extends object ? keyof TChildShape extends never ? EmptyRecord : {
+} ? SDKChildrenShape<TChildren, EffectiveGroupScope<TOwnScope, TInheritedScope>, EffectiveGroupHumanInLoopMode<TOwnHumanInLoopMode, TInheritedHumanInLoopMode>> extends infer TChildShape extends object ? keyof TChildShape extends never ? EmptyRecord : {
     [TKey in CamelCase<TName>]: TChildShape;
 } : never : EmptyRecord;
-type SDKChildrenShape<TChildren, TInheritedScope extends ScopeInput> = Simplify<UnionToIntersection<SDKNodeShape<RawChildrenValue<TChildren>, TInheritedScope>>>;
+type SDKChildrenShape<TChildren, TInheritedScope extends ScopeInput, TInheritedHumanInLoopMode extends HumanInLoopMode | undefined> = Simplify<UnionToIntersection<SDKNodeShape<RawChildrenValue<TChildren>, TInheritedScope, TInheritedHumanInLoopMode>>>;
 export interface CreateSDKOptions<TServices extends object = Record<string, unknown>> {
     services?: TServices;
     casing?: "camel";
+    humanInLoop?: HumanInLoopRuntimeOptions;
 }
 export declare function createSDK<TRootInfo, TServices extends object = Record<string, unknown>>(root: Group<any> & {
     readonly __agentKitGroupTypeInfo: TRootInfo;
 }, options?: CreateSDKOptions<TServices>): TRootInfo extends {
     children: infer TChildren extends readonly unknown[];
-} ? SDKChildrenShape<TChildren, undefined> : EmptyRecord;
+} ? SDKChildrenShape<TChildren, undefined, undefined> : EmptyRecord;
 export {};

package/dist/sdk.js

@@ -1,5 +1,8 @@
 import { access, readFile, writeFile } from "node:fs/promises";
 import { UserError, assertCommandRequirements, resolveCommandSecrets } from "./index.js";
+import { mergeApprovalsGroup } from "./human-in-loop/approvals-commands.js";
+import { invokeWithHumanInLoop } from "./human-in-loop/index.js";
+import { hasMcpProxyGroups, resolveMcpProxies } from "./mcp-proxy.js";
 import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
 import { filterSchemaForScope } from "./schema-scope.js";
 const RESERVED_SERVICE_NAMES = new Set(["params", "secrets", "fetch", "fs", "env", "progress"]);
@@ -169,15 +172,25 @@ function defineMember(target, key, value) {
     });
 }
 export function createSDK(root, options = {}) {
+    const mergedRoot = mergeApprovalsGroup(root);
+    if (!hasMcpProxyGroups(mergedRoot)) {
+        return createResolvedSDK(mergedRoot, options);
+    }
+    return createDeferredSDK(mergedRoot, options);
+}
+function createResolvedSDK(root, options = {}) {
     const services = options.services ?? {};
+    const runtimeOptions = options.humanInLoop ?? {};
     void options.casing;
     validateServices(services);
-    function build(node) {
+    function build(node, path) {
         if (node.kind === "command") {
             return async (params) => {
                 const secrets = resolveCommandSecrets(node);
                 const baseContext = {
                     ...services,
+                    runtimeOptions,
+                    root,
                     secrets,
                     fetch: globalThis.fetch,
                     fs: createFs(),
@@ -192,27 +205,65 @@ export function createSDK(root, options = {}) {
                     throw new Error(`Bug: command "${node.name}" must define an object params schema for SDK.`);
                 }
                 const validatedParams = validateSDKArguments(paramsSchema, params);
-                return node.handler({
+                return invokeWithHumanInLoop(node, {
                     ...baseContext,
                     params: validatedParams,
-                });
+                }, runtimeOptions, [...path, node.name].join("."));
             };
         }
         const output = {};
+        const nextPath = node === root ? path : [...path, node.name];
         for (const child of node.children) {
             if (child.kind === "command") {
                 if (!child.scope.includes("sdk")) {
                     continue;
                 }
-                defineMember(output, formatSegment(child.name), build(child));
+                defineMember(output, formatSegment(child.name), build(child, nextPath));
                 continue;
             }
-            const childValue = build(child);
+            const childValue = build(child, nextPath);
             if (isPlainObject(childValue) && Object.keys(childValue).length > 0) {
                 defineMember(output, formatSegment(child.name), childValue);
             }
         }
         return output;
     }
-    return build(root);
+    return build(root, []);
+}
+function createDeferredSDK(root, options) {
+    let sdkPromise;
+    const resolveSDK = () => {
+        sdkPromise ??= (async () => {
+            await resolveMcpProxies(root);
+            return createResolvedSDK(root, options);
+        })();
+        return sdkPromise;
+    };
+    const resolvePath = async (path) => {
+        let current = await resolveSDK();
+        for (const segment of path) {
+            if (typeof segment !== "string" && typeof segment !== "number") {
+                return undefined;
+            }
+            current = current[segment];
+        }
+        return current;
+    };
+    const createPathProxy = (path) => new Proxy(() => undefined, {
+        apply(_target, _thisArg, argumentsList) {
+            return resolvePath(path).then((value) => {
+                if (typeof value !== "function") {
+                    throw new TypeError(`SDK member "${path.map(String).join(".")}" is not callable.`);
+                }
+                return value(...argumentsList);
+            });
+        },
+        get(_target, property) {
+            if (property === "then") {
+                return path.length === 0 ? resolveSDK().then.bind(resolveSDK()) : undefined;
+            }
+            return createPathProxy([...path, property]);
+        },
+    });
+    return createPathProxy([]);
 }

package/dist/user-error.d.ts

@@ -0,0 +1,3 @@
+export declare class UserError extends Error {
+    constructor(message: string);
+}

package/dist/user-error.js

@@ -0,0 +1,6 @@
+export class UserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UserError";
+    }
+}

package/node_modules/@poe-code/agent-human-in-loop/README.md

@@ -0,0 +1,42 @@
+## Overview
+
+`@poe-code/agent-human-in-loop` is a UI-only package for asking a human "approve this?" before an agent proceeds. The UI is providerized, sync vs async is the caller's choice because the API returns a Promise you can await immediately or hold and resolve later, and the package is approval-only: decline returns a declined outcome and can optionally capture a reason.
+
+## API
+
+```ts
+declare function requestApproval(
+  args: ApprovalRequest & { provider: HumanInLoopProvider }
+): Promise<ApprovalResult>;
+
+declare function osascriptProvider(options?: OsascriptProviderOptions): HumanInLoopProvider;
+
+declare function mockProvider(
+  answer: ApprovalResult | (() => ApprovalResult | Promise<ApprovalResult>)
+): HumanInLoopProvider;
+```
+
+## Providers
+
+- `osascriptProvider({ title?, binary? })` — macOS native dialog via `display dialog`. Mac only.
+- `mockProvider(answer | thunk)` — fixed or scripted answers for tests.
+
+## Env vars
+
+None in v1.
+
+## AppleScript escaping note
+
+Messages and prompts are passed verbatim through the dialog; the provider escapes `"` and `\` for AppleScript string literals. Do not pass user-supplied AppleScript fragments expecting them to execute.
+
+## Example
+
+```ts
+import { requestApproval, osascriptProvider } from "@poe-code/agent-human-in-loop";
+
+const result = await requestApproval({
+  message: "Run `rm -rf /tmp/foo`?",
+  declineInputPrompt: "Why decline?",
+  provider: osascriptProvider({ title: "Claude" })
+});
+```

package/node_modules/@poe-code/agent-human-in-loop/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { ApprovalRequest, ApprovalResult, HumanInLoopProvider, } from "./types.js";
+export { requestApproval } from "./request-approval.js";
+export { osascriptProvider } from "./providers/osascript.js";
+export type { OsascriptProviderOptions } from "./providers/osascript.js";
+export { mockProvider } from "./providers/mock.js";

package/node_modules/@poe-code/agent-human-in-loop/dist/index.js

@@ -0,0 +1,3 @@
+export { requestApproval } from "./request-approval.js";
+export { osascriptProvider } from "./providers/osascript.js";
+export { mockProvider } from "./providers/mock.js";

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/mock.d.ts

@@ -0,0 +1,2 @@
+import type { ApprovalResult, HumanInLoopProvider } from "../types.js";
+export declare function mockProvider(answer: ApprovalResult | (() => ApprovalResult | Promise<ApprovalResult>)): HumanInLoopProvider;

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/mock.js

@@ -0,0 +1,11 @@
+export function mockProvider(answer) {
+    return {
+        id: "mock",
+        async requestApproval(_request) {
+            if (typeof answer === "function") {
+                return await answer();
+            }
+            return answer;
+        },
+    };
+}

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/osascript-script.d.ts

@@ -0,0 +1,4 @@
+import type { ApprovalRequest, ApprovalResult } from "../types.js";
+export declare function escapeAppleScriptString(value: string): string;
+export declare function buildScript(request: ApprovalRequest, title: string): string;
+export declare function parseStdout(out: string): ApprovalResult;

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/osascript-script.js

@@ -0,0 +1,40 @@
+export function escapeAppleScriptString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+export function buildScript(request, title) {
+    const escapedMessage = escapeAppleScriptString(request.message);
+    const escapedTitle = escapeAppleScriptString(title);
+    if (request.declineInputPrompt === undefined) {
+        return `button returned of (display dialog "${escapedMessage}" with title "${escapedTitle}" buttons {"Decline","Approve"} default button "Approve")`;
+    }
+    const escapedPrompt = escapeAppleScriptString(request.declineInputPrompt);
+    return `set firstResp to button returned of (display dialog "${escapedMessage}" with title "${escapedTitle}" buttons {"Decline","Approve"} default button "Approve")
+if firstResp is "Approve" then
+  return "APPROVED"
+end if
+try
+  set reason to text returned of (display dialog "${escapedPrompt}" default answer "" with title "${escapedTitle}" buttons {"Cancel","Submit"} default button "Submit")
+  return "DECLINED:" & reason
+on error number -128
+  return "DECLINED:"
+end try`;
+}
+export function parseStdout(out) {
+    const value = out.replace(/\n+$/u, "");
+    switch (value) {
+        case "Approve":
+        case "APPROVED":
+            return { outcome: "approved" };
+        case "Decline":
+            return { outcome: "declined" };
+        default:
+            break;
+    }
+    if (value.startsWith("DECLINED:")) {
+        const reason = value.slice("DECLINED:".length);
+        return reason === ""
+            ? { outcome: "declined" }
+            : { outcome: "declined", reason };
+    }
+    throw new Error(`unexpected osascript output: ${out}`);
+}

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/osascript.d.ts

@@ -0,0 +1,6 @@
+import type { HumanInLoopProvider } from "../types.js";
+export interface OsascriptProviderOptions {
+    title?: string;
+    binary?: string;
+}
+export declare function osascriptProvider(options?: OsascriptProviderOptions): HumanInLoopProvider;

package/node_modules/@poe-code/agent-human-in-loop/dist/providers/osascript.js

@@ -0,0 +1,33 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { buildScript, parseStdout } from "./osascript-script.js";
+const execFileAsync = promisify(execFile);
+function isUserCanceled(error) {
+    const message = error instanceof Error ? error.message : error === undefined ? "" : String(error);
+    const stderr = error?.stderr ?? "";
+    return `${message}\n${stderr}`.includes("(-128)");
+}
+export function osascriptProvider(options = {}) {
+    const title = options.title ?? "Approval needed";
+    const binary = options.binary ?? "osascript";
+    return {
+        id: "osascript",
+        async requestApproval(request) {
+            const script = buildScript(request, title);
+            try {
+                const { stdout } = await execFileAsync(binary, ["-e", script]);
+                return parseStdout(stdout);
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    throw new Error("osascript not found — provide a different provider on this platform");
+                }
+                if (isUserCanceled(error)) {
+                    return { outcome: "declined" };
+                }
+                const stderr = error.stderr ?? String(error);
+                throw new Error(`osascript failed: ${stderr.trim()}`);
+            }
+        }
+    };
+}

package/node_modules/@poe-code/agent-human-in-loop/dist/request-approval.d.ts

@@ -0,0 +1,4 @@
+import type { ApprovalRequest, ApprovalResult, HumanInLoopProvider } from "./types.js";
+export declare function requestApproval(args: ApprovalRequest & {
+    provider: HumanInLoopProvider;
+}): Promise<ApprovalResult>;

package/node_modules/@poe-code/agent-human-in-loop/dist/request-approval.js

@@ -0,0 +1,4 @@
+export function requestApproval(args) {
+    const { provider, ...request } = args;
+    return provider.requestApproval(request);
+}

package/node_modules/@poe-code/agent-human-in-loop/dist/types.d.ts

@@ -0,0 +1,14 @@
+export interface ApprovalRequest {
+    message: string;
+    declineInputPrompt?: string;
+}
+export type ApprovalResult = {
+    outcome: "approved";
+} | {
+    outcome: "declined";
+    reason?: string;
+};
+export interface HumanInLoopProvider {
+    readonly id: string;
+    requestApproval(request: ApprovalRequest): Promise<ApprovalResult>;
+}

package/node_modules/@poe-code/agent-human-in-loop/dist/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/agent-human-in-loop/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@poe-code/agent-human-in-loop",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "cd ../.. && vitest run --passWithNoTests packages/agent-human-in-loop",
+    "typecheck": "tsc --noEmit",
+    "dev": "tsx example.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}

package/node_modules/@poe-code/agent-mcp-config/dist/apply.d.ts

@@ -0,0 +1,6 @@
+import type { McpServerEntry, ApplyOptions } from "./types.js";
+export declare class UnsupportedAgentError extends Error {
+    constructor(agentId: string);
+}
+export declare function configure(agentId: string, server: McpServerEntry, options: ApplyOptions): Promise<void>;
+export declare function unconfigure(agentId: string, serverName: string, options: ApplyOptions): Promise<void>;

package/node_modules/@poe-code/agent-mcp-config/dist/apply.js

@@ -0,0 +1,175 @@
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { runMutations, configMutation, fileMutation, readFileIfExists } from "@poe-code/config-mutations";
+import { getAgentConfig, resolveConfigPath, isSupported } from "./configs.js";
+import { getShapeTransformer } from "./shapes.js";
+function getConfigDirectory(configPath) {
+    return path.dirname(configPath);
+}
+export class UnsupportedAgentError extends Error {
+    constructor(agentId) {
+        super(`Unsupported agent: ${agentId}`);
+        this.name = "UnsupportedAgentError";
+    }
+}
+function isConfigObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveServerMap(document, configKey) {
+    const value = document[configKey];
+    return isConfigObject(value) ? value : {};
+}
+function mergeServerMap(document, configKey, servers) {
+    return { ...document, [configKey]: servers };
+}
+function expandHomePath(configPath, homeDir) {
+    if (!configPath.startsWith("~")) {
+        return configPath;
+    }
+    if (configPath === "~") {
+        return homeDir;
+    }
+    if (configPath.startsWith("~/")) {
+        return path.join(homeDir, configPath.slice(2));
+    }
+    return path.join(homeDir, configPath.slice(1));
+}
+function parseYamlDocument(content) {
+    if (content.trim() === "") {
+        return {};
+    }
+    const parsed = parseYaml(content);
+    if (parsed === null || parsed === undefined) {
+        return {};
+    }
+    if (!isConfigObject(parsed)) {
+        throw new Error("Expected YAML document to be an object.");
+    }
+    return parsed;
+}
+function serializeYamlDocument(document) {
+    const serialized = stringifyYaml(document);
+    return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
+}
+async function readYamlConfig(configPath, options) {
+    const absolutePath = expandHomePath(configPath, options.homeDir);
+    const existingContent = await readFileIfExists(options.fs, absolutePath);
+    if (existingContent === null) {
+        return {};
+    }
+    return parseYamlDocument(existingContent);
+}
+async function writeYamlConfig(configPath, document, options) {
+    if (options.dryRun) {
+        return;
+    }
+    const absolutePath = expandHomePath(configPath, options.homeDir);
+    const configDir = path.dirname(absolutePath);
+    await options.fs.mkdir(configDir, { recursive: true });
+    await options.fs.writeFile(absolutePath, serializeYamlDocument(document), {
+        encoding: "utf8"
+    });
+}
+function removeServer(document, configKey, serverName) {
+    const servers = resolveServerMap(document, configKey);
+    if (!(serverName in servers)) {
+        return { changed: false, content: document };
+    }
+    const nextServers = { ...servers };
+    delete nextServers[serverName];
+    if (Object.keys(nextServers).length === 0) {
+        const nextDocument = { ...document };
+        delete nextDocument[configKey];
+        return { changed: true, content: nextDocument };
+    }
+    return {
+        changed: true,
+        content: mergeServerMap(document, configKey, nextServers)
+    };
+}
+export async function configure(agentId, server, options) {
+    if (!isSupported(agentId)) {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const config = getAgentConfig(agentId);
+    const configPath = resolveConfigPath(config, options.platform);
+    const shapeTransformer = getShapeTransformer(config.shape);
+    const shaped = shapeTransformer(server);
+    if (shaped === undefined) {
+        await unconfigure(agentId, server.name, options);
+        return;
+    }
+    if (config.format === "yaml") {
+        const document = await readYamlConfig(configPath, options);
+        const servers = resolveServerMap(document, config.configKey);
+        const nextDocument = mergeServerMap(document, config.configKey, {
+            ...servers,
+            [server.name]: shaped
+        });
+        await writeYamlConfig(configPath, nextDocument, options);
+        return;
+    }
+    const configDir = getConfigDirectory(configPath);
+    await runMutations([
+        fileMutation.ensureDirectory({
+            path: configDir,
+            label: `Ensure directory ${configDir}`
+        }),
+        // Use transform to replace the server entry entirely (not deep-merge)
+        // This ensures old fields like 'args' are removed when switching to array 'command'
+        configMutation.transform({
+            target: configPath,
+            format: config.format,
+            transform: (document) => {
+                const servers = resolveServerMap(document, config.configKey);
+                const newServers = {
+                    ...servers,
+                    [server.name]: shaped
+                };
+                return {
+                    changed: true,
+                    content: mergeServerMap(document, config.configKey, newServers)
+                };
+            },
+            label: `Add ${server.name} to ${configPath}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}
+export async function unconfigure(agentId, serverName, options) {
+    if (!isSupported(agentId)) {
+        throw new UnsupportedAgentError(agentId);
+    }
+    const config = getAgentConfig(agentId);
+    const configPath = resolveConfigPath(config, options.platform);
+    if (config.format === "yaml") {
+        const document = await readYamlConfig(configPath, options);
+        const { changed, content } = removeServer(document, config.configKey, serverName);
+        if (!changed) {
+            return;
+        }
+        await writeYamlConfig(configPath, content, options);
+        return;
+    }
+    await runMutations([
+        configMutation.prune({
+            target: configPath,
+            format: config.format,
+            shape: {
+                [config.configKey]: {
+                    [serverName]: {}
+                }
+            },
+            label: `Remove ${serverName} from ${configPath}`
+        })
+    ], {
+        fs: options.fs,
+        homeDir: options.homeDir,
+        dryRun: options.dryRun,
+        observers: options.observers
+    });
+}

package/node_modules/@poe-code/agent-mcp-config/dist/configs.d.ts

@@ -0,0 +1,22 @@
+import type { ShapeName } from "./shapes.js";
+export type ConfigFormat = "json" | "toml" | "yaml";
+export type Platform = "darwin" | "linux" | "win32";
+export interface AgentMcpConfig {
+    configFile: string | ((platform: Platform) => string);
+    configKey: string;
+    format: ConfigFormat;
+    shape: ShapeName;
+    mcpOutputFormat?: string;
+}
+export declare const supportedAgents: readonly string[];
+export type AgentSupportStatus = "supported" | "unsupported" | "unknown";
+export interface AgentSupportResult {
+    status: AgentSupportStatus;
+    input: string;
+    id?: string;
+    config?: AgentMcpConfig;
+}
+export declare function resolveAgentSupport(input: string, registry?: Record<string, AgentMcpConfig>): AgentSupportResult;
+export declare function isSupported(agentId: string): boolean;
+export declare function getAgentConfig(agentId: string): AgentMcpConfig | undefined;
+export declare function resolveConfigPath(config: AgentMcpConfig, platform: Platform): string;