@marinoscar/platform-api 0.1.0-next.20 → 0.1.0-next.22

package/dist/ai/runtime/ai.service.js

@@ -277,15 +277,71 @@ let AiService = AiService_1 = class AiService {
             speak: (req) => this.startSpeechRun(bound, req),
             createRealtimeSession: (req, opts) => this.createRealtimeSession(bound, req, opts),
             run: (operationId, input, opts) => this.runOperation(bound, operationId, input, opts),
+            editImageInline: (req, opts) => this.editImageInline(bound, req, opts),
+            transcribeInline: (req, opts) => this.transcribeInline(bound, req, opts),
         };
     }
+    /**
+     * The AI client for work with NO acting user: a per-organization job
+     * (memory titles, a digest), an importer's tagging. It runs the same gate
+     * pipeline as `forUser` and records one usage row per round-trip with
+     * `userId: null` and `scope.feature`, but:
+     *
+     * - the feature must be registered with `systemCalls: true`, else every call
+     *   is refused with `AI_KEY_REQUIRED` (an app whose rule is "AI keys are per
+     *   user" registers none, and system calls stay impossible for it);
+     * - the key is the organization's own, else the deployment's, NEVER a
+     *   user's, and `ai.keyPolicy` does not apply (no person is borrowing);
+     * - only the per-organization limits (`limits.perOrg`) apply;
+     * - the kill switches (`ai.enabled`, the organization's) still apply first.
+     *
+     * Server-side code only: it is not reachable over HTTP and must never be
+     * handed to a worker node. See `AiSystemClient` for what it offers.
+     *
+     * @example
+     * ```ts
+     * const titles = await this.ai
+     *   .forSystem({ orgId, feature: 'example_titles' })
+     *   .respondStructured({ schema, input });
+     * ```
+     *
+     * @stability experimental
+     */
+    forSystem(scope) {
+        const bound = {
+            userId: null,
+            ...(scope.orgId ? { orgId: scope.orgId } : {}),
+            feature: scope.feature,
+            ...(scope.jobId ? { jobId: scope.jobId } : {}),
+        };
+        return {
+            respond: (req, opts) => this.respond(bound, req, opts),
+            stream: (req, opts) => this.lazyStream(bound, req, opts),
+            openStream: (req, opts) => this.openStream(bound, req, opts),
+            respondStructured: (req, opts) => this.respondStructured(bound, req, opts),
+            embed: (req, opts) => this.embed(bound, req, opts),
+            editImageInline: (req, opts) => this.editImageInline(bound, req, opts),
+            transcribeInline: (req, opts) => this.transcribeInline(bound, req, opts),
+        };
+    }
+    /** The acting user of a call only a user can make (queued runs, realtime, custom operations). */
+    userOf(scope) {
+        if (scope.userId === null) {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'This call needs an acting user; a system client cannot make it.');
+        }
+        return scope.userId;
+    }
     /**
      * The organization this call runs in: the scope's own, else (single tenancy)
      * the default organization, else a `MissingOrgScopeError` (multi tenancy).
      * Memoised on the scope, so one call resolves it once.
      */
     async orgOf(scope) {
-        scope.orgId ??= await (0, index_3.resolveOrgId)(this.prisma, scope.orgId, scope.jobId ? `AI call under job ${scope.jobId}` : `AI call for user ${scope.userId}`);
+        scope.orgId ??= await (0, index_3.resolveOrgId)(this.prisma, scope.orgId, scope.jobId
+            ? `AI call under job ${scope.jobId}`
+            : scope.userId === null
+                ? 'AI system call'
+                : `AI call for user ${scope.userId}`);
         return scope.orgId;
     }
     // ---- respond ----------------------------------------------------------------
@@ -304,9 +360,10 @@ let AiService = AiService_1 = class AiService {
         if (!(await this.aiConfig.resolveForOrg(orgId)).defaults.allowBackgroundRuns) {
             throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'Background AI runs are disabled in this deployment.');
         }
-        const call = await this.prepare(scope.userId, req, { streaming: false, orgId, feature: scope.feature });
+        const userId = this.userOf(scope);
+        const call = await this.prepare(userId, req, { streaming: false, orgId, feature: scope.feature });
         return this.runs.create({
-            userId: scope.userId,
+            userId,
             orgId,
             provider: call.provider,
             modelId: call.request.model,
@@ -351,7 +408,9 @@ let AiService = AiService_1 = class AiService {
     /** The settler every result of `call` leaves through (see `ai-hosted-outputs.ts`). */
     hostedOutputs(scope, call) {
         return new ai_hosted_outputs_1.AiHostedOutputSettler({
-            userId: scope.userId,
+            // A system call has no user and `prepare` refuses its hosted tools, so
+            // nothing is ever stored under this owner.
+            userId: scope.userId ?? '',
             ...(scope.orgId ? { orgId: scope.orgId } : {}),
             ...(scope.jobId ? { jobId: scope.jobId } : {}),
             ...(scope.runId ? { runId: scope.runId } : {}),
@@ -418,7 +477,7 @@ let AiService = AiService_1 = class AiService {
     }
     // ---- realtime ---------------------------------------------------------------------
     async createRealtimeSession(scope, req, opts = {}) {
-        const call = await this.prepareRealtime(scope.userId, req, scope.feature, await this.orgOf(scope));
+        const call = await this.prepareRealtime(this.userOf(scope), req, scope.feature, await this.orgOf(scope));
         const { ctx, keySource } = await this.context(scope, call, opts, () => ({
             instructions: call.request.instructions,
         }));
@@ -454,7 +513,7 @@ let AiService = AiService_1 = class AiService {
      * row and span as every built-in port. See `AiUserClient.run`.
      */
     async runOperation(scope, operationId, input, opts = {}) {
-        const call = await this.prepareOperation(scope.userId, operationId, input, opts, await this.orgOf(scope), scope.feature);
+        const call = await this.prepareOperation(this.userOf(scope), operationId, input, opts, await this.orgOf(scope), scope.feature);
         // ⚠ The input is NOT passed as the debug prompt: an operation's input is
         // whatever the app defined (a transcript, a document) and only the
         // operation id is safe to name.
@@ -556,9 +615,10 @@ let AiService = AiService_1 = class AiService {
     // ---- images ---------------------------------------------------------------------
     async startImageRun(scope, operation, req) {
         const orgId = await this.orgOf(scope);
-        const call = await this.prepareImage(scope.userId, operation, req, orgId, scope.feature);
+        const userId = this.userOf(scope);
+        const call = await this.prepareImage(userId, operation, req, orgId, scope.feature);
         return this.runs.create({
-            userId: scope.userId,
+            userId,
             orgId,
             provider: call.provider,
             modelId: call.modelId,
@@ -597,33 +657,153 @@ let AiService = AiService_1 = class AiService {
             ? await this.inputs.read(call.inputs.mask, { maxBytes: media_types_1.AI_IMAGE_INPUT_MAX_BYTES, label: 'mask' })
             : undefined;
         const request = (0, ai_image_run_request_1.toImageGenerationRequest)(call.stored);
-        const { ctx, keySource } = await this.context(scope, call, opts, () => ({ prompt: request.prompt }));
-        const tracker = this.track(scope, call, keySource, call.operation);
-        let result;
-        try {
+        return this.imageRoundTrip(scope, call, call.operation, opts, request.prompt, (ctx) => {
             if (edit) {
                 // `prepareImage` refused a port without `edit`; this narrows the type.
                 const editPort = call.port.edit;
-                result = await editPort({ ...request, images, ...(mask ? { mask } : {}) }, ctx);
-            }
-            else {
-                result = await call.port.generate(request, ctx);
+                return editPort({ ...request, images, ...(mask ? { mask } : {}) }, ctx);
             }
+            return call.port.generate(request, ctx);
+        });
+    }
+    /**
+     * Steps 6-9 of one image round-trip, shared by the queued run
+     * (`executeImageRun`) and the inline edit (`editImageInline`): resolve the
+     * key, apply the limits, call the port, record ONE usage row (with the image count as its units) and end the span. The error never carries the key.
+     */
+    async imageRoundTrip(scope, call, operation, opts, prompt, send) {
+        const { ctx, keySource } = await this.context(scope, call, opts, () => ({ prompt }));
+        const tracker = this.track(scope, call, keySource, operation);
+        let result;
+        try {
+            result = await send(ctx);
         }
         catch (err) {
-            const error = toAiError(err, opts.signal);
+            const error = scrubKey(toAiError(err, opts.signal), ctx.apiKey);
             await tracker.finish(failure(error, opts.signal));
             throw error;
         }
         await tracker.finish({ status: 'succeeded', result, units: { images: result.images.length } });
         return result;
     }
+    // ---- inline media (a caller already inside its own job) ----------------------------
+    async editImageInline(scope, req, opts = {}) {
+        const call = await this.prepareImageInline(scope.userId, req, await this.orgOf(scope), scope.feature);
+        return this.imageRoundTrip(scope, call, 'images.edit', opts, call.request.prompt, (ctx) => call.edit(call.request, ctx));
+    }
+    async transcribeInline(scope, req, opts = {}) {
+        const call = await this.prepareTranscriptionInline(scope.userId, req, await this.orgOf(scope), scope.feature);
+        return this.transcriptionRoundTrip(scope, call, opts, { language: call.request.language, prompt: call.request.prompt }, call.request, call.exceeded);
+    }
+    /**
+     * The gate pipeline for an inline image edit: kill switch, the system
+     * caller's opt-in, request shape (prompt, `n`, the images' count, size and
+     * type, the mask), target, provider, model with `image_edit` (model AND port
+     * with `edit`). Decrypts nothing; the bytes are already the caller's.
+     *
+     * @internal
+     */
+    async prepareImageInline(userId, req, orgId, featureId) {
+        // 1. Kill switch — before anything else is read.
+        await this.aiConfig.assertEnabled(orgId);
+        const feature = this.featureOf(featureId);
+        this.assertSystemCaller(userId, feature);
+        assertImageShape(req, false);
+        assertInlineImages(req);
+        if (req.providerOptions !== undefined)
+            assertProviderOptionsShape(req.providerOptions);
+        if (!req.model?.trim()) {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'Name the image model explicitly.');
+        }
+        const { provider, model } = await this.resolveTarget(userId, req, { orgId, feature });
+        // 2. Provider enabled in settings AND registered in this process.
+        const slot = await this.aiConfig.assertProviderEnabled(provider, orgId);
+        const port = this.registry.get(provider)?.images;
+        // 3. Model enabled, `image_edit` declared (model AND provider port), key reach.
+        const { model: usableImage } = await this.usableModels.assertUsable(userId, provider, model, ['image_edit'], { orgId });
+        assertFeatureFits(feature, provider, model, usableImage.capabilities);
+        if (!port?.edit) {
+            throw capabilityUnsupported(provider, model, 'image_edit');
+        }
+        const policy = await this.aiConfig.resolveForOrg(orgId);
+        // Named fields only: whatever else the caller's object carried stays here.
+        const request = {
+            model,
+            prompt: req.prompt,
+            images: req.images.map(inlinePayload),
+            ...(req.mask ? { mask: inlinePayload(req.mask) } : {}),
+            ...(req.size !== undefined ? { size: req.size } : {}),
+            ...(req.quality !== undefined ? { quality: req.quality } : {}),
+            ...(req.background !== undefined ? { background: req.background } : {}),
+            ...(req.outputFormat !== undefined ? { outputFormat: req.outputFormat } : {}),
+            ...(req.n !== undefined ? { n: req.n } : {}),
+            ...(req.providerOptions !== undefined ? { providerOptions: req.providerOptions } : {}),
+        };
+        return {
+            provider,
+            modelId: model,
+            edit: port.edit.bind(port),
+            request,
+            ...(0, ai_config_service_1.providerCallSettings)(slot),
+            logPromptContent: policy.logPromptContent,
+        };
+    }
+    /**
+     * The gate pipeline for an inline transcription: kill switch, the system
+     * caller's opt-in, request shape, target (an omitted model is the first
+     * usable `audio_transcription` model), provider, model with
+     * `audio_transcription` (model AND port), then the recording itself: type
+     * and the provider's size limit (a stream is counted as it is sent).
+     * Decrypts nothing.
+     *
+     * @internal
+     */
+    async prepareTranscriptionInline(userId, req, orgId, featureId) {
+        // 1. Kill switch — before anything else is read.
+        await this.aiConfig.assertEnabled(orgId);
+        const feature = this.featureOf(featureId);
+        this.assertSystemCaller(userId, feature);
+        assertTranscriptionOptions(req);
+        const audio = req.audio;
+        if (!audio || typeof audio.mimeType !== 'string' || !mimeAllowed(audio.mimeType, media_types_1.AI_TRANSCRIPTION_INPUT_MIME_TYPES)) {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'A transcription needs an audio recording (audio/*, video/mp4 or video/webm).', {
+                details: { mimeType: audio?.mimeType },
+            });
+        }
+        const { provider, model } = req.model?.trim()
+            ? await this.resolveTarget(userId, req, { orgId, feature })
+            : await this.firstUsableModel(userId, 'audio_transcription', req.provider, orgId);
+        // 2. Provider enabled in settings AND registered in this process.
+        const slot = await this.aiConfig.assertProviderEnabled(provider, orgId);
+        const port = this.registry.get(provider)?.audio;
+        // 3. Model enabled, `audio_transcription` declared (model AND port), key reach.
+        const { model: usableTranscription } = await this.usableModels.assertUsable(userId, provider, model, ['audio_transcription'], { orgId });
+        assertFeatureFits(feature, provider, model, usableTranscription.capabilities);
+        const transcribe = port?.transcribe?.bind(port);
+        if (!port || !transcribe) {
+            throw capabilityUnsupported(provider, model, 'audio_transcription');
+        }
+        // 4. The recording within the provider's limit.
+        const maxBytes = port.transcriptionMaxBytes ?? media_types_1.AI_TRANSCRIPTION_DEFAULT_MAX_BYTES;
+        const capped = capInlineAudio(audio, maxBytes);
+        const policy = await this.aiConfig.resolveForOrg(orgId);
+        return {
+            provider,
+            modelId: model,
+            transcribe,
+            request: { model, audio: capped.audio, ...transcriptionFields(req) },
+            exceeded: capped.exceeded,
+            ...(0, ai_config_service_1.providerCallSettings)(slot),
+            logPromptContent: policy.logPromptContent,
+        };
+    }
     // ---- transcription ------------------------------------------------------------------
     async startTranscriptionRun(scope, req) {
         const orgId = await this.orgOf(scope);
-        const call = await this.prepareTranscription(scope.userId, req, orgId, scope.feature);
+        const userId = this.userOf(scope);
+        const call = await this.prepareTranscription(userId, req, orgId, scope.feature);
         return this.runs.create({
-            userId: scope.userId,
+            userId,
             orgId,
             provider: call.provider,
             modelId: call.modelId,
@@ -652,35 +832,41 @@ let AiService = AiService_1 = class AiService {
         const audio = await this.openRecording(call);
         let result;
         try {
-            const { ctx, keySource } = await this.context(scope, call, opts, () => ({
-                language: call.stored.language,
-                prompt: call.stored.prompt,
-            }));
-            const tracker = this.track(scope, call, keySource, 'audio.transcribe');
             const request = { model: call.modelId, audio: audio.payload, ...transcriptionFields(call.stored) };
-            try {
-                result = await call.transcribe(request, ctx);
-            }
-            catch (err) {
-                // A recording that turned out larger than its row said: the cap
-                // stopped the upload, and THAT is the answer, not the transport
-                // failure the SDK saw.
-                const error = audio.exceeded() ?? toAiError(err, opts.signal);
-                await tracker.finish(failure(error, opts.signal));
-                throw error;
-            }
-            result = this.boundExtras(result);
-            await tracker.finish({
-                status: 'succeeded',
-                result,
-                ...(result.durationSeconds !== undefined ? { units: { audioSeconds: result.durationSeconds } } : {}),
-            });
+            result = await this.transcriptionRoundTrip(scope, call, opts, { language: call.stored.language, prompt: call.stored.prompt }, request, audio.exceeded);
         }
         finally {
             audio.close();
         }
         return result;
     }
+    /**
+     * Steps 6-9 of one transcription round-trip, shared by the queued run and
+     * the inline call: key, limits, the port, ONE usage row (with the audio seconds as units, when reported) and the span. The error never carries the key.
+     */
+    async transcriptionRoundTrip(scope, call, opts, promptInfo, request, exceeded) {
+        const { ctx, keySource } = await this.context(scope, call, opts, () => promptInfo);
+        const tracker = this.track(scope, call, keySource, 'audio.transcribe');
+        let result;
+        try {
+            result = await call.transcribe(request, ctx);
+        }
+        catch (err) {
+            // A recording that turned out larger than its row said: the cap
+            // stopped the upload, and THAT is the answer, not the transport
+            // failure the SDK saw.
+            const error = scrubKey(exceeded() ?? toAiError(err, opts.signal), ctx.apiKey);
+            await tracker.finish(failure(error, opts.signal));
+            throw error;
+        }
+        result = this.boundExtras(result);
+        await tracker.finish({
+            status: 'succeeded',
+            result,
+            ...(result.durationSeconds !== undefined ? { units: { audioSeconds: result.durationSeconds } } : {}),
+        });
+        return result;
+    }
     /**
      * The result with its `extras` checked (PP-14.17, #935): kept when bounded
      * and well-formed, dropped otherwise. The transcript is never lost to a bad
@@ -721,9 +907,10 @@ let AiService = AiService_1 = class AiService {
     // ---- speech -------------------------------------------------------------------------
     async startSpeechRun(scope, req) {
         const orgId = await this.orgOf(scope);
-        const call = await this.prepareSpeech(scope.userId, req, scope.feature, orgId);
+        const userId = this.userOf(scope);
+        const call = await this.prepareSpeech(userId, req, scope.feature, orgId);
         return this.runs.create({
-            userId: scope.userId,
+            userId,
             orgId,
             provider: call.provider,
             modelId: call.modelId,
@@ -917,6 +1104,7 @@ let AiService = AiService_1 = class AiService {
         // 1. Kill switch — before anything else is read.
         await this.aiConfig.assertEnabled(opts.orgId);
         const feature = this.featureOf(opts.feature);
+        this.assertSystemCaller(userId, feature);
         const { provider, model } = await this.resolveTarget(userId, req, { orgId: opts.orgId, feature });
         // 2. Provider enabled in settings AND registered in this process.
         const slot = await this.aiConfig.assertProviderEnabled(provider, opts.orgId);
@@ -932,6 +1120,12 @@ let AiService = AiService_1 = class AiService {
         // and an MCP server on an allowed host.
         (0, hosted_tools_1.assertHostedToolShapes)(req.tools);
         (0, hosted_tools_1.assertHostedToolsAllowed)(req.tools, policy.hostedTools);
+        if (userId === null && (0, hosted_tools_1.hostedToolsOf)(req.tools).length > 0) {
+            // A hosted tool's output (a generated image) is stored as the user's own object.
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'Hosted tools are not available to system calls.', {
+                details: { provider, model, capability: 'hosted_tools' },
+            });
+        }
         // 3. Model enabled, capabilities (model AND provider port), key reach.
         const needed = requiredCapabilities(req, opts.streaming);
         const { model: usable } = await this.usableModels.assertUsable(userId, provider, model, needed, { orgId: opts.orgId });
@@ -948,7 +1142,13 @@ let AiService = AiService_1 = class AiService {
             throw new ai_error_1.AiError('AI_CAPABILITY_UNSUPPORTED', `Model "${model}" does not offer reasoning effort "${effort}".`, { details: { provider, model, capability: 'reasoning', effort } });
         }
         // 4b. Storage-object inputs: ownership, readiness, modality, size, strategy.
-        const storageInputs = await this.planStorageInputs(userId, provider, model, usable, req.input, opts.orgId);
+        if (userId === null && storageParts(req.input).length > 0) {
+            // A stored file is authorised by its owner; a system call has none. Pass bytes or a url instead.
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'System calls cannot reference storage objects; pass a url or the content.', {
+                details: { provider, model, capability: 'file_input' },
+            });
+        }
+        const storageInputs = userId === null ? [] : await this.planStorageInputs(userId, provider, model, usable, req.input, opts.orgId);
         // 5. Clamp output tokens: the deployment cap and the model's own
         // `ai.limits.perModel` cap (#450) combine — the smaller wins — and bound
         // the call even when the request named no limit of its own.
@@ -986,6 +1186,7 @@ let AiService = AiService_1 = class AiService {
             throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'Name the embedding model explicitly: vectors are only comparable within one model.');
         }
         const feature = this.featureOf(featureId);
+        this.assertSystemCaller(userId, feature);
         const { provider, model } = await this.resolveTarget(userId, req, { feature });
         // 2. Provider enabled in settings AND registered in this process.
         const slot = await this.aiConfig.assertProviderEnabled(provider, orgId);
@@ -1388,7 +1589,9 @@ let AiService = AiService_1 = class AiService {
      * operation whose model is never the chat `ai.defaultModel`.
      */
     async firstUsableModel(userId, capability, provider, orgId, operation) {
-        const usable = await this.usableModels.listForUser(userId, orgId ? { orgId } : {});
+        const usable = userId === null
+            ? await this.usableModels.listForSystem(orgId ? { orgId } : {})
+            : await this.usableModels.listForUser(userId, orgId ? { orgId } : {});
         const match = usable.find((m) => (provider === undefined || m.provider === provider) &&
             m.capabilities.capabilities.includes(capability) &&
             this.registry.supports(m.provider, capability) &&
@@ -1409,7 +1612,10 @@ let AiService = AiService_1 = class AiService {
         }
         const orgId = await this.orgOf(scope);
         // #739: the org tier needs the call's organization.
-        const { apiKey, keySource, tier } = await this.keyResolver.resolve(scope.userId, call.provider, { orgId });
+        // A system call (no user) is served by the organization's or the deployment's key, never a user's.
+        const { apiKey, keySource, tier } = scope.userId === null
+            ? await this.keyResolver.resolveForSystem(call.provider, { orgId })
+            : await this.keyResolver.resolve(scope.userId, call.provider, { orgId });
         call.keyTier = tier;
         // 6b. Rate limits (#450) — here because the org-key limits need to know
         // whose key pays. A refusal records no usage row: nothing was sent.
@@ -1458,6 +1664,18 @@ let AiService = AiService_1 = class AiService {
         }
         return { provider: target.provider, model: target.model };
     }
+    /**
+     * A system call (no acting user) must name a registered feature that opted in
+     * with `systemCalls: true` (checked right after the kill switch). Refused with
+     * `AI_KEY_REQUIRED`: without the opt-in there is no key a system call may use.
+     */
+    assertSystemCaller(userId, feature) {
+        if (userId !== null)
+            return;
+        if (!feature?.systemCalls) {
+            throw new ai_error_1.AiError('AI_KEY_REQUIRED', 'System AI calls are not enabled for this feature; register it with systemCalls: true.', { details: { ...(feature ? { feature: feature.id } : {}), reason: 'system_calls_not_enabled' } });
+        }
+    }
     /** The registered feature a call names, or `undefined`; an unknown id is AI_INVALID_REQUEST. */
     featureOf(id) {
         if (id === undefined)
@@ -1645,6 +1863,10 @@ function assertTranscriptionShape(req) {
     if (typeof req.storageObjectId !== 'string' || req.storageObjectId.trim().length === 0) {
         throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'A transcription needs the recording\'s storageObjectId.');
     }
+    assertTranscriptionOptions(req);
+}
+/** The recording-independent part of a transcription request's shape (shared with the inline form). */
+function assertTranscriptionOptions(req) {
     if (req.language !== undefined && !ai_audio_run_request_1.AI_LANGUAGE_CODE.test(req.language)) {
         throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'language must be an ISO-639-1 code such as "en".', {
             details: { language: req.language },
@@ -1686,6 +1908,91 @@ function assertProviderOptionsShape(options) {
         throw new ai_error_1.AiError('AI_INVALID_REQUEST', `providerOptions must be a JSON object of at most ${media_types_1.AI_PROVIDER_OPTIONS_MAX_BYTES} bytes.`, { details: { max: media_types_1.AI_PROVIDER_OPTIONS_MAX_BYTES } });
     }
 }
+/** A MIME type (parameters such as `;codecs=opus` ignored) against an allow-list that may use `type/*`. */
+function mimeAllowed(mimeType, allowed) {
+    const base = mimeType.split(';')[0].trim().toLowerCase();
+    return allowed.some((pattern) => pattern.endsWith('/*') ? base.startsWith(pattern.slice(0, -1)) && base.length > pattern.length - 1 : base === pattern);
+}
+/** The bytes of an inline payload, copied by reference into the named fields the adapter takes. */
+function inlinePayload(payload) {
+    return {
+        data: payload.data,
+        mimeType: payload.mimeType,
+        ...(payload.filename !== undefined ? { filename: payload.filename } : {}),
+    };
+}
+/**
+ * An inline edit's images and mask, checked before any gate reads a table: 1
+ * to `AI_IMAGE_EDIT_MAX_INPUTS` non-empty images of an allowed type and at
+ * most `AI_IMAGE_INPUT_MAX_BYTES` each; a PNG mask within the same size.
+ * Errors name the index and the limit, never the bytes.
+ */
+function assertInlineImages(req) {
+    const { images, mask } = req;
+    if (!Array.isArray(images) || images.length === 0 || images.length > media_types_1.AI_IMAGE_EDIT_MAX_INPUTS) {
+        throw new ai_error_1.AiError('AI_INVALID_REQUEST', `An image edit needs 1 to ${media_types_1.AI_IMAGE_EDIT_MAX_INPUTS} source images.`, { details: { max: media_types_1.AI_IMAGE_EDIT_MAX_INPUTS } });
+    }
+    const check = (payload, label, allowed, index) => {
+        const where = index === undefined ? {} : { index };
+        if (!payload ||
+            !(payload.data instanceof Uint8Array) ||
+            payload.data.byteLength === 0 ||
+            typeof payload.mimeType !== 'string') {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', `The ${label} must be non-empty bytes with a MIME type.`, { details: where });
+        }
+        if (!mimeAllowed(payload.mimeType, allowed)) {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', `The ${label} must be ${allowed.join(', ')}.`, {
+                details: { ...where, mimeType: payload.mimeType },
+            });
+        }
+        if (payload.data.byteLength > media_types_1.AI_IMAGE_INPUT_MAX_BYTES) {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', `The ${label} is larger than ${media_types_1.AI_IMAGE_INPUT_MAX_BYTES} bytes.`, {
+                details: { ...where, size: payload.data.byteLength, maxBytes: media_types_1.AI_IMAGE_INPUT_MAX_BYTES },
+            });
+        }
+    };
+    images.forEach((image, index) => check(image, 'image', media_types_1.AI_IMAGE_INPUT_MIME_TYPES, index));
+    if (mask !== undefined)
+        check(mask, 'mask', media_types_1.AI_IMAGE_MASK_MIME_TYPES);
+}
+/**
+ * An inline recording within `maxBytes`: bytes are checked now; a stream is
+ * refused now when it declares a larger `size`, and otherwise counted as it is
+ * sent and cut off past the cap (`exceeded()` then names the cause, as for a
+ * stored recording that outgrows its row).
+ */
+function capInlineAudio(audio, maxBytes) {
+    const tooLarge = (size) => new ai_error_1.AiError('AI_INVALID_REQUEST', `The audio is larger than ${maxBytes} bytes (${maxBytes / 1024 / 1024} MiB).`, {
+        details: { size, maxBytes },
+    });
+    if (!('stream' in audio) || audio.stream === undefined) {
+        const bytes = audio;
+        if (!(bytes.data instanceof Uint8Array) || bytes.data.byteLength === 0) {
+            throw new ai_error_1.AiError('AI_INVALID_REQUEST', 'The audio must be non-empty bytes.');
+        }
+        if (bytes.data.byteLength > maxBytes)
+            throw tooLarge(bytes.data.byteLength);
+        return { audio: bytes, exceeded: () => undefined };
+    }
+    if (audio.size !== undefined && audio.size > maxBytes)
+        throw tooLarge(audio.size);
+    let seen = 0;
+    let overflow;
+    const source = audio.stream;
+    const counted = {
+        async *[Symbol.asyncIterator]() {
+            for await (const chunk of source) {
+                seen += chunk.byteLength;
+                if (seen > maxBytes) {
+                    overflow = tooLarge(seen);
+                    throw overflow;
+                }
+                yield chunk;
+            }
+        },
+    };
+    return { audio: { ...audio, stream: counted }, exceeded: () => overflow };
+}
 /** The optional, provider-facing fields of a transcription request (named fields only). */
 function transcriptionFields(req) {
     return {