@skyold/model-protocol 0.1.0-beta.0

package/dist/tokenforge-tasks.js

@@ -0,0 +1,1132 @@
+import { embeddingCapabilityFailure } from './openai-embeddings.js';
+import { OPENAI_IMAGES_PROTOCOL, VOLC_IMAGES_PROTOCOL, parseImageGenerationCapabilityV1, } from './media-images.js';
+import { parseVideoGenerationCapabilityV1 } from './media-video.js';
+export const TOKENFORGE_TASKS_API_VERSION = '2026-07-13';
+export const TOKENFORGE_TASKS_V2_API_VERSION = '2026-07-19';
+export const TOKENFORGE_TASKS_PROTOCOL = 'tokenforge-tasks/v1';
+/**
+ * P1C compatibility contract: the persisted and synchronized `supportsResponses` flag is an
+ * exclusive Task chat-family selector, not an additive statement that publishes both families.
+ * This keeps Gateway and Server target snapshots deterministic without introducing a new seam.
+ */
+export function resolveDeclaredOpenAiChatProtocolFamily(input) {
+    return input.supportsResponses ? 'openai-responses/v1' : 'openai-chat/v1';
+}
+const MAX_CLIENT_REQUEST_ID_CHARS = 128;
+const MAX_MESSAGES = 128;
+const MAX_CONTENT_PARTS = 64;
+const MAX_EMBEDDING_BATCH_ITEMS = 2_048;
+const MAX_FUNCTION_IDENTIFIER_CHARS = 128;
+const MAX_FUNCTION_ARGUMENT_BYTES = 65_536;
+const MAX_JSON_SCHEMA_DEPTH = 16;
+const MAX_JSON_SCHEMA_NODES = 1_024;
+const MAX_JSON_SCHEMA_BYTES = 65_536;
+const MAX_V2_BODY_BYTES = 256 * 1024;
+const MAX_PROVIDER_OPTIONS_BYTES = 16 * 1024;
+const MAX_PROMPT_BYTES = 32 * 1024;
+const MAX_MEDIA_URL_CHARS = 4_096;
+const MAX_OBJECT_KEY_CHARS = 1_024;
+const MAX_VIDEO_TEXT_BYTES = 64 * 1024;
+const UTF8_ENCODER = new TextEncoder();
+const TOP_LEVEL_FIELDS = new Set([
+    'apiVersion',
+    'clientRequestId',
+    'model',
+    'task',
+    'providerOptions',
+]);
+const CHAT_TASK_FIELDS = new Set([
+    'kind',
+    'mode',
+    'input',
+    'maxOutputTokens',
+    'temperature',
+    'tools',
+    'toolChoice',
+]);
+const EMBEDDING_TASK_FIELDS = new Set(['kind', 'mode', 'input', 'dimensions', 'encodingFormat']);
+const IMAGE_GENERATE_TASK_FIELDS = new Set([
+    'kind',
+    'mode',
+    'operation',
+    'prompt',
+    'count',
+    'size',
+    'quality',
+    'outputFormat',
+    'responseFormat',
+]);
+const IMAGE_EDIT_TASK_FIELDS = new Set([...IMAGE_GENERATE_TASK_FIELDS, 'images', 'mask']);
+const VIDEO_TASK_FIELDS = new Set([
+    'kind',
+    'mode',
+    'input',
+    'durationSeconds',
+    'aspectRatio',
+    'size',
+    'returnLastFrame',
+    'callbackUrl',
+]);
+const REASONING_EFFORTS = new Set([
+    'none',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+]);
+export class TaskStreamEgressError extends Error {
+    code;
+    name = 'TaskStreamEgressError';
+    constructor(code) {
+        super(`TokenForge Task stream rejected: ${code}`);
+        this.code = code;
+    }
+}
+export class TokenforgeTaskRequestError extends Error {
+    code;
+    status;
+    name = 'TokenforgeTaskRequestError';
+    constructor(code, status) {
+        super(`TokenForge Task request rejected: ${code}`);
+        this.code = code;
+        this.status = status;
+    }
+}
+const TASK_STREAM_TERMINAL_TYPES = new Set([
+    'response.incomplete',
+    'response.completed',
+    'response.failed',
+]);
+const requiredField = (validate) => ({ validate });
+const optionalField = (validate) => ({
+    validate,
+    optional: true,
+});
+const isString = (value) => typeof value === 'string';
+const isNonEmptyString = (value) => typeof value === 'string' && value.length > 0;
+const isBoolean = (value) => typeof value === 'boolean';
+const isNonNegativeSafeInteger = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+function matchesRuntimeSchema(value, schema) {
+    if (!isPlainRecord(value) ||
+        Object.keys(value).some((key) => !Object.prototype.hasOwnProperty.call(schema, key))) {
+        return false;
+    }
+    return Object.entries(schema).every(([key, rule]) => {
+        if (!Object.prototype.hasOwnProperty.call(value, key)) {
+            return rule.optional === true;
+        }
+        return rule.validate(value[key]);
+    });
+}
+function isContentPart(value) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    if (value['type'] === 'text') {
+        return matchesRuntimeSchema(value, {
+            type: requiredField((item) => item === 'text'),
+            text: requiredField(isString),
+        });
+    }
+    if (value['type'] === 'refusal') {
+        return matchesRuntimeSchema(value, {
+            type: requiredField((item) => item === 'refusal'),
+            text: requiredField(isString),
+        });
+    }
+    if (value['type'] === 'reasoning_summary') {
+        return matchesRuntimeSchema(value, {
+            type: requiredField((item) => item === 'reasoning_summary'),
+            text: requiredField(isString),
+        });
+    }
+    return false;
+}
+function isOutputItem(value) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    if (value['type'] === 'message') {
+        return matchesRuntimeSchema(value, {
+            type: requiredField((item) => item === 'message'),
+            content: requiredField((item) => Array.isArray(item) && item.every((part) => isContentPart(part))),
+        });
+    }
+    if (value['type'] === 'function_call') {
+        return matchesRuntimeSchema(value, {
+            type: requiredField((item) => item === 'function_call'),
+            callId: requiredField(isNonEmptyString),
+            name: requiredField(isNonEmptyString),
+            arguments: requiredField(isString),
+        });
+    }
+    return false;
+}
+function isTokenDetails(value, field) {
+    return matchesRuntimeSchema(value, {
+        [field]: optionalField(isNonNegativeSafeInteger),
+    });
+}
+function isUsage(value) {
+    return matchesRuntimeSchema(value, {
+        inputTokens: optionalField(isNonNegativeSafeInteger),
+        outputTokens: optionalField(isNonNegativeSafeInteger),
+        totalTokens: optionalField(isNonNegativeSafeInteger),
+        cachedInputTokens: optionalField(isNonNegativeSafeInteger),
+        cacheCreationInputTokens: optionalField(isNonNegativeSafeInteger),
+        reasoningOutputTokens: optionalField(isNonNegativeSafeInteger),
+        inputTokenDetails: optionalField((item) => isTokenDetails(item, 'cachedTokens')),
+        outputTokenDetails: optionalField((item) => isTokenDetails(item, 'reasoningTokens')),
+        vectorCount: optionalField(isNonNegativeSafeInteger),
+        dimensions: optionalField(isNonNegativeSafeInteger),
+        encodingFormat: optionalField((item) => item === 'float' || item === 'base64'),
+        spaceId: optionalField(isNonEmptyString),
+        estimated: requiredField(isBoolean),
+    });
+}
+function isIncompleteDetails(value) {
+    return matchesRuntimeSchema(value, {
+        reason: requiredField(isNonEmptyString),
+    });
+}
+function isProviderError(value) {
+    return matchesRuntimeSchema(value, {
+        code: requiredField(isNonEmptyString),
+        message: optionalField(isString),
+    });
+}
+function isStreamError(value) {
+    return matchesRuntimeSchema(value, {
+        code: requiredField(isNonEmptyString),
+        category: requiredField(isNonEmptyString),
+        retryable: requiredField(isBoolean),
+    });
+}
+const BASE_STREAM_EVENT_SCHEMA = {
+    type: requiredField(isNonEmptyString),
+    eventId: requiredField(isNonEmptyString),
+    sequenceNumber: requiredField(isNonNegativeSafeInteger),
+    responseId: requiredField(isNonEmptyString),
+};
+const INDEXED_ITEM_SCHEMA = {
+    itemId: requiredField(isNonEmptyString),
+    outputIndex: requiredField(isNonNegativeSafeInteger),
+};
+const INDEXED_CONTENT_SCHEMA = {
+    ...INDEXED_ITEM_SCHEMA,
+    contentIndex: requiredField(isNonNegativeSafeInteger),
+};
+const TASK_STREAM_EVENT_SCHEMAS = {
+    'response.started': {},
+    'response.in_progress': {
+        status: requiredField((value) => value === 'in_progress'),
+    },
+    'output.item.added': {
+        ...INDEXED_ITEM_SCHEMA,
+        itemKind: requiredField((value) => value === 'message' || value === 'reasoning' || value === 'function_call'),
+        item: requiredField(isOutputItem),
+    },
+    'output.text.delta': {
+        ...INDEXED_CONTENT_SCHEMA,
+        delta: requiredField(isString),
+    },
+    'output.refusal.delta': {
+        ...INDEXED_CONTENT_SCHEMA,
+        delta: requiredField(isString),
+    },
+    'output.tool_call.delta': {
+        ...INDEXED_ITEM_SCHEMA,
+        callId: requiredField(isNonEmptyString),
+        name: optionalField(isNonEmptyString),
+        argumentsDelta: requiredField(isString),
+    },
+    'output.reasoning_summary.delta': {
+        ...INDEXED_CONTENT_SCHEMA,
+        delta: requiredField(isString),
+    },
+    'output.content_part.added': {
+        ...INDEXED_CONTENT_SCHEMA,
+        part: requiredField(isContentPart),
+    },
+    'output.content_part.completed': {
+        ...INDEXED_CONTENT_SCHEMA,
+        part: requiredField(isContentPart),
+    },
+    'output.item.completed': {
+        ...INDEXED_ITEM_SCHEMA,
+        itemKind: requiredField((value) => value === 'message' || value === 'reasoning' || value === 'function_call'),
+        status: requiredField((value) => value === 'completed' || value === 'incomplete'),
+        item: requiredField(isOutputItem),
+    },
+    'output.text.completed': {
+        ...INDEXED_CONTENT_SCHEMA,
+        text: requiredField(isString),
+    },
+    'output.refusal.completed': {
+        ...INDEXED_CONTENT_SCHEMA,
+        refusal: requiredField(isString),
+    },
+    'output.tool_call.completed': {
+        ...INDEXED_ITEM_SCHEMA,
+        callId: requiredField(isNonEmptyString),
+        name: requiredField(isNonEmptyString),
+        arguments: requiredField(isString),
+    },
+    'output.reasoning_summary.completed': {
+        ...INDEXED_CONTENT_SCHEMA,
+        text: requiredField(isString),
+    },
+    'usage.updated': {
+        usage: requiredField(isUsage),
+    },
+    'response.incomplete': {
+        reason: requiredField(isNonEmptyString),
+        status: optionalField((value) => value === 'incomplete'),
+        incompleteDetails: optionalField(isIncompleteDetails),
+        usage: optionalField(isUsage),
+    },
+    'response.completed': {
+        status: optionalField((value) => value === 'completed'),
+        usage: optionalField(isUsage),
+    },
+    'response.failed': {
+        status: optionalField((value) => value === 'failed'),
+        error: requiredField(isStreamError),
+        providerError: optionalField(isProviderError),
+        usage: optionalField(isUsage),
+    },
+};
+export function createTaskStreamEventBuilderV1(input) {
+    let terminalEmitted = false;
+    return {
+        append(event) {
+            if (!isTaskStreamEventPayload(event)) {
+                throw new TaskStreamEgressError('invalid_task_stream_event');
+            }
+            if (terminalEmitted) {
+                throw new TaskStreamEgressError('task_stream_already_terminated');
+            }
+            if (TASK_STREAM_TERMINAL_TYPES.has(event.type)) {
+                terminalEmitted = true;
+            }
+            return {
+                event: 'task.event',
+                data: {
+                    apiVersion: TOKENFORGE_TASKS_API_VERSION,
+                    requestId: input.requestId,
+                    taskId: input.taskId,
+                    sequenceNumber: event.sequenceNumber,
+                    event,
+                },
+            };
+        },
+        finish() {
+            if (!terminalEmitted) {
+                throw new TaskStreamEgressError('task_stream_terminal_required');
+            }
+        },
+    };
+}
+function isTaskStreamEventPayload(event) {
+    if (!isPlainRecord(event) || typeof event['type'] !== 'string') {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(TASK_STREAM_EVENT_SCHEMAS, event['type'])) {
+        return false;
+    }
+    const schema = TASK_STREAM_EVENT_SCHEMAS[event['type']];
+    return matchesRuntimeSchema(event, { ...BASE_STREAM_EVENT_SCHEMA, ...schema });
+}
+export function decodeTokenforgeTaskRequest(body) {
+    const request = requireRecord(body, 'body_required');
+    if (request['apiVersion'] === TOKENFORGE_TASKS_API_VERSION) {
+        return decodeTokenforgeTaskRequestV1(request);
+    }
+    if (request['apiVersion'] === TOKENFORGE_TASKS_V2_API_VERSION) {
+        return decodeTokenforgeTaskRequestV2(request);
+    }
+    reject('unsupported_api_version', 400);
+}
+function decodeTokenforgeTaskRequestV1(request) {
+    assertKnownFields(request, TOP_LEVEL_FIELDS);
+    const model = requiredString(request['model'], 'model_required');
+    const clientRequestId = decodeClientRequestId(request['clientRequestId']);
+    const providerOptions = decodeProviderOptions(request['providerOptions'], false);
+    const task = requireRecord(request['task'], 'unsupported_task');
+    const kind = task['kind'];
+    if (kind === 'chat')
+        return decodeChatTask(task, model, clientRequestId, providerOptions);
+    if (kind === 'embedding')
+        return decodeEmbeddingTask(task, model, clientRequestId, providerOptions);
+    reject('unsupported_task', 400);
+}
+function decodeTokenforgeTaskRequestV2(request) {
+    assertV2JsonSize(request, MAX_V2_BODY_BYTES);
+    assertKnownFields(request, TOP_LEVEL_FIELDS);
+    const model = requiredString(request['model'], 'model_required');
+    const clientRequestId = decodeClientRequestId(request['clientRequestId']);
+    const providerOptions = decodeProviderOptions(request['providerOptions'], true);
+    const task = requireRecord(request['task'], 'unsupported_task');
+    if (task['kind'] === 'chat')
+        return decodeChatTask(task, model, clientRequestId, providerOptions);
+    if (task['kind'] === 'embedding')
+        return decodeEmbeddingTask(task, model, clientRequestId, providerOptions);
+    if (task['kind'] === 'image_generation')
+        return decodeImageGenerationTaskV2(task, model, clientRequestId, providerOptions);
+    if (task['kind'] === 'video_generation')
+        return decodeVideoGenerationTaskV2(task, model, clientRequestId, providerOptions);
+    reject('unsupported_task', 400);
+}
+export function validateTokenforgeTaskM1Activation(decoded) {
+    if (decoded.taskKind === 'video_generation')
+        reject('unsupported_capability', 422);
+    if (decoded.taskKind !== 'image_generation')
+        return;
+    const input = decoded.normalizedInput;
+    if (input['operation'] !== 'generate' || decoded.executionMode !== 'sync') {
+        reject('unsupported_capability', 422);
+    }
+}
+export function validateTokenforgeTaskCapability(decoded, capability) {
+    if (decoded.ingressProtocolFamily !== TOKENFORGE_TASKS_PROTOCOL) {
+        reject('unsupported_capability', 422);
+    }
+    const optionNamespaces = Object.keys(decoded.providerOptions);
+    const allowedOptionNamespace = optionNamespaceForProtocolFamily(capability.protocolFamily);
+    if (optionNamespaces.length > 0 &&
+        (allowedOptionNamespace === null ||
+            optionNamespaces.some((namespace) => namespace !== allowedOptionNamespace))) {
+        reject('unsupported_provider_option', 422);
+    }
+    if (capability.protocolFamily === 'openai-chat/v1' &&
+        Object.keys(decoded.providerOptions['openai'] ?? {}).length > 0) {
+        reject('unsupported_provider_option', 422);
+    }
+    if (decoded.taskKind !== capability.taskKind ||
+        !capability.executionModes.includes(decoded.executionMode) ||
+        !decoded.inputModalities.every((item) => capability.inputModalities.includes(item)) ||
+        !decoded.outputModalities.every((item) => capability.outputModalities.includes(item)) ||
+        (decoded.requiresFunctionTools && !capability.features.includes('function_tools')) ||
+        (decoded.requiresReasoning && !capability.features.includes('reasoning'))) {
+        reject('unsupported_capability', 422);
+    }
+    if (decoded.taskKind === 'embedding') {
+        validateTaskEmbeddingCapability(decoded, capability);
+    }
+    if (decoded.taskKind === 'image_generation') {
+        validateTaskImageGenerationCapability(decoded, capability);
+    }
+    if (decoded.taskKind === 'video_generation') {
+        validateTaskVideoGenerationCapability(decoded, capability);
+    }
+}
+function optionNamespaceForProtocolFamily(protocolFamily) {
+    if (protocolFamily === 'openai-chat/v1' || protocolFamily === 'openai-responses/v1') {
+        return 'openai';
+    }
+    if (protocolFamily === 'anthropic-messages/v1') {
+        return 'anthropic';
+    }
+    if (protocolFamily === OPENAI_IMAGES_PROTOCOL)
+        return 'openaiImages';
+    if (protocolFamily === VOLC_IMAGES_PROTOCOL)
+        return 'volcImages';
+    return null;
+}
+function decodeChatTask(task, model, clientRequestId, providerOptions) {
+    assertKnownFields(task, CHAT_TASK_FIELDS);
+    if (task['mode'] !== 'sync' && task['mode'] !== 'stream') {
+        reject('unsupported_task_mode', 400);
+    }
+    const messages = decodeMessages(task['input']);
+    const maxOutputTokens = optionalPositiveInteger(task['maxOutputTokens'], 'invalid_input');
+    const temperature = optionalFiniteNumber(task['temperature']);
+    if (temperature !== undefined && (temperature < 0 || temperature > 2)) {
+        reject('invalid_input', 400);
+    }
+    const tools = decodeTools(task['tools']);
+    const toolChoice = decodeToolChoice(task['toolChoice']);
+    if (typeof toolChoice === 'object' && !tools?.some((tool) => tool.name === toolChoice.call)) {
+        reject('invalid_input', 400);
+    }
+    const modalities = messageModalities(messages);
+    const inputUsesFunctions = messages.some((message) => message.role === 'tool' ||
+        (message.role === 'assistant' &&
+            message.content.some((part) => part.type === 'function_call')));
+    const normalizedInput = {
+        input: messages,
+        ...(clientRequestId === undefined ? {} : { clientRequestId }),
+        ...(maxOutputTokens === undefined ? {} : { maxOutputTokens }),
+        ...(temperature === undefined ? {} : { temperature }),
+        ...(tools === undefined ? {} : { tools }),
+        ...(toolChoice === undefined ? {} : { toolChoice }),
+    };
+    return {
+        ingressProtocolFamily: TOKENFORGE_TASKS_PROTOCOL,
+        model,
+        taskKind: 'chat',
+        executionMode: task['mode'],
+        inputModalities: modalities,
+        outputModalities: ['text'],
+        requiresFunctionTools: inputUsesFunctions || (tools !== undefined && tools.length > 0),
+        requiresReasoning: providerOptions.openai?.reasoningEffort !== undefined,
+        normalizedInput,
+        providerOptions: { ...providerOptions },
+    };
+}
+function decodeEmbeddingTask(task, model, clientRequestId, providerOptions) {
+    assertKnownFields(task, EMBEDDING_TASK_FIELDS);
+    if (task['mode'] !== 'sync') {
+        reject('unsupported_task_mode', 400);
+    }
+    if (!Array.isArray(task['input']) || task['input'].length === 0) {
+        reject('input_required', 400);
+    }
+    if (task['input'].length > MAX_EMBEDDING_BATCH_ITEMS) {
+        reject('input_limit_exceeded', 400);
+    }
+    const input = task['input'].map((item) => requiredString(item, 'input_required'));
+    const dimensions = optionalPositiveInteger(task['dimensions'], 'invalid_input');
+    const encodingFormat = task['encodingFormat'] ?? 'float';
+    if (encodingFormat !== 'float' && encodingFormat !== 'base64') {
+        reject('invalid_input', 400);
+    }
+    return {
+        ingressProtocolFamily: TOKENFORGE_TASKS_PROTOCOL,
+        model,
+        taskKind: 'embedding',
+        executionMode: 'sync',
+        inputModalities: ['text'],
+        outputModalities: ['vector'],
+        requiresFunctionTools: false,
+        requiresReasoning: false,
+        normalizedInput: {
+            input,
+            inputEncoding: 'utf8_text',
+            encodingFormat,
+            ...(clientRequestId === undefined ? {} : { clientRequestId }),
+            ...(dimensions === undefined ? {} : { dimensions }),
+        },
+        providerOptions: { ...providerOptions },
+    };
+}
+function decodeImageGenerationTaskV2(task, model, clientRequestId, providerOptions) {
+    const operation = task['operation'];
+    if (operation !== 'generate' && operation !== 'edit')
+        reject('unsupported_task', 400);
+    assertKnownFields(task, operation === 'generate' ? IMAGE_GENERATE_TASK_FIELDS : IMAGE_EDIT_TASK_FIELDS);
+    if (task['mode'] !== 'sync' && task['mode'] !== 'stream')
+        reject('unsupported_task_mode', 400);
+    const prompt = requiredString(task['prompt'], 'input_required', false);
+    if (UTF8_ENCODER.encode(prompt).byteLength > MAX_PROMPT_BYTES)
+        reject('input_limit_exceeded', 400);
+    const count = optionalBoundedInteger(task['count'], 1, 10);
+    const size = decodeMediaSize(task['size']);
+    const quality = optionalEnum(task['quality'], ['auto', 'low', 'medium', 'high']);
+    const outputFormat = optionalEnum(task['outputFormat'], ['png', 'jpeg', 'webp']);
+    const responseFormat = optionalEnum(task['responseFormat'], ['url', 'b64_json']);
+    const images = operation === 'edit' ? decodeMediaInputs(task['images'], 10, true) : undefined;
+    const mask = operation === 'edit' && task['mask'] !== undefined
+        ? decodeMediaInputV2(task['mask'])
+        : undefined;
+    return {
+        ingressProtocolFamily: TOKENFORGE_TASKS_PROTOCOL,
+        model,
+        taskKind: 'image_generation',
+        executionMode: task['mode'],
+        inputModalities: operation === 'edit' ? ['text', 'image'] : ['text'],
+        outputModalities: ['image'],
+        requiresFunctionTools: false,
+        requiresReasoning: false,
+        normalizedInput: {
+            operation,
+            prompt,
+            ...(images === undefined ? {} : { images }),
+            ...(mask === undefined ? {} : { mask }),
+            ...(count === undefined ? {} : { count }),
+            ...(size === undefined ? {} : { size }),
+            ...(quality === undefined ? {} : { quality }),
+            ...(outputFormat === undefined ? {} : { outputFormat }),
+            ...(responseFormat === undefined ? {} : { responseFormat }),
+            ...(clientRequestId === undefined ? {} : { clientRequestId }),
+        },
+        providerOptions: { ...providerOptions },
+    };
+}
+function decodeVideoGenerationTaskV2(task, model, clientRequestId, providerOptions) {
+    assertKnownFields(task, VIDEO_TASK_FIELDS);
+    if (task['mode'] !== 'async')
+        reject('unsupported_task_mode', 400);
+    const input = decodeVideoInput(task['input']);
+    const durationSeconds = optionalBoundedInteger(task['durationSeconds'], 1, 60);
+    const aspectRatio = optionalString(task['aspectRatio'], 'invalid_input');
+    if (aspectRatio !== undefined && aspectRatio.length > 32)
+        reject('input_limit_exceeded', 400);
+    const size = decodeMediaSize(task['size']);
+    if (task['returnLastFrame'] !== undefined && typeof task['returnLastFrame'] !== 'boolean')
+        reject('invalid_input', 400);
+    const callbackUrl = optionalString(task['callbackUrl'], 'invalid_input');
+    if (callbackUrl !== undefined && (callbackUrl.length > 2_048 || !isHttpsUrl(callbackUrl)))
+        reject('invalid_input', 400);
+    assertNoEmbeddedVideoCommandConflict(input, durationSeconds, aspectRatio);
+    return {
+        ingressProtocolFamily: TOKENFORGE_TASKS_PROTOCOL,
+        model,
+        taskKind: 'video_generation',
+        executionMode: 'async',
+        inputModalities: videoInputModalities(input),
+        outputModalities: ['video'],
+        requiresFunctionTools: false,
+        requiresReasoning: false,
+        normalizedInput: {
+            input,
+            ...(durationSeconds === undefined ? {} : { durationSeconds }),
+            ...(aspectRatio === undefined ? {} : { aspectRatio }),
+            ...(size === undefined ? {} : { size }),
+            ...(task['returnLastFrame'] === undefined
+                ? {}
+                : { returnLastFrame: task['returnLastFrame'] }),
+            ...(callbackUrl === undefined ? {} : { callbackUrl }),
+            ...(clientRequestId === undefined ? {} : { clientRequestId }),
+        },
+        providerOptions: { ...providerOptions },
+    };
+}
+function videoInputModalities(input) {
+    const hasText = input.some((item) => item.type === 'input_text');
+    const hasImage = input.some((item) => item.type === 'input_image');
+    return [...(hasText ? ['text'] : []), ...(hasImage ? ['image'] : [])];
+}
+function decodeMediaInputs(value, max, required) {
+    if (!Array.isArray(value) || (required && value.length === 0))
+        reject('input_required', 400);
+    if (value.length > max)
+        reject('input_limit_exceeded', 400);
+    return value.map(decodeMediaInputV2);
+}
+export function decodeMediaInputV2(value) {
+    const input = requireRecord(value, 'invalid_input');
+    if (input['kind'] === 'url') {
+        assertKnownFields(input, new Set(['kind', 'url', 'mimeType']));
+        const url = requiredString(input['url'], 'invalid_input');
+        if (url.length > MAX_MEDIA_URL_CHARS)
+            reject('input_limit_exceeded', 400);
+        if (!isHttpsUrl(url))
+            reject('invalid_input', 400);
+        const mimeType = optionalString(input['mimeType'], 'invalid_input');
+        return { kind: 'url', url, ...(mimeType === undefined ? {} : { mimeType }) };
+    }
+    if (input['kind'] === 'object') {
+        assertKnownFields(input, new Set(['kind', 'objectKey']));
+        const objectKey = requiredString(input['objectKey'], 'invalid_input');
+        if (objectKey.length > MAX_OBJECT_KEY_CHARS)
+            reject('input_limit_exceeded', 400);
+        return { kind: 'object', objectKey };
+    }
+    reject('invalid_input', 400);
+}
+function decodeVideoInput(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        reject('input_required', 400);
+    if (value.length > 8)
+        reject('input_limit_exceeded', 400);
+    let textBytes = 0;
+    let imageCount = 0;
+    return value.map((item) => {
+        const part = requireRecord(item, 'invalid_input');
+        if (part['type'] === 'input_text') {
+            assertKnownFields(part, new Set(['type', 'text']));
+            const text = requiredString(part['text'], 'input_required', false);
+            textBytes += UTF8_ENCODER.encode(text).byteLength;
+            if (textBytes > MAX_VIDEO_TEXT_BYTES)
+                reject('input_limit_exceeded', 400);
+            return { type: 'input_text', text };
+        }
+        if (part['type'] === 'input_image') {
+            assertKnownFields(part, new Set(['type', 'media']));
+            imageCount += 1;
+            if (imageCount > 7)
+                reject('input_limit_exceeded', 400);
+            return { type: 'input_image', media: decodeMediaInputV2(part['media']) };
+        }
+        reject('invalid_input', 400);
+    });
+}
+function assertNoEmbeddedVideoCommandConflict(input, durationSeconds, aspectRatio) {
+    for (const part of input) {
+        if (part.type !== 'input_text')
+            continue;
+        const duration = /(?:^|\s)--dur(?:ation)?(?:\s+|=)(\d+)(?=\s|$)/u.exec(part.text)?.[1];
+        if (durationSeconds !== undefined &&
+            duration !== undefined &&
+            Number(duration) !== durationSeconds) {
+            reject('invalid_request', 400);
+        }
+        const ratio = /(?:^|\s)--ratio(?:\s+|=)([^\s]+)(?=\s|$)/u.exec(part.text)?.[1];
+        if (aspectRatio !== undefined && ratio !== undefined && ratio !== aspectRatio) {
+            reject('invalid_request', 400);
+        }
+    }
+}
+function decodeMediaSize(value) {
+    if (value === undefined)
+        return undefined;
+    const size = requireRecord(value, 'invalid_input');
+    assertKnownFields(size, new Set(['width', 'height']));
+    const width = optionalBoundedInteger(size['width'], 256, 4096);
+    const height = optionalBoundedInteger(size['height'], 256, 4096);
+    if (width === undefined || height === undefined)
+        reject('invalid_input', 400);
+    return { width, height };
+}
+function decodeMessages(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        reject('input_required', 400);
+    }
+    if (value.length > MAX_MESSAGES) {
+        reject('input_limit_exceeded', 400);
+    }
+    return value.map((item) => decodeMessage(item));
+}
+function decodeMessage(value) {
+    const message = requireRecord(value, 'invalid_input');
+    assertKnownFields(message, new Set(['role', 'content']));
+    const role = message['role'];
+    const content = message['content'];
+    if (!Array.isArray(content) || content.length === 0) {
+        reject('input_required', 400);
+    }
+    if (content.length > MAX_CONTENT_PARTS) {
+        reject('input_limit_exceeded', 400);
+    }
+    if (role === 'system' || role === 'developer') {
+        return { role, content: content.map((part) => decodeInputText(part)) };
+    }
+    if (role === 'user') {
+        return {
+            role,
+            content: content.map((part) => {
+                const type = recordType(part);
+                return type === 'input_text' ? decodeInputText(part) : decodeInputImage(part);
+            }),
+        };
+    }
+    if (role === 'assistant') {
+        return {
+            role,
+            content: content.map((part) => {
+                const type = recordType(part);
+                return type === 'input_text' ? decodeInputText(part) : decodeFunctionCall(part);
+            }),
+        };
+    }
+    if (role === 'tool') {
+        if (content.length !== 1) {
+            reject('invalid_input', 400);
+        }
+        return { role, content: [decodeToolResult(content[0])] };
+    }
+    reject('invalid_input', 400);
+}
+function decodeInputText(value) {
+    const part = requireRecord(value, 'invalid_input');
+    if (part['type'] !== 'input_text') {
+        reject('invalid_input', 400);
+    }
+    assertKnownFields(part, new Set(['type', 'text']));
+    return { type: 'input_text', text: requiredString(part['text'], 'input_required') };
+}
+function decodeInputImage(value) {
+    const part = requireRecord(value, 'invalid_input');
+    if (part['type'] !== 'input_image') {
+        reject('invalid_input', 400);
+    }
+    assertKnownFields(part, new Set(['type', 'source', 'detail']));
+    const source = requireRecord(part['source'], 'invalid_input');
+    assertKnownFields(source, new Set(['kind', 'value']));
+    if (source['kind'] !== 'https_url' && source['kind'] !== 'data_url') {
+        reject('invalid_input', 400);
+    }
+    const detail = part['detail'];
+    if (detail !== undefined && detail !== 'auto' && detail !== 'low' && detail !== 'high') {
+        reject('invalid_input', 400);
+    }
+    return {
+        type: 'input_image',
+        source: { kind: source['kind'], value: requiredString(source['value'], 'invalid_input') },
+        ...(detail === undefined ? {} : { detail }),
+    };
+}
+function decodeFunctionCall(value) {
+    const part = requireRecord(value, 'invalid_input');
+    if (part['type'] !== 'function_call') {
+        reject('invalid_input', 400);
+    }
+    assertKnownFields(part, new Set(['type', 'callId', 'name', 'arguments']));
+    const callId = functionIdentifier(part['callId']);
+    const name = functionIdentifier(part['name']);
+    const args = requiredString(part['arguments'], 'invalid_input', false);
+    if (UTF8_ENCODER.encode(args).byteLength > MAX_FUNCTION_ARGUMENT_BYTES) {
+        reject('input_limit_exceeded', 400);
+    }
+    return { type: 'function_call', callId, name, arguments: args };
+}
+function decodeToolResult(value) {
+    const part = requireRecord(value, 'invalid_input');
+    if (part['type'] !== 'tool_result') {
+        reject('invalid_input', 400);
+    }
+    assertKnownFields(part, new Set(['type', 'callId', 'output']));
+    return {
+        type: 'tool_result',
+        callId: functionIdentifier(part['callId']),
+        output: requiredString(part['output'], 'invalid_input', false),
+    };
+}
+function decodeTools(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.length === 0) {
+        reject('invalid_input', 400);
+    }
+    return value.map((rawTool) => {
+        const tool = requireRecord(rawTool, 'invalid_input');
+        assertKnownFields(tool, new Set(['type', 'name', 'description', 'parameters', 'strict']));
+        if (tool['type'] !== 'function') {
+            reject('invalid_input', 400);
+        }
+        const name = functionIdentifier(tool['name']);
+        const description = optionalString(tool['description'], 'invalid_input');
+        const parameters = validateJsonSchema(tool['parameters']);
+        if (tool['strict'] !== undefined && typeof tool['strict'] !== 'boolean') {
+            reject('invalid_input', 400);
+        }
+        return {
+            type: 'function',
+            name,
+            parameters,
+            ...(description === undefined ? {} : { description }),
+            ...(tool['strict'] === undefined ? {} : { strict: tool['strict'] }),
+        };
+    });
+}
+function decodeToolChoice(value) {
+    if (value === undefined || value === 'auto' || value === 'none') {
+        return value;
+    }
+    const choice = requireRecord(value, 'invalid_input');
+    assertKnownFields(choice, new Set(['call']));
+    return { call: functionIdentifier(choice['call']) };
+}
+function decodeProviderOptions(value, allowMedia) {
+    if (value === undefined) {
+        return {};
+    }
+    if (allowMedia)
+        assertV2JsonSize(value, MAX_PROVIDER_OPTIONS_BYTES);
+    if (!isPlainRecord(value)) {
+        reject('unsupported_provider_option', 400);
+    }
+    const keys = Object.keys(value);
+    if (keys.some((key) => key !== 'openai' &&
+        key !== 'anthropic' &&
+        (!allowMedia || (key !== 'openaiImages' && key !== 'volcImages')))) {
+        reject('unsupported_provider_option', 400);
+    }
+    const output = {};
+    if (value['openai'] !== undefined) {
+        const openai = providerOptionRecord(value['openai']);
+        if (Object.keys(openai).some((key) => key !== 'reasoningEffort')) {
+            reject('unsupported_provider_option', 400);
+        }
+        const effort = openai['reasoningEffort'];
+        if (effort !== undefined && !REASONING_EFFORTS.has(effort)) {
+            reject('unsupported_provider_option', 400);
+        }
+        output.openai = effort === undefined ? {} : { reasoningEffort: effort };
+    }
+    if (value['anthropic'] !== undefined) {
+        const anthropic = providerOptionRecord(value['anthropic']);
+        if (Object.keys(anthropic).some((key) => key !== 'topK')) {
+            reject('unsupported_provider_option', 400);
+        }
+        const topK = anthropic['topK'];
+        if (topK !== undefined &&
+            (typeof topK !== 'number' || !Number.isSafeInteger(topK) || topK <= 0)) {
+            reject('unsupported_provider_option', 400);
+        }
+        output.anthropic = topK === undefined ? {} : { topK };
+    }
+    if (value['openaiImages'] !== undefined) {
+        const openaiImages = providerOptionRecord(value['openaiImages']);
+        if (Object.keys(openaiImages).some((key) => key !== 'background' && key !== 'moderation' && key !== 'outputCompression'))
+            reject('unsupported_provider_option', 400);
+        const background = openaiImages['background'];
+        const moderation = openaiImages['moderation'];
+        const outputCompression = openaiImages['outputCompression'];
+        if ((background !== undefined &&
+            background !== 'transparent' &&
+            background !== 'opaque' &&
+            background !== 'auto') ||
+            (moderation !== undefined && moderation !== 'low' && moderation !== 'auto') ||
+            (outputCompression !== undefined &&
+                (typeof outputCompression !== 'number' ||
+                    !Number.isSafeInteger(outputCompression) ||
+                    outputCompression < 0 ||
+                    outputCompression > 100)))
+            reject('unsupported_provider_option', 400);
+        output.openaiImages = {
+            ...(background === undefined ? {} : { background }),
+            ...(moderation === undefined ? {} : { moderation }),
+            ...(outputCompression === undefined ? {} : { outputCompression }),
+        };
+    }
+    if (value['volcImages'] !== undefined) {
+        const volcImages = providerOptionRecord(value['volcImages']);
+        if (Object.keys(volcImages).some((key) => key !== 'watermark') ||
+            (volcImages['watermark'] !== undefined && typeof volcImages['watermark'] !== 'boolean'))
+            reject('unsupported_provider_option', 400);
+        output.volcImages =
+            volcImages['watermark'] === undefined ? {} : { watermark: volcImages['watermark'] };
+    }
+    return output;
+}
+function validateTaskEmbeddingCapability(decoded, capability) {
+    const failure = embeddingCapabilityFailure(decoded, capability);
+    if (failure !== undefined) {
+        reject('unsupported_capability', 422);
+    }
+}
+function validateTaskImageGenerationCapability(decoded, capability) {
+    if (capability.protocolFamily !== OPENAI_IMAGES_PROTOCOL &&
+        capability.protocolFamily !== VOLC_IMAGES_PROTOCOL) {
+        reject('unsupported_capability', 422);
+    }
+    const facts = parseImageGenerationCapabilityV1(capability.imageGenerationCapability);
+    if (facts === null)
+        reject('unsupported_capability', 422);
+    const input = decoded.normalizedInput;
+    const prompt = input['prompt'];
+    const count = input['count'] ?? 1;
+    if (typeof prompt !== 'string' ||
+        UTF8_ENCODER.encode(prompt).byteLength > facts.maxPromptUtf8Bytes ||
+        typeof count !== 'number' ||
+        count < facts.minCount ||
+        count > facts.maxCount)
+        reject('unsupported_capability', 422);
+    const size = input['size'];
+    if (size !== undefined &&
+        (!isPlainRecord(size) ||
+            !facts.allowedSizes.some((allowed) => allowed.width === size['width'] && allowed.height === size['height'])))
+        reject('unsupported_capability', 422);
+    const quality = input['quality'];
+    const outputFormat = input['outputFormat'];
+    const responseFormat = input['responseFormat'];
+    if ((quality !== undefined && !facts.qualities.includes(quality)) ||
+        (outputFormat !== undefined && !facts.outputFormats.includes(outputFormat)) ||
+        (responseFormat !== undefined && !facts.responseFormats.includes(responseFormat)))
+        reject('unsupported_capability', 422);
+}
+function validateTaskVideoGenerationCapability(decoded, capability) {
+    const facts = parseVideoGenerationCapabilityV1(capability.videoGenerationCapability);
+    if ((capability.protocolFamily !== 'volc-video/v1' &&
+        capability.protocolFamily !== 'ppio-video/v1') ||
+        facts === null) {
+        reject('unsupported_capability', 422);
+    }
+    const input = decoded.normalizedInput;
+    const items = input['input'];
+    if (!Array.isArray(items))
+        reject('unsupported_capability', 422);
+    const imageCount = items.filter((item) => isPlainRecord(item) && item['type'] === 'input_image').length;
+    const hasText = items.some((item) => isPlainRecord(item) && item['type'] === 'input_text');
+    if (imageCount > facts.maxInputImages ||
+        (imageCount > 0 && !facts.inputKinds.includes('image')) ||
+        (hasText && !facts.inputKinds.includes('text'))) {
+        reject('unsupported_capability', 422);
+    }
+    const durationSeconds = input['durationSeconds'];
+    const aspectRatio = input['aspectRatio'];
+    const size = input['size'];
+    if ((durationSeconds !== undefined &&
+        (typeof durationSeconds !== 'number' ||
+            !facts.allowedDurationsSeconds.includes(durationSeconds))) ||
+        (aspectRatio !== undefined &&
+            (typeof aspectRatio !== 'string' || !facts.allowedAspectRatios.includes(aspectRatio))) ||
+        (size !== undefined &&
+            (!isPlainRecord(size) ||
+                !facts.allowedSizes.some((allowed) => allowed.width === size['width'] && allowed.height === size['height']))) ||
+        (input['returnLastFrame'] === true && !facts.supportsLastFrame) ||
+        (input['callbackUrl'] !== undefined && !facts.supportsCallback)) {
+        reject('unsupported_capability', 422);
+    }
+}
+function validateJsonSchema(value) {
+    if (!isPlainRecord(value)) {
+        reject('invalid_input', 400);
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        reject('invalid_input', 400);
+    }
+    if (UTF8_ENCODER.encode(serialized).byteLength > MAX_JSON_SCHEMA_BYTES) {
+        reject('input_limit_exceeded', 400);
+    }
+    let nodes = 0;
+    const seen = new Set();
+    const visit = (item, depth) => {
+        nodes += 1;
+        if (nodes > MAX_JSON_SCHEMA_NODES || depth > MAX_JSON_SCHEMA_DEPTH) {
+            reject('input_limit_exceeded', 400);
+        }
+        if (item === null || typeof item === 'string' || typeof item === 'boolean') {
+            return;
+        }
+        if (typeof item === 'number') {
+            if (!Number.isFinite(item)) {
+                reject('invalid_input', 400);
+            }
+            return;
+        }
+        if (typeof item !== 'object' || seen.has(item)) {
+            reject('invalid_input', 400);
+        }
+        seen.add(item);
+        if (Array.isArray(item)) {
+            item.forEach((child) => visit(child, child !== null && typeof child === 'object' ? depth + 1 : depth));
+        }
+        else if (isPlainRecord(item)) {
+            Object.values(item).forEach((child) => visit(child, child !== null && typeof child === 'object' ? depth + 1 : depth));
+        }
+        else {
+            reject('invalid_input', 400);
+        }
+        seen.delete(item);
+    };
+    visit(value, 1);
+    return value;
+}
+function messageModalities(messages) {
+    const hasImage = messages.some((message) => message.role === 'user' && message.content.some((part) => part.type === 'input_image'));
+    return hasImage ? ['text', 'image'] : ['text'];
+}
+function recordType(value) {
+    return isPlainRecord(value) ? value['type'] : undefined;
+}
+function functionIdentifier(value) {
+    const identifier = requiredString(value, 'invalid_input');
+    if (identifier.length > MAX_FUNCTION_IDENTIFIER_CHARS) {
+        reject('input_limit_exceeded', 400);
+    }
+    return identifier;
+}
+function decodeClientRequestId(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || !value.trim() || value.length > MAX_CLIENT_REQUEST_ID_CHARS) {
+        reject('invalid_client_request_id', 400);
+    }
+    return value;
+}
+function providerOptionRecord(value) {
+    if (!isPlainRecord(value)) {
+        reject('unsupported_provider_option', 400);
+    }
+    return value;
+}
+function requireRecord(value, code) {
+    if (!isPlainRecord(value)) {
+        reject(code, 400);
+    }
+    return value;
+}
+function isPlainRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function assertKnownFields(value, allowed, code = 'unknown_field') {
+    if (Object.keys(value).some((key) => !allowed.has(key))) {
+        reject(code, 400);
+    }
+}
+function requiredString(value, code, trimRequired = true) {
+    if (typeof value !== 'string' || (trimRequired && !value.trim())) {
+        reject(code, 400);
+    }
+    return value;
+}
+function optionalString(value, code) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return requiredString(value, code);
+}
+function optionalPositiveInteger(value, code) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+        reject(code, 400);
+    }
+    return value;
+}
+function optionalBoundedInteger(value, minimum, maximum) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' ||
+        !Number.isSafeInteger(value) ||
+        value < minimum ||
+        value > maximum) {
+        reject('input_limit_exceeded', 400);
+    }
+    return value;
+}
+function optionalEnum(value, allowed) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !allowed.includes(value))
+        reject('invalid_input', 400);
+    return value;
+}
+function isHttpsUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && Boolean(url.hostname) && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+}
+function assertV2JsonSize(value, maximum) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        reject('invalid_input', 400);
+    }
+    if (UTF8_ENCODER.encode(serialized).byteLength > maximum)
+        reject('input_limit_exceeded', 400);
+}
+function optionalFiniteNumber(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        reject('invalid_input', 400);
+    }
+    return value;
+}
+function reject(code, status) {
+    throw new TokenforgeTaskRequestError(code, status);
+}
+//# sourceMappingURL=tokenforge-tasks.js.map