@transloadit/zod 4.4.1 → 5.0.0

package/dist/v4/aiMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiMessages.d.ts","sourceRoot":"","sources":["../../src/v4/aiMessages.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AAEhC,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAsC,CAAA;AAkQvF,sGAAsG;AACtG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAQ5D;AAED,eAAO,MAAM,sBAAsB;;;;;;;iBAOjC,CAAA;AAEF;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,SAAS,CAAC,CAAC,OAAO,EACtB,QAAQ,SAAS,CAAC,CAAC,OAAO,EAC1B,IAAI,SAAS,CAAC,CAAC,OAAO,EACtB,eAAe,SAAS,CAAC,CAAC,OAAO,EAEjC,gBAAgB,EAAE,IAAI,EACtB,kBAAkB,EAAE,QAAQ,EAC5B,eAAe,EAAE,IAAI,EACrB,sBAAsB,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsOxC;AAED,qEAAqE;AACrE,wBAAgB,6BAA6B,CAC3C,IAAI,SAAS,CAAC,CAAC,OAAO,EACtB,QAAQ,SAAS,CAAC,CAAC,OAAO,EAC1B,IAAI,SAAS,CAAC,CAAC,OAAO,EACtB,eAAe,SAAS,CAAC,CAAC,OAAO,EAEjC,gBAAgB,EAAE,IAAI,EACtB,kBAAkB,EAAE,QAAQ,EAC5B,eAAe,EAAE,IAAI,EACrB,sBAAsB,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAQxC"}

package/dist/v4/aiMessages.js

@@ -0,0 +1,479 @@
+import { optionalWithV3Semantics } from "./lib/sdkZodOptional.js";
+import { z } from 'zod/v4';
+import { isRecord } from "./object.js";
+export const jsonValueSchema = z.lazy(() => jsonValueUnionSchema);
+const jsonValueUnionSchema = z.union([
+    z.string(),
+    z.number().finite(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+]);
+// Define provider options schema to match the AI SDK.
+const providerMetadataSchema = optionalWithV3Semantics(z.record(z.string(), z.record(z.string(), jsonValueSchema)));
+function* legacyRecordEntries(value) {
+    // Zod records also validate inherited enumerable properties, unlike JSON.stringify.
+    for (const key in value) {
+        yield [key, value[key]];
+    }
+}
+function legacyJsonFrame(value) {
+    if (Array.isArray(value)) {
+        // Zod arrays consume the iterator, ignoring non-element properties.
+        const copy = [...value];
+        return { source: value, copy, entries: copy.entries(), depth: 1, values: 1 };
+    }
+    if (isRecord(value) && ['object', 'file'].includes(z.core.util.getParsedType(value))) {
+        return { source: value, copy: {}, entries: legacyRecordEntries(value), depth: 1, values: 1 };
+    }
+    // Preserve non-JSON objects (Date, Map, promises, etc.) for Zod to reject, not coerce.
+    return undefined;
+}
+function snapshotLegacyJson(result, limits) {
+    const root = legacyJsonFrame(result);
+    if (root === undefined) {
+        return { value: result };
+    }
+    const ancestors = new WeakSet([root.source]);
+    const snapshots = new WeakMap([[root.source, root]]);
+    const stack = [root];
+    // An iterative snapshot avoids both recursive cycle checking and reading getters twice
+    // (once in a preflight walk, then again with potentially different values inside Zod).
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        if (limits !== undefined &&
+            (stack.length + frame.depth - 1 > limits.depth || frame.values > limits.values)) {
+            return undefined;
+        }
+        const entry = frame.entries.next();
+        if (entry.done) {
+            ancestors.delete(frame.source);
+            stack.pop();
+            const parent = stack[stack.length - 1];
+            if (parent !== undefined) {
+                parent.depth = Math.max(parent.depth, frame.depth + 1);
+                parent.values += frame.values;
+            }
+            continue;
+        }
+        const [key, value] = entry.value;
+        if (typeof value === 'object' && value !== null && ancestors.has(value)) {
+            return undefined;
+        }
+        // Preserve graph sharing so a small DAG cannot expand exponentially before Zod runs.
+        // A shared object's getters deliberately contribute one stable snapshot, not one per path.
+        const existing = typeof value === 'object' && value !== null ? snapshots.get(value) : undefined;
+        const child = existing === undefined ? legacyJsonFrame(value) : undefined;
+        // Defining a data property preserves a literal __proto__ key for Zod's own handling.
+        Object.defineProperty(frame.copy, key, {
+            configurable: true,
+            enumerable: true,
+            value: existing?.copy ?? child?.copy ?? value,
+            writable: true,
+        });
+        if (child !== undefined) {
+            snapshots.set(child.source, child);
+            ancestors.add(child.source);
+            stack.push(child);
+        }
+        else {
+            frame.depth = Math.max(frame.depth, (existing?.depth ?? 0) + 1);
+            frame.values += existing?.values ?? 1;
+        }
+    }
+    return { value: root.copy };
+}
+/** Normalizes legacy JSON/text tool results at both the runtime and portable Robot boundaries. */
+function legacyJsonToolOutput(result, isError) {
+    try {
+        const snapshot = snapshotLegacyJson(result);
+        const parsed = snapshot === undefined ? undefined : jsonValueSchema.safeParse(snapshot.value);
+        if (parsed?.success) {
+            return { type: isError ? 'error-json' : 'json', value: parsed.data };
+        }
+    }
+    catch {
+        // Accessors can throw; deeply nested acyclic input can still exceed Zod's stack.
+        // Keep the existing text fallback without using a stack overflow to detect cycles.
+    }
+    return { type: isError ? 'error-text' : 'text', value: stringifyLegacyToolResult(result) };
+}
+function withCurrentProviderOptions(value) {
+    const { experimental_providerMetadata, providerOptions: currentProviderOptions, ...rest } = value;
+    const providerOptions = currentProviderOptions ?? experimental_providerMetadata;
+    return providerOptions === undefined ? rest : { ...rest, providerOptions };
+}
+function legacyToolContentProviderOptions(value) {
+    if (value === undefined)
+        return {};
+    try {
+        // Bound Zod's recursive work, including repeated DAG paths, before validating metadata.
+        // Return the validated snapshot so changing getters cannot reintroduce cycles afterward.
+        const snapshot = snapshotLegacyJson(value, { depth: 128, values: 10_000 });
+        if (snapshot === undefined)
+            return undefined;
+        const parsed = providerMetadataSchema.safeParse(snapshot.value);
+        return parsed.success ? { providerOptions: parsed.data } : undefined;
+    }
+    catch {
+        // Unreadable metadata follows the same legacy result fallback as invalid content.
+        return undefined;
+    }
+}
+function normalizeLegacyToolContentPart(part) {
+    if (!isRecord(part))
+        return undefined;
+    const normalized = withCurrentProviderOptions(part);
+    const providerOptions = legacyToolContentProviderOptions(normalized.providerOptions);
+    if (providerOptions === undefined)
+        return undefined;
+    if (normalized.type === 'text' && typeof normalized.text === 'string') {
+        return { type: 'text', text: normalized.text, ...providerOptions };
+    }
+    if (normalized.type === 'image' && typeof normalized.data === 'string') {
+        return {
+            type: 'image-data',
+            data: normalized.data,
+            mediaType: typeof normalized.mimeType === 'string' ? normalized.mimeType : 'image',
+            ...providerOptions,
+        };
+    }
+    if (normalized.type === 'media' &&
+        typeof normalized.data === 'string' &&
+        typeof normalized.mediaType === 'string') {
+        return {
+            type: 'file-data',
+            data: normalized.data,
+            mediaType: normalized.mediaType,
+            ...providerOptions,
+        };
+    }
+    return undefined;
+}
+function legacyToolOutput(result, isError, experimentalContent) {
+    if (!isError && Array.isArray(experimentalContent)) {
+        const content = experimentalContent.flatMap((part) => {
+            const normalized = normalizeLegacyToolContentPart(part);
+            return normalized === undefined ? [] : [normalized];
+        });
+        if (content.length === experimentalContent.length) {
+            return { type: 'content', value: content };
+        }
+    }
+    return legacyJsonToolOutput(result, isError);
+}
+function stringifyLegacyToolResult(result) {
+    try {
+        const serialized = JSON.stringify(result);
+        if (serialized !== undefined) {
+            return serialized;
+        }
+    }
+    catch {
+        // Fall back to the platform string representation for circular or unsupported values.
+    }
+    return String(result);
+}
+function normalizeMessagePart(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const normalized = withCurrentProviderOptions(value);
+    if (normalized.type === 'image' && !('mediaType' in normalized) && 'mimeType' in normalized) {
+        const { mimeType, ...rest } = normalized;
+        return { ...rest, mediaType: mimeType };
+    }
+    if (normalized.type === 'media' &&
+        typeof normalized.data === 'string' &&
+        typeof normalized.mediaType === 'string') {
+        const { data, mediaType, type: _type, ...rest } = normalized;
+        return { ...rest, type: 'file', data: { type: 'data', data }, mediaType };
+    }
+    if (normalized.type === 'tool-call' && !('input' in normalized) && 'args' in normalized) {
+        const { args, ...rest } = normalized;
+        return { ...rest, input: args };
+    }
+    if (normalized.type === 'tool-result' && 'output' in normalized) {
+        const output = normalized.output;
+        if (isRecord(output) && output.type === 'content' && Array.isArray(output.value)) {
+            return {
+                ...normalized,
+                output: {
+                    ...output,
+                    value: output.value.map((part) => {
+                        const converted = normalizeLegacyToolContentPart(part);
+                        if (converted !== undefined)
+                            return converted;
+                        // Explicit output has no result fallback. Reject invalid legacy-shaped content;
+                        // returning it unchanged would strip its metadata alias or recurse into cycles.
+                        // Every content variant requires a literal type, so this untagged sentinel rejects.
+                        if (isRecord(part) &&
+                            (part.type === 'text' || part.type === 'image' || part.type === 'media')) {
+                            return z.NEVER;
+                        }
+                        return part;
+                    }),
+                },
+            };
+        }
+    }
+    if (normalized.type === 'tool-result' && !('output' in normalized)) {
+        const { experimental_content: experimentalContent, isError, result, ...rest } = normalized;
+        return {
+            ...rest,
+            output: legacyToolOutput(result, isError === true, experimentalContent),
+        };
+    }
+    return normalized;
+}
+/** Accepts legacy provider metadata and message parts before validating the current message shape. */
+export function normalizeCoreMessage(value) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    const normalized = withCurrentProviderOptions(value);
+    return Array.isArray(normalized.content)
+        ? { ...normalized, content: normalized.content.map(normalizeMessagePart) }
+        : normalized;
+}
+export const toolCallPartBaseSchema = z.object({
+    type: z.literal('tool-call'),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    input: z.unknown(),
+    providerOptions: providerMetadataSchema,
+    providerExecuted: optionalWithV3Semantics(z.boolean()),
+});
+/**
+ * Shares message compatibility without pulling server AI clients or Node globals into the SDK.
+ * Inference retains each caller's binary union and tool-call output through both Zod versions.
+ */
+export function createCoreMessageSchemas(inlineDataSchema, toolCallPartSchema, jsonValueSchema, providerMetadataSchema) {
+    const providerReferenceSchema = z.record(z.string(), z.string());
+    const taggedFileDataSchema = z.discriminatedUnion('type', [
+        z.object({ type: z.literal('data'), data: inlineDataSchema }),
+        z.object({ type: z.literal('url'), url: z.instanceof(URL) }),
+        z.object({ type: z.literal('reference'), reference: providerReferenceSchema }),
+        z.object({ type: z.literal('text'), text: z.string() }),
+    ]);
+    const taggedReasoningFileDataSchema = z.discriminatedUnion('type', [
+        z.object({ type: z.literal('data'), data: inlineDataSchema }),
+        z.object({ type: z.literal('url'), url: z.instanceof(URL) }),
+    ]);
+    const textPartSchema = z.object({
+        type: z.literal('text'),
+        text: z.string(),
+        providerOptions: providerMetadataSchema,
+    });
+    const imagePartSchema = z.object({
+        type: z.literal('image'),
+        image: z.union([inlineDataSchema, z.instanceof(URL), providerReferenceSchema]),
+        mediaType: optionalWithV3Semantics(z.string()),
+        providerOptions: providerMetadataSchema,
+    });
+    const filePartSchema = z.object({
+        type: z.literal('file'),
+        data: z.union([
+            taggedFileDataSchema,
+            inlineDataSchema,
+            z.instanceof(URL),
+            providerReferenceSchema,
+        ]),
+        filename: optionalWithV3Semantics(z.string()),
+        mediaType: z.string(),
+        providerOptions: providerMetadataSchema,
+    });
+    const reasoningPartSchema = z.object({
+        type: z.literal('reasoning'),
+        text: z.string(),
+        providerOptions: providerMetadataSchema,
+    });
+    function isCustomKind(value) {
+        return value.includes('.');
+    }
+    const customPartSchema = z.object({
+        type: z.literal('custom'),
+        kind: z.string().refine(isCustomKind),
+        providerOptions: providerMetadataSchema,
+    });
+    const reasoningFilePartSchema = z.object({
+        type: z.literal('reasoning-file'),
+        data: z.union([taggedReasoningFileDataSchema, inlineDataSchema, z.instanceof(URL)]),
+        mediaType: z.string(),
+        providerOptions: providerMetadataSchema,
+    });
+    const toolOutputSchema = z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('text'),
+            value: z.string(),
+            providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+            type: z.literal('json'),
+            value: jsonValueSchema,
+            providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+            type: z.literal('execution-denied'),
+            reason: optionalWithV3Semantics(z.string()),
+            providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+            type: z.literal('error-text'),
+            value: z.string(),
+            providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+            type: z.literal('error-json'),
+            value: jsonValueSchema,
+            providerOptions: providerMetadataSchema,
+        }),
+        z.object({
+            type: z.literal('content'),
+            value: z.array(z.union([
+                z.object({
+                    type: z.literal('text'),
+                    text: z.string(),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('file'),
+                    data: taggedFileDataSchema,
+                    mediaType: z.string(),
+                    filename: optionalWithV3Semantics(z.string()),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('file-data'),
+                    data: z.string(),
+                    mediaType: z.string(),
+                    filename: optionalWithV3Semantics(z.string()),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('file-url'),
+                    url: z.string(),
+                    mediaType: optionalWithV3Semantics(z.string()),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('file-id'),
+                    fileId: z.union([z.string(), providerReferenceSchema]),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('file-reference'),
+                    providerReference: providerReferenceSchema,
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('image-data'),
+                    data: z.string(),
+                    mediaType: z.string(),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('image-url'),
+                    url: z.string(),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('image-file-id'),
+                    fileId: z.union([z.string(), providerReferenceSchema]),
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({
+                    type: z.literal('image-file-reference'),
+                    providerReference: providerReferenceSchema,
+                    providerOptions: providerMetadataSchema,
+                }),
+                z.object({ type: z.literal('custom'), providerOptions: providerMetadataSchema }),
+            ])),
+        }),
+    ]);
+    const toolResultPartSchema = z.object({
+        type: z.literal('tool-result'),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        output: toolOutputSchema,
+        providerOptions: providerMetadataSchema,
+    });
+    const toolApprovalRequestSchema = z.object({
+        type: z.literal('tool-approval-request'),
+        approvalId: z.string(),
+        toolCallId: z.string(),
+        isAutomatic: optionalWithV3Semantics(z.boolean()),
+        signature: optionalWithV3Semantics(z.string()),
+    });
+    const toolApprovalResponseSchema = z.object({
+        type: z.literal('tool-approval-response'),
+        approvalId: z.string(),
+        approved: z.boolean(),
+        reason: optionalWithV3Semantics(z.string()),
+        providerExecuted: optionalWithV3Semantics(z.boolean()),
+    });
+    const coreSystemMessageSchema = z.object({
+        role: z.literal('system'),
+        content: z.string(),
+        providerOptions: providerMetadataSchema,
+    });
+    const coreUserMessageSchema = z.object({
+        role: z.literal('user'),
+        content: z.union([
+            z.string(),
+            z.array(z.union([textPartSchema, imagePartSchema, filePartSchema])),
+        ]),
+        providerOptions: providerMetadataSchema,
+    });
+    const coreAssistantMessageSchema = z.object({
+        role: z.literal('assistant'),
+        content: z.union([
+            z.string(),
+            z.array(z.union([
+                textPartSchema,
+                customPartSchema,
+                filePartSchema,
+                reasoningPartSchema,
+                reasoningFilePartSchema,
+                toolCallPartSchema,
+                toolResultPartSchema,
+                toolApprovalRequestSchema,
+            ])),
+        ]),
+        providerOptions: providerMetadataSchema,
+    });
+    const coreToolMessageSchema = z.object({
+        role: z.literal('tool'),
+        content: z.array(z.union([toolResultPartSchema, toolApprovalResponseSchema])),
+        providerOptions: providerMetadataSchema,
+    });
+    const outputSchema = z.discriminatedUnion('role', [
+        coreSystemMessageSchema,
+        coreUserMessageSchema,
+        coreAssistantMessageSchema,
+        coreToolMessageSchema,
+    ]);
+    return {
+        outputSchema,
+        coreSystemMessageSchema,
+        coreUserMessageSchema,
+        coreAssistantMessageSchema,
+        coreToolMessageSchema,
+        textPartSchema,
+        imagePartSchema,
+        filePartSchema,
+        customPartSchema,
+        reasoningPartSchema,
+        reasoningFilePartSchema,
+        toolCallPartSchema,
+        toolResultPartSchema,
+        toolApprovalRequestSchema,
+        toolApprovalResponseSchema,
+        toolOutputSchema,
+    };
+}
+/** Build the validated current message shape for runtime callers. */
+export function createCoreMessageOutputSchema(inlineDataSchema, toolCallPartSchema, jsonValueSchema, providerMetadataSchema) {
+    return createCoreMessageSchemas(inlineDataSchema, toolCallPartSchema, jsonValueSchema, providerMetadataSchema).outputSchema;
+}

package/dist/v4/apiParameterDescription.d.ts

@@ -0,0 +1,14 @@
+import type { z } from 'zod/v4';
+/** Portable copy paired with the publisher's richer glossary rendering. */
+export interface ApiParameterDescriptionSource {
+    readonly commonMark: string;
+    readonly referenceMarkdown: string;
+}
+export type ApiParameterDescription = string | ApiParameterDescriptionSource;
+/** Keep useful parameter help without importing API2's translation identity registry. */
+export declare function describeApiParameter<Schema extends z.ZodTypeAny>(_descriptionId: string, schema: Schema, description: ApiParameterDescription): Schema;
+/** Preserve portable help when rebuilding a schema, without publication-only metadata. */
+export declare function inheritApiParameterDescription<Schema extends z.ZodTypeAny>(source: z.ZodTypeAny, target: Schema): Schema;
+/** Attach available field help while retaining the original shape's types and runtime behavior. */
+export declare function describeApiParameterFields<Shape extends Record<string, z.ZodTypeAny>>(scope: string, shape: Shape, descriptions: Readonly<Partial<Record<string, ApiParameterDescription>>>): Shape;
+//# sourceMappingURL=apiParameterDescription.d.ts.map

package/dist/v4/apiParameterDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiParameterDescription.d.ts","sourceRoot":"","sources":["../../src/v4/apiParameterDescription.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,2EAA2E;AAC3E,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACnC;AAED,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,6BAA6B,CAAA;AAE5E,yFAAyF;AACzF,wBAAgB,oBAAoB,CAAC,MAAM,SAAS,CAAC,CAAC,UAAU,EAC9D,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,uBAAuB,GACnC,MAAM,CAER;AAED,0FAA0F;AAC1F,wBAAgB,8BAA8B,CAAC,MAAM,SAAS,CAAC,CAAC,UAAU,EACxE,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED,mGAAmG;AACnG,wBAAgB,0BAA0B,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,EACnF,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACvE,KAAK,CAQP"}

package/dist/v4/apiParameterDescription.js

@@ -0,0 +1,19 @@
+/** Keep useful parameter help without importing API2's translation identity registry. */
+export function describeApiParameter(_descriptionId, schema, description) {
+    return schema.describe(typeof description === 'string' ? description : description.commonMark);
+}
+/** Preserve portable help when rebuilding a schema, without publication-only metadata. */
+export function inheritApiParameterDescription(source, target) {
+    return source.description === undefined ? target : target.describe(source.description);
+}
+/** Attach available field help while retaining the original shape's types and runtime behavior. */
+export function describeApiParameterFields(scope, shape, descriptions) {
+    const describedShape = { ...shape };
+    for (const field in describedShape) {
+        const description = Object.hasOwn(descriptions, field) ? descriptions[field] : undefined;
+        if (description === undefined)
+            continue;
+        describedShape[field] = describeApiParameter(scope, describedShape[field], description);
+    }
+    return describedShape;
+}

package/dist/v4/assemblyReplay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assemblyReplay.d.ts","sourceRoot":"","sources":["../../src/v4/assemblyReplay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;kCAiBlC,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;qCAInC,CAAA;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;sCAAuC,CAAA;AAErF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAatB,CAAA"}
+{"version":3,"file":"assemblyReplay.d.ts","sourceRoot":"","sources":["../../src/v4/assemblyReplay.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;kCAiBlC,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;qCAInC,CAAA;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;sCAAqD,CAAA;AAEnG,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAatB,CAAA"}

package/dist/v4/assemblyReplay.js

@@ -1,25 +1,26 @@
+import { optionalWithV3Semantics } from "./lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
 import { assemblyAuthInstructionsSchema, fieldsSchema, notifyUrlSchema, templateIdSchema, } from "./template.js";
 export const assemblyReplayStepSchema = z
     .object({
-    field: z.unknown().optional(),
-    force_name: z.unknown().optional(),
-    force_original_id: z.unknown().optional(),
-    key: z.unknown().optional(),
-    output_meta: z.unknown().optional(),
-    password: z.unknown().optional(),
-    prompt: z.unknown().optional(),
-    robot: z.string().optional(),
-    secret: z.unknown().optional(),
-    url: z.unknown().optional(),
-    use: z.unknown().optional(),
+    field: optionalWithV3Semantics(z.unknown()),
+    force_name: optionalWithV3Semantics(z.unknown()),
+    force_original_id: optionalWithV3Semantics(z.unknown()),
+    key: optionalWithV3Semantics(z.unknown()),
+    output_meta: optionalWithV3Semantics(z.unknown()),
+    password: optionalWithV3Semantics(z.unknown()),
+    prompt: optionalWithV3Semantics(z.unknown()),
+    robot: optionalWithV3Semantics(z.string()),
+    secret: optionalWithV3Semantics(z.unknown()),
+    url: optionalWithV3Semantics(z.unknown()),
+    use: optionalWithV3Semantics(z.unknown()),
 })
     .catchall(z.unknown())
     .describe('A full Assembly step or partial replay step override. Replay keeps this relaxed so credentials and missing robot properties can be merged back from the original Template before normal Assembly validation runs.');
 export const assemblyReplayStepsSchema = z
     .union([z.record(z.string(), assemblyReplayStepSchema), z.array(assemblyReplayStepSchema)])
     .describe('Replay step overrides. Object-form steps are the normal Assembly shape; array-form steps are accepted for legacy replay compatibility and normalized before execution.');
-export const optionalAssemblyReplayStepsSchema = assemblyReplayStepsSchema.optional();
+export const optionalAssemblyReplayStepsSchema = optionalWithV3Semantics(assemblyReplayStepsSchema);
 export const assemblyReplaySchema = z
     .object({
     auth: assemblyAuthInstructionsSchema,