@kamilio/wire 0.1.0

package/node_modules/toolcraft/dist/human-in-loop/runner.js

@@ -0,0 +1,245 @@
+import { access, lstat, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { InvalidTransitionError } from "@poe-code/task-list";
+import { UserError, resolveCommandSecrets } from "../index.js";
+import { ensureApprovalList } from "./approval-tasks.js";
+import { resolveProvider } from "./gate.js";
+import { createRuntimeLogger } from "../runtime-logging.js";
+const MAX_AVAILABLE_COMMAND_PATHS = 20;
+export async function runApproval(approvalId, runtimeOptions, root) {
+    const { tasks } = await ensureApprovalList(runtimeOptions);
+    const task = await tasks.get(approvalId);
+    if (task.state !== "pending") {
+        return;
+    }
+    const approval = readApprovalPayload(task);
+    const provider = resolveProvider(runtimeOptions);
+    try {
+        await tasks.fire(approvalId, "claim", {
+            metadataPatch: {
+                pid: process.pid
+            }
+        });
+    }
+    catch (error) {
+        if (error instanceof InvalidTransitionError) {
+            return;
+        }
+        throw error;
+    }
+    try {
+        const approvalResult = await provider.requestApproval({
+            message: approval.message,
+            declineInputPrompt: approval.declineInputPrompt ?? undefined
+        });
+        if (approvalResult.outcome === "declined") {
+            await tasks.fire(approvalId, "decline", {
+                metadataPatch: {
+                    error: {
+                        reason: approvalResult.reason
+                    }
+                }
+            });
+            return;
+        }
+    }
+    catch (error) {
+        await tasks.fire(approvalId, "fail", {
+            metadataPatch: {
+                error: errorMetadataFromUnknown(error)
+            }
+        });
+        return;
+    }
+    await tasks.fire(approvalId, "start");
+    try {
+        const command = findCommand(root, approval.commandPath);
+        const ctx = createHandlerContext(command, approval.params);
+        const result = await command.handler(ctx);
+        const serializedResult = serializeJsonResult(result);
+        if (!serializedResult.ok) {
+            await tasks.fire(approvalId, "fail", {
+                metadataPatch: {
+                    error: {
+                        message: "result not JSON-serializable"
+                    }
+                }
+            });
+            return;
+        }
+        await tasks.fire(approvalId, "succeed", {
+            metadataPatch: {
+                result: serializedResult.value
+            }
+        });
+    }
+    catch (error) {
+        await tasks.fire(approvalId, "fail", {
+            metadataPatch: {
+                error: errorMetadataFromUnknown(error)
+            }
+        });
+    }
+}
+function readApprovalPayload(task) {
+    const metadata = task.metadata;
+    if (typeof metadata !== "object" || metadata === null) {
+        throw new UserError(`Malformed approval metadata for "${task.qualifiedId}".`);
+    }
+    if (metadata.schemaVersion !== 1) {
+        throw new UserError(`Malformed approval metadata for "${task.qualifiedId}".`);
+    }
+    if (typeof metadata.commandPath !== "string" ||
+        typeof metadata.message !== "string" ||
+        typeof metadata.params !== "object" ||
+        metadata.params === null) {
+        throw new UserError(`Malformed approval metadata for "${task.qualifiedId}".`);
+    }
+    const declineInputPrompt = typeof metadata.declineInputPrompt === "string" || metadata.declineInputPrompt === null
+        ? metadata.declineInputPrompt
+        : undefined;
+    return {
+        approvalId: typeof metadata.approvalId === "string" ? metadata.approvalId : undefined,
+        commandPath: metadata.commandPath,
+        params: metadata.params,
+        message: metadata.message,
+        declineInputPrompt,
+        enqueuedAt: typeof metadata.enqueuedAt === "string" ? metadata.enqueuedAt : undefined,
+        pid: typeof metadata.pid === "number" || metadata.pid === null ? metadata.pid : undefined,
+        result: metadata.result,
+        error: metadata.error
+    };
+}
+function findCommand(root, commandPath) {
+    const pathSegments = commandPath.split(".").filter((segment) => segment.length > 0);
+    const unknownCommandPathError = () => new UserError(`Unknown approval command path "${commandPath}". ${formatAvailableApprovalCommandPaths(root)}`);
+    if (pathSegments.length === 0) {
+        throw unknownCommandPathError();
+    }
+    let current = root;
+    for (const segment of pathSegments) {
+        if (current.kind !== "group") {
+            throw unknownCommandPathError();
+        }
+        const next = current.children.find((child) => child.name === segment);
+        if (next === undefined) {
+            throw unknownCommandPathError();
+        }
+        current = next;
+    }
+    if (current.kind !== "command") {
+        throw unknownCommandPathError();
+    }
+    return current;
+}
+function formatAvailableApprovalCommandPaths(root) {
+    const paths = enumerateApprovalCommandPaths(root);
+    const visiblePaths = paths.slice(0, MAX_AVAILABLE_COMMAND_PATHS);
+    const remaining = paths.length - visiblePaths.length;
+    const suffix = remaining > 0 ? `, … and ${remaining} more` : "";
+    return `Available: ${visiblePaths.join(", ")}${suffix}.`;
+}
+function enumerateApprovalCommandPaths(root) {
+    const paths = [];
+    const visit = (node, path) => {
+        if (node.kind === "command") {
+            paths.push(path.join("."));
+            return;
+        }
+        for (const child of getVisibleCliChildren(node)) {
+            visit(child, [...path, child.name]);
+        }
+    };
+    if (root.kind === "command") {
+        visit(root, [root.name]);
+        return paths.sort();
+    }
+    for (const child of getVisibleCliChildren(root)) {
+        visit(child, [child.name]);
+    }
+    return paths.sort();
+}
+function isNodeVisibleInCli(node) {
+    if (node.kind === "command") {
+        return node.scope.includes("cli");
+    }
+    return (getVisibleCliChildren(node).length > 0 ||
+        Boolean(node.default && node.default.scope.includes("cli")) ||
+        node.scope === undefined ||
+        node.scope.includes("cli"));
+}
+function getVisibleCliChildren(root) {
+    return root.kind === "group" ? root.children.filter(isNodeVisibleInCli) : [];
+}
+function createHandlerContext(command, params) {
+    const diagnostics = createRuntimeLogger();
+    return {
+        params,
+        secrets: resolveCommandSecrets(command),
+        fetch: globalThis.fetch,
+        fs: createFs(),
+        env: createEnv(),
+        diagnostics,
+        progress(message) {
+            diagnostics.emit({ level: "info", message, category: "progress" });
+        }
+    };
+}
+function createFs() {
+    return {
+        readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
+        },
+        exists: async (path) => {
+            try {
+                await access(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        lstat: async (path) => lstat(path),
+        rename: async (fromPath, toPath) => rename(fromPath, toPath),
+        unlink: async (path) => unlink(path)
+    };
+}
+function createEnv(values = process.env) {
+    return {
+        get(key) {
+            return values[key];
+        }
+    };
+}
+function serializeJsonResult(value) {
+    try {
+        const serialized = JSON.stringify(value);
+        if (serialized === undefined) {
+            return {
+                ok: false
+            };
+        }
+        return {
+            ok: true,
+            value: JSON.parse(serialized)
+        };
+    }
+    catch {
+        return {
+            ok: false
+        };
+    }
+}
+function errorMetadataFromUnknown(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+        };
+    }
+    return {
+        name: "Error",
+        message: String(error)
+    };
+}

package/node_modules/toolcraft/dist/human-in-loop/spawn.d.ts

@@ -0,0 +1,3 @@
+import type { HumanInLoopRuntimeOptions } from "./types.js";
+export declare function spawnApprovalRunner(approvalId: string, runtimeOptions: HumanInLoopRuntimeOptions, spawnFn?: typeof import("node:child_process").spawn): void;
+export default spawnApprovalRunner;

package/node_modules/toolcraft/dist/human-in-loop/spawn.js

@@ -0,0 +1,16 @@
+import { spawn } from "node:child_process";
+export function spawnApprovalRunner(approvalId, runtimeOptions, spawnFn) {
+    const { execPath, entryArgs } = runtimeOptions.binPath ?? {
+        execPath: process.execPath,
+        entryArgs: [process.argv[1]],
+    };
+    const fn = spawnFn ?? spawn;
+    const child = fn(execPath, [...entryArgs, "approvals", "run", approvalId], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+        cwd: process.cwd(),
+    });
+    child.unref();
+}
+export default spawnApprovalRunner;

package/node_modules/toolcraft/dist/human-in-loop/state-machine.d.ts

@@ -0,0 +1,4 @@
+import type { StateMachineDef } from "@poe-code/task-list";
+export type ApprovalState = "pending" | "prompting" | "approved-running" | "approved-done" | "approved-failed" | "declined";
+export type ApprovalEvent = "claim" | "start" | "succeed" | "fail" | "decline";
+export declare const approvalStateMachine: Readonly<StateMachineDef<ApprovalState, ApprovalEvent>>;

package/node_modules/toolcraft/dist/human-in-loop/state-machine.js

@@ -0,0 +1,18 @@
+const approvalStateMachineDefinition = {
+    initial: "pending",
+    states: ["pending", "prompting", "approved-running", "approved-done", "approved-failed", "declined"],
+    events: {
+        claim: { from: ["pending"], to: "prompting" },
+        start: { from: ["prompting"], to: "approved-running" },
+        succeed: { from: ["approved-running"], to: "approved-done" },
+        fail: { from: ["prompting", "approved-running"], to: "approved-failed" },
+        decline: { from: ["pending", "prompting"], to: "declined" },
+    },
+};
+Object.freeze(approvalStateMachineDefinition.states);
+for (const event of Object.values(approvalStateMachineDefinition.events)) {
+    Object.freeze(event.from);
+    Object.freeze(event);
+}
+Object.freeze(approvalStateMachineDefinition.events);
+export const approvalStateMachine = Object.freeze(approvalStateMachineDefinition);

package/node_modules/toolcraft/dist/human-in-loop/types.d.ts

@@ -0,0 +1,41 @@
+import type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";
+import type { TaskList } from "@poe-code/task-list";
+import type { ObjectSchema, Static } from "toolcraft-schema";
+import { UserError } from "../user-error.js";
+export interface HumanInLoopConfig<TParamsSchema extends ObjectSchema<any>> {
+    mode: "sync" | "async";
+    message: (ctx: {
+        params: Static<TParamsSchema>;
+        commandPath: string;
+    }) => string;
+    declineInputPrompt?: string;
+}
+export interface HumanInLoopRuntimeOptions {
+    provider?: HumanInLoopProvider;
+    taskList?: TaskList | {
+        dir: string;
+        format: "markdown-dir" | "yaml-file";
+    };
+    listName?: string;
+    binPath?: {
+        execPath: string;
+        entryArgs: readonly string[];
+    };
+}
+export interface HumanInLoopPending {
+    status: "pending-approval";
+    approvalId: string;
+    message: string;
+    enqueuedAt: string;
+}
+export declare class ApprovalDeclinedError extends UserError {
+    readonly reason?: string;
+    readonly approvalId?: string;
+    readonly commandPath: string;
+    constructor(options: {
+        commandPath: string;
+        reason?: string;
+        approvalId?: string;
+    });
+}
+export type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";

package/node_modules/toolcraft/dist/human-in-loop/types.js

@@ -0,0 +1,13 @@
+import { UserError } from "../user-error.js";
+export class ApprovalDeclinedError extends UserError {
+    reason;
+    approvalId;
+    commandPath;
+    constructor(options) {
+        super(options.reason === undefined ? "Declined." : `Declined: ${options.reason}`);
+        this.name = "ApprovalDeclinedError";
+        this.reason = options.reason;
+        this.approvalId = options.approvalId;
+        this.commandPath = options.commandPath;
+    }
+}

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

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

package/node_modules/toolcraft/dist/index.compile-check.js

@@ -0,0 +1,74 @@
+import { S } from "toolcraft-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 ignoredMcpGroup = defineGroup({
+    name: "mcp-root",
+    mcp: {
+        transport: "stdio",
+        command: "server",
+    },
+    children: [],
+});
+const ignoredToolsGroup = defineGroup({
+    name: "tools-root",
+    tools: ["usage"],
+    children: [],
+});
+const ignoredRenameGroup = defineGroup({
+    name: "rename-root",
+    rename: {
+        usage: "bot.create",
+    },
+    children: [],
+});
+const ignoredPlainGroup = defineGroup({
+    name: "plain-root",
+    children: [],
+});
+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/node_modules/toolcraft/dist/index.d.ts

@@ -0,0 +1,212 @@
+import type { McpServerConfig } from "@poe-code/agent-mcp-config";
+import type { ObjectSchema, Static } from "toolcraft-schema";
+import type { LoggerOutput, RenderTableOptions, ThemePalette } from "toolcraft-design";
+import { ApprovalDeclinedError } from "./human-in-loop/types.js";
+import type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/types.js";
+import { ToolcraftBugError, UserError } from "./user-error.js";
+import type { RuntimeLogger } from "./runtime-logging.js";
+type ScopeValue = "cli" | "mcp" | "sdk";
+type AnyObjectSchema = ObjectSchema<Record<string, never>>;
+type EmptyServices = Record<string, never>;
+type ScopeInput = readonly Scope[] | undefined;
+type HumanInLoopMode = "sync" | "async";
+type HumanInLoopModeInput = HumanInLoopMode | null | undefined;
+export type Scope = ScopeValue;
+type ResolveOwnHumanInLoopMode<TValue> = TValue extends {
+    mode: infer TMode extends HumanInLoopMode;
+} ? TMode : TValue extends null ? null : undefined;
+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, options?: {
+        encoding?: BufferEncoding;
+        flag?: string;
+        mode?: number;
+    }): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+    rename(fromPath: string, toPath: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+}
+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 interface CommandExample {
+    title: string;
+    params: Record<string, unknown>;
+}
+export type GroupCheckContext<TServices extends object = EmptyServices> = TServices & {
+    params?: unknown;
+    secrets?: Record<string, string | undefined>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    diagnostics: RuntimeLogger;
+    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;
+    diagnostics: RuntimeLogger;
+    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;
+    diagnostics: RuntimeLogger;
+    progress(message: string): void;
+};
+export interface CommandConfig<TServices extends object, TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TResult> {
+    name: string;
+    description?: string;
+    hidden?: boolean;
+    examples?: CommandExample[];
+    aliases?: string[];
+    positional?: string[];
+    params: TParamsSchema;
+    result?: ObjectSchema<any>;
+    secrets?: TSecrets;
+    scope?: Scope[];
+    confirm?: boolean;
+    humanInLoop?: HumanInLoopConfig<TParamsSchema> | null;
+    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;
+    hidden: boolean;
+    examples: CommandExample[];
+    aliases: string[];
+    positional: string[];
+    params: TParamsSchema;
+    result?: ObjectSchema<any>;
+    secrets: SecretDeclarations;
+    scope: Scope[];
+    confirm: boolean;
+    humanInLoop?: HumanInLoopConfig<TParamsSchema> | null;
+    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[];
+    mcp?: McpServerConfig;
+    scope?: Scope[];
+    humanInLoop?: HumanInLoopConfig<AnyObjectSchema> | null;
+    secrets?: SecretDeclarations;
+    tools?: string[];
+    rename?: Record<string, string>;
+    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[];
+    humanInLoop?: HumanInLoopConfig<AnyObjectSchema> | null;
+    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, TOwnHumanInLoopMode extends HumanInLoopModeInput = undefined> {
+    name: TName;
+    params: TParamsSchema;
+    result: TResult;
+    ownScope: TOwnScope;
+    ownHumanInLoopMode: TOwnHumanInLoopMode;
+}
+export interface GroupTypeInfo<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = ScopeInput, TOwnHumanInLoopMode extends HumanInLoopModeInput = undefined> {
+    name: TName;
+    children: TChildren;
+    ownScope: TOwnScope;
+    ownHumanInLoopMode: TOwnHumanInLoopMode;
+}
+type TypedCommandMetadata<TName extends string, TParamsSchema extends ObjectSchema<any>, TResult, TOwnScope extends ScopeInput, TOwnHumanInLoopMode extends HumanInLoopModeInput> = {
+    readonly __agentKitCommandTypeInfo: CommandTypeInfo<TName, TParamsSchema, TResult, TOwnScope, TOwnHumanInLoopMode>;
+};
+type TypedGroupMetadata<TServices extends object, TName extends string, TChildren extends readonly unknown[], TOwnScope extends ScopeInput, TOwnHumanInLoopMode extends HumanInLoopModeInput> = {
+    readonly __agentKitGroupTypeInfo: GroupTypeInfo<TServices, TName, TChildren, TOwnScope, TOwnHumanInLoopMode>;
+};
+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, TOwnHumanInLoop extends HumanInLoopConfig<TParamsSchema> | null | undefined = undefined>(config: Omit<CommandConfig<TServices, TParamsSchema, TSecrets, TResult>, "name" | "scope" | "humanInLoop"> & {
+    name: TName;
+    scope?: TOwnScope;
+    humanInLoop?: TOwnHumanInLoop;
+}): Command<TServices, TParamsSchema, TSecrets, TResult> & TypedCommandMetadata<TName, TParamsSchema, TResult, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
+export declare function defineGroup<TServices extends object = EmptyServices, TName extends string = string, TChildren extends readonly unknown[] = readonly CommandNode<TServices>[], TOwnScope extends ScopeInput = undefined, TOwnHumanInLoop extends HumanInLoopConfig<AnyObjectSchema> | null | undefined = undefined>(config: Omit<GroupConfig<TServices>, "name" | "children" | "scope" | "humanInLoop"> & {
+    name: TName;
+    children: TChildren & readonly CommandNode<TServices>[];
+    scope?: TOwnScope;
+    humanInLoop?: TOwnHumanInLoop;
+}): Group<TServices> & TypedGroupMetadata<TServices, TName, TChildren, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
+export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
+export { S, toJsonSchema } from "toolcraft-schema";
+export { AuthenticationError, BadRequestError, ClientError, ConflictError, HttpError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, ServerError, ServiceUnavailableError, UnprocessableEntityError, createHttpError } from "./http-errors.js";
+export type { HttpErrorRequest, HttpErrorResponse } from "./http-errors.js";
+export { ApprovalDeclinedError, ToolcraftBugError, UserError };
+export { createRuntimeLogger, isLogLevel, shouldEmitDiagnostic } from "./runtime-logging.js";
+export { findPackageMetadata, packageMetadata } from "./package-metadata.js";
+export type { PackageMetadata } from "./package-metadata.js";
+export type { DiagnosticLogEvent, LogLevel, RuntimeLogger, RuntimeLoggerInput } from "./runtime-logging.js";
+export type { AnySchema, ArraySchema, BooleanSchema, EnumSchema, JsonSchema, NumberSchema, ObjectSchema, OptionalSchema, Static, StringSchema } from "toolcraft-schema";
+export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntimeOptions };