@skyold/provider-adapters 0.1.0-beta.0

package/dist/openai-images/codec.js

@@ -0,0 +1,979 @@
+import { decodeOpenAiImagesProtocolSnapshotV1, MAX_IMAGE_REVISED_PROMPT_UTF8_BYTES_V1, materializeInlineImageBase64ValueV1, parseImageGenerationCapabilityV1, parseImageTaskCapabilityDeclarationV2, stableMediaInputDigestV2, } from '@skyold/model-protocol';
+import { consumeStrictImageResponseJson, } from '../image-response-json.js';
+const PROTOCOL_FAMILY = 'openai-images/v1';
+const TOKENFORGE_TASKS_PROTOCOL = 'tokenforge-tasks/v1';
+const RESPONSE_INVALID = 'PROVIDER_RESPONSE_INVALID';
+const RESPONSE_TOO_LARGE = 'PROVIDER_RESPONSE_TOO_LARGE';
+const RESPONSE_INCOMPLETE = 'PROVIDER_RESPONSE_INCOMPLETE';
+const MAX_INLINE_TOTAL_BYTES = 100 * 1024 * 1024;
+const MAX_OUTPUT_ITEM_BYTES = 25 * 1024 * 1024;
+const MAX_OUTPUT_ITEM_BASE64_CHARS = 4 * Math.ceil(MAX_OUTPUT_ITEM_BYTES / 3);
+const MAX_BOUNDED_RESPONSE_BYTES = 144 * 1024 * 1024;
+const RESPONSE_ENVELOPE_BYTES = 128 * 1024;
+const RESPONSE_ITEM_METADATA_BYTES = MAX_IMAGE_REVISED_PROMPT_UTF8_BYTES_V1 + 1024;
+const MAX_URL_CHARS = 4_096;
+const MAX_INPUT_IMAGE_BYTES = 16 * 1024 * 1024;
+const MAX_MULTIPART_BYTES = 64 * 1024 * 1024;
+const SHA256 = /^[a-f0-9]{64}$/;
+const encoder = new TextEncoder();
+export const openAiImagesCodec = {
+    protocolFamily: PROTOCOL_FAMILY,
+    supportsTask(task, capability) {
+        try {
+            requestFacts(task, capability);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    encodeProviderRequest(task, providerModel, capability) {
+        const facts = requestFacts(task, capability);
+        return encoder.encode(JSON.stringify({
+            model: providerModel,
+            prompt: facts.prompt,
+            ...(facts.count === undefined ? {} : { n: facts.count }),
+            ...(facts.size === undefined ? {} : { size: `${facts.size.width}x${facts.size.height}` }),
+            ...(facts.quality === undefined ? {} : { quality: facts.quality }),
+            ...(facts.sendOutputFormat === undefined ? {} : { output_format: facts.sendOutputFormat }),
+            ...(facts.sendResponseFormat === undefined
+                ? {}
+                : { response_format: facts.sendResponseFormat }),
+            ...facts.providerOptions,
+        }));
+    },
+    async encodeEditProviderRequest(task, providerModel, capability, preparedMedia, signal, diagnostics) {
+        const facts = requestFacts(task, capability);
+        if (facts.operation !== 'edit')
+            throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+        const prepared = snapshotPreparedEditMedia(facts, preparedMedia);
+        const fields = [
+            textField('model', providerModel),
+            textField('prompt', facts.prompt),
+            ...prepared.images.map((image, index) => binaryField('image[]', `image-${index + 1}.${extension(image.mimeType)}`, image)),
+            ...(prepared.mask === undefined
+                ? []
+                : [binaryField('mask', `mask.${extension(prepared.mask.mimeType)}`, prepared.mask)]),
+            ...(facts.count === undefined ? [] : [textField('n', String(facts.count))]),
+            ...(facts.size === undefined
+                ? []
+                : [textField('size', `${facts.size.width}x${facts.size.height}`)]),
+            ...(facts.quality === undefined ? [] : [textField('quality', facts.quality)]),
+            ...(facts.background === undefined ? [] : [textField('background', facts.background)]),
+            ...(facts.sendOutputFormat === undefined
+                ? []
+                : [textField('output_format', facts.sendOutputFormat)]),
+            ...(facts.outputCompression === undefined
+                ? []
+                : [textField('output_compression', String(facts.outputCompression))]),
+        ];
+        const boundary = await deterministicBoundary(fields, signal, diagnostics);
+        assertNotAborted(signal);
+        const multipart = createMultipartBody(fields, boundary);
+        for (const target of multipart.binaryTargets) {
+            await writePreparedMedia(target, multipart.body, boundary, facts, signal, diagnostics);
+        }
+        assertNotAborted(signal);
+        return { body: multipart.body, boundary };
+    },
+    responseBodyPolicy(task, capability) {
+        return {
+            mode: 'bounded-success-stream',
+            maxBytes: responseBodyMaxBytes(requestFacts(task, capability)),
+        };
+    },
+    async decodeProviderStart(response, task, capability, diagnostics) {
+        const responseMetadata = metadata(response);
+        if (response.status < 200 || response.status >= 300) {
+            return failedStart(responseMetadata, response.status);
+        }
+        try {
+            const request = requestFacts(task, capability);
+            const decoded = await decodeResponseBody(response.body, request, diagnostics);
+            const root = decoded.root;
+            const expectedCount = request.count ?? 1;
+            if (decoded.items.length !== expectedCount)
+                throw new Error(RESPONSE_INVALID);
+            const items = decoded.items;
+            const decodedUsage = decodeUsage(root.usage, items.length);
+            const protocolSnapshot = decodeOpenAiImagesProtocolSnapshotV1({
+                protocolFamily: PROTOCOL_FAMILY,
+                created: root.created,
+                items: decoded.snapshotItems,
+                ...(root.background === undefined ? {} : { background: root.background }),
+                ...(root.outputFormat === undefined ? {} : { outputFormat: root.outputFormat }),
+                ...(root.quality === undefined ? {} : { quality: root.quality }),
+                ...(root.size === undefined ? {} : { size: root.size }),
+                ...(decodedUsage.snapshot === undefined ? {} : { usage: decodedUsage.snapshot }),
+            });
+            const output = { type: 'media', items };
+            return {
+                kind: 'sync',
+                acceptance: { state: 'accepted' },
+                responseMetadata,
+                terminal: {
+                    status: 'succeeded',
+                    acceptanceState: 'accepted',
+                    retryable: false,
+                    result: {
+                        taskKind: 'image_generation',
+                        output,
+                        usage: decodedUsage.normalized,
+                        protocolSnapshot,
+                    },
+                    usage: decodedUsage.normalized,
+                },
+            };
+        }
+        catch (error) {
+            return invalidStart(responseMetadata, responseFailureCode(error));
+        }
+    },
+};
+class ImageResponseError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+async function decodeResponseBody(body, request, diagnostics) {
+    const rootValues = {};
+    const items = [];
+    const snapshotItems = [];
+    let inlineTotal = 0;
+    const tracker = await consumeStrictImageResponseJson({
+        body,
+        maxBytes: responseBodyMaxBytes(request),
+        paths: [
+            '$.created',
+            '$.background',
+            '$.output_format',
+            '$.quality',
+            '$.size',
+            '$.usage',
+            '$.data.*',
+        ],
+        allowedContainer,
+        onValue: ({ value, key, parent, stack }) => {
+            if (stack.length === 1 && typeof key === 'string') {
+                rootValues[key] = value;
+                return;
+            }
+            if (stack.length === 2 && stack[1]?.key === 'data' && typeof key === 'number') {
+                diagnostics?.onParserRetainedItems?.(Array.isArray(parent) ? Object.keys(parent).length : 0);
+                if (key !== items.length || items.length >= (request.count ?? 1)) {
+                    throw new ImageResponseError(RESPONSE_INVALID);
+                }
+                const preflight = preflightItem(value, request);
+                const output = materializeItem(preflight, request);
+                if (output.kind === 'inline') {
+                    inlineTotal += output.sizeBytes;
+                    if (inlineTotal > MAX_INLINE_TOTAL_BYTES) {
+                        throw new ImageResponseError(RESPONSE_INVALID);
+                    }
+                }
+                items.push(output);
+                snapshotItems.push(preflight.revisedPrompt === undefined ? {} : { revisedPrompt: preflight.revisedPrompt });
+            }
+        },
+        invalidError: () => new ImageResponseError(RESPONSE_INVALID),
+        tooLargeError: () => new ImageResponseError(RESPONSE_TOO_LARGE),
+        bodyError: (error) => new ImageResponseError(transportBodyFailureCode(error) ?? RESPONSE_INCOMPLETE),
+        isProtocolError: (error) => error instanceof ImageResponseError,
+    });
+    if (!tracker.sawArray(['data']))
+        throw new ImageResponseError(RESPONSE_INVALID);
+    const root = decodeResponseRoot({ ...rootValues, data: Array(items.length).fill(null) }, request);
+    return { root, items, snapshotItems };
+}
+function responseBodyMaxBytes(request) {
+    const count = request.count ?? 1;
+    const payloadBytes = request.responseFormat === 'b64_json' ? MAX_OUTPUT_ITEM_BASE64_CHARS : MAX_URL_CHARS;
+    return Math.min(MAX_BOUNDED_RESPONSE_BYTES, RESPONSE_ENVELOPE_BYTES + count * (payloadBytes + RESPONSE_ITEM_METADATA_BYTES));
+}
+const ROOT_RESPONSE_KEYS = new Set([
+    'created',
+    'data',
+    'background',
+    'output_format',
+    'quality',
+    'size',
+    'usage',
+]);
+const DATA_ITEM_KEYS = new Set(['url', 'b64_json', 'revised_prompt']);
+const USAGE_KEYS = new Set([
+    'input_tokens',
+    'input_tokens_details',
+    'output_tokens',
+    'output_tokens_details',
+    'total_tokens',
+]);
+const TOKEN_DETAIL_KEYS = new Set(['image_tokens', 'text_tokens']);
+function allowedContainer(path, kind) {
+    if (path.length === 0)
+        return kind === 'object';
+    if (typeof path[0] === 'string' && !ROOT_RESPONSE_KEYS.has(path[0]))
+        return true;
+    if (path.length === 1 && path[0] === 'data')
+        return kind === 'array';
+    if (path.length === 2 && path[0] === 'data' && typeof path[1] === 'number') {
+        return kind === 'object';
+    }
+    if (path.length >= 3 &&
+        path[0] === 'data' &&
+        typeof path[1] === 'number' &&
+        typeof path[2] === 'string' &&
+        !DATA_ITEM_KEYS.has(path[2])) {
+        return true;
+    }
+    if (path.length === 1 && path[0] === 'usage')
+        return kind === 'object';
+    if (path.length >= 2 &&
+        path[0] === 'usage' &&
+        typeof path[1] === 'string' &&
+        !USAGE_KEYS.has(path[1])) {
+        return true;
+    }
+    if (path.length === 2 &&
+        path[0] === 'usage' &&
+        (path[1] === 'input_tokens_details' || path[1] === 'output_tokens_details')) {
+        return kind === 'object';
+    }
+    if (path.length >= 3 &&
+        path[0] === 'usage' &&
+        (path[1] === 'input_tokens_details' || path[1] === 'output_tokens_details') &&
+        typeof path[2] === 'string' &&
+        !TOKEN_DETAIL_KEYS.has(path[2])) {
+        return true;
+    }
+    return false;
+}
+function transportBodyFailureCode(error) {
+    if (error === null || typeof error !== 'object' || !('code' in error))
+        return null;
+    const code = error.code;
+    return code === RESPONSE_TOO_LARGE || code === RESPONSE_INCOMPLETE ? code : null;
+}
+function responseFailureCode(error) {
+    if (error instanceof ImageResponseError)
+        return error.code;
+    return transportBodyFailureCode(error) ?? RESPONSE_INVALID;
+}
+function requestFacts(task, capability) {
+    const operation = task.input['operation'];
+    if (task.protocolFamily !== PROTOCOL_FAMILY ||
+        (task.ingressProtocolFamily !== PROTOCOL_FAMILY &&
+            task.ingressProtocolFamily !== TOKENFORGE_TASKS_PROTOCOL) ||
+        task.dispatchProtocolFamily !== PROTOCOL_FAMILY ||
+        task.taskKind !== 'image_generation' ||
+        task.executionMode !== 'sync' ||
+        (operation === 'generate'
+            ? task.inputModalities.length !== 1 || task.inputModalities[0] !== 'text'
+            : operation === 'edit'
+                ? task.inputModalities.length !== 2 ||
+                    task.inputModalities[0] !== 'text' ||
+                    task.inputModalities[1] !== 'image'
+                : true) ||
+        task.outputModalities.length !== 1 ||
+        task.outputModalities[0] !== 'image') {
+        throw new Error('OPENAI_IMAGES_TASK_UNSUPPORTED');
+    }
+    const declared = parseImageGenerationCapabilityV1(capability.imageGenerationCapability);
+    if (declared === null)
+        throw new Error('OPENAI_IMAGES_CAPABILITY_INVALID');
+    const input = task.input;
+    if ((operation !== 'generate' && operation !== 'edit') || typeof input['prompt'] !== 'string') {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    const declarationV2 = operation === 'edit' || capability.operations !== undefined
+        ? parseCapabilityV2(capability)
+        : null;
+    if (operation === 'edit' &&
+        (declarationV2 === null ||
+            !declarationV2.operations.includes('edit') ||
+            declarationV2.imageEditingCapability === undefined)) {
+        throw new Error('OPENAI_IMAGES_CAPABILITY_INVALID');
+    }
+    if (operation === 'generate' &&
+        capability.operations !== undefined &&
+        declarationV2?.operations.includes('generate') !== true) {
+        throw new Error('OPENAI_IMAGES_CAPABILITY_INVALID');
+    }
+    if (encoder.encode(input['prompt']).byteLength > declared.maxPromptUtf8Bytes) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    const count = optionalInteger(input['count']);
+    const effectiveCount = count ?? 1;
+    if (effectiveCount < declared.minCount || effectiveCount > declared.maxCount) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    const size = optionalSize(input['size']);
+    if (size !== undefined &&
+        !declared.allowedSizes.some((allowed) => allowed.width === size.width && allowed.height === size.height)) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    const quality = optionalQuality(input['quality']);
+    if (quality !== undefined && !declared.qualities.includes(quality)) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    const output = resolveFormat(optionalOutputFormat(input['outputFormat']), declared.outputFormats, declared.requestMapping.outputFormat);
+    const response = resolveFormat(optionalResponseFormat(input['responseFormat']), declared.responseFormats, declared.requestMapping.responseFormat);
+    const providerOptions = decodeProviderOptions(task.providerOptions, declared, output.effective, operation);
+    if (operation === 'edit' && response.send !== undefined) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    let images;
+    let mask;
+    if (operation === 'edit') {
+        images = decodeMediaInputs(input['images']);
+        const editing = declarationV2.imageEditingCapability;
+        if (images.length === 0 || images.length > editing.maxInputImages) {
+            throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+        }
+        mask = input['mask'] === undefined ? undefined : decodeMediaInput(input['mask']);
+        if (mask !== undefined && !editing.supportsMask) {
+            throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+        }
+    }
+    const background = providerOptions['background'];
+    const outputCompression = providerOptions['output_compression'];
+    return {
+        operation,
+        prompt: input['prompt'],
+        ...(images === undefined ? {} : { images }),
+        ...(mask === undefined ? {} : { mask }),
+        ...(operation === 'edit' ? { editingCapability: declarationV2.imageEditingCapability } : {}),
+        ...(count === undefined ? {} : { count }),
+        ...(size === undefined ? {} : { size }),
+        allowedSizes: declared.allowedSizes,
+        ...(quality === undefined ? {} : { quality }),
+        outputFormat: output.effective,
+        responseFormat: response.effective,
+        ...(output.send === undefined ? {} : { sendOutputFormat: output.send }),
+        ...(response.send === undefined ? {} : { sendResponseFormat: response.send }),
+        providerOptions,
+        ...(background === 'transparent' || background === 'opaque' || background === 'auto'
+            ? { background }
+            : {}),
+        ...(typeof outputCompression === 'number' ? { outputCompression } : {}),
+    };
+}
+function resolveFormat(explicit, supported, mapping) {
+    if (mapping.mode === 'fixed') {
+        if (explicit !== undefined && explicit !== mapping.value) {
+            throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+        }
+        return { effective: mapping.value };
+    }
+    if (explicit === undefined)
+        return { effective: mapping.defaultValue };
+    if (!supported.includes(explicit))
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    return { effective: explicit, send: explicit };
+}
+function decodeProviderOptions(value, capability, outputFormat, operation) {
+    const keys = Object.keys(value);
+    if (keys.some((key) => key !== 'openaiImages')) {
+        throw new Error('OPENAI_IMAGES_PROVIDER_OPTIONS_INVALID');
+    }
+    if (value['openaiImages'] === undefined)
+        return {};
+    const options = record(value['openaiImages']);
+    const allowed = new Set(capability.requestMapping.providerOptions.openaiImages);
+    if (Object.keys(options).some((key) => (key !== 'background' && key !== 'moderation' && key !== 'outputCompression') ||
+        !allowed.has(key))) {
+        throw new Error('OPENAI_IMAGES_PROVIDER_OPTIONS_INVALID');
+    }
+    const background = options['background'];
+    const moderation = options['moderation'];
+    const outputCompression = options['outputCompression'];
+    if ((background !== undefined &&
+        background !== 'transparent' &&
+        background !== 'opaque' &&
+        background !== 'auto') ||
+        (moderation !== undefined && moderation !== 'low' && moderation !== 'auto') ||
+        (outputCompression !== undefined &&
+            (!Number.isSafeInteger(outputCompression) ||
+                outputCompression < 0 ||
+                outputCompression > 100)) ||
+        (background === 'transparent' && outputFormat !== 'png' && outputFormat !== 'webp') ||
+        (outputCompression !== undefined && outputFormat !== 'jpeg' && outputFormat !== 'webp') ||
+        (operation === 'edit' && moderation !== undefined)) {
+        throw new Error('OPENAI_IMAGES_PROVIDER_OPTIONS_INVALID');
+    }
+    return {
+        ...(background === undefined ? {} : { background }),
+        ...(moderation === undefined ? {} : { moderation }),
+        ...(outputCompression === undefined ? {} : { output_compression: outputCompression }),
+    };
+}
+function parseCapabilityV2(capability) {
+    return parseImageTaskCapabilityDeclarationV2({
+        schemaVersion: 2,
+        taskKind: capability.taskKind,
+        protocolFamily: capability.protocolFamily,
+        operations: capability.operations,
+        inputModalities: capability.inputModalities,
+        outputModalities: capability.outputModalities,
+        executionModes: capability.executionModes,
+        supportsCallback: false,
+        supportsCancel: false,
+        imageGenerationCapability: capability.imageGenerationCapability,
+        ...(capability.imageEditingCapability === undefined
+            ? {}
+            : { imageEditingCapability: capability.imageEditingCapability }),
+    });
+}
+function decodeMediaInputs(value) {
+    if (!Array.isArray(value))
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    return value.map(decodeMediaInput);
+}
+function decodeMediaInput(value) {
+    const input = record(value);
+    if (input['kind'] === 'url' &&
+        hasExactKeys(input, ['kind', 'url'], ['mimeType']) &&
+        typeof input['url'] === 'string' &&
+        (input['mimeType'] === undefined || typeof input['mimeType'] === 'string')) {
+        return {
+            kind: 'url',
+            url: input['url'],
+            ...(input['mimeType'] === undefined ? {} : { mimeType: input['mimeType'] }),
+        };
+    }
+    if (input['kind'] === 'object' &&
+        hasExactKeys(input, ['kind', 'objectKey']) &&
+        typeof input['objectKey'] === 'string') {
+        return { kind: 'object', objectKey: input['objectKey'] };
+    }
+    throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+}
+function snapshotPreparedEditMedia(facts, preparedMedia) {
+    const images = facts.images;
+    const preparedImages = preparedMedia?.images === undefined ? undefined : [...preparedMedia.images];
+    const preparedMask = preparedMedia?.mask;
+    if (images === undefined ||
+        preparedMedia?.operation !== 'edit' ||
+        preparedImages?.length !== images.length ||
+        Boolean(preparedMask) !== Boolean(facts.mask)) {
+        throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+    }
+    const imageSnapshots = preparedImages.map(snapshotPreparedMedia);
+    const maskSnapshot = preparedMask === undefined ? undefined : snapshotPreparedMedia(preparedMask);
+    for (const [index, source] of images.entries()) {
+        if (imageSnapshots[index]?.sourceDigest !== stableMediaInputDigestV2(source)) {
+            throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+        }
+    }
+    if (facts.mask !== undefined &&
+        maskSnapshot?.sourceDigest !== stableMediaInputDigestV2(facts.mask)) {
+        throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+    }
+    const allPrepared = [...imageSnapshots, ...(maskSnapshot === undefined ? [] : [maskSnapshot])];
+    let declaredTotal = 0;
+    for (const input of allPrepared) {
+        validatePreparedMetadata(input, facts);
+        declaredTotal += input.sizeBytes;
+        if (declaredTotal >= MAX_MULTIPART_BYTES) {
+            throw new Error('OPENAI_IMAGES_MULTIPART_TOO_LARGE');
+        }
+    }
+    return {
+        images: imageSnapshots,
+        ...(maskSnapshot === undefined ? {} : { mask: maskSnapshot }),
+    };
+}
+function snapshotPreparedMedia(input) {
+    const sourceDigest = input.sourceDigest;
+    const mimeType = input.mimeType;
+    const sizeBytes = input.sizeBytes;
+    const sha256 = input.sha256;
+    const stream = Reflect.get(input, 'stream');
+    if (typeof stream !== 'function')
+        throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_INVALID');
+    return {
+        sourceDigest,
+        mimeType,
+        sizeBytes,
+        sha256,
+        openStream: stream.bind(input),
+    };
+}
+async function writePreparedMedia(target, body, boundary, facts, signal, diagnostics) {
+    const input = target.field.media;
+    validatePreparedMetadata(input, facts);
+    assertNotAborted(signal);
+    let iterator;
+    try {
+        iterator = input.openStream()[Symbol.asyncIterator]();
+    }
+    catch {
+        throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_INVALID');
+    }
+    let size = 0;
+    let complete = false;
+    try {
+        while (true) {
+            assertNotAborted(signal);
+            let next;
+            try {
+                next = await nextWithAbort(iterator, signal);
+            }
+            catch (error) {
+                if (signal.aborted || isAbortError(error))
+                    throw new Error('OPENAI_IMAGES_MEDIA_ABORTED');
+                throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_INVALID');
+            }
+            assertNotAborted(signal);
+            if (next.done) {
+                diagnostics?.onAfterFinalMediaChunk?.();
+                assertNotAborted(signal);
+                break;
+            }
+            if (!(next.value instanceof Uint8Array)) {
+                throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_INVALID');
+            }
+            size += next.value.byteLength;
+            if (size > input.sizeBytes || size > MAX_INPUT_IMAGE_BYTES) {
+                throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+            }
+            body.set(next.value, target.offset + size - next.value.byteLength);
+        }
+        if (size !== input.sizeBytes)
+            throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+        const bytes = body.subarray(target.offset, target.offset + size);
+        const actualSha256 = await sha256Hex(bytes, signal);
+        diagnostics?.onAfterMediaDigest?.();
+        assertNotAborted(signal);
+        if (actualSha256 !== input.sha256 || detectMimeType(bytes) !== input.mimeType) {
+            throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+        }
+        if (containsBytes(bytes, encoder.encode(boundary))) {
+            throw new Error('OPENAI_IMAGES_MULTIPART_BOUNDARY_INVALID');
+        }
+        complete = true;
+    }
+    finally {
+        if (!complete)
+            closeIterator(iterator);
+    }
+}
+function validatePreparedMetadata(input, facts) {
+    if (!Number.isSafeInteger(input.sizeBytes) ||
+        input.sizeBytes <= 0 ||
+        input.sizeBytes > MAX_INPUT_IMAGE_BYTES ||
+        !SHA256.test(input.sha256) ||
+        facts.editingCapability?.inputMimeTypes.includes(input.mimeType) !== true) {
+        throw new Error('OPENAI_IMAGES_PREPARED_MEDIA_MISMATCH');
+    }
+}
+function closeIterator(iterator) {
+    if (iterator.return === undefined)
+        return;
+    try {
+        void Promise.resolve(iterator.return()).catch(() => undefined);
+    }
+    catch {
+        // Cleanup is best-effort and must not replace the bounded media failure.
+    }
+}
+async function nextWithAbort(iterator, signal) {
+    if (signal.aborted)
+        throw new Error('OPENAI_IMAGES_MEDIA_ABORTED');
+    return await new Promise((resolve, reject) => {
+        const aborted = () => reject(new Error('OPENAI_IMAGES_MEDIA_ABORTED'));
+        signal.addEventListener('abort', aborted, { once: true });
+        iterator
+            .next()
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', aborted));
+    });
+}
+function assertNotAborted(signal) {
+    if (signal.aborted)
+        throw new Error('OPENAI_IMAGES_MEDIA_ABORTED');
+}
+function isAbortError(error) {
+    return error instanceof Error && error.message === 'OPENAI_IMAGES_MEDIA_ABORTED';
+}
+function detectMimeType(bytes) {
+    if (bytes.length >= 8 &&
+        [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].every((value, index) => bytes[index] === value)) {
+        return 'image/png';
+    }
+    if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return 'image/jpeg';
+    }
+    if (bytes.length >= 12 &&
+        decoderAscii(bytes, 0, 4) === 'RIFF' &&
+        decoderAscii(bytes, 8, 12) === 'WEBP') {
+        return 'image/webp';
+    }
+    return null;
+}
+function decoderAscii(bytes, start, end) {
+    return String.fromCharCode(...bytes.subarray(start, end));
+}
+function textField(name, value) {
+    return { kind: 'text', name, value: encoder.encode(value) };
+}
+function binaryField(name, filename, media) {
+    return {
+        kind: 'binary',
+        name,
+        filename,
+        mimeType: media.mimeType,
+        media,
+    };
+}
+function extension(mimeType) {
+    if (mimeType === 'image/jpeg')
+        return 'jpg';
+    if (mimeType === 'image/webp')
+        return 'webp';
+    return 'png';
+}
+async function deterministicBoundary(fields, signal, diagnostics) {
+    const seed = [];
+    for (const field of fields) {
+        seed.push(field.kind === 'binary'
+            ? [field.name, field.filename, field.mimeType, field.media.sizeBytes, field.media.sha256]
+            : [field.name, await sha256Hex(field.value, signal)]);
+    }
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+        const digest = (await sha256Hex(encoder.encode(JSON.stringify(['tokenforge-openai-images-edit-v1', seed, attempt])), signal)).slice(0, 48);
+        diagnostics?.onAfterBoundaryDigest?.();
+        assertNotAborted(signal);
+        const boundary = `tokenforge-${digest}`;
+        const boundaryBytes = encoder.encode(boundary);
+        if (fields.every((field) => field.kind === 'binary' || !containsBytes(field.value, boundaryBytes))) {
+            return boundary;
+        }
+    }
+    throw new Error('OPENAI_IMAGES_MULTIPART_BOUNDARY_INVALID');
+}
+async function sha256Hex(value, signal) {
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', value));
+    assertNotAborted(signal);
+    return Array.from(digest, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function createMultipartBody(fields, boundary) {
+    const preparedFields = fields.map((field) => ({
+        field,
+        header: encoder.encode(field.kind === 'text'
+            ? `--${boundary}\r\nContent-Disposition: form-data; name="${field.name}"\r\n\r\n`
+            : `--${boundary}\r\nContent-Disposition: form-data; name="${field.name}"; filename="${field.filename}"\r\nContent-Type: ${field.mimeType}\r\n\r\n`),
+    }));
+    const closing = encoder.encode(`--${boundary}--\r\n`);
+    let totalBytes = closing.byteLength;
+    for (const { field, header } of preparedFields) {
+        totalBytes +=
+            header.byteLength +
+                (field.kind === 'text' ? field.value.byteLength : field.media.sizeBytes) +
+                2;
+        if (totalBytes > MAX_MULTIPART_BYTES) {
+            throw new Error('OPENAI_IMAGES_MULTIPART_TOO_LARGE');
+        }
+    }
+    const body = new Uint8Array(totalBytes);
+    const binaryTargets = [];
+    let offset = 0;
+    const append = (value) => {
+        body.set(value, offset);
+        offset += value.byteLength;
+    };
+    for (const { field, header } of preparedFields) {
+        append(header);
+        if (field.kind === 'text') {
+            append(field.value);
+        }
+        else {
+            binaryTargets.push({ field, offset });
+            offset += field.media.sizeBytes;
+        }
+        append(encoder.encode('\r\n'));
+    }
+    append(closing);
+    return { body, binaryTargets };
+}
+function containsBytes(haystack, needle) {
+    outer: for (let offset = 0; offset <= haystack.length - needle.length; offset += 1) {
+        for (let index = 0; index < needle.length; index += 1) {
+            if (haystack[offset + index] !== needle[index])
+                continue outer;
+        }
+        return true;
+    }
+    return false;
+}
+function decodeResponseRoot(value, request) {
+    const root = record(value);
+    if (!hasRequiredKeys(root, ['created', 'data']) ||
+        !nonNegativeInteger(root['created']) ||
+        !Array.isArray(root['data'])) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    const background = root['background'];
+    const outputFormat = root['output_format'];
+    const quality = root['quality'];
+    const size = root['size'];
+    if ((background !== undefined && background !== 'transparent' && background !== 'opaque') ||
+        (outputFormat !== undefined &&
+            outputFormat !== 'png' &&
+            outputFormat !== 'jpeg' &&
+            outputFormat !== 'webp') ||
+        (outputFormat !== undefined && outputFormat !== request.outputFormat) ||
+        (quality !== undefined && quality !== 'low' && quality !== 'medium' && quality !== 'high') ||
+        (size !== undefined &&
+            (!imagePixelSize(size) ||
+                !request.allowedSizes.some((allowed) => `${allowed.width}x${allowed.height}` === size) ||
+                (request.size !== undefined && `${request.size.width}x${request.size.height}` !== size)))) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    return {
+        created: root['created'],
+        data: root['data'],
+        ...(background === undefined ? {} : { background }),
+        ...(outputFormat === undefined ? {} : { outputFormat }),
+        ...(quality === undefined ? {} : { quality }),
+        ...(size === undefined ? {} : { size }),
+        ...(root['usage'] === undefined ? {} : { usage: root['usage'] }),
+    };
+}
+function preflightItem(value, request) {
+    const item = record(value);
+    const expectedField = request.responseFormat === 'url' ? 'url' : 'b64_json';
+    const conflictingField = request.responseFormat === 'url' ? 'b64_json' : 'url';
+    if (!Object.prototype.hasOwnProperty.call(item, expectedField) ||
+        Object.prototype.hasOwnProperty.call(item, conflictingField) ||
+        !hasRequiredKeys(item, [expectedField]) ||
+        (item['revised_prompt'] !== undefined &&
+            (typeof item['revised_prompt'] !== 'string' ||
+                encoder.encode(item['revised_prompt']).byteLength > MAX_IMAGE_REVISED_PROMPT_UTF8_BYTES_V1))) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    const revisedPrompt = item['revised_prompt'];
+    if (request.responseFormat === 'url') {
+        const url = item['url'];
+        if (typeof url !== 'string' ||
+            url.length === 0 ||
+            url.length > MAX_URL_CHARS ||
+            !isHttpsUrl(url)) {
+            throw new Error(RESPONSE_INVALID);
+        }
+        return { kind: 'reference', url, ...(revisedPrompt === undefined ? {} : { revisedPrompt }) };
+    }
+    return {
+        kind: 'inline',
+        base64: item['b64_json'],
+        ...(revisedPrompt === undefined ? {} : { revisedPrompt }),
+    };
+}
+function materializeItem(item, request) {
+    if (item.kind === 'reference') {
+        return {
+            kind: 'reference',
+            reference: {
+                kind: 'url',
+                url: item.url,
+                mimeType: mimeType(request.outputFormat),
+            },
+        };
+    }
+    return materializeInlineImageBase64ValueV1(item.base64, request.outputFormat);
+}
+function decodeUsage(value, imageCount) {
+    if (value === undefined) {
+        return { normalized: { requests: 1, imageCount, estimated: false } };
+    }
+    const usage = record(value);
+    if (!hasRequiredKeys(usage, [
+        'input_tokens',
+        'input_tokens_details',
+        'output_tokens',
+        'total_tokens',
+    ]) ||
+        !nonNegativeInteger(usage['input_tokens']) ||
+        !nonNegativeInteger(usage['output_tokens']) ||
+        !nonNegativeInteger(usage['total_tokens'])) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    const inputTokenDetails = decodeTokenDetails(usage['input_tokens_details']);
+    const outputTokenDetails = usage['output_tokens_details'] === undefined
+        ? undefined
+        : decodeTokenDetails(usage['output_tokens_details']);
+    if (safeIntegerSum(inputTokenDetails.imageTokens, inputTokenDetails.textTokens) !==
+        usage['input_tokens'] ||
+        (outputTokenDetails !== undefined &&
+            safeIntegerSum(outputTokenDetails.imageTokens, outputTokenDetails.textTokens) !==
+                usage['output_tokens']) ||
+        safeIntegerSum(usage['input_tokens'], usage['output_tokens']) !== usage['total_tokens']) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    const snapshot = {
+        inputTokens: usage['input_tokens'],
+        inputTokenDetails,
+        outputTokens: usage['output_tokens'],
+        totalTokens: usage['total_tokens'],
+        ...(outputTokenDetails === undefined ? {} : { outputTokenDetails }),
+    };
+    return {
+        normalized: {
+            inputTokens: snapshot.inputTokens,
+            outputTokens: snapshot.outputTokens,
+            totalTokens: snapshot.totalTokens,
+            inputTokenDetails,
+            ...(outputTokenDetails === undefined ? {} : { outputTokenDetails }),
+            requests: 1,
+            imageCount,
+            estimated: false,
+        },
+        snapshot,
+    };
+}
+function decodeTokenDetails(value) {
+    const details = record(value);
+    if (!hasRequiredKeys(details, ['image_tokens', 'text_tokens']) ||
+        !nonNegativeInteger(details['image_tokens']) ||
+        !nonNegativeInteger(details['text_tokens'])) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    return { imageTokens: details['image_tokens'], textTokens: details['text_tokens'] };
+}
+function invalidStart(responseMetadata, failureCode = RESPONSE_INVALID) {
+    const failureOrigin = failureCode === RESPONSE_TOO_LARGE || failureCode === RESPONSE_INCOMPLETE
+        ? 'transport'
+        : 'provider';
+    return {
+        kind: 'sync',
+        acceptance: { state: 'accepted' },
+        responseMetadata,
+        terminal: {
+            status: 'failed',
+            acceptanceState: 'accepted',
+            failureOrigin,
+            failureCode,
+            retryable: false,
+        },
+    };
+}
+function failedStart(responseMetadata, status) {
+    const rateLimited = status === 429;
+    const unknown = status >= 500;
+    const acceptanceState = unknown ? 'unknown' : 'not-accepted';
+    return {
+        kind: 'sync',
+        acceptance: { state: acceptanceState },
+        responseMetadata,
+        terminal: {
+            status: 'failed',
+            acceptanceState,
+            failureOrigin: 'provider',
+            failureCode: rateLimited
+                ? 'PROVIDER_RATE_LIMITED'
+                : unknown
+                    ? 'PROVIDER_ACCEPTANCE_UNKNOWN'
+                    : 'PROVIDER_REQUEST_FAILED',
+            retryable: rateLimited,
+        },
+    };
+}
+function optionalInteger(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    return value;
+}
+function optionalSize(value) {
+    if (value === undefined)
+        return undefined;
+    const size = record(value);
+    if (!hasExactKeys(size, ['width', 'height']) ||
+        !Number.isSafeInteger(size['width']) ||
+        !Number.isSafeInteger(size['height'])) {
+        throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+    }
+    return { width: size['width'], height: size['height'] };
+}
+function optionalQuality(value) {
+    if (value === undefined ||
+        value === 'auto' ||
+        value === 'low' ||
+        value === 'medium' ||
+        value === 'high') {
+        return value;
+    }
+    throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+}
+function optionalOutputFormat(value) {
+    if (value === undefined || value === 'png' || value === 'jpeg' || value === 'webp')
+        return value;
+    throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+}
+function optionalResponseFormat(value) {
+    if (value === undefined || value === 'url' || value === 'b64_json')
+        return value;
+    throw new Error('OPENAI_IMAGES_REQUEST_INVALID');
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function imagePixelSize(value) {
+    if (typeof value !== 'string')
+        return false;
+    const match = /^([1-9]\d{1,3})x([1-9]\d{1,3})$/.exec(value);
+    if (match === null)
+        return false;
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    return width >= 64 && width <= 8192 && height >= 64 && height <= 8192;
+}
+function safeIntegerSum(left, right) {
+    const sum = left + right;
+    return Number.isSafeInteger(sum) ? sum : null;
+}
+function mimeType(format) {
+    if (format === 'jpeg')
+        return 'image/jpeg';
+    if (format === 'webp')
+        return 'image/webp';
+    return 'image/png';
+}
+function isHttpsUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && Boolean(url.hostname) && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+}
+function record(value) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)) {
+        throw new Error(RESPONSE_INVALID);
+    }
+    return value;
+}
+function hasExactKeys(value, required, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    return (Object.keys(value).every((key) => allowed.has(key)) &&
+        required.every((key) => Object.prototype.hasOwnProperty.call(value, key)));
+}
+function hasRequiredKeys(value, required) {
+    return required.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function metadata(response) {
+    const providerRequestId = response.headers['x-request-id'] ?? response.headers['openai-request-id'];
+    return {
+        headersReceived: true,
+        statusCode: response.status,
+        ...(providerRequestId ? { providerRequestId } : {}),
+    };
+}
+//# sourceMappingURL=codec.js.map