@kamilio/wire 0.1.9 → 0.1.11

package/node_modules/toolcraft/dist/safe-bash.js

@@ -0,0 +1,226 @@
+import path from "node:path";
+import { cloneDefaultValue, toJsonSchema, validate } from "toolcraft-schema";
+import { executeCLICommand, formatCLIName } from "./cli.js";
+import { validateServices } from "./runtime/io.js";
+/** Checks paths, parameter names and values against a library's inferred definitions. */
+export function toolcraftDefaults(_library, defaults) {
+    // Snapshot configuration so changing the caller's defaults cannot change registered commands.
+    return cloneDefaultValue(defaults);
+}
+function discoverCommands(root, prefix = "") {
+    const commands = new Map();
+    const visit = (node, commandPath) => {
+        if (node.kind === "command") {
+            if (node.scope.includes("cli") && !node.hidden)
+                commands.set(commandPath, node);
+            return;
+        }
+        if (node.scope && !node.scope.includes("cli"))
+            return;
+        for (const child of node.children)
+            visit(child, `${commandPath}${commandPath ? "/" : ""}${child.name}`);
+    };
+    if (!root.scope || root.scope.includes("cli")) {
+        for (const child of root.children)
+            visit(child, `${prefix}${child.name}`);
+    }
+    return commands;
+}
+function visibleLibrary(root) {
+    const aliases = (node) => {
+        const name = formatCLIName(node.name, "kebab");
+        return name === node.name || node.aliases.includes(name) ? [...node.aliases] : [...node.aliases, name];
+    };
+    const children = root.children.filter(child => child.kind === "command"
+        ? child.scope.includes("cli") && !child.hidden
+        : !child.scope || child.scope.includes("cli"))
+        .map(child => child.kind === "group" ? visibleLibrary(child) : { ...child, aliases: aliases(child) });
+    const defaultCommand = children.find(child => child.kind === "command" && child.name === root.default?.name);
+    return { ...root, aliases: aliases(root), children, default: defaultCommand };
+}
+function handlerFileSystem(invocation) {
+    const { fs, signal, cwd } = invocation;
+    const resolve = (value) => path.posix.resolve(cwd, value);
+    return {
+        async readFile(value, encoding = "utf8") {
+            return Buffer.from(await fs.readFile(resolve(value), { signal })).toString(encoding);
+        },
+        async writeFile(value, contents, options = {}) {
+            const bytes = Buffer.from(contents, options.encoding ?? "utf8");
+            const target = resolve(value);
+            const flag = options.flag ?? "w";
+            if (flag === "a")
+                await fs.appendFile(target, bytes, { signal, mode: options.mode });
+            else if (flag === "w" || flag === "wx")
+                await fs.writeFile(target, bytes, { signal, mode: options.mode, flag });
+            else
+                throw new Error(`Unsupported virtual write flag: ${flag}`);
+        },
+        async exists(value) {
+            try {
+                await fs.stat(resolve(value), { signal });
+                return true;
+            }
+            catch (error) {
+                if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT")
+                    return false;
+                throw error;
+            }
+        },
+        async lstat(value) {
+            const stat = await fs.lstat(resolve(value), { signal });
+            return { isSymbolicLink: () => stat.type === "symlink" };
+        },
+        async rename(from, to) { await fs.rename(resolve(from), resolve(to), { signal }); },
+        async unlink(value) {
+            if (!fs.unlink)
+                throw new Error("Virtual filesystem does not support unlink");
+            await fs.unlink(resolve(value), { signal });
+        }
+    };
+}
+function assertNativeSchema(schema, commandPath) {
+    if (schema === null || typeof schema !== "object" || Array.isArray(schema))
+        return;
+    const document = schema;
+    if (document.pattern !== undefined || document.patternProperties !== undefined) {
+        throw new TypeError(`Schema regex validation is unsupported in native Toolcraft commands: ${commandPath}; use the invocation's bounded regex capability in the handler`);
+    }
+    // Visit schema positions only: parameter names and literal defaults are not keywords.
+    for (const key of ["properties", "$defs", "definitions", "dependentSchemas", "dependencies"]) {
+        const map = document[key];
+        if (map !== null && typeof map === "object" && !Array.isArray(map)) {
+            for (const child of Object.values(map))
+                assertNativeSchema(child, commandPath);
+        }
+    }
+    for (const key of ["allOf", "anyOf", "oneOf", "prefixItems", "items", "additionalItems", "additionalProperties", "contains", "if", "then", "else", "not", "propertyNames", "unevaluatedItems", "unevaluatedProperties"]) {
+        const child = document[key];
+        if (Array.isArray(child)) {
+            for (const item of child)
+                assertNativeSchema(item, commandPath);
+        }
+        else
+            assertNativeSchema(child, commandPath);
+    }
+}
+/** Executes already-tokenized argv in process, using the same parser and dispatch as runCLI. */
+export function createToolcraftCommandExecutor(library, options = {}) {
+    const roots = (Array.isArray(library) ? library : [library])
+        .filter(root => !root.scope || root.scope.includes("cli"));
+    const multiple = Array.isArray(library);
+    const commands = new Map(roots.flatMap(root => [...discoverCommands(root, multiple ? `${root.name}/` : "")]));
+    for (const [commandPath, command] of commands) {
+        assertNativeSchema(toJsonSchema(command.params), commandPath);
+        if (command.stream)
+            assertNativeSchema(toJsonSchema(command.stream.event), commandPath);
+    }
+    const defaults = cloneDefaultValue(options.defaults ?? {});
+    for (const [commandPath, values] of Object.entries(defaults)) {
+        const command = commands.get(commandPath);
+        if (!command)
+            throw new TypeError(`Unknown default command path: ${commandPath}`);
+        for (const [key, value] of Object.entries(values)) {
+            if (!Object.prototype.hasOwnProperty.call(command.params.shape, key))
+                throw new TypeError(`Unknown default parameter: ${commandPath}/${key}`);
+            const result = validate(command.params.shape[key], value);
+            if (!result.ok)
+                throw new TypeError(`Invalid default parameter ${commandPath}/${key}: ${result.issues.map(issue => issue.message).join("; ")}`);
+        }
+    }
+    if (options.services && typeof options.services !== "function")
+        validateServices(options.services);
+    return {
+        async execute(argv, invocation) {
+            invocation.signal.throwIfAborted();
+            let services;
+            let root;
+            try {
+                const configuredServices = typeof options.services === "function" ? options.services(invocation) : options.services;
+                services = { ...configuredServices, ...invocation.services };
+                const rootName = multiple ? argv[0] : roots[0]?.name;
+                const selectedRoot = multiple ? roots.find(candidate => candidate.name === rootName || formatCLIName(candidate.name, "kebab") === rootName || candidate.aliases.includes(rootName ?? "")) : roots[0];
+                if (!selectedRoot)
+                    throw new TypeError(`Unknown toolcraft root: ${rootName}`);
+                root = selectedRoot;
+            }
+            catch (error) {
+                invocation.signal.throwIfAborted();
+                await invocation.stderr.write(new TextEncoder().encode(`${error instanceof Error ? error.message : String(error)}\n`));
+                return { exitCode: 1 };
+            }
+            const args = multiple ? argv.slice(1) : argv;
+            let pending = Promise.resolve();
+            let queuedBytes = 0;
+            const runtime = {
+                signal: invocation.signal,
+                exitCode: 0,
+                defaults: multiple ? Object.fromEntries(Object.entries(defaults).filter(([key]) => key.startsWith(`${root.name}/`)).map(([key, value]) => [key.slice(root.name.length + 1), value])) : defaults,
+                capabilities: { signal: invocation.signal, stdin: invocation.stdin, stdout: invocation.stdout, stderr: invocation.stderr, cwd: invocation.cwd, regex: invocation.regex, registerCleanup: invocation.registerCleanup, invoke: invocation.invoke, inputBudget: invocation.inputBudget },
+                write(chunk, stream = "stdout") {
+                    invocation.signal.throwIfAborted();
+                    const bytes = new TextEncoder().encode(chunk);
+                    queuedBytes += bytes.byteLength;
+                    if (queuedBytes > 1024 * 1024)
+                        throw new Error("Toolcraft synchronous output exceeded 1 MiB; use a streaming command for larger output");
+                    pending = pending.then(async () => {
+                        invocation.signal.throwIfAborted();
+                        await invocation[stream].write(bytes);
+                        queuedBytes -= bytes.byteLength;
+                    });
+                    // The awaited flush propagates sink failures; observe immediately to avoid unhandled rejections.
+                    void pending.catch(() => { });
+                },
+                async flush() { await pending; }
+            };
+            const deniedFetch = async () => { throw new Error("Network capability is unavailable for this invocation"); };
+            await executeCLICommand(visibleLibrary(root), {
+                argv: ["toolcraft", root.name, ...args],
+                rootUsageName: root.name,
+                version: options.version,
+                apiVersion: options.apiVersion,
+                services: services,
+                env: { ...invocation.env },
+                fs: handlerFileSystem(invocation),
+                fetch: invocation.fetch ?? deniedFetch,
+                humanInLoop: Object.prototype.hasOwnProperty.call(invocation, "humanInLoop") ? invocation.humanInLoop : options.humanInLoop,
+                controls: { output: true, yes: true, ...options.controls },
+                errorReports: false,
+                outputEmitter: entry => runtime.write(`${entry}\n`)
+            }, runtime);
+            return { exitCode: runtime.exitCode };
+        }
+    };
+}
+/** Registers every CLI-visible root and alias; nested commands use shared Toolcraft discovery. */
+export function toolcraftCommands(library, options = {}) {
+    const executor = createToolcraftCommandExecutor(library, options);
+    const roots = Array.isArray(library) ? library : [library];
+    return {
+        name: "toolcraft",
+        setup(host) {
+            if (typeof host.provideCapabilities !== "function")
+                throw new Error("Toolcraft requires a safe-bash runtime with invocation capabilities");
+            for (const root of roots) {
+                if (root.scope && !root.scope.includes("cli"))
+                    continue;
+                for (const name of new Set([root.name, formatCLIName(root.name, "kebab"), ...root.aliases])) {
+                    host.commands.register({
+                        name,
+                        description: root.description,
+                        execute(context) {
+                            const capabilities = context.capabilities;
+                            return executor.execute(Array.isArray(library) ? [root.name, ...context.args] : context.args, {
+                                ...context,
+                                services: capabilities?.services,
+                                fetch: capabilities?.fetch,
+                                regex: capabilities?.regex,
+                                ...(Object.prototype.hasOwnProperty.call(capabilities ?? {}, "humanInLoop") ? { humanInLoop: capabilities?.humanInLoop } : {})
+                            });
+                        }
+                    });
+                }
+            }
+        }
+    };
+}

package/node_modules/toolcraft/dist/schema-member-names.d.ts

@@ -0,0 +1,2 @@
+import type { AnySchema } from "toolcraft-schema";
+export declare function validateCasedSchemaMembers(schema: AnySchema, formatMember: (key: string) => string, surface: "SDK member" | "MCP field", discriminator?: string): void;

package/node_modules/toolcraft/dist/schema-member-names.js

@@ -0,0 +1,39 @@
+import { UserError } from "./user-error.js";
+export function validateCasedSchemaMembers(schema, formatMember, surface, discriminator) {
+    switch (schema.kind) {
+        case "optional":
+            validateCasedSchemaMembers(schema.inner, formatMember, surface, discriminator);
+            return;
+        case "array":
+            validateCasedSchemaMembers(schema.item, formatMember, surface);
+            return;
+        case "record":
+            validateCasedSchemaMembers(schema.value, formatMember, surface);
+            return;
+        case "union":
+            for (const branch of schema.branches) {
+                validateCasedSchemaMembers(branch, formatMember, surface);
+            }
+            return;
+        case "oneOf":
+            for (const branch of Object.values(schema.branches)) {
+                validateCasedSchemaMembers(branch, formatMember, surface, schema.discriminator);
+            }
+            return;
+        case "object": {
+            const sourceKeysByMember = new Map();
+            if (discriminator !== undefined) {
+                sourceKeysByMember.set(formatMember(discriminator), discriminator);
+            }
+            for (const [key, child] of Object.entries(schema.shape)) {
+                const member = formatMember(key);
+                const existingKey = sourceKeysByMember.get(member);
+                if (existingKey !== undefined) {
+                    throw new UserError(`Parameters "${existingKey}" and "${key}" use conflicting ${surface} "${member}".`);
+                }
+                sourceKeysByMember.set(member, key);
+                validateCasedSchemaMembers(child, formatMember, surface);
+            }
+        }
+    }
+}

package/node_modules/toolcraft/dist/schema-scope.d.ts

@@ -1,4 +1,5 @@
 import type { AnySchema } from "toolcraft-schema";
 type SchemaScope = "cli" | "mcp" | "sdk";
 export declare function filterSchemaForScope(schema: AnySchema, scope: SchemaScope): AnySchema | undefined;
+export declare function getUnfilteredSchema(schema: AnySchema): AnySchema;
 export {};

package/node_modules/toolcraft/dist/schema-scope.js

@@ -1,4 +1,15 @@
+const unfilteredSchemas = new WeakMap();
 export function filterSchemaForScope(schema, scope) {
+    const filtered = filterScopedSchema(schema, scope);
+    if (filtered !== undefined && filtered !== schema && schema.kind !== "optional") {
+        unfilteredSchemas.set(filtered, unfilteredSchemas.get(schema) ?? schema);
+    }
+    return filtered;
+}
+export function getUnfilteredSchema(schema) {
+    return unfilteredSchemas.get(schema) ?? schema;
+}
+function filterScopedSchema(schema, scope) {
     if (schema.scope !== undefined && !schema.scope.includes(scope)) {
         return undefined;
     }
@@ -27,22 +38,24 @@ export function filterSchemaForScope(schema, scope) {
             const value = filterSchemaForScope(schema.value, scope);
             return value === undefined ? undefined : { ...schema, value };
         }
-        case "oneOf":
-            return {
-                ...schema,
-                branches: Object.fromEntries(Object.entries(schema.branches).flatMap(([name, branch]) => {
-                    const filtered = filterSchemaForScope(branch, scope);
-                    return filtered?.kind === "object" ? [[name, filtered]] : [];
-                }))
-            };
-        case "union":
-            return {
-                ...schema,
-                branches: schema.branches.flatMap((branch) => {
-                    const filtered = filterSchemaForScope(branch, scope);
-                    return filtered?.kind === "object" ? [filtered] : [];
-                })
-            };
+        case "oneOf": {
+            const branches = Object.fromEntries(Object.entries(schema.branches).flatMap(([name, branch]) => {
+                const filtered = filterSchemaForScope(branch, scope);
+                return filtered?.kind === "object" ? [[name, filtered]] : [];
+            }));
+            return Object.keys(branches).length === 0 && schema.nullable !== true
+                ? undefined
+                : { ...schema, branches };
+        }
+        case "union": {
+            const branches = schema.branches.flatMap((branch) => {
+                const filtered = filterSchemaForScope(branch, scope);
+                return filtered?.kind === "object" ? [filtered] : [];
+            });
+            return branches.length === 0 && schema.nullable !== true
+                ? undefined
+                : { ...schema, branches };
+        }
         case "object":
             return {
                 ...schema,

package/node_modules/toolcraft/dist/schema-standard.compile-check.js

@@ -0,0 +1,4 @@
+import { S } from "./index.js";
+import { withStandardSchema } from "./schema.js";
+const ignoredSchema = S.Object({ limit: S.Optional(S.Number({ default: 10 })) });
+withStandardSchema(structuredClone(ignoredSchema));

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

@@ -0,0 +1,2 @@
+export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate, withStandardSchema } from "toolcraft-schema";
+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 "toolcraft-schema";

package/node_modules/toolcraft/dist/schema.js

@@ -0,0 +1 @@
+export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate, withStandardSchema } from "toolcraft-schema";

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

@@ -33,6 +33,17 @@ const ignoredRoot = defineGroup({
                                 apiKey: params.APIKey,
                             }),
                         }),
+                        defineCommand({
+                            name: "json-payload",
+                            scope: ["sdk"],
+                            params: S.Object({
+                                payload_json: S.Json(),
+                                items_by_id: S.Record(S.Object({
+                                    display_name: S.String(),
+                                })),
+                            }),
+                            handler: async ({ params }) => params,
+                        }),
                         defineCommand({
                             name: "cli-only",
                             scope: ["cli"],
@@ -95,7 +106,10 @@ const ignoredOptions = {
     services: {
         logger: console,
     },
-    humanInLoop: {},
+    humanInLoop: {
+        invoke: async (node, ctx) => node.handler(ctx),
+        mergeApprovalsGroup: (root) => root,
+    },
 };
 const ignoredSdk = createSDK(ignoredRoot, ignoredOptions);
 const ignoredResult = ignoredSdk.poeCode.generate.text({
@@ -113,6 +127,22 @@ const ignoredHttpServerResult = ignoredSdk.poeCode.generate.httpServer({
 void ignoredHttpServerResult.then((value) => {
     void value.apiKey;
 });
+void ignoredSdk.poeCode.generate.jsonPayload({
+    payloadJson: {
+        file_upload: "upload-1",
+        nested_value: { preserve_this_key: true },
+    },
+    itemsById: {
+        "item-1": { displayName: "One" },
+    },
+});
+ignoredSdk.poeCode.generate.jsonPayload({
+    payloadJson: null,
+    itemsById: {
+        // @ts-expect-error declared fields inside arbitrary-key records are still camel-cased
+        "item-1": { display_name: "One" },
+    },
+});
 const ignoredQueuedResult = ignoredSdk.poeCode.generate.queued({
     promptText: "hello",
 });

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

@@ -1,7 +1,12 @@
+import "./node-require-shim.js";
 import type { ObjectSchema, Static } from "toolcraft-schema";
-import type { Group, LogLevel, RuntimeLoggerInput, Scope } from "./index.js";
+import type { Group, HandlerFs, LogLevel, RuntimeLoggerInput, Scope } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.js";
-import type { HumanInLoopPending, HumanInLoopRuntimeOptions } from "./human-in-loop/index.js";
+import type { HumanInLoopPending, HumanInLoopRuntime } from "./human-in-loop/types.js";
+import { mergeApprovalsRoot } from "./human-in-loop/wiring.js";
+import { type ValidationError } from "./validation-errors.js";
+import type { StreamConsumerOptions, ToolcraftStream } from "./stream.js";
+export { mergeApprovalsRoot };
 type ScopeInput = readonly Scope[] | undefined;
 type HumanInLoopMode = "sync" | "async";
 type HumanInLoopModeInput = HumanInLoopMode | null | undefined;
@@ -27,11 +32,13 @@ type CapitalizeJoinCamelWords<TWords extends readonly string[]> = TWords extends
     ...infer TTail extends readonly string[]
 ] ? `${Capitalize<THead>}${CapitalizeJoinCamelWords<TTail>}` : "";
 type CamelCase<TValue extends string> = JoinCamelWords<SplitCamelWords<TValue>>;
-type Camelize<TValue> = TValue extends Primitive ? TValue : TValue extends readonly (infer TItem)[] ? Array<Camelize<TItem>> : TValue extends object ? {
+type Camelize<TValue> = TValue extends Primitive ? TValue : TValue extends readonly (infer TItem)[] ? Array<Camelize<TItem>> : TValue extends object ? string extends keyof TValue ? {
+    [TKey in keyof TValue]: Camelize<TValue[TKey]>;
+} : {
     [TKey in keyof TValue as TKey extends string ? CamelCase<TKey> : TKey]: Camelize<TValue[TKey]>;
 } : TValue;
-type SDKResult<TResult, THumanInLoopMode extends HumanInLoopMode | undefined> = THumanInLoopMode extends "async" ? HumanInLoopPending : TResult;
-type SDKMethod<TParamsSchema extends ObjectSchema<any>, TResult> = (params: Camelize<Static<TParamsSchema>>) => Promise<TResult>;
+type SDKResult<TResult, THumanInLoopMode extends HumanInLoopMode | undefined> = [THumanInLoopMode] extends ["async"] ? ["async"] extends [THumanInLoopMode] ? HumanInLoopPending : TResult : TResult;
+type SDKMethod<TParamsSchema extends ObjectSchema<any>, TResult> = TResult extends ToolcraftStream<infer TEvent> ? (params: Camelize<Static<TParamsSchema>>, options?: StreamConsumerOptions) => ToolcraftStream<TEvent> : (params: Camelize<Static<TParamsSchema>>) => Promise<TResult>;
 type UnionToIntersection<TValue> = (TValue extends unknown ? (value: TValue) => void : never) extends (value: infer TResult) => void ? TResult : never;
 type Simplify<TValue> = {
     [TKey in keyof TValue]: TValue[TKey];
@@ -62,20 +69,22 @@ type SDKNodeShape<TNode, TInheritedScope extends ScopeInput, TInheritedHumanInLo
 type SDKChildrenShape<TChildren, TInheritedScope extends ScopeInput, TInheritedHumanInLoopMode extends HumanInLoopMode | undefined> = Simplify<UnionToIntersection<SDKNodeShape<RawChildrenValue<TChildren>, TInheritedScope, TInheritedHumanInLoopMode>>>;
 export interface CreateSDKOptions<TServices extends object = Record<string, unknown>> {
     approvals?: boolean;
+    env?: Record<string, string>;
     fetch?: typeof globalThis.fetch;
+    fs?: HandlerFs;
     services?: TServices;
     casing?: "camel";
-    humanInLoop?: HumanInLoopRuntimeOptions;
+    humanInLoop?: HumanInLoopRuntime;
     apiVersion?: string;
     projectRoot?: string;
     errorReports?: ErrorReportsOption;
     logLevel?: LogLevel;
     logger?: RuntimeLoggerInput;
 }
-export declare function createSDK<TRootInfo, TServices extends object = Record<string, unknown>>(root: Group<any> & {
-    readonly __agentKitGroupTypeInfo: TRootInfo;
-}, options?: CreateSDKOptions<TServices>): TRootInfo extends {
-    children: infer TChildren extends readonly unknown[];
-} ? SDKChildrenShape<TChildren, undefined, undefined> : EmptyRecord;
-export declare function createSDK<TServices extends object = Record<string, unknown>>(root: Group<TServices>, options?: CreateSDKOptions<TServices>): Record<string, unknown>;
-export {};
+export declare function validateObjectSchema(schema: ObjectSchema<any>, value: unknown, label: string, errors: ValidationError[]): Record<string, unknown>;
+type SDKRootShape<TRoot> = TRoot extends {
+    readonly __agentKitGroupTypeInfo: {
+        children: infer TChildren extends readonly unknown[];
+    };
+} ? SDKChildrenShape<TChildren, undefined, undefined> : Record<string, unknown>;
+export declare function createSDK<TRoot extends Group<any>, TServices extends object = Record<string, unknown>>(root: TRoot, options?: CreateSDKOptions<TServices>): SDKRootShape<TRoot>;