toolcraft 0.0.232 → 0.0.233

package/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/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: "{}" });
@@ -135,23 +146,23 @@ function stackedList(value) {
 function displayRowValue(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}`,
@@ -161,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: stackedList(value) }));
+        .map(([key, value]) => ({ label: labels.get(key), value: stackedList(value) }));
     return renderDetailCard({
         theme: primitives.getTheme(),
         title,
@@ -304,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");
         }
@@ -330,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/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/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/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/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/dist/schema.d.ts

@@ -1,2 +1,2 @@
 export { Json, OneOf, Record, S, Union, toJsonSchema, toJsonSchemaDocument, validate } from "toolcraft-schema";
-export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationResult } from "toolcraft-schema";
+export type { AnySchema, ArraySchema, BooleanSchema, CliMissingParameterChoice, CliMissingParameterContext, CliMissingParameterResolution, CliOutputMode, CliSchemaOptions, EnumSchema, JsonSchema, JsonSchemaDocument, JsonSchemaDocumentOptions, JsonValue, JsonValueSchema, NumberSchema, ObjectSchema, OneOfSchema, OptionalSchema, RecordSchema, SchemaBase, Static, StringSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult } from "toolcraft-schema";

package/dist/sdk.d.ts

@@ -3,8 +3,10 @@ import type { ObjectSchema, Static } from "toolcraft-schema";
 import type { Group, HandlerFs, LogLevel, RuntimeLoggerInput, Scope } from "./index.js";
 import { type ErrorReportsOption } from "./error-report.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;
@@ -86,4 +88,3 @@ type SDKRootShape<TRoot> = TRoot extends {
     };
 } ? 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>;
-export {};