@kamilio/wire 0.1.9 → 0.1.10

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

@@ -1,9 +1,9 @@
-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 { createEnv, createFs } from "../runtime/io.js";
 import { ensureApprovalList } from "./approval-tasks.js";
-import { resolveProvider } from "./gate.js";
 import { createRuntimeLogger } from "../runtime-logging.js";
+import { assertApprovalPlanHash, createApprovalPlan, formatApprovalMessage, isApprovalPlanValue } from "./plan-hash.js";
 const MAX_AVAILABLE_COMMAND_PATHS = 20;
 export async function runApproval(approvalId, runtimeOptions, root) {
     const { tasks } = await ensureApprovalList(runtimeOptions);
@@ -12,7 +12,7 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         return;
     }
     const approval = readApprovalPayload(task);
-    const provider = resolveProvider(runtimeOptions);
+    const provider = runtimeOptions.provider;
     try {
         await tasks.fire(approvalId, "claim", {
             metadataPatch: {
@@ -27,6 +27,7 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         throw error;
     }
     try {
+        verifyStoredApprovalPlan(approval);
         const approvalResult = await provider.requestApproval({
             message: approval.message,
             declineInputPrompt: approval.declineInputPrompt ?? undefined
@@ -50,10 +51,32 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         });
         return;
     }
+    let command;
+    let ctx;
+    try {
+        command = findCommand(root, approval.commandPath);
+        ctx = createHandlerContext(command, approval.params);
+        if (approval.planHash !== undefined) {
+            if (command.humanInLoop?.plan === undefined) {
+                throw new UserError("Approval plan can no longer be verified by this command.");
+            }
+            const executionPlan = createApprovalPlan(await command.humanInLoop.plan({
+                params: approval.params,
+                commandPath: approval.commandPath
+            }));
+            assertApprovalPlanHash(approval.planHash, executionPlan.hash);
+        }
+    }
+    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) {
@@ -80,6 +103,21 @@ export async function runApproval(approvalId, runtimeOptions, root) {
         });
     }
 }
+function verifyStoredApprovalPlan(approval) {
+    const hasPlan = approval.plan !== undefined;
+    const hasPlanHash = approval.planHash !== undefined;
+    if (!hasPlan && !hasPlanHash) {
+        return;
+    }
+    if (approval.plan === undefined || approval.planHash === undefined) {
+        throw new UserError("Malformed approval plan metadata.");
+    }
+    const storedPlan = createApprovalPlan(approval.plan);
+    assertApprovalPlanHash(approval.planHash, storedPlan.hash);
+    if (!approval.message.endsWith(formatApprovalMessage("", storedPlan))) {
+        throw new UserError("Approval prompt does not match its stored plan hash.");
+    }
+}
 function readApprovalPayload(task) {
     const metadata = task.metadata;
     if (typeof metadata !== "object" || metadata === null) {
@@ -103,6 +141,8 @@ function readApprovalPayload(task) {
         params: metadata.params,
         message: metadata.message,
         declineInputPrompt,
+        plan: isApprovalPlanValue(metadata.plan) ? metadata.plan : undefined,
+        planHash: typeof metadata.planHash === "string" ? metadata.planHash : undefined,
         enqueuedAt: typeof metadata.enqueuedAt === "string" ? metadata.enqueuedAt : undefined,
         pid: typeof metadata.pid === "number" || metadata.pid === null ? metadata.pid : undefined,
         result: metadata.result,
@@ -184,33 +224,6 @@ function createHandlerContext(command, params) {
         }
     };
 }
-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);

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

@@ -0,0 +1,19 @@
+import type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";
+import type { TaskList } from "@poe-code/task-list";
+import type { HumanInLoopRuntime } from "./types.js";
+/** The concrete runtime built by `createHumanInLoop` — carries its options for the approvals built-ins. */
+export interface HumanInLoopRuntimeInstance extends HumanInLoopRuntime {
+    readonly runtimeOptions: HumanInLoopRuntimeOptions;
+}
+export interface HumanInLoopRuntimeOptions {
+    provider: HumanInLoopProvider;
+    taskList?: TaskList | {
+        dir: string;
+        format: "markdown-dir" | "yaml-file";
+    };
+    listName?: string;
+    binPath?: {
+        execPath: string;
+        entryArgs: readonly string[];
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { HumanInLoopRuntimeInstance, HumanInLoopRuntimeOptions } from "./runtime-options.js";
+export declare function createHumanInLoop(options: HumanInLoopRuntimeOptions): HumanInLoopRuntimeInstance;

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

@@ -0,0 +1,14 @@
+import { UserError } from "../user-error.js";
+import { mergeApprovalsGroup } from "./approvals-commands.js";
+import { invokeWithHumanInLoop } from "./gate.js";
+export function createHumanInLoop(options) {
+    if (options?.provider === undefined) {
+        throw new UserError('createHumanInLoop requires a provider — import one from "toolcraft/human-in-loop" (e.g. osascriptProvider) or pass your own');
+    }
+    const runtimeOptions = { ...options };
+    return {
+        runtimeOptions,
+        invoke: (node, ctx, commandPath) => invokeWithHumanInLoop(node, ctx, runtimeOptions, commandPath),
+        mergeApprovalsGroup
+    };
+}

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

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

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

@@ -1,6 +1,5 @@
-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 type { Command, Group, HandlerContext } from "../index.js";
 import { UserError } from "../user-error.js";
 export interface HumanInLoopConfig<TParamsSchema extends ObjectSchema<any>> {
     mode: "sync" | "async";
@@ -8,25 +7,27 @@ export interface HumanInLoopConfig<TParamsSchema extends ObjectSchema<any>> {
         params: Static<TParamsSchema>;
         commandPath: string;
     }) => string;
+    plan?: (ctx: {
+        params: Static<TParamsSchema>;
+        commandPath: string;
+    }) => unknown | Promise<unknown>;
     declineInputPrompt?: string;
 }
-export interface HumanInLoopRuntimeOptions {
-    provider?: HumanInLoopProvider;
-    taskList?: TaskList | {
-        dir: string;
-        format: "markdown-dir" | "yaml-file";
-    };
-    listName?: string;
-    binPath?: {
-        execPath: string;
-        entryArgs: readonly string[];
-    };
+/**
+ * The wired human-in-loop runtime. Core entrypoints only know this interface;
+ * the implementation ships behind the `toolcraft/human-in-loop` export and is
+ * created with `createHumanInLoop({ provider, ... })`.
+ */
+export interface HumanInLoopRuntime {
+    invoke<T>(node: Command<any, any, any, T>, ctx: HandlerContext<any, any, any>, commandPath: string): Promise<T | HumanInLoopPending>;
+    mergeApprovalsGroup<TServices extends object>(root: Group<TServices>): Group<TServices>;
 }
 export interface HumanInLoopPending {
     status: "pending-approval";
     approvalId: string;
     message: string;
     enqueuedAt: string;
+    planHash?: string;
 }
 export declare class ApprovalDeclinedError extends UserError {
     readonly reason?: string;
@@ -38,4 +39,3 @@ export declare class ApprovalDeclinedError extends UserError {
         approvalId?: string;
     });
 }
-export type { HumanInLoopProvider } from "@poe-code/agent-human-in-loop";

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

@@ -0,0 +1,11 @@
+import type { CommandNode, Group } from "../index.js";
+import type { HumanInLoopRuntime } from "./types.js";
+/**
+ * Human-in-loop config on a command is only allowed when a runtime is wired.
+ * Called by every entrypoint (CLI, MCP, SDK) after the root is normalized.
+ */
+export declare function assertHumanInLoopWired(root: CommandNode<any>, humanInLoop: HumanInLoopRuntime | undefined): void;
+export declare function mergeApprovalsRoot<TServices extends object>(root: Group<TServices>, options: {
+    approvals?: boolean;
+    humanInLoop?: HumanInLoopRuntime;
+}): Group<TServices>;

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

@@ -0,0 +1,36 @@
+import { UserError } from "../user-error.js";
+const WIRING_HINT = 'pass { humanInLoop: createHumanInLoop({ provider, ... }) } from "toolcraft/human-in-loop"';
+/**
+ * Human-in-loop config on a command is only allowed when a runtime is wired.
+ * Called by every entrypoint (CLI, MCP, SDK) after the root is normalized.
+ */
+export function assertHumanInLoopWired(root, humanInLoop) {
+    if (humanInLoop !== undefined) {
+        return;
+    }
+    const commandPath = findHumanInLoopCommandPath(root, []);
+    if (commandPath !== undefined) {
+        throw new UserError(`command '${commandPath}' declares humanInLoop but no runtime is wired — ${WIRING_HINT}`);
+    }
+}
+export function mergeApprovalsRoot(root, options) {
+    if (options.approvals !== true) {
+        return root;
+    }
+    if (options.humanInLoop === undefined) {
+        throw new UserError(`approvals: true requires a wired humanInLoop runtime — ${WIRING_HINT}`);
+    }
+    return options.humanInLoop.mergeApprovalsGroup(root);
+}
+function findHumanInLoopCommandPath(node, path) {
+    if (node.kind === "command") {
+        return node.humanInLoop ? path.join(".") || node.name : undefined;
+    }
+    for (const child of node.children) {
+        const found = findHumanInLoopCommandPath(child, [...path, child.name]);
+        if (found !== undefined) {
+            return found;
+        }
+    }
+    return undefined;
+}

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

@@ -1,5 +1,24 @@
 import { S } from "toolcraft-schema";
-import { defineCommand, defineGroup } from "./index.js";
+import { asMCPResult, cloneCommandNode, defineCommand, defineGroup } from "./index.js";
+import { createFileChangeRenderers } from "./file-change-renderer.js";
+import { validate as validateSchema } from "./schema.js";
+const ignoredValidationOptions = { defaults: "none" };
+const ignoredWithoutDefaults = validateSchema(S.Object({ count: S.Optional(S.Number({ default: 2 })) }), {}, ignoredValidationOptions);
+const ignoredMCPResult = asMCPResult({
+    content: [{ type: "text", text: "upstream message" }],
+    structuredContent: { id: "one" },
+    _meta: { trace: "request" }
+});
+const ignoredMCPResultCommand = defineCommand({
+    name: "upstream",
+    params: S.Object({}),
+    handler: () => ignoredMCPResult,
+    render: { json: (result) => ({ id: result.structuredContent.id, trace: result._meta.trace }) }
+});
+const ignoredClonedCommand = cloneCommandNode(ignoredMCPResultCommand);
+const ignoredExtendedCommand = { ...ignoredMCPResultCommand, extraRuntimeState: 1 };
+const ignoredClonedDefinition = cloneCommandNode(ignoredExtendedCommand);
+const ignoredScopeOverrideClone = cloneCommandNode(ignoredMCPResultCommand, ["cli"]);
 const ignoredScope = ["cli", "sdk"];
 const ignoredSecrets = {
     apiKey: { env: "API_KEY" },
@@ -29,6 +48,36 @@ const ignoredCommand = defineCommand({
         };
     },
 });
+const ignoredFileChangeCommand = defineCommand({
+    name: "status",
+    params: S.Object({}),
+    render: createFileChangeRenderers({ mode: "status" }),
+    handler: async () => ({
+        changes: [{ kind: "added", path: "flows/morning.json", newContent: "{}\n" }]
+    })
+});
+defineCommand({
+    name: "mapped-result",
+    params: S.Object({}),
+    result: S.Object({ data: S.Array(S.String()) }),
+    mcpResult: (result) => ({ data: result }),
+    handler: async () => [],
+});
+defineCommand({
+    name: "invalid-async-mapped-result",
+    params: S.Object({}),
+    result: S.Object({ data: S.Array(S.String()) }),
+    // @ts-expect-error MCP result mappers are synchronous
+    mcpResult: async (result) => ({ data: result }),
+    handler: async () => [],
+});
+defineCommand({
+    name: "scalar-mapped-result",
+    params: S.Object({}),
+    result: S.String(),
+    mcpResult: () => "ready",
+    handler: async () => [],
+});
 const ignoredGroup = defineGroup({
     name: "root",
     scope: ignoredScope,

package/node_modules/toolcraft/dist/index.d.ts

@@ -1,212 +1,3 @@
-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 * from "./runtime.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 };