toolcraft 0.0.1

package/dist/index.compile-check.d.ts

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

package/dist/index.compile-check.js

@@ -0,0 +1,50 @@
+import { S } from "agent-kit-schema";
+import { defineCommand, defineGroup } from "./index.js";
+const ignoredScope = ["cli", "sdk"];
+const ignoredSecrets = {
+    apiKey: { env: "API_KEY" },
+    sessionToken: { env: "SESSION_TOKEN", optional: true },
+};
+const ignoredCommand = defineCommand({
+    name: "deploy",
+    params: S.Object({
+        name: S.String(),
+        force: S.Optional(S.Boolean()),
+    }),
+    secrets: ignoredSecrets,
+    requires: {
+        auth: true,
+    },
+    render: {
+        json: (result) => result,
+    },
+    handler: async ({ params, secrets, fetch, fs, env, progress }) => {
+        progress(params.name);
+        await fs.exists("/tmp");
+        env.get("HOME");
+        void fetch;
+        return {
+            authenticated: Boolean(secrets.apiKey),
+            force: params.force ?? false,
+        };
+    },
+});
+const ignoredGroup = defineGroup({
+    name: "root",
+    scope: ignoredScope,
+    secrets: {
+        rootToken: { env: "ROOT_TOKEN" },
+    },
+    children: [ignoredCommand],
+    default: ignoredCommand,
+});
+const ignoredStringSchema = S.String();
+const ignoredNumberSchema = S.Number();
+const ignoredBooleanSchema = S.Boolean();
+const ignoredEnumSchema = S.Enum(["cli", "sdk"]);
+const ignoredArraySchema = S.Array(S.String());
+const ignoredObjectSchema = S.Object({
+    name: S.String(),
+    enabled: S.Optional(S.Boolean()),
+});
+const ignoredOptionalSchema = S.Optional(S.Number());

package/dist/index.d.ts

@@ -0,0 +1,164 @@
+import type { ObjectSchema, Static } from "agent-kit-schema";
+import type { LoggerOutput, RenderTableOptions, ThemePalette } from "@poe-code/design-system";
+type ScopeValue = "cli" | "mcp" | "sdk";
+type AnyObjectSchema = ObjectSchema<Record<string, never>>;
+type EmptyServices = Record<string, never>;
+type ScopeInput = readonly Scope[] | undefined;
+export type Scope = ScopeValue;
+export interface SecretDefinition {
+    env: string;
+    description?: string;
+    optional?: boolean;
+}
+export type SecretDeclarations = Record<string, SecretDefinition>;
+type OptionalSecretKeys<TSecrets extends SecretDeclarations> = {
+    [TKey in keyof TSecrets]: TSecrets[TKey] extends {
+        optional: true;
+    } ? TKey : never;
+}[keyof TSecrets];
+type RequiredSecretKeys<TSecrets extends SecretDeclarations> = Exclude<keyof TSecrets, OptionalSecretKeys<TSecrets>>;
+export type InferSecrets<TSecrets extends SecretDeclarations | undefined> = TSecrets extends SecretDeclarations ? {
+    [TKey in RequiredSecretKeys<TSecrets>]: string;
+} & {
+    [TKey in OptionalSecretKeys<TSecrets>]?: string;
+} : Record<string, never>;
+export interface HandlerFs {
+    readFile(path: string, encoding?: BufferEncoding): Promise<string>;
+    writeFile(path: string, contents: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+export interface HandlerEnv {
+    get(key: string): string | undefined;
+}
+export interface RenderPrimitives {
+    logger: LoggerOutput;
+    renderTable(options: RenderTableOptions): string;
+    getTheme(): ThemePalette;
+    note(message: string, title?: string): void;
+}
+export interface CheckResult {
+    ok: boolean;
+    message?: string;
+}
+export type GroupCheckContext<TServices extends object = EmptyServices> = TServices & {
+    params?: unknown;
+    secrets?: Record<string, string | undefined>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    progress(message: string): void;
+};
+export type CommandCheckContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
+    params?: Static<TParamsSchema>;
+    secrets?: InferSecrets<TSecrets>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    progress(message: string): void;
+};
+export interface Requires<TContext = unknown> {
+    auth?: boolean;
+    apiVersion?: string;
+    check?: (ctx: TContext) => Promise<CheckResult>;
+}
+export interface Renderers<TResult> {
+    rich?: (result: TResult, primitives: RenderPrimitives) => void;
+    markdown?: (result: TResult, primitives: RenderPrimitives) => string;
+    json?: (result: TResult, primitives: RenderPrimitives) => unknown;
+}
+export type HandlerContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & {
+    params: Static<TParamsSchema>;
+    secrets: InferSecrets<TSecrets>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    progress(message: string): void;
+};
+export interface CommandConfig<TServices extends object, TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TResult> {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    positional?: string[];
+    params: TParamsSchema;
+    secrets?: TSecrets;
+    scope?: Scope[];
+    confirm?: boolean;
+    requires?: Requires<CommandCheckContext<TParamsSchema, TSecrets, TServices>>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult>;
+    render?: Renderers<TResult>;
+}
+export interface Command<TServices extends object = EmptyServices, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown> {
+    kind: "command";
+    name: string;
+    description?: string;
+    aliases: string[];
+    positional: string[];
+    params: TParamsSchema;
+    secrets: SecretDeclarations;
+    scope: Scope[];
+    confirm: boolean;
+    requires?: Requires<any>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult>;
+    render?: Renderers<TResult>;
+}
+export interface GroupConfig<TServices extends object> {
+    name: string;
+    description?: string;
+    aliases?: string[];
+    scope?: Scope[];
+    secrets?: SecretDeclarations;
+    requires?: Requires<GroupCheckContext<TServices>>;
+    children: Array<CommandNode<TServices>>;
+    default?: Command<TServices, any, any, any>;
+}
+export interface Group<TServices extends object = EmptyServices> {
+    kind: "group";
+    name: string;
+    description?: string;
+    aliases: string[];
+    scope?: Scope[];
+    secrets: SecretDeclarations;
+    requires?: Requires<any>;
+    children: Array<CommandNode<TServices>>;
+    default?: Command<TServices, any, any, any>;
+}
+export type CommandNode<TServices extends object = EmptyServices> = Command<TServices, any, any, any> | Group<TServices>;
+export interface CommandTypeInfo<TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TResult = unknown, TOwnScope extends ScopeInput = ScopeInput> {
+    name: TName;
+    params: TParamsSchema;
+    result: TResult;
+    ownScope: TOwnScope;
+}
+export interface GroupTypeInfo<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = ScopeInput> {
+    name: TName;
+    children: TChildren;
+    ownScope: TOwnScope;
+}
+type TypedCommandMetadata<TName extends string, TParamsSchema extends ObjectSchema<any>, TResult, TOwnScope extends ScopeInput> = {
+    readonly __agentKitCommandTypeInfo: CommandTypeInfo<TName, TParamsSchema, TResult, TOwnScope>;
+};
+type TypedGroupMetadata<TServices extends object, TName extends string, TChildren extends readonly unknown[], TOwnScope extends ScopeInput> = {
+    readonly __agentKitGroupTypeInfo: GroupTypeInfo<TServices, TName, TChildren, TOwnScope>;
+};
+export declare class UserError extends Error {
+    constructor(message: string);
+}
+export interface CommandRequirementOptions {
+    apiVersion?: string;
+    authEnvVar?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare function resolveCommandSecrets(command: Command<any, any, any, any>, env?: Record<string, string | undefined>): Record<string, string | undefined>;
+export declare function assertCommandRequirements(command: Command<any, any, any, any>, context: GroupCheckContext<any>, options?: CommandRequirementOptions): Promise<void>;
+export declare function defineCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown, TOwnScope extends ScopeInput = undefined>(config: Omit<CommandConfig<TServices, TParamsSchema, TSecrets, TResult>, "name" | "scope"> & {
+    name: TName;
+    scope?: TOwnScope;
+}): Command<TServices, TParamsSchema, TSecrets, TResult> & TypedCommandMetadata<TName, TParamsSchema, TResult, TOwnScope>;
+export declare function defineGroup<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = undefined>(config: Omit<GroupConfig<TServices>, "name" | "children" | "scope"> & {
+    name: TName;
+    children: TChildren & readonly CommandNode<TServices>[];
+    scope?: TOwnScope;
+}): Group<TServices> & TypedGroupMetadata<TServices, TName, TChildren, TOwnScope>;
+export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
+export { S, toJsonSchema } from "agent-kit-schema";
+export type { AnySchema, ArraySchema, BooleanSchema, EnumSchema, JsonSchema, NumberSchema, ObjectSchema, OptionalSchema, Static, StringSchema } from "agent-kit-schema";

package/dist/index.js

@@ -0,0 +1,366 @@
+import { fileURLToPath } from "node:url";
+const commandConfigSymbol = Symbol("agent-kit.command.config");
+const groupConfigSymbol = Symbol("agent-kit.group.config");
+const commandSourcePathSymbol = Symbol("agent-kit.command.sourcePath");
+export class UserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UserError";
+    }
+}
+function cloneScope(scope) {
+    return scope === undefined ? undefined : [...scope];
+}
+function cloneSecretDefinition(secret) {
+    return {
+        env: secret.env,
+        description: secret.description,
+        optional: secret.optional,
+    };
+}
+function cloneSecrets(secrets) {
+    if (secrets === undefined) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(secrets).map(([key, secret]) => [key, cloneSecretDefinition(secret)]));
+}
+function cloneRequires(requires) {
+    if (requires === undefined) {
+        return undefined;
+    }
+    return {
+        auth: requires.auth,
+        apiVersion: requires.apiVersion,
+        check: requires.check,
+    };
+}
+function parseStackPath(candidate) {
+    if (candidate.startsWith("file://")) {
+        try {
+            return fileURLToPath(candidate);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (candidate.startsWith("/")) {
+        return candidate;
+    }
+    return undefined;
+}
+function extractStackPath(line) {
+    const trimmed = line.trim();
+    const fileIndex = trimmed.indexOf("file://");
+    if (fileIndex >= 0) {
+        const location = trimmed.slice(fileIndex);
+        const separatorIndex = location.lastIndexOf(":");
+        const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+        const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0
+            ? location.slice(0, previousSeparatorIndex)
+            : location;
+        return parseStackPath(candidate);
+    }
+    const slashIndex = trimmed.indexOf("/");
+    if (slashIndex < 0) {
+        return undefined;
+    }
+    const location = trimmed.slice(slashIndex);
+    const separatorIndex = location.lastIndexOf(":");
+    const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+    const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0
+        ? location.slice(0, previousSeparatorIndex)
+        : location;
+    return parseStackPath(candidate);
+}
+function inferCommandSourcePath() {
+    const stack = new Error().stack;
+    if (typeof stack !== "string") {
+        return undefined;
+    }
+    for (const line of stack.split("\n").slice(1)) {
+        const candidate = extractStackPath(line);
+        if (candidate === undefined) {
+            continue;
+        }
+        if (candidate.includes("/packages/agent-kit/src/index.ts") ||
+            candidate.includes("/packages/agent-kit/dist/index.js") ||
+            candidate.includes("/node_modules/agent-kit/dist/index.js")) {
+            continue;
+        }
+        return candidate;
+    }
+    return undefined;
+}
+function composeChecks(parentCheck, childCheck) {
+    if (parentCheck === undefined) {
+        return childCheck;
+    }
+    if (childCheck === undefined) {
+        return parentCheck;
+    }
+    return async (ctx) => {
+        const parentResult = await parentCheck(ctx);
+        if (!parentResult.ok) {
+            return parentResult;
+        }
+        return childCheck(ctx);
+    };
+}
+function mergeRequires(parent, child) {
+    if (parent === undefined && child === undefined) {
+        return undefined;
+    }
+    const merged = {
+        auth: child?.auth ?? parent?.auth,
+        apiVersion: child?.apiVersion ?? parent?.apiVersion,
+        check: composeChecks(parent?.check, child?.check),
+    };
+    if (merged.auth === undefined &&
+        merged.apiVersion === undefined &&
+        merged.check === undefined) {
+        return undefined;
+    }
+    return merged;
+}
+function parseSimpleSemver(value) {
+    const parts = value.split(".");
+    if (parts.length !== 3) {
+        return undefined;
+    }
+    const parsed = parts.map((part) => {
+        if (part.length === 0) {
+            return Number.NaN;
+        }
+        for (const char of part) {
+            if (char < "0" || char > "9") {
+                return Number.NaN;
+            }
+        }
+        return Number(part);
+    });
+    if (parsed.some((part) => !Number.isInteger(part) || part < 0)) {
+        return undefined;
+    }
+    return parsed;
+}
+function parseMinimumApiVersion(requirement) {
+    if (!requirement.startsWith(">=")) {
+        return undefined;
+    }
+    return parseSimpleSemver(requirement.slice(2).trim());
+}
+function compareSemver(left, right) {
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] === right[index]) {
+            continue;
+        }
+        return left[index] > right[index] ? 1 : -1;
+    }
+    return 0;
+}
+export function resolveCommandSecrets(command, env = process.env) {
+    const secrets = {};
+    for (const [name, secret] of Object.entries(command.secrets)) {
+        const value = env[secret.env];
+        if (value === undefined && secret.optional !== true) {
+            const details = secret.description ? `\n  ${secret.description}` : "";
+            throw new UserError(`Error: Missing required secret ${secret.env}${details}`);
+        }
+        secrets[name] = value;
+    }
+    return secrets;
+}
+export async function assertCommandRequirements(command, context, options = {}) {
+    const requires = command.requires;
+    if (requires === undefined) {
+        return;
+    }
+    const env = options.env ?? process.env;
+    const authEnvVar = options.authEnvVar ?? "POE_API_KEY";
+    if (requires.auth === true && env[authEnvVar] === undefined) {
+        throw new UserError(`Error: Command "${command.name}" requires authentication.\n  Run 'poe-code login' first.`);
+    }
+    if (requires.apiVersion !== undefined) {
+        const minimumVersion = parseMinimumApiVersion(requires.apiVersion);
+        if (minimumVersion === undefined) {
+            throw new UserError(`Error: Command "${command.name}" has invalid apiVersion requirement "${requires.apiVersion}". Expected format ">=X.Y.Z".`);
+        }
+        if (options.apiVersion === undefined) {
+            throw new UserError(`Error: Command "${command.name}" requires API version ${requires.apiVersion}, but no runner API version was provided.`);
+        }
+        const runnerVersion = parseSimpleSemver(options.apiVersion);
+        if (runnerVersion === undefined) {
+            throw new UserError(`Error: Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version "${options.apiVersion}" is not valid semver.`);
+        }
+        if (compareSemver(runnerVersion, minimumVersion) < 0) {
+            throw new UserError(`Error: Command "${command.name}" requires API version ${requires.apiVersion}, but runner API version is ${options.apiVersion}.`);
+        }
+    }
+    const checkResult = await requires.check?.(context);
+    if (checkResult && !checkResult.ok) {
+        throw new UserError(checkResult.message ?? "Command precondition failed.");
+    }
+}
+function mergeSecrets(parent, child) {
+    return cloneSecrets({
+        ...parent,
+        ...child,
+    });
+}
+function resolveCommandScope(ownScope, inheritedScope) {
+    return cloneScope(ownScope ?? inheritedScope) ?? ["cli", "sdk"];
+}
+function resolveGroupScope(ownScope, inheritedScope) {
+    return cloneScope(ownScope ?? inheritedScope);
+}
+function createBaseCommand(config) {
+    const command = {
+        kind: "command",
+        name: config.name,
+        description: config.description,
+        aliases: [...(config.aliases ?? [])],
+        positional: [...(config.positional ?? [])],
+        params: config.params,
+        secrets: cloneSecrets(config.secrets),
+        scope: resolveCommandScope(config.scope, undefined),
+        confirm: config.confirm ?? false,
+        requires: cloneRequires(config.requires),
+        handler: config.handler,
+        render: config.render,
+    };
+    Object.defineProperty(command, commandConfigSymbol, {
+        value: {
+            scope: cloneScope(config.scope),
+            secrets: cloneSecrets(config.secrets),
+            requires: cloneRequires(config.requires),
+            sourcePath: inferCommandSourcePath(),
+        },
+    });
+    return command;
+}
+function createBaseGroup(config) {
+    const group = {
+        kind: "group",
+        name: config.name,
+        description: config.description,
+        aliases: [...(config.aliases ?? [])],
+        scope: resolveGroupScope(config.scope, undefined),
+        secrets: cloneSecrets(config.secrets),
+        requires: cloneRequires(config.requires),
+        children: [],
+        default: undefined,
+    };
+    Object.defineProperty(group, groupConfigSymbol, {
+        value: {
+            scope: cloneScope(config.scope),
+            secrets: cloneSecrets(config.secrets),
+            requires: cloneRequires(config.requires),
+            children: [...config.children],
+            default: config.default,
+        },
+    });
+    return group;
+}
+function getInternalCommandConfig(command) {
+    return command[commandConfigSymbol];
+}
+function getInternalGroupConfig(group) {
+    return group[groupConfigSymbol];
+}
+function materializeCommand(command, inherited) {
+    const internal = getInternalCommandConfig(command);
+    const materialized = {
+        kind: "command",
+        name: command.name,
+        description: command.description,
+        aliases: [...command.aliases],
+        positional: [...command.positional],
+        params: command.params,
+        secrets: mergeSecrets(inherited.secrets, internal.secrets),
+        scope: resolveCommandScope(internal.scope, inherited.scope),
+        confirm: command.confirm,
+        requires: mergeRequires(inherited.requires, internal.requires),
+        handler: command.handler,
+        render: command.render,
+    };
+    Object.defineProperty(materialized, commandConfigSymbol, {
+        value: {
+            scope: cloneScope(internal.scope),
+            secrets: cloneSecrets(internal.secrets),
+            requires: cloneRequires(internal.requires),
+            sourcePath: internal.sourcePath,
+        },
+    });
+    Object.defineProperty(materialized, commandSourcePathSymbol, {
+        value: internal.sourcePath,
+    });
+    return materialized;
+}
+function materializeGroup(group, inherited) {
+    const internal = getInternalGroupConfig(group);
+    const scope = resolveGroupScope(internal.scope, inherited.scope);
+    const secrets = mergeSecrets(inherited.secrets, internal.secrets);
+    const requires = mergeRequires(inherited.requires, internal.requires);
+    const materializedChildren = internal.children.map((child) => materializeNode(child, {
+        scope,
+        secrets,
+        requires,
+    }));
+    let defaultChild;
+    if (internal.default !== undefined) {
+        const defaultIndex = internal.children.indexOf(internal.default);
+        if (defaultIndex === -1) {
+            throw new UserError(`Default command "${internal.default.name}" must be listed in children.`);
+        }
+        const resolvedDefault = materializedChildren[defaultIndex];
+        if (resolvedDefault?.kind !== "command") {
+            throw new UserError(`Default child "${internal.default.name}" must be a command.`);
+        }
+        defaultChild = resolvedDefault;
+    }
+    const materialized = {
+        kind: "group",
+        name: group.name,
+        description: group.description,
+        aliases: [...group.aliases],
+        scope,
+        secrets,
+        requires,
+        children: materializedChildren,
+        default: defaultChild,
+    };
+    Object.defineProperty(materialized, groupConfigSymbol, {
+        value: {
+            scope: cloneScope(internal.scope),
+            secrets: cloneSecrets(internal.secrets),
+            requires: cloneRequires(internal.requires),
+            children: [...internal.children],
+            default: internal.default,
+        },
+    });
+    return materialized;
+}
+function materializeNode(node, inherited) {
+    if (node.kind === "command") {
+        return materializeCommand(node, inherited);
+    }
+    return materializeGroup(node, inherited);
+}
+export function defineCommand(config) {
+    return materializeCommand(createBaseCommand(config), {
+        scope: undefined,
+        secrets: {},
+        requires: undefined,
+    });
+}
+export function defineGroup(config) {
+    return materializeGroup(createBaseGroup(config), {
+        scope: undefined,
+        secrets: {},
+        requires: undefined,
+    });
+}
+export function getCommandSourcePath(command) {
+    return command[commandSourcePathSymbol];
+}
+export { S, toJsonSchema } from "agent-kit-schema";

package/dist/mcp.compile-check.d.ts

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

package/dist/mcp.compile-check.js

@@ -0,0 +1,26 @@
+import { S } from "agent-kit-schema";
+import { defineCommand, defineGroup } from "./index.js";
+import { createMCPServer, runMCP } from "./mcp.js";
+const ignoredRoot = defineGroup({
+    name: "root",
+    children: [
+        defineCommand({
+            name: "usage",
+            scope: ["mcp"],
+            params: S.Object({
+                dryRun: S.Boolean(),
+            }),
+            handler: async ({ params }) => params,
+        }),
+    ],
+});
+const ignoredOptions = {
+    name: "cmdkit-test",
+    version: "1.0.0",
+    tools: ["usage"],
+    casing: "snake",
+};
+const ignoredServer = createMCPServer(ignoredRoot, ignoredOptions);
+const ignoredServerArray = createMCPServer([ignoredRoot], ignoredOptions);
+const ignoredRun = runMCP(ignoredRoot, ignoredOptions);
+const ignoredRunArray = runMCP([ignoredRoot], ignoredOptions);

package/dist/mcp.d.ts

@@ -0,0 +1,31 @@
+import { type SDKTransport, type Server as TinyServer } from "tiny-stdio-mcp-server";
+import type { Group } from "./index.js";
+type Casing = "snake" | "camel";
+type CmdkitServer = Omit<TinyServer, "connect"> & {
+    connect(transport: SDKTransport): Promise<void>;
+};
+export interface RunMCPOptions<TServices extends object = Record<string, unknown>> {
+    name: string;
+    version: string;
+    /**
+     * Optional allowlist of MCP tool names or group prefixes.
+     *
+     * Tool names always use `__`-joined snake_case path segments, for example
+     * `root__bot__create`.
+     *
+     * Passing a group prefix like `root__bot` includes every descendant tool in
+     * that subtree.
+     */
+    tools?: string[];
+    services?: TServices;
+    /**
+     * Controls MCP input-schema key casing and accepted argument-key casing.
+     *
+     * This does not change tool names. Tool names always stay `__`-joined
+     * snake_case path segments.
+     */
+    casing?: Casing;
+}
+export declare function createMCPServer<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options: RunMCPOptions<TServices>): CmdkitServer;
+export declare function runMCP<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options: RunMCPOptions<TServices>): Promise<void>;
+export {};