@skyold/model-protocol 0.1.0-beta.0

package/dist/runtime-v2-validation.js

@@ -0,0 +1,915 @@
+import { decodeImageGenerationProtocolSnapshotV1, decodeMediaTaskResultV2, parseImageGenerationCapabilityV1, } from './media-images.js';
+export function validateFixedDispatchInput(input) {
+    if (!input.target.sourceId.trim()) {
+        throw new Error('SOURCE_ID_REQUIRED');
+    }
+    validateProviderDispatchInputV2(input);
+}
+export function validateProviderDispatchInputV2(input) {
+    if (!input.target.connectionRef.trim()) {
+        throw new Error('CONNECTION_REF_REQUIRED');
+    }
+    if (input.task.protocolFamily !== input.target.capability.protocolFamily ||
+        input.task.dispatchProtocolFamily !== input.target.capability.protocolFamily) {
+        throw new Error('PROTOCOL_FAMILY_MISMATCH');
+    }
+    if (input.target.capability.protocolFamily !== input.capability.protocolFamily) {
+        throw new Error('CAPABILITY_PROTOCOL_MISMATCH');
+    }
+    if (!capabilityMatchesTarget(input)) {
+        throw new Error('TARGET_CAPABILITY_MISMATCH');
+    }
+    if (input.task.taskKind !== input.capability.taskKind) {
+        throw new Error('TASK_KIND_MISMATCH');
+    }
+    if (!input.capability.executionModes.includes(input.task.executionMode)) {
+        throw new Error('EXECUTION_MODE_MISMATCH');
+    }
+    if (!modalitiesMatch(input.task.inputModalities, input.capability.inputModalities)) {
+        throw new Error('INPUT_MODALITY_MISMATCH');
+    }
+    if (!modalitiesMatch(input.task.outputModalities, input.capability.outputModalities)) {
+        throw new Error('OUTPUT_MODALITY_MISMATCH');
+    }
+}
+function capabilityMatchesTarget(input) {
+    const { capability, target } = input;
+    return (target.provider === capability.provider &&
+        target.providerModel === capability.model &&
+        target.capability.taskKind === capability.taskKind &&
+        target.capability.protocolFamily === capability.protocolFamily &&
+        sameValues(target.capability.inputModalities, capability.inputModalities) &&
+        sameValues(target.capability.outputModalities, capability.outputModalities) &&
+        sameValues(target.capability.executionModes, capability.executionModes) &&
+        sameValues(target.capability.features, capability.features) &&
+        sameOptionalValues(target.capability.operations, capability.operations) &&
+        embeddingCapabilitiesMatch(target.capability.embeddingCapability, capability.embeddingCapability) &&
+        imageGenerationCapabilitiesMatch(target.capability.imageGenerationCapability, capability.imageGenerationCapability) &&
+        imageEditingCapabilitiesMatch(target.capability.imageEditingCapability, capability.imageEditingCapability) &&
+        imageUsageReportingCapabilitiesMatch(target.capability.imageUsageReportingCapability, capability.imageUsageReportingCapability) &&
+        target.connectionRef === capability.dispatchRef &&
+        capability.active);
+}
+function imageUsageReportingCapabilitiesMatch(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.schemaVersion === right.schemaVersion &&
+        sameValueSet(left.guaranteedUnits, right.guaranteedUnits));
+}
+function imageEditingCapabilitiesMatch(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.maxInputImages === right.maxInputImages &&
+        left.supportsMask === right.supportsMask &&
+        sameValueSet(left.inputMimeTypes, right.inputMimeTypes));
+}
+function imageGenerationCapabilitiesMatch(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    const parsedLeft = parseImageGenerationCapabilityV1(left);
+    const parsedRight = parseImageGenerationCapabilityV1(right);
+    if (parsedLeft === null || parsedRight === null)
+        return false;
+    return (parsedLeft.schemaVersion === parsedRight.schemaVersion &&
+        parsedLeft.minCount === parsedRight.minCount &&
+        parsedLeft.maxCount === parsedRight.maxCount &&
+        parsedLeft.maxPromptUtf8Bytes === parsedRight.maxPromptUtf8Bytes &&
+        parsedLeft.certifiedModelRevision === parsedRight.certifiedModelRevision &&
+        sameValueSet(parsedLeft.supportedPolicies, parsedRight.supportedPolicies) &&
+        sameValueSet(parsedLeft.responseFormats, parsedRight.responseFormats) &&
+        sameValueSet(parsedLeft.outputFormats, parsedRight.outputFormats) &&
+        sameOptionalValueSet(parsedLeft.allowedBackgrounds, parsedRight.allowedBackgrounds) &&
+        formatMappingsMatch(parsedLeft.requestMapping.responseFormat, parsedRight.requestMapping.responseFormat) &&
+        formatMappingsMatch(parsedLeft.requestMapping.outputFormat, parsedRight.requestMapping.outputFormat) &&
+        sameValueSet(parsedLeft.requestMapping.providerOptions.openaiImages, parsedRight.requestMapping.providerOptions.openaiImages) &&
+        sameValueSet(parsedLeft.requestMapping.providerOptions.volcImages, parsedRight.requestMapping.providerOptions.volcImages) &&
+        sameValueSet(parsedLeft.qualities, parsedRight.qualities) &&
+        sameValueSet(parsedLeft.allowedSizes.map((size) => `${size.width}x${size.height}`), parsedRight.allowedSizes.map((size) => `${size.width}x${size.height}`)));
+}
+function sameOptionalValueSet(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return sameValueSet(left, right);
+}
+function formatMappingsMatch(left, right) {
+    if (left.mode !== right.mode)
+        return false;
+    return left.mode === 'parameter'
+        ? left.defaultValue === right.defaultValue
+        : left.value === right.value;
+}
+function sameOptionalValues(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return sameValues(left, right);
+}
+function embeddingCapabilitiesMatch(left, right) {
+    if (left === undefined || right === undefined) {
+        return left === right;
+    }
+    return (left.schemaVersion === right.schemaVersion &&
+        left.nativeDimensions === right.nativeDimensions &&
+        sameValues(left.allowedDimensions, right.allowedDimensions) &&
+        sameValues(left.encodingFormats, right.encodingFormats) &&
+        left.normalized === right.normalized &&
+        left.maxBatchItems === right.maxBatchItems &&
+        left.maxInputTokensPerItem === right.maxInputTokensPerItem &&
+        left.maxTotalInputTokens === right.maxTotalInputTokens &&
+        sameValues(left.inputEncodings, right.inputEncodings) &&
+        left.compatibilitySpace.provider === right.compatibilitySpace.provider &&
+        left.compatibilitySpace.model === right.compatibilitySpace.model &&
+        left.compatibilitySpace.modelVersion === right.compatibilitySpace.modelVersion &&
+        left.compatibilitySpace.dimensions === right.compatibilitySpace.dimensions &&
+        left.compatibilitySpace.preprocessingVersion ===
+            right.compatibilitySpace.preprocessingVersion &&
+        left.compatibilitySpace.spaceId === right.compatibilitySpace.spaceId);
+}
+export function validateProviderExecutionStart(input, expectedTaskKind) {
+    const value = runtimeRecord(input, 'ADAPTER_EXECUTION_START_INVALID');
+    validateProviderAcceptance(value['acceptance'], 'ADAPTER_EXECUTION_START_INVALID');
+    validateProviderResponseMetadata(value['responseMetadata'], 'ADAPTER_EXECUTION_START_INVALID');
+    if (value['kind'] !== 'sync' && value['kind'] !== 'stream') {
+        throw new Error('ADAPTER_EXECUTION_START_INVALID');
+    }
+    if (input.kind === 'sync') {
+        assertOnlyKeys(value, ['kind', 'acceptance', 'responseMetadata', 'terminal'], 'ADAPTER_EXECUTION_START_INVALID');
+        validateAdapterTerminalOutcome(input.terminal, expectedTaskKind);
+        validateTerminalAcceptance(input.acceptance, input.terminal);
+        return input;
+    }
+    if (!isAsyncIterable(value['events']) ||
+        !isPromiseLike(value['terminal']) ||
+        typeof value['abort'] !== 'function') {
+        throw new Error('ADAPTER_EXECUTION_START_INVALID');
+    }
+    assertOnlyKeys(value, ['kind', 'acceptance', 'responseMetadata', 'events', 'terminal', 'abort'], 'ADAPTER_EXECUTION_START_INVALID');
+    return {
+        ...input,
+        events: validateStreamEvents(input.events),
+        terminal: input.terminal.then((terminal) => {
+            validateAdapterTerminalOutcome(terminal, expectedTaskKind);
+            validateTerminalAcceptance(input.acceptance, terminal);
+            return terminal;
+        }),
+    };
+}
+/**
+ * Runtime boundary for third-party or dynamically registered Adapter streams.
+ * Invalid Provider-specific data must fail before it becomes a normalized Host fact.
+ */
+export function validateNormalizedStreamEvent(input) {
+    const value = runtimeRecord(input, 'ADAPTER_STREAM_EVENT_INVALID');
+    if (typeof value['type'] !== 'string' ||
+        !requiredString(value['eventId']) ||
+        !nonNegativeInteger(value['sequenceNumber']) ||
+        !requiredString(value['responseId'])) {
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+    switch (value['type']) {
+        case 'response.started':
+            assertStreamEventKeys(value, []);
+            break;
+        case 'response.in_progress':
+            assertStreamEventKeys(value, ['status']);
+            requireLiteral(value['status'], 'in_progress');
+            break;
+        case 'output.item.added':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'itemKind', 'item']);
+            validateIndexedItem(value);
+            validateOutputItemKind(value['itemKind']);
+            validateNormalizedOutputItem(value['item']);
+            validateOutputItemKindMatch(value['itemKind'], value['item']);
+            break;
+        case 'output.text.delta':
+        case 'output.refusal.delta':
+        case 'output.reasoning_summary.delta':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'contentIndex', 'delta']);
+            validateIndexedContent(value);
+            requireString(value['delta']);
+            break;
+        case 'output.tool_call.delta':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'callId', 'name', 'argumentsDelta']);
+            validateIndexedItem(value);
+            requireNonEmptyString(value['callId']);
+            optionalRequiredString(value['name']);
+            requireString(value['argumentsDelta']);
+            break;
+        case 'output.content_part.added':
+        case 'output.content_part.completed':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'contentIndex', 'part']);
+            validateIndexedContent(value);
+            validateNormalizedContentPart(value['part']);
+            break;
+        case 'output.item.completed':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'itemKind', 'status', 'item']);
+            validateIndexedItem(value);
+            validateOutputItemKind(value['itemKind']);
+            if (value['status'] !== 'completed' && value['status'] !== 'incomplete') {
+                throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+            }
+            validateNormalizedOutputItem(value['item']);
+            validateOutputItemKindMatch(value['itemKind'], value['item']);
+            break;
+        case 'output.text.completed':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'contentIndex', 'text']);
+            validateIndexedContent(value);
+            requireString(value['text']);
+            break;
+        case 'output.refusal.completed':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'contentIndex', 'refusal']);
+            validateIndexedContent(value);
+            requireString(value['refusal']);
+            break;
+        case 'output.tool_call.completed':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'callId', 'name', 'arguments']);
+            validateIndexedItem(value);
+            requireNonEmptyString(value['callId']);
+            requireNonEmptyString(value['name']);
+            requireString(value['arguments']);
+            break;
+        case 'output.reasoning_summary.completed':
+            assertStreamEventKeys(value, ['itemId', 'outputIndex', 'contentIndex', 'text']);
+            validateIndexedContent(value);
+            requireString(value['text']);
+            break;
+        case 'usage.updated':
+            assertStreamEventKeys(value, ['usage']);
+            validateNormalizedUsage(value['usage']);
+            break;
+        case 'response.incomplete':
+            assertStreamEventKeys(value, ['reason', 'status', 'incompleteDetails', 'usage']);
+            requireNonEmptyString(value['reason']);
+            if (value['status'] !== undefined)
+                requireLiteral(value['status'], 'incomplete');
+            validateOptionalIncompleteDetails(value['incompleteDetails']);
+            validateOptionalUsage(value['usage']);
+            break;
+        case 'response.completed':
+            assertStreamEventKeys(value, ['status', 'usage']);
+            if (value['status'] !== undefined)
+                requireLiteral(value['status'], 'completed');
+            validateOptionalUsage(value['usage']);
+            break;
+        case 'response.cancelled':
+            assertStreamEventKeys(value, ['status', 'usage']);
+            requireLiteral(value['status'], 'cancelled');
+            validateOptionalUsage(value['usage']);
+            break;
+        case 'response.failed': {
+            assertStreamEventKeys(value, ['status', 'error', 'providerError', 'usage']);
+            if (value['status'] !== undefined)
+                requireLiteral(value['status'], 'failed');
+            const error = runtimeRecord(value['error'], 'ADAPTER_STREAM_EVENT_INVALID');
+            assertOnlyKeys(error, ['code', 'category', 'retryable'], 'ADAPTER_STREAM_EVENT_INVALID');
+            requireNonEmptyString(error['code']);
+            requireNonEmptyString(error['category']);
+            if (typeof error['retryable'] !== 'boolean') {
+                throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+            }
+            validateOptionalProviderError(value['providerError']);
+            validateOptionalUsage(value['usage']);
+            break;
+        }
+        default:
+            throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+    return input;
+}
+/** Runtime-validates terminal facts before Engine exposes them to a Host. */
+export function validateAdapterTerminalOutcome(input, expectedTaskKind) {
+    const value = runtimeRecord(input, 'ADAPTER_TERMINAL_INVALID');
+    assertOnlyKeys(value, [
+        'status',
+        'acceptanceState',
+        'failureOrigin',
+        'failureCode',
+        'retryable',
+        'result',
+        'usage',
+        'incompleteDetails',
+        'providerError',
+        'normalizedResponse',
+    ], 'ADAPTER_TERMINAL_INVALID');
+    if (!['succeeded', 'failed', 'cancelled', 'incomplete'].includes(String(value['status'])) ||
+        !['accepted', 'not-accepted', 'unknown'].includes(String(value['acceptanceState'])) ||
+        typeof value['retryable'] !== 'boolean') {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    if (value['status'] === 'succeeded' && value['acceptanceState'] !== 'accepted') {
+        throw new Error('ADAPTER_SUCCEEDED_WITHOUT_ACCEPTANCE');
+    }
+    optionalNonEmptyStringOrThrow(value['failureOrigin'], 'ADAPTER_TERMINAL_INVALID');
+    optionalNonEmptyStringOrThrow(value['failureCode'], 'ADAPTER_TERMINAL_INVALID');
+    validateOptionalUsage(value['usage'], 'ADAPTER_TERMINAL_INVALID');
+    validateOptionalIncompleteDetails(value['incompleteDetails'], 'ADAPTER_TERMINAL_INVALID');
+    validateOptionalProviderError(value['providerError'], 'ADAPTER_TERMINAL_INVALID');
+    const result = value['result'] === undefined ? undefined : validateNormalizedResult(value['result']);
+    if (result !== undefined &&
+        expectedTaskKind !== undefined &&
+        result.taskKind !== expectedTaskKind) {
+        throw new Error('ADAPTER_TERMINAL_TASK_KIND_MISMATCH');
+    }
+    if (result?.usage !== undefined &&
+        value['usage'] !== undefined &&
+        !sameNormalizedUsage(result.usage, value['usage'])) {
+        throw new Error('ADAPTER_TERMINAL_USAGE_MISMATCH');
+    }
+    if (value['normalizedResponse'] !== undefined) {
+        const response = validateNormalizedResponsesSyncResponse(value['normalizedResponse']);
+        if (!normalizedResponseStatusMatchesTerminal(response.status, String(value['status']))) {
+            throw new Error('ADAPTER_TERMINAL_RESPONSE_STATUS_MISMATCH');
+        }
+        if (response.usage !== undefined &&
+            value['usage'] !== undefined &&
+            !sameNormalizedUsage(response.usage, value['usage'])) {
+            throw new Error('ADAPTER_TERMINAL_USAGE_MISMATCH');
+        }
+    }
+    return input;
+}
+function validateNormalizedResult(value) {
+    const result = runtimeRecord(value, 'ADAPTER_TERMINAL_INVALID');
+    if (result['taskKind'] === 'chat') {
+        assertOnlyKeys(result, ['taskKind', 'output', 'usage'], 'ADAPTER_TERMINAL_INVALID');
+        validateChatOutput(result['output']);
+    }
+    else if (result['taskKind'] === 'embedding') {
+        assertOnlyKeys(result, ['taskKind', 'output', 'usage'], 'ADAPTER_TERMINAL_INVALID');
+        validateEmbeddingOutput(result['output'], result['usage']);
+    }
+    else if (result['taskKind'] === 'image_generation') {
+        assertOnlyKeys(result, ['taskKind', 'output', 'usage', 'protocolSnapshot'], 'ADAPTER_TERMINAL_INVALID');
+        let output;
+        try {
+            output = decodeMediaTaskResultV2(result['output']);
+            if (result['protocolSnapshot'] !== undefined) {
+                const snapshot = decodeImageGenerationProtocolSnapshotV1(result['protocolSnapshot']);
+                if (snapshot.items.length !== output.items.length) {
+                    throw new Error('ADAPTER_TERMINAL_INVALID');
+                }
+            }
+        }
+        catch {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+        const usage = result['usage'];
+        if (usage !== undefined &&
+            runtimeRecord(usage, 'ADAPTER_TERMINAL_INVALID')['imageCount'] !== undefined &&
+            runtimeRecord(usage, 'ADAPTER_TERMINAL_INVALID')['imageCount'] !== output.items.length) {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+    }
+    else {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    validateOptionalUsage(result['usage'], 'ADAPTER_TERMINAL_INVALID');
+    return value;
+}
+function validateChatOutput(value) {
+    const output = runtimeRecord(value, 'ADAPTER_TERMINAL_INVALID');
+    assertOnlyKeys(output, ['items', 'finishReason', 'incompleteReason'], 'ADAPTER_TERMINAL_INVALID');
+    if (!Array.isArray(output['items']) || !requiredString(output['finishReason'])) {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    optionalNonEmptyStringOrThrow(output['incompleteReason'], 'ADAPTER_TERMINAL_INVALID');
+    for (const raw of output['items']) {
+        const item = runtimeRecord(raw, 'ADAPTER_TERMINAL_INVALID');
+        if (item['type'] === 'text' || item['type'] === 'refusal') {
+            assertOnlyKeys(item, ['type', 'text'], 'ADAPTER_TERMINAL_INVALID');
+            if (typeof item['text'] !== 'string')
+                throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+        else if (item['type'] === 'function_call') {
+            assertOnlyKeys(item, ['type', 'callId', 'name', 'arguments'], 'ADAPTER_TERMINAL_INVALID');
+            if (!requiredString(item['callId']) ||
+                !requiredString(item['name']) ||
+                typeof item['arguments'] !== 'string') {
+                throw new Error('ADAPTER_TERMINAL_INVALID');
+            }
+        }
+        else {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+    }
+}
+function validateEmbeddingOutput(value, rawUsage) {
+    const output = runtimeRecord(value, 'ADAPTER_TERMINAL_INVALID');
+    assertOnlyKeys(output, ['vectors', 'dimensions', 'encodingFormat', 'spaceId'], 'ADAPTER_TERMINAL_INVALID');
+    if (!Array.isArray(output['vectors']) ||
+        output['vectors'].length === 0 ||
+        !positiveInteger(output['dimensions']) ||
+        (output['encodingFormat'] !== 'float' && output['encodingFormat'] !== 'base64') ||
+        !requiredString(output['spaceId'])) {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    const dimensions = output['dimensions'];
+    const indices = new Set();
+    for (const raw of output['vectors']) {
+        const vector = runtimeRecord(raw, 'ADAPTER_TERMINAL_INVALID');
+        assertOnlyKeys(vector, ['index', 'vector'], 'ADAPTER_TERMINAL_INVALID');
+        if (!nonNegativeInteger(vector['index']) || indices.has(vector['index'])) {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+        indices.add(vector['index']);
+        if (output['encodingFormat'] === 'float') {
+            if (!Array.isArray(vector['vector']) ||
+                vector['vector'].length !== dimensions ||
+                vector['vector'].some((entry) => typeof entry !== 'number' || !Number.isFinite(entry))) {
+                throw new Error('ADAPTER_TERMINAL_INVALID');
+            }
+        }
+        else if (!validFloat32Base64(vector['vector'], dimensions)) {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+    }
+    if (rawUsage !== undefined) {
+        const usage = runtimeRecord(rawUsage, 'ADAPTER_TERMINAL_INVALID');
+        if ((usage['vectorCount'] !== undefined && usage['vectorCount'] !== output['vectors'].length) ||
+            (usage['dimensions'] !== undefined && usage['dimensions'] !== dimensions) ||
+            (usage['encodingFormat'] !== undefined &&
+                usage['encodingFormat'] !== output['encodingFormat']) ||
+            (usage['spaceId'] !== undefined && usage['spaceId'] !== output['spaceId'])) {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+    }
+}
+function validateNormalizedResponsesSyncResponse(value) {
+    const response = runtimeRecord(value, 'ADAPTER_TERMINAL_INVALID');
+    assertOnlyKeys(response, [
+        'protocolFamily',
+        'id',
+        'object',
+        'status',
+        'model',
+        'store',
+        'output',
+        'usage',
+        'incompleteDetails',
+        'error',
+    ], 'ADAPTER_TERMINAL_INVALID');
+    if (response['protocolFamily'] !== 'openai-responses/v1' ||
+        !requiredString(response['id']) ||
+        response['object'] !== 'response' ||
+        !['completed', 'incomplete', 'failed', 'cancelled'].includes(String(response['status'])) ||
+        response['store'] !== false ||
+        !Array.isArray(response['output']) ||
+        !optionalNonEmptyString(response['model'])) {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    for (const item of response['output'])
+        validateNormalizedResponsesOutputItem(item);
+    validateOptionalUsage(response['usage'], 'ADAPTER_TERMINAL_INVALID');
+    validateOptionalIncompleteDetails(response['incompleteDetails'], 'ADAPTER_TERMINAL_INVALID');
+    validateOptionalProviderError(response['error'], 'ADAPTER_TERMINAL_INVALID');
+    if ((response['status'] === 'incomplete' && response['incompleteDetails'] === undefined) ||
+        (response['status'] === 'failed' && response['error'] === undefined) ||
+        (response['status'] !== 'incomplete' && response['incompleteDetails'] !== undefined) ||
+        (response['status'] !== 'failed' && response['error'] !== undefined)) {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    return value;
+}
+function validateNormalizedResponsesOutputItem(value) {
+    const item = runtimeRecord(value, 'ADAPTER_TERMINAL_INVALID');
+    if (!requiredString(item['id']) || !validResponsesOutputStatus(item['status'])) {
+        throw new Error('ADAPTER_TERMINAL_INVALID');
+    }
+    if (item['type'] === 'message') {
+        assertOnlyKeys(item, ['id', 'type', 'status', 'role', 'content'], 'ADAPTER_TERMINAL_INVALID');
+        if ((item['role'] !== undefined && item['role'] !== 'assistant') ||
+            !Array.isArray(item['content'])) {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+        for (const rawPart of item['content']) {
+            const part = runtimeRecord(rawPart, 'ADAPTER_TERMINAL_INVALID');
+            if (part['type'] === 'output_text') {
+                assertOnlyKeys(part, ['type', 'text'], 'ADAPTER_TERMINAL_INVALID');
+                if (typeof part['text'] !== 'string')
+                    throw new Error('ADAPTER_TERMINAL_INVALID');
+            }
+            else if (part['type'] === 'refusal') {
+                assertOnlyKeys(part, ['type', 'refusal'], 'ADAPTER_TERMINAL_INVALID');
+                if (typeof part['refusal'] !== 'string')
+                    throw new Error('ADAPTER_TERMINAL_INVALID');
+            }
+            else {
+                throw new Error('ADAPTER_TERMINAL_INVALID');
+            }
+        }
+        return;
+    }
+    if (item['type'] === 'reasoning') {
+        assertOnlyKeys(item, ['id', 'type', 'status', 'summary'], 'ADAPTER_TERMINAL_INVALID');
+        if (!Array.isArray(item['summary']))
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        for (const rawPart of item['summary']) {
+            const part = runtimeRecord(rawPart, 'ADAPTER_TERMINAL_INVALID');
+            assertOnlyKeys(part, ['type', 'text'], 'ADAPTER_TERMINAL_INVALID');
+            if (part['type'] !== 'summary_text' || typeof part['text'] !== 'string') {
+                throw new Error('ADAPTER_TERMINAL_INVALID');
+            }
+        }
+        return;
+    }
+    if (item['type'] === 'function_call') {
+        assertOnlyKeys(item, ['id', 'type', 'status', 'callId', 'name', 'arguments'], 'ADAPTER_TERMINAL_INVALID');
+        if (!requiredString(item['callId']) ||
+            !requiredString(item['name']) ||
+            typeof item['arguments'] !== 'string') {
+            throw new Error('ADAPTER_TERMINAL_INVALID');
+        }
+        return;
+    }
+    throw new Error('ADAPTER_TERMINAL_INVALID');
+}
+function validResponsesOutputStatus(value) {
+    return value === 'in_progress' || value === 'completed' || value === 'incomplete';
+}
+function normalizedResponseStatusMatchesTerminal(responseStatus, terminalStatus) {
+    return ((responseStatus === 'completed' && terminalStatus === 'succeeded') ||
+        responseStatus === terminalStatus);
+}
+function validFloat32Base64(value, dimensions) {
+    if (typeof value !== 'string' || value.length !== 4 * Math.ceil((dimensions * 4) / 3)) {
+        return false;
+    }
+    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(value);
+}
+function sameNormalizedUsage(left, right) {
+    const fields = [
+        'inputTokens',
+        'outputTokens',
+        'totalTokens',
+        'cachedInputTokens',
+        'cacheCreationInputTokens',
+        'cacheCreation5mInputTokens',
+        'cacheCreation1hInputTokens',
+        'reasoningOutputTokens',
+        'vectorCount',
+        'dimensions',
+        'encodingFormat',
+        'spaceId',
+        'requests',
+        'imageCount',
+        'estimated',
+    ];
+    if (fields.some((field) => left[field] !== right[field]))
+        return false;
+    return (sameUsageDetails(left.inputTokenDetails, right.inputTokenDetails) &&
+        sameUsageDetails(left.outputTokenDetails, right.outputTokenDetails));
+}
+function sameUsageDetails(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return ['cachedTokens', 'reasoningTokens', 'imageTokens', 'textTokens'].every((field) => left[field] === right[field]);
+}
+export function validateProviderAsyncJobStart(input) {
+    const value = runtimeRecord(input, 'ADAPTER_ASYNC_START_INVALID');
+    assertOnlyKeys(value, ['kind', 'acceptance', 'responseMetadata', 'providerJobId', 'failureCode', 'retryable'], 'ADAPTER_ASYNC_START_INVALID');
+    const acceptance = runtimeRecord(value['acceptance'], 'ADAPTER_ASYNC_START_INVALID');
+    assertOnlyKeys(acceptance, ['state'], 'ADAPTER_ASYNC_START_INVALID');
+    validateProviderResponseMetadata(value['responseMetadata'], 'ADAPTER_ASYNC_START_INVALID');
+    if (value['kind'] === 'async') {
+        assertOnlyKeys(value, ['kind', 'acceptance', 'responseMetadata', 'providerJobId'], 'ADAPTER_ASYNC_START_INVALID');
+        if (acceptance['state'] !== 'accepted' ||
+            typeof value['providerJobId'] !== 'string' ||
+            !value['providerJobId'].trim()) {
+            throw new Error('ADAPTER_ASYNC_START_INVALID');
+        }
+        return input;
+    }
+    if (value['kind'] !== 'failed' ||
+        (acceptance['state'] !== 'not-accepted' && acceptance['state'] !== 'unknown') ||
+        typeof value['failureCode'] !== 'string' ||
+        !value['failureCode'].trim() ||
+        typeof value['retryable'] !== 'boolean') {
+        throw new Error('ADAPTER_ASYNC_START_INVALID');
+    }
+    assertOnlyKeys(value, ['kind', 'acceptance', 'responseMetadata', 'failureCode', 'retryable'], 'ADAPTER_ASYNC_START_INVALID');
+    return input;
+}
+export function validateProviderAsyncJobSnapshot(input) {
+    const value = runtimeRecord(input, 'ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+    assertOnlyKeys(value, [
+        'providerJobId',
+        'model',
+        'status',
+        'createdAt',
+        'updatedAt',
+        'videoUrl',
+        'lastFrameUrl',
+        'usage',
+        'error',
+    ], 'ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+    const validStatuses = new Set(['queued', 'running', 'cancelled', 'succeeded', 'failed']);
+    if (typeof value['providerJobId'] !== 'string' ||
+        !value['providerJobId'].trim() ||
+        typeof value['model'] !== 'string' ||
+        !value['model'].trim() ||
+        typeof value['status'] !== 'string' ||
+        !validStatuses.has(value['status']) ||
+        !nonNegativeInteger(value['createdAt']) ||
+        !nonNegativeInteger(value['updatedAt']) ||
+        value['updatedAt'] < value['createdAt'] ||
+        !optionalNonEmptyString(value['videoUrl']) ||
+        !optionalNonEmptyString(value['lastFrameUrl'])) {
+        throw new Error('ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+    }
+    if (value['usage'] !== undefined) {
+        const usage = runtimeRecord(value['usage'], 'ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+        assertOnlyKeys(usage, ['completionTokens', 'totalTokens'], 'ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+        if (!nonNegativeInteger(usage['completionTokens']) ||
+            !nonNegativeInteger(usage['totalTokens']) ||
+            usage['totalTokens'] < usage['completionTokens']) {
+            throw new Error('ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+        }
+    }
+    if (value['error'] !== undefined) {
+        const error = runtimeRecord(value['error'], 'ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+        assertOnlyKeys(error, ['code', 'message'], 'ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+        if (typeof error['code'] !== 'string' ||
+            !error['code'].trim() ||
+            typeof error['message'] !== 'string' ||
+            !error['message'].trim()) {
+            throw new Error('ADAPTER_ASYNC_JOB_SNAPSHOT_INVALID');
+        }
+    }
+    return input;
+}
+export function validateProviderAsyncJobList(input) {
+    const value = runtimeRecord(input, 'ADAPTER_ASYNC_JOB_LIST_INVALID');
+    assertOnlyKeys(value, ['items', 'total'], 'ADAPTER_ASYNC_JOB_LIST_INVALID');
+    if (!Array.isArray(value['items']) || !nonNegativeInteger(value['total'])) {
+        throw new Error('ADAPTER_ASYNC_JOB_LIST_INVALID');
+    }
+    for (const item of value['items']) {
+        try {
+            validateProviderAsyncJobSnapshot(item);
+        }
+        catch {
+            throw new Error('ADAPTER_ASYNC_JOB_LIST_INVALID');
+        }
+    }
+    if (value['total'] < value['items'].length) {
+        throw new Error('ADAPTER_ASYNC_JOB_LIST_INVALID');
+    }
+    return input;
+}
+async function* validateStreamEvents(events) {
+    let responseId;
+    let previousSequence = -1;
+    let terminalSeen = false;
+    const eventIds = new Set();
+    for await (const event of events) {
+        const validated = validateNormalizedStreamEvent(event);
+        if (terminalSeen ||
+            (responseId !== undefined && validated.responseId !== responseId) ||
+            validated.sequenceNumber <= previousSequence ||
+            eventIds.has(validated.eventId)) {
+            throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+        }
+        responseId ??= validated.responseId;
+        previousSequence = validated.sequenceNumber;
+        eventIds.add(validated.eventId);
+        terminalSeen = isTerminalStreamEvent(validated.type);
+        yield validated;
+    }
+}
+function validateProviderAcceptance(value, errorCode) {
+    const acceptance = runtimeRecord(value, errorCode);
+    assertOnlyKeys(acceptance, ['state'], errorCode);
+    if (acceptance['state'] !== 'accepted' &&
+        acceptance['state'] !== 'not-accepted' &&
+        acceptance['state'] !== 'unknown') {
+        throw new Error(errorCode);
+    }
+}
+function validateIndexedItem(value) {
+    if (!requiredString(value['itemId']) || !nonNegativeInteger(value['outputIndex'])) {
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+}
+function assertStreamEventKeys(value, extra) {
+    assertOnlyKeys(value, ['type', 'eventId', 'sequenceNumber', 'responseId', ...extra], 'ADAPTER_STREAM_EVENT_INVALID');
+}
+function validateIndexedContent(value) {
+    validateIndexedItem(value);
+    if (!nonNegativeInteger(value['contentIndex'])) {
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+}
+function validateOutputItemKind(value) {
+    if (value !== 'message' && value !== 'reasoning' && value !== 'function_call') {
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+}
+function validateOutputItemKindMatch(kind, item) {
+    const normalized = item;
+    if ((kind === 'function_call' && normalized.type !== 'function_call') ||
+        ((kind === 'message' || kind === 'reasoning') && normalized.type !== 'message')) {
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+}
+function isTerminalStreamEvent(type) {
+    return (type === 'response.completed' ||
+        type === 'response.incomplete' ||
+        type === 'response.cancelled' ||
+        type === 'response.failed');
+}
+function validateNormalizedContentPart(value) {
+    const part = runtimeRecord(value, 'ADAPTER_STREAM_EVENT_INVALID');
+    assertOnlyKeys(part, ['type', 'text'], 'ADAPTER_STREAM_EVENT_INVALID');
+    if (part['type'] !== 'text' &&
+        part['type'] !== 'refusal' &&
+        part['type'] !== 'reasoning_summary') {
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+    }
+    requireString(part['text']);
+}
+function validateNormalizedOutputItem(value) {
+    const item = runtimeRecord(value, 'ADAPTER_STREAM_EVENT_INVALID');
+    if (item['type'] === 'message') {
+        assertOnlyKeys(item, ['type', 'content'], 'ADAPTER_STREAM_EVENT_INVALID');
+        if (!Array.isArray(item['content']))
+            throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+        for (const part of item['content'])
+            validateNormalizedContentPart(part);
+        return;
+    }
+    if (item['type'] === 'function_call') {
+        assertOnlyKeys(item, ['type', 'callId', 'name', 'arguments'], 'ADAPTER_STREAM_EVENT_INVALID');
+        requireNonEmptyString(item['callId']);
+        requireNonEmptyString(item['name']);
+        requireString(item['arguments']);
+        return;
+    }
+    throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+}
+function validateNormalizedUsage(value, errorCode = 'ADAPTER_STREAM_EVENT_INVALID') {
+    const usage = runtimeRecord(value, errorCode);
+    assertOnlyKeys(usage, [
+        'inputTokens',
+        'outputTokens',
+        'totalTokens',
+        'cachedInputTokens',
+        'cacheCreationInputTokens',
+        'cacheCreation5mInputTokens',
+        'cacheCreation1hInputTokens',
+        'reasoningOutputTokens',
+        'inputTokenDetails',
+        'outputTokenDetails',
+        'vectorCount',
+        'dimensions',
+        'encodingFormat',
+        'spaceId',
+        'estimated',
+        'requests',
+        'imageCount',
+    ], errorCode);
+    if (typeof usage['estimated'] !== 'boolean')
+        throw new Error(errorCode);
+    const counters = [
+        'inputTokens',
+        'outputTokens',
+        'totalTokens',
+        'cachedInputTokens',
+        'cacheCreationInputTokens',
+        'cacheCreation5mInputTokens',
+        'cacheCreation1hInputTokens',
+        'reasoningOutputTokens',
+        'vectorCount',
+        'dimensions',
+        'requests',
+        'imageCount',
+    ];
+    for (const key of counters) {
+        if (usage[key] !== undefined && !nonNegativeInteger(usage[key])) {
+            throw new Error(errorCode);
+        }
+    }
+    validateUsageDetails(usage['inputTokenDetails'], errorCode);
+    validateUsageDetails(usage['outputTokenDetails'], errorCode);
+    if (usage['encodingFormat'] !== undefined &&
+        usage['encodingFormat'] !== 'float' &&
+        usage['encodingFormat'] !== 'base64') {
+        throw new Error(errorCode);
+    }
+    optionalNonEmptyStringOrThrow(usage['spaceId'], errorCode);
+}
+function validateUsageDetails(value, errorCode) {
+    if (value === undefined)
+        return;
+    const details = runtimeRecord(value, errorCode);
+    assertOnlyKeys(details, ['cachedTokens', 'reasoningTokens', 'imageTokens', 'textTokens'], errorCode);
+    for (const key of ['cachedTokens', 'reasoningTokens', 'imageTokens', 'textTokens']) {
+        if (details[key] !== undefined && !nonNegativeInteger(details[key])) {
+            throw new Error(errorCode);
+        }
+    }
+}
+function validateOptionalUsage(value, errorCode = 'ADAPTER_STREAM_EVENT_INVALID') {
+    if (value !== undefined)
+        validateNormalizedUsage(value, errorCode);
+}
+function validateOptionalIncompleteDetails(value, errorCode = 'ADAPTER_STREAM_EVENT_INVALID') {
+    if (value === undefined)
+        return;
+    const details = runtimeRecord(value, errorCode);
+    assertOnlyKeys(details, ['reason'], errorCode);
+    if (!requiredString(details['reason']))
+        throw new Error(errorCode);
+}
+function validateOptionalProviderError(value, errorCode = 'ADAPTER_STREAM_EVENT_INVALID') {
+    if (value === undefined)
+        return;
+    const error = runtimeRecord(value, errorCode);
+    assertOnlyKeys(error, ['code', 'message'], errorCode);
+    if (!requiredString(error['code']) || !optionalNonEmptyString(error['message'])) {
+        throw new Error(errorCode);
+    }
+}
+function requireLiteral(value, expected) {
+    if (value !== expected)
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+}
+function requireString(value) {
+    if (typeof value !== 'string')
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+}
+function requireNonEmptyString(value) {
+    if (!requiredString(value))
+        throw new Error('ADAPTER_STREAM_EVENT_INVALID');
+}
+function optionalRequiredString(value) {
+    if (value !== undefined)
+        requireNonEmptyString(value);
+}
+function requiredString(value) {
+    return typeof value === 'string' && Boolean(value.trim());
+}
+function optionalNonEmptyStringOrThrow(value, errorCode) {
+    if (!optionalNonEmptyString(value))
+        throw new Error(errorCode);
+}
+function isAsyncIterable(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}
+function isPromiseLike(value) {
+    return (value !== null &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
+function validateProviderResponseMetadata(value, errorCode) {
+    const metadata = runtimeRecord(value, errorCode);
+    assertOnlyKeys(metadata, ['headersReceived', 'statusCode', 'providerRequestId', 'observedModel'], errorCode);
+    if (typeof metadata.headersReceived !== 'boolean' ||
+        (metadata.statusCode !== undefined &&
+            (!Number.isInteger(metadata.statusCode) ||
+                metadata.statusCode < 100 ||
+                metadata.statusCode > 599)) ||
+        !optionalNonEmptyString(metadata.providerRequestId) ||
+        !optionalNonEmptyString(metadata.observedModel)) {
+        throw new Error(errorCode);
+    }
+}
+function runtimeRecord(value, errorCode) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(errorCode);
+    }
+    return value;
+}
+function assertOnlyKeys(value, allowed, errorCode) {
+    const keys = new Set(allowed);
+    if (Object.keys(value).some((key) => !keys.has(key)))
+        throw new Error(errorCode);
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function positiveInteger(value) {
+    return nonNegativeInteger(value) && value > 0;
+}
+function optionalNonEmptyString(value) {
+    return value === undefined || (typeof value === 'string' && Boolean(value.trim()));
+}
+function validateTerminalAcceptance(acceptance, terminal) {
+    const terminalFacts = terminal;
+    if (terminalFacts.status === 'succeeded' && terminalFacts.acceptanceState !== 'accepted') {
+        throw new Error('ADAPTER_SUCCEEDED_WITHOUT_ACCEPTANCE');
+    }
+    if (acceptance.state !== terminal.acceptanceState) {
+        throw new Error('ADAPTER_ACCEPTANCE_MISMATCH');
+    }
+}
+function modalitiesMatch(requestedModalities, supportedModalities) {
+    return requestedModalities.every((modality) => supportedModalities.includes(modality));
+}
+function sameValues(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function sameValueSet(left, right) {
+    return left.length === right.length && left.every((value) => right.includes(value));
+}
+//# sourceMappingURL=runtime-v2-validation.js.map