@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/dist/node-require-shim.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+const globalWithRequire = globalThis;
+globalWithRequire.require ??= createRequire(path.join(process.cwd(), "package.json"));

package/node_modules/toolcraft/dist/package-metadata.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 function pathFromInput(from) {
@@ -12,8 +12,15 @@ function pathFromInput(from) {
 }
 function getSearchDirectory(from) {
     const resolved = pathFromInput(from);
+    let searchPath = resolved;
     try {
-        return statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+        searchPath = realpathSync(resolved);
+    }
+    catch {
+        searchPath = resolved;
+    }
+    try {
+        return statSync(searchPath).isDirectory() ? searchPath : path.dirname(searchPath);
     }
     catch {
         return path.dirname(resolved);

package/node_modules/toolcraft/dist/process-runner.d.ts

@@ -0,0 +1 @@
+export * from "@poe-code/process-runner";

package/node_modules/toolcraft/dist/process-runner.js

@@ -0,0 +1 @@
+export * from "@poe-code/process-runner";

package/node_modules/toolcraft/dist/project-root.d.ts

@@ -0,0 +1 @@
+export declare function findProjectRoot(from?: string): string | undefined;

package/node_modules/toolcraft/dist/project-root.js

@@ -0,0 +1,15 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+export function findProjectRoot(from = process.cwd()) {
+    let current = from === process.cwd() ? process.cwd() : path.resolve(from);
+    while (true) {
+        if (existsSync(path.join(current, "package.json"))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}

package/node_modules/toolcraft/dist/redaction.js

@@ -12,28 +12,37 @@ export function isSensitiveName(name) {
     const normalized = normalizeName(name);
     return SENSITIVE_NAME_PARTS.some((candidate) => normalized.includes(candidate));
 }
-function redactSecretLikeFieldsValue(value, name, seen) {
+function redactSecretLikeFieldsValue(value, name, seen, applyToJSON = true) {
     if (name.length > 0 && isSensitiveName(name)) {
         return REDACTED_VALUE;
     }
-    if (Array.isArray(value)) {
-        if (seen.has(value)) {
-            return "[Circular]";
-        }
-        seen.add(value);
-        return value.map((entry) => redactSecretLikeFieldsValue(entry, name, seen));
+    if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+        return value;
+    }
+    if (seen.has(value)) {
+        return "[Circular]";
     }
-    if (isPlainObject(value)) {
-        if (seen.has(value)) {
-            return "[Circular]";
+    seen.add(value);
+    const toJSON = applyToJSON ? value.toJSON : undefined;
+    if (typeof toJSON === "function") {
+        const serialized = toJSON.call(value, name);
+        if (serialized !== value) {
+            const redacted = redactSecretLikeFieldsValue(serialized, name, seen, false);
+            seen.delete(value);
+            return redacted;
         }
-        seen.add(value);
-        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
-            key,
-            redactSecretLikeFieldsValue(entry, key, seen)
-        ]));
     }
-    return value;
+    if (typeof value === "function") {
+        seen.delete(value);
+        return undefined;
+    }
+    const redacted = Array.isArray(value)
+        ? value.map((entry, index) => redactSecretLikeFieldsValue(entry, String(index), seen))
+        : Object.fromEntries(Object.entries(value)
+            .filter(([key, entry]) => key !== "toJSON" || typeof entry !== "function")
+            .map(([key, entry]) => [key, redactSecretLikeFieldsValue(entry, key, seen)]));
+    seen.delete(value);
+    return redacted;
 }
 export function redactSecretLikeFields(value, name = "") {
     return redactSecretLikeFieldsValue(value, name, new WeakSet());
@@ -61,7 +70,7 @@ export function redactHttpBody(body) {
 export function redactHttpHeaderValue(name, value) {
     const normalized = normalizeName(name);
     if (AUTHORIZATION_HEADER_NAMES.has(normalized)) {
-        return "Bearer ****";
+        return value.startsWith("Bearer ") ? "Bearer ****" : "****";
     }
     if (SECRET_HEADER_NAMES.has(normalized) || isSensitiveName(name)) {
         return REDACTED_VALUE;

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

@@ -1,5 +1,5 @@
 import type { Command, RenderPrimitives } from "./index.js";
-export type OutputMode = "rich" | "md" | "json";
+export type OutputMode = "rich" | "md" | "json" | (string & {});
 type WriteStream = "stdout" | "stderr";
 type WriteFn = (chunk: string, stream?: WriteStream) => void;
 export interface RenderResultStatus {

package/node_modules/toolcraft/dist/renderer.js

@@ -1,26 +1,19 @@
 import YAML from "yaml";
 import { renderDetailCard } from "toolcraft-design";
+import { isMCPResult } from "./mcp-result.js";
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isMcpCallToolResult(value) {
-    if (!isObject(value)) {
-        return false;
-    }
-    const hasContent = Array.isArray(value.content);
-    const hasStructured = value.structuredContent !== undefined;
-    if (!hasContent && !hasStructured) {
-        return false;
-    }
-    return Object.keys(value).every((key) => key === "content" || key === "structuredContent" || key === "isError" || key === "_meta");
-}
 function isMcpTextContent(value) {
     return isObject(value) && value.type === "text" && typeof value.text === "string";
 }
 function extractMcpPayload(envelope) {
     const structuredContent = envelope.structuredContent;
-    if (isObject(structuredContent) && "result" in structuredContent) {
-        return structuredContent.result;
+    if (isObject(structuredContent)) {
+        const keys = Object.keys(structuredContent);
+        if (keys.length === 1 && keys[0] === "result") {
+            return structuredContent.result;
+        }
     }
     if (structuredContent !== undefined) {
         return structuredContent;
@@ -30,12 +23,15 @@ function extractMcpPayload(envelope) {
             .filter(isMcpTextContent)
             .map((block) => block.text)
             .join("\n");
-        return text.length > 0 ? text : undefined;
+        if (text.length > 0) {
+            return text;
+        }
+        return envelope.isError === true ? "Upstream tool failed." : undefined;
     }
     return undefined;
 }
 function unwrapMcpEnvelope(result) {
-    if (!isMcpCallToolResult(result)) {
+    if (!isMCPResult(result)) {
         return { result, mcpError: false };
     }
     return {
@@ -87,10 +83,25 @@ function humanizeKey(key) {
     }
     return output;
 }
+function getResultLabels(result) {
+    const labels = new Map();
+    const counts = new Map();
+    for (const key of Object.keys(result)) {
+        const label = humanizeKey(key);
+        labels.set(key, label);
+        counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    for (const [key, label] of labels) {
+        if (counts.get(label) > 1)
+            labels.set(key, key);
+    }
+    return labels;
+}
 function detailRows(result, depth = 0) {
     const rows = [];
+    const labels = getResultLabels(result);
     for (const [key, value] of Object.entries(result)) {
-        const label = `${"  ".repeat(depth)}${humanizeKey(key)}`;
+        const label = `${"  ".repeat(depth)}${labels.get(key)}`;
         if (isObject(value)) {
             if (Object.keys(value).length === 0) {
                 rows.push({ label, value: "{}" });
@@ -129,39 +140,29 @@ function displayScalar(value) {
     }
     return stringifyValue(value) || "—";
 }
-function isUrl(value) {
-    return typeof value === "string" && (value.startsWith("https://") || value.startsWith("http://"));
-}
-function compactUrl(value) {
-    try {
-        const url = new URL(value);
-        const tail = url.pathname.split("/").filter(Boolean).at(-1);
-        return tail ? `${url.hostname}/…/${tail}` : url.hostname;
-    }
-    catch {
-        return value;
-    }
+function stackedList(value) {
+    return value.map((entry) => displayScalar(entry)).join("\n") || "—";
 }
 function displayRowValue(value) {
-    return isUrl(value) ? compactUrl(value) : displayScalar(value);
+    return displayScalar(value);
 }
-function directScalarRows(result) {
+function directScalarRows(result, labels) {
     return Object.entries(result)
         .filter(([, value]) => !isObject(value) && !Array.isArray(value))
-        .map(([key, value]) => ({ label: humanizeKey(key), value: displayRowValue(value) }));
+        .map(([key, value]) => ({ label: labels.get(key), value: displayRowValue(value) }));
 }
-function directObjectSections(result) {
+function directObjectSections(result, labels) {
     return Object.entries(result)
         .filter(([, value]) => isObject(value))
-        .map(([key, value]) => ({ title: humanizeKey(key), rows: detailRows(value) }))
+        .map(([key, value]) => ({ title: labels.get(key), rows: detailRows(value) }))
         .filter((section) => section.rows.length > 0);
 }
-function directArrayObjectSections(result) {
+function directArrayObjectSections(result, labels) {
     return Object.entries(result).flatMap(([key, value]) => {
         if (!isNonEmptyArrayOfObjects(value)) {
             return [];
         }
-        const title = humanizeKey(key);
+        const title = labels.get(key);
         return value
             .map((entry, index) => ({
             title: value.length === 1 ? title : `${title} ${index + 1}`,
@@ -171,12 +172,13 @@ function directArrayObjectSections(result) {
     });
 }
 function renderObjectCard(result, primitives, title) {
-    const scalarRows = directScalarRows(result);
-    const nestedSections = directObjectSections(result);
-    const arrayObjectSections = directArrayObjectSections(result);
+    const labels = getResultLabels(result);
+    const scalarRows = directScalarRows(result, labels);
+    const nestedSections = directObjectSections(result, labels);
+    const arrayObjectSections = directArrayObjectSections(result, labels);
     const listRows = Object.entries(result)
         .filter(([, value]) => Array.isArray(value) && !isNonEmptyArrayOfObjects(value))
-        .map(([key, value]) => ({ label: humanizeKey(key), value: displayScalar(value) }));
+        .map(([key, value]) => ({ label: labels.get(key), value: stackedList(value) }));
     return renderDetailCard({
         theme: primitives.getTheme(),
         title,
@@ -314,9 +316,8 @@ export function renderResult(command, result, output, primitives, write = (chunk
     process.stdout.write(chunk);
 }) {
     const unwrapped = unwrapMcpEnvelope(result);
-    result = unwrapped.result;
     if (unwrapped.mcpError) {
-        const payload = autoRender(command, result, output, primitives);
+        const payload = autoRender(command, unwrapped.result, output, primitives);
         if (payload.length > 0) {
             write(`${payload}\n`, "stderr");
         }
@@ -340,7 +341,7 @@ export function renderResult(command, result, output, primitives, write = (chunk
         command.render.rich(result, primitives);
         return { mcpError: false };
     }
-    const payload = autoRender(command, result, output, primitives);
+    const payload = autoRender(command, unwrapped.result, output, primitives);
     if (payload.length > 0) {
         write(`${payload}\n`);
     }

package/node_modules/toolcraft/dist/runtime/io.d.ts

@@ -0,0 +1,5 @@
+import type { HandlerEnv, HandlerFs } from "../index.js";
+export declare const RESERVED_SERVICE_NAMES: Set<string>;
+export declare function createFs(fs?: HandlerFs): HandlerFs;
+export declare function createEnv(values?: Record<string, string | undefined>): HandlerEnv;
+export declare function validateServices(services: object): void;

package/node_modules/toolcraft/dist/runtime/io.js

@@ -0,0 +1,59 @@
+import { access, lstat, readFile, rename, unlink, writeFile } from "node:fs/promises";
+export const RESERVED_SERVICE_NAMES = new Set([
+    "params",
+    "secrets",
+    "fetch",
+    "fs",
+    "env",
+    "diagnostics",
+    "progress",
+    "runtimeOptions",
+    "root",
+    "signal",
+    "stdin",
+    "stdout",
+    "stderr",
+    "cwd",
+    "regex",
+    "registerCleanup",
+    "invoke",
+    "inputBudget"
+]);
+const RESERVED_SERVICE_NAMES_MESSAGE = `Available reserved names: ${[...RESERVED_SERVICE_NAMES].join(", ")}.`;
+export function createFs(fs) {
+    if (fs !== undefined) {
+        return fs;
+    }
+    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)
+    };
+}
+export function createEnv(values = process.env) {
+    return {
+        get(key) {
+            return values[key];
+        }
+    };
+}
+export function validateServices(services) {
+    for (const name of Object.keys(services)) {
+        if (RESERVED_SERVICE_NAMES.has(name)) {
+            throw new Error(`Service name "${name}" is reserved. Choose a different name. ${RESERVED_SERVICE_NAMES_MESSAGE}`);
+        }
+    }
+}

package/node_modules/toolcraft/dist/runtime-platform.d.ts

@@ -0,0 +1,2 @@
+export { fileURLToPath } from "node:url";
+export declare function defaultEnvironment(): Record<string, string | undefined>;

package/node_modules/toolcraft/dist/runtime-platform.js

@@ -0,0 +1,2 @@
+export { fileURLToPath } from "node:url";
+export function defaultEnvironment() { return process.env; }

package/node_modules/toolcraft/dist/runtime-platform.workerd.d.ts

@@ -0,0 +1,3 @@
+/** Stack locations are diagnostic only; Workers have no host environment. */
+export declare function fileURLToPath(value: string): string;
+export declare function defaultEnvironment(): Record<string, string | undefined>;

package/node_modules/toolcraft/dist/runtime-platform.workerd.js

@@ -0,0 +1,10 @@
+/** Stack locations are diagnostic only; Workers have no host environment. */
+export function fileURLToPath(value) {
+    const url = new URL(value);
+    if (url.protocol !== "file:" || (url.hostname && url.hostname !== "localhost"))
+        throw new Error("Not a local file URL");
+    if (url.pathname.toLowerCase().includes("%2f"))
+        throw new Error("Encoded path separators are not file paths");
+    return decodeURIComponent(url.pathname);
+}
+export function defaultEnvironment() { return {}; }

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

@@ -0,0 +1,266 @@
+import type { McpServerConfig } from "@poe-code/agent-mcp-config";
+import type { AnySchema, 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, HumanInLoopRuntime } from "./human-in-loop/types.js";
+import { ToolcraftBugError, UserError, isUserError } from "./user-error.js";
+import type { RuntimeLogger } from "./runtime-logging.js";
+import type { StreamStatusEvent, ToolcraftStream } from "./stream.js";
+export { createManagedStream } from "./stream.js";
+export type { StreamConsumerOptions, StreamStatusEvent, StreamStatusType, ToolcraftStream } from "./stream.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;
+export type MCPResultValue = Record<string, unknown> | readonly unknown[] | string | number | boolean | null;
+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;
+    outputFormat: string;
+}
+export interface CheckResult {
+    ok: boolean;
+    message?: string;
+}
+export interface CommandExample {
+    title: string;
+    params: Record<string, unknown>;
+}
+export type GroupCheckContext<TServices extends object = EmptyServices> = TServices & HandlerInvocationCapabilities & {
+    params?: unknown;
+    secrets?: Record<string, string | undefined>;
+    fetch: typeof globalThis.fetch;
+    fs: HandlerFs;
+    env: HandlerEnv;
+    diagnostics: RuntimeLogger;
+    signal?: AbortSignal;
+    progress(message: string): void;
+};
+export type CommandCheckContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & HandlerInvocationCapabilities & {
+    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;
+}
+/** Standard MCP hints that describe a tool's behavior to clients. */
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+/** Additional capabilities supplied by native invocation hosts. */
+export interface HandlerInvocationCapabilities {
+    readonly signal?: AbortSignal;
+}
+export type HandlerContext<TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TServices extends object = EmptyServices> = TServices & HandlerInvocationCapabilities & {
+    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;
+    title?: string;
+    description?: string;
+    annotations?: ToolAnnotations;
+    hidden?: boolean;
+    examples?: CommandExample[];
+    aliases?: string[];
+    positional?: string[];
+    params: TParamsSchema;
+    result?: AnySchema;
+    mcpResult?: (result: TResult) => MCPResultValue;
+    secrets?: TSecrets;
+    scope?: Scope[];
+    confirm?: boolean;
+    humanInLoop?: HumanInLoopConfig<TParamsSchema> | null;
+    requires?: Requires<CommandCheckContext<TParamsSchema, TSecrets, TServices>>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult> | TResult;
+    render?: Renderers<TResult>;
+}
+export interface StreamDefinition<TEventSchema extends AnySchema = AnySchema> {
+    event: TEventSchema;
+    bufferSize: number;
+}
+export type StreamHandlerContext<TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TServices extends object> = HandlerContext<TParamsSchema, TSecrets, TServices> & {
+    signal: AbortSignal;
+    status(event: StreamStatusEvent): void;
+    refreshSecrets(): Promise<InferSecrets<TSecrets>>;
+};
+export interface StreamCommandConfig<TServices extends object, TParamsSchema extends ObjectSchema<any>, TSecrets extends SecretDeclarations | undefined, TEventSchema extends AnySchema> extends Omit<CommandConfig<TServices, TParamsSchema, TSecrets, AsyncIterable<Static<TEventSchema>>>, "handler" | "render" | "result" | "mcpResult" | "humanInLoop" | "confirm"> {
+    event: TEventSchema;
+    handler: (ctx: StreamHandlerContext<TParamsSchema, TSecrets, TServices>) => AsyncIterable<Static<TEventSchema>> | Promise<AsyncIterable<Static<TEventSchema>>>;
+    render?: Renderers<Static<TEventSchema>>;
+}
+export interface Command<TServices extends object = EmptyServices, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TResult = unknown> {
+    kind: "command";
+    name: string;
+    title?: string;
+    description?: string;
+    annotations?: ToolAnnotations;
+    hidden: boolean;
+    examples: CommandExample[];
+    aliases: string[];
+    positional: string[];
+    params: TParamsSchema;
+    result?: AnySchema;
+    mcpResult?: (result: TResult) => MCPResultValue;
+    stream?: StreamDefinition<any>;
+    secrets: SecretDeclarations;
+    scope: Scope[];
+    confirm: boolean;
+    humanInLoop?: HumanInLoopConfig<TParamsSchema> | null;
+    requires?: Requires<any>;
+    handler: (ctx: HandlerContext<TParamsSchema, TSecrets, TServices>) => Promise<TResult> | 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 {
+    mode: HumanInLoopMode;
+} | null | undefined = undefined>(config: Omit<CommandConfig<TServices, TParamsSchema, TSecrets, TResult>, "name" | "scope" | "humanInLoop"> & {
+    name: TName;
+    scope?: TOwnScope;
+    humanInLoop?: (TOwnHumanInLoop | {
+        [K in keyof TOwnHumanInLoop]: TOwnHumanInLoop[K];
+    }) & (HumanInLoopConfig<TParamsSchema> | null);
+}): Command<TServices, TParamsSchema, TSecrets, TResult> & TypedCommandMetadata<TName, TParamsSchema, TResult, TOwnScope, ResolveOwnHumanInLoopMode<TOwnHumanInLoop>>;
+export declare function defineStreamCommand<TServices extends object = EmptyServices, TName extends string = string, TParamsSchema extends ObjectSchema<any> = AnyObjectSchema, TSecrets extends SecretDeclarations | undefined = undefined, TEventSchema extends AnySchema = AnySchema, TOwnScope extends ScopeInput = undefined>(config: Omit<StreamCommandConfig<TServices, TParamsSchema, TSecrets, TEventSchema>, "name" | "scope"> & {
+    name: TName;
+    scope?: TOwnScope;
+}): Command<TServices, TParamsSchema, TSecrets, AsyncIterable<Static<TEventSchema>>> & TypedCommandMetadata<TName, TParamsSchema, ToolcraftStream<Static<TEventSchema>>, TOwnScope, undefined>;
+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 type ClonedCommandNode<TNode extends CommandNode<any>> = TNode extends Command<infer TServices, infer TParams, infer TSecrets, infer TResult> ? Command<TServices, TParams, TSecrets, TResult> & Pick<TNode, Extract<keyof TNode, "__agentKitCommandTypeInfo">> : TNode extends Group<infer TServices> ? Group<TServices> & Pick<TNode, Extract<keyof TNode, "__agentKitGroupTypeInfo">> : never;
+export declare function cloneCommandNode<TNode extends CommandNode<any>>(node: TNode): ClonedCommandNode<TNode>;
+export declare function cloneCommandNode<TServices extends object>(node: CommandNode<TServices>, scopeOverride: Scope[]): CommandNode<TServices>;
+export declare function getCommandSourcePath(command: Command<any, any, any, any>): string | undefined;
+export declare function hasMcpProxyConfig(group: Group<any>): boolean;
+export { S, toJsonSchema, withStandardSchema } from "./schema.js";
+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, isUserError };
+export { suggest } from "./suggest.js";
+export { createRuntimeLogger, isLogLevel, shouldEmitDiagnostic } from "./runtime-logging.js";
+export { isSensitiveName, redactHttpBody } from "./redaction.js";
+export { asMCPResult } from "./mcp-result.js";
+export type { FileChangeRendererOptions, FileChangeResult } from "./file-change-renderer.js";
+export type { FileChange, FileChangeDisplayMode, FileChangeKind } from "toolcraft-design";
+export type { DiagnosticLogEvent, LogLevel, RuntimeLogger, RuntimeLoggerInput } from "./runtime-logging.js";
+export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonSchemaOptions, Input, Output, StandardSchema, Standardized, StandardIssue, StandardResult, StandardJsonSchemaOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult } from "./schema.js";
+export type { HumanInLoopConfig, HumanInLoopPending, HumanInLoopRuntime };