@marinoscar/platform-api 0.1.0-next.3 → 0.1.0-next.4

package/dist/ai/runtime/ai.service.d.ts

@@ -0,0 +1,624 @@
+import type { z } from 'zod';
+import type { AiPrisma } from '../data/ai-db';
+import { AiConfigService } from '../config/ai-config.service';
+import { AiError } from '../core/ai-error';
+import type { AiCapability, AiModelCapabilities } from '../core/capabilities';
+import { type AiOperationHandler, type AiResponsesPort } from '../core/provider-adapter.interface';
+import { type AiOperationDefinition } from '../core/operation-registry';
+import { type AiFileInputStrategy, type AiStorageInputModality } from '../core/types/file-inputs.types';
+import { AiProviderRegistry } from '../core/provider-registry';
+import { type AiEmbeddingRequest, type AiEmbeddingResult, type AiAudioPort, type AiEmbeddingsPort, type AiImageResult, type AiImagesPort, type AiRealtimePort, type AiRealtimeSessionRequest, type AiSpeechResult, type AiTranscriptionResult } from '../core/types/media.types';
+import type { AiHostedToolCallItem, AiImageGenerationCallResult, AiResponse, AiResponseRequest, AiStreamEvent } from '../core/types/responses.types';
+import { AiKeyResolver, type AiKeyTier } from '../keys/ai-key-resolver.service';
+import type { UsableAiModel } from '../keys/dto/usable-ai-model.dto';
+import { UsableModelsService } from '../keys/usable-models.service';
+import { AiOutputWriter } from '../storage/ai-output-writer';
+import { type AiFeatureDefinition } from '../features/ai-feature.registry';
+import { type AiTargetResolver } from './target-resolver';
+import { type AiResolvedOptions } from '../ai.options';
+import { AiStorageInputResolver, type AiStorageInput } from '../storage/ai-storage-input.resolver';
+import { type StoredAiSpeechRunRequest, type StoredAiTranscriptionRunRequest } from './ai-audio-run-request';
+import { type AiImageOperation, type StoredAiImageRunRequest } from './ai-image-run-request';
+import { type AiHostedOutputOwner } from './ai-hosted-outputs';
+import { AiRunsService } from './ai-runs.service';
+import type { AiCallOptions, AiEditImageRequest, AiEmbedRequest, AiGenerateImageRequest, AiRealtimeRequest, AiRealtimeSessionResult, AiRequest, AiRunHandle, AiRunOperationOptions, AiSpeakRequest, AiStructuredRequest, AiTranscribeRequest, AiStructuredResponse, AiToolLoopRequest, AiToolLoopResult } from './ai-runtime.types';
+import { AiLimitsService } from './ai-limits.service';
+import { AiUsageRecorder } from './ai-usage.recorder';
+/** The facade's span — one per provider round-trip. The adapter's own `ai.provider.call` nests inside it. */
+export declare const AI_REQUEST_SPAN = "ai.request";
+/** Prompt text is logged (only when `ai.logPromptContent`) truncated to this many characters. */
+export declare const AI_PROMPT_LOG_MAX_CHARS = 2048;
+/**
+ * One user's AI client. Obtain it with `AiService.forUser(userId)`; every
+ * method runs the full gate pipeline, resolves the right key, records one
+ * usage row per provider round-trip, and traces the call.
+ *
+ * @stability experimental
+ */
+export interface AiUserClient {
+    /** The user this client acts for. */
+    readonly userId: string;
+    /** One response. */
+    respond(req: AiRequest, opts?: AiCallOptions): Promise<AiResponse>;
+    /**
+     * A streamed response. Lazy: gate and pre-stream provider errors surface on
+     * the first iteration. A caller that must answer them BEFORE committing to
+     * a stream (an SSE route) uses `openStream` instead.
+     */
+    stream(req: AiRequest, opts?: AiCallOptions): AsyncIterable<AiStreamEvent>;
+    /**
+     * A streamed response whose gates and provider connection are settled
+     * EAGERLY: the promise rejects with an `AiError` for every failure that
+     * happens before the first event; after that, a failure is an in-band
+     * `error` event and the iterable ends.
+     */
+    openStream(req: AiRequest, opts?: AiCallOptions): Promise<AsyncIterable<AiStreamEvent>>;
+    /**
+     * A response validated against `schema` — `parsed` is typed and always
+     * present. Output that is not JSON or does not match is
+     * `AiError('AI_STRUCTURED_OUTPUT_INVALID')` (502).
+     */
+    respondStructured<S extends z.ZodTypeAny>(req: AiStructuredRequest<S>, opts?: AiCallOptions): Promise<AiStructuredResponse<z.output<S>>>;
+    /**
+     * The function-calling agent loop (`ai-tool-loop.ts`): up to `maxSteps`
+     * (default 8, max 20) gated round-trips, each with its own usage row.
+     */
+    runTools(req: AiToolLoopRequest, opts?: AiCallOptions): Promise<AiToolLoopResult>;
+    /**
+     * Queues the request as a background run (an `ai.response.run` job) and
+     * returns at once; poll `AiRunsService.get(userId, runId)`. The gates run
+     * now — an unusable request fails fast — and again when the job executes.
+     *
+     * @throws AiError('AI_INVALID_REQUEST') when `ai.defaults.allowBackgroundRuns`
+     *   is off, or the request carries a function tool (in-process code cannot
+     *   survive the queue hop; use `runTools`).
+     */
+    startRun(req: AiRequest): Promise<AiRunHandle>;
+    /**
+     * Embeddings for one text or a batch of up to `AI_EMBEDDINGS_MAX_INPUTS`
+     * (256) texts, one vector per input in input order. Synchronous — no job:
+     * a large backfill enqueues a job type of its own that calls this per
+     * chunk. `model` is REQUIRED (vectors are only comparable within one
+     * model, so it is never inferred from `ai.defaultModel`).
+     *
+     * @throws AiError('AI_INVALID_REQUEST') for an empty or oversized batch,
+     *   an empty text, or a non-positive `dimensions`;
+     *   AiError('AI_CAPABILITY_UNSUPPORTED') for a model without `embeddings`.
+     */
+    embed(req: AiEmbedRequest, opts?: AiCallOptions): Promise<AiEmbeddingResult>;
+    /**
+     * Queues an image generation (an `ai.image.generate` job) and returns at
+     * once; poll `AiRunsService.get(userId, runId)` — a succeeded run's
+     * `output.storageObjectIds` are storage objects the user owns. Always
+     * asynchronous, and not subject to `ai.defaults.allowBackgroundRuns` (there
+     * is no synchronous form to fall back to). The gates run now and again
+     * when the job executes. `model` is REQUIRED.
+     *
+     * @throws AiError('AI_CAPABILITY_UNSUPPORTED') for a model without
+     *   `image_generation`; AiError('AI_INVALID_REQUEST') for an empty prompt
+     *   or `n` outside 1-4.
+     */
+    generateImage(req: AiGenerateImageRequest): Promise<AiRunHandle>;
+    /**
+     * As `generateImage`, editing the caller's own images (by storage object
+     * id — see `AiEditImageRequest`), with capability `image_edit`.
+     *
+     * @throws NotFoundException / ForbiddenException for an unknown input or
+     *   another user's (the same answers `ObjectsService` gives);
+     *   AiError('AI_INVALID_REQUEST') for an input that is not ready, not an
+     *   allowed image type, or too large.
+     */
+    editImage(req: AiEditImageRequest): Promise<AiRunHandle>;
+    /**
+     * Queues a transcription of one of the caller's recordings (an
+     * `ai.audio.transcribe` job) and returns at once; poll
+     * `AiRunsService.get(userId, runId)` — a succeeded run's `output.text` is
+     * the transcript. Always asynchronous, and not subject to
+     * `ai.defaults.allowBackgroundRuns`. The gates run now and again when the
+     * job executes. See `AiTranscribeRequest` for the input's rules and how an
+     * omitted `model` is chosen.
+     *
+     * @throws NotFoundException / ForbiddenException for an unknown recording
+     *   or another user's; AiError('AI_INVALID_REQUEST') for one that is not
+     *   ready, not audio (or MP4/WebM video), or larger than the provider
+     *   accepts; AiError('AI_CAPABILITY_UNSUPPORTED') for a model without
+     *   `audio_transcription`.
+     */
+    transcribe(req: AiTranscribeRequest): Promise<AiRunHandle>;
+    /**
+     * Queues text-to-speech (an `ai.audio.speech` job) and returns at once;
+     * poll `AiRunsService.get(userId, runId)` — a succeeded run's
+     * `output.storageObjectId` is the audio, a storage object the user owns
+     * (`aiGenerated: true`: disclose it). Always asynchronous, and not subject
+     * to `ai.defaults.allowBackgroundRuns`. See `AiSpeakRequest` for how an
+     * omitted model or voice is chosen.
+     *
+     * @throws AiError('AI_INVALID_REQUEST') for empty input or more than 4096
+     *   characters, a voice the model does not speak, a speed outside 0.25-4;
+     *   AiError('AI_CAPABILITY_UNSUPPORTED') for a model without `audio_speech`.
+     */
+    speak(req: AiSpeakRequest): Promise<AiRunHandle>;
+    /**
+     * Mints a realtime voice session (#449): an EPHEMERAL provider secret the
+     * browser opens one WebRTC session with, directly to the provider. The
+     * caller's key is spent server-side on the mint and never returned.
+     * Synchronous — no job. Counts as one request against the rate limits and
+     * records one usage row (`operation: 'realtime'`, `units: { sessions: 1 }`).
+     * See `AiRealtimeRequest` for how an omitted model or voice is chosen.
+     *
+     * @throws AiError('AI_REALTIME_DISABLED') when `ai.defaults.allowRealtime`
+     *   is off; AiError('AI_CAPABILITY_UNSUPPORTED') for a model without
+     *   `realtime`; AiError('AI_KEY_REQUIRED') with no key;
+     *   AiError('AI_INVALID_REQUEST') for a voice the model does not list or
+     *   over-long instructions.
+     */
+    createRealtimeSession(req: AiRealtimeRequest, opts?: AiCallOptions): Promise<AiRealtimeSessionResult>;
+    /**
+     * Runs a CUSTOM operation (PP-14.17, #935): an operation an app or package
+     * registered with `registerAiOperation`, served by a provider adapter's
+     * `operations` map (diarization, moderation, rerank, OCR). It is not a
+     * second pipeline: the call goes through the same gates as every built-in
+     * port, in the same order: the kill switch; the operation is registered and
+     * runnable; `inputSchema`; the target (an omitted `model` is the first usable
+     * model declaring the operation's capability, served by a provider that
+     * implements it); the provider is enabled; the model is enabled, declares the
+     * capability and is reachable with the key that would pay; the feature's
+     * needs; key resolution (the key policy); the rate limits; the handler;
+     * `outputSchema`; then ONE usage row (`operation` is the operation id, plus
+     * the caller's `feature`) and one `ai.request` span.
+     *
+     * The input is validated before any key is read, the output before it is
+     * returned. Nothing of the input or output is logged, put on a span or
+     * stored on the usage row (only ids, counts, codes and the units the
+     * operation's `usageUnits` reports); an output or an error carrying the
+     * call's key is refused or replaced by a generic one.
+     *
+     * @typeParam O - the output type `outputSchema` guarantees.
+     * @param operationId - a registered operation id (`audio.diarize`).
+     * @param input - parsed with the operation's `inputSchema`.
+     * @param opts - `provider` / `model` to pick the target, and `signal`.
+     * @returns the validated output.
+     *
+     * @throws AiError('AI_INVALID_REQUEST') for an unregistered or built-in
+     *   operation id, or an input that fails its schema;
+     *   AiError('AI_CAPABILITY_UNSUPPORTED') for a model without the
+     *   operation's capability or a provider that does not implement it;
+     *   AiError('AI_STRUCTURED_OUTPUT_INVALID') for an output that fails its
+     *   schema (the call is still recorded); every other gate's `AiError`.
+     */
+    run<O = unknown>(operationId: string, input: unknown, opts?: AiRunOperationOptions): Promise<O>;
+}
+/** Internal: who a client acts for, and under which job (for usage rows). */
+export interface AiClientScope {
+    userId: string;
+    /**
+     * The organization the call runs in (issue #725): `principal.activeOrgId` for
+     * an HTTP call, the job payload's `orgId` for a background run. Resolved to
+     * the single-mode default organization on first use when absent (a caller
+     * that predates organizations); in multi mode an absent organization is an
+     * error, never a guess. `ai_runs`, `ai_usage_events` and the storage objects
+     * a call reads or writes are all under row-level security.
+     */
+    orgId?: string;
+    jobId?: string;
+    /**
+     * The registered AI feature the call is made for (`registerAiFeature`,
+     * #739): routed through `AI_TARGET_RESOLVER`, checked against the
+     * feature's `needs`, and recorded as the `ai.feature` span attribute.
+     */
+    feature?: string;
+    /**
+     * The feature a background run was started for, read back from
+     * `ai_runs.feature` when its job executes (PP-14.17, #935). ATTRIBUTION
+     * ONLY: it lands on the usage row and the span, and is not gated again (the
+     * gates ran when the run was queued).
+     *
+     * @internal
+     */
+    attributedFeature?: string;
+    /** The background run being executed — names the folder its outputs are stored in. */
+    runId?: string;
+}
+/**
+ * Who pays and where a provider round-trip goes, whatever the operation —
+ * what the key/context step and the usage/span step need, and nothing more.
+ */
+export interface AiCallTarget {
+    provider: string;
+    /** The resolved model id. */
+    modelId: string;
+    baseUrl?: string;
+    /** The provider slot's other non-secret settings (#448), passed to the adapter as-is. */
+    providerSettings?: Readonly<Record<string, unknown>>;
+    logPromptContent: boolean;
+    /** Hosted tool TYPES the request carries (for the span) — never their options. */
+    hostedTools?: string[];
+    /** Which tier's key served the call (#739), set once it is resolved; the `ai.key.tier` span attribute. */
+    keyTier?: AiKeyTier;
+}
+/** Everything the gate pipeline settled for one `responses` call. */
+export interface PreparedAiCall extends AiCallTarget {
+    port: AiResponsesPort;
+    /** The request the adapter receives — model resolved, tokens clamped. */
+    request: AiResponseRequest;
+    model: UsableAiModel;
+    /**
+     * The request's storage-object inputs (#441), authorised and checked from
+     * their rows — nothing read, nothing presigned yet. Empty when it has none.
+     */
+    storageInputs: PlannedStorageInput[];
+}
+/** One storage-object input `prepare` accepted, and how its provider wants it. */
+export interface PlannedStorageInput {
+    input: AiStorageInput;
+    modality: AiStorageInputModality;
+    strategy: AiFileInputStrategy;
+}
+/** Everything the gate pipeline settled for one `embeddings` call. */
+export interface PreparedAiEmbeddingCall extends AiCallTarget {
+    port: AiEmbeddingsPort;
+    /** The request the adapter receives — model resolved, named fields only. */
+    request: AiEmbeddingRequest;
+}
+/** Everything the gate pipeline settled for one image generation or edit. */
+export interface PreparedAiImageCall extends AiCallTarget {
+    operation: AiImageOperation;
+    port: AiImagesPort;
+    /** The request as it is stored in `ai_runs.request` — named fields only, never a key. */
+    stored: StoredAiImageRunRequest;
+    /** An edit's resolved inputs (metadata only — bytes are read when the job runs). */
+    inputs: {
+        images: AiStorageInput[];
+        mask?: AiStorageInput;
+    };
+}
+/** Everything the gate pipeline settled for one transcription. */
+export interface PreparedAiTranscriptionCall extends AiCallTarget {
+    transcribe: NonNullable<AiAudioPort['transcribe']>;
+    /** The request as it is stored in `ai_runs.request` — named fields only, never a key. */
+    stored: StoredAiTranscriptionRunRequest;
+    /** The recording (metadata only — bytes are read when the job runs). */
+    input: AiStorageInput;
+    /** The largest recording the provider accepts. */
+    maxBytes: number;
+}
+/** Everything the gate pipeline settled for one speech synthesis. */
+export interface PreparedAiSpeechCall extends AiCallTarget {
+    speech: NonNullable<AiAudioPort['speech']>;
+    /** The request as it is stored in `ai_runs.request` — voice and format resolved, never a key. */
+    stored: StoredAiSpeechRunRequest;
+}
+/** Everything the gate pipeline settled for one custom operation (PP-14.17). */
+export interface PreparedAiOperationCall extends AiCallTarget {
+    /** The registered operation. */
+    operation: AiOperationDefinition;
+    /** The adapter's implementation of it. */
+    handler: AiOperationHandler;
+    /** The input, parsed with the operation's `inputSchema`. */
+    input: unknown;
+}
+/** Everything the gate pipeline settled for one realtime session mint. */
+export interface PreparedAiRealtimeCall extends AiCallTarget {
+    port: AiRealtimePort;
+    /** The request the adapter receives — model and voice resolved, named fields only. */
+    request: AiRealtimeSessionRequest & {
+        voice: string;
+    };
+}
+/** `executeImageRun`'s (and the audio runs') options. */
+export interface AiImageRunExecutionOptions extends AiCallOptions {
+    /** The organization the run belongs to: the job payload's `orgId` (#725). */
+    orgId?: string;
+    /** The job the round-trip is incurred under, for its usage row. */
+    jobId?: string;
+    /**
+     * The feature the run was started for (`ai_runs.feature`, PP-14.17, #935):
+     * recorded on the round-trip's usage row and span, NOT gated again (the
+     * gates ran when the run was queued). A value that is not a feature id is ignored.
+     */
+    feature?: string;
+    /**
+     * Runs after the gates pass and before the key is resolved or the provider
+     * called — the handler checks there is storage to keep the output in, so a
+     * call whose images could not be stored is never paid for.
+     */
+    beforeCall?: () => Promise<void>;
+}
+interface PrepareOptions {
+    streaming: boolean;
+    /** The organization stored inputs are read in (row-level security); absent: the single-mode default. */
+    orgId?: string;
+    /** The registered feature the call is made for (#739). */
+    feature?: string;
+}
+/**
+ * The AI runtime facade: the one way a feature calls a model. `forUser(userId)`
+ * returns a client whose every call runs the gate pipeline (kill switch,
+ * provider, model, capability, limits, key resolution) and records usage; the
+ * key is resolved per call and never leaves the server.
+ *
+ * @example
+ * ```ts
+ * const answer = await this.ai.forUser(userId, { orgId, feature: 'example_summary' }).respond({ input });
+ * ```
+ *
+ * @stability experimental
+ */
+export declare class AiService {
+    private readonly aiConfig;
+    private readonly registry;
+    private readonly usableModels;
+    private readonly keyResolver;
+    private readonly prisma;
+    private readonly usage;
+    private readonly runs;
+    private readonly inputs;
+    private readonly outputs;
+    private readonly limits;
+    private readonly logger;
+    constructor(aiConfig: AiConfigService, registry: AiProviderRegistry, usableModels: UsableModelsService, keyResolver: AiKeyResolver, prisma: AiPrisma, usage: AiUsageRecorder, runs: AiRunsService, inputs: AiStorageInputResolver, outputs: AiOutputWriter, limits: AiLimitsService, targetResolver?: AiTargetResolver, options?: AiResolvedOptions);
+    private readonly targets;
+    /**
+     * The AI client for `userId`. Cheap — create one per request.
+     *
+     * `jobId` is internal plumbing for the background-run handler, so its
+     * usage rows name the job they were incurred under.
+     */
+    forUser(userId: string, scope?: {
+        orgId?: string;
+        jobId?: string;
+        runId?: string;
+        feature?: string;
+        attributedFeature?: string;
+    }): AiUserClient;
+    /**
+     * 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.
+     */
+    private orgOf;
+    private respond;
+    private respondStructured;
+    private startRun;
+    /** Steps 6-7 for an already-gated call. */
+    private invoke;
+    /** The settler every result of `call` leaves through (see `ai-hosted-outputs.ts`). */
+    private hostedOutputs;
+    /**
+     * Persists one hosted `image_generation` result (#442) through the AI
+     * output writer (#437): the bytes become a `ready` storage object OWNED BY
+     * THE USER under `ai-outputs/<userId>/<runId or responseId>/`, and the
+     * published result carries its `storageObjectId` — never the bytes. Called
+     * once per image, even when a stream shows the item twice.
+     *
+     * STORAGE UNAVAILABLE IS NOT A FAILED RESPONSE. The provider call already
+     * happened (and was billed), and the rest of the answer — text, citations,
+     * other tool calls — is intact, so the image is published with
+     * `storageObjectId: null` and `storageError: 'AI_STORAGE_UNAVAILABLE'`
+     * instead, and a warning is logged (never the bytes). A dedicated image
+     * run (`generateImage`) refuses up front instead; a hosted tool cannot,
+     * because whether the model draws anything is only known afterwards.
+     *
+     * @internal
+     */
+    protected persistHostedImage(owner: AiHostedOutputOwner, item: Extract<AiHostedToolCallItem, {
+        tool: 'image_generation';
+    }>, responseId: string | undefined): Promise<AiImageGenerationCallResult>;
+    private embed;
+    private createRealtimeSession;
+    /**
+     * `run(operationId, input)` (PP-14.17, #935): one provider round-trip of a
+     * custom operation, through the same gates, key resolution, limits, usage
+     * row and span as every built-in port. See `AiUserClient.run`.
+     */
+    private runOperation;
+    /** The non-token units one successful custom call reports; a throwing callback never fails the call. */
+    private operationUnits;
+    /**
+     * The gate pipeline for a custom operation: kill switch, the operation is
+     * registered and runnable, its `inputSchema`, target (an omitted model is
+     * the first usable model declaring the operation's capability whose
+     * provider implements it), provider, model with the capability (model AND
+     * provider), the feature's needs. Decrypts nothing.
+     *
+     * @internal
+     */
+    prepareOperation(userId: string, operationId: string, input: unknown, opts: AiRunOperationOptions, orgId?: string, featureId?: string): Promise<PreparedAiOperationCall>;
+    private startImageRun;
+    /**
+     * Executes one stored image run for `userId` — the `ai.image.generate`
+     * handler's entry point, not a fork's (a fork calls `generateImage`/
+     * `editImage`, which queue). Re-runs every gate, reads an edit's input
+     * bytes, then makes ONE provider round-trip with one usage row.
+     *
+     * @internal
+     */
+    executeImageRun(userId: string, stored: StoredAiImageRunRequest, opts?: AiImageRunExecutionOptions): Promise<AiImageResult>;
+    private startTranscriptionRun;
+    /**
+     * Executes one stored transcription run for `userId` — the
+     * `ai.audio.transcribe` handler's entry point, not a fork's (a fork calls
+     * `transcribe`, which queues). Re-runs every gate, opens the recording,
+     * then makes ONE provider round-trip with one usage row.
+     *
+     * @internal
+     */
+    executeTranscriptionRun(userId: string, stored: StoredAiTranscriptionRunRequest, opts?: AiImageRunExecutionOptions): Promise<AiTranscriptionResult>;
+    /**
+     * 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
+     * extra, and the dropped value is never logged (it is the user's content).
+     */
+    private boundExtras;
+    /**
+     * The recording as the adapter receives it. A row that knows its size
+     * (already checked against the cap) is STREAMED through a reader that
+     * fails past `maxBytes`; a simple upload whose size is not recorded yet
+     * (`0`) is read with the cap enforced first, so an oversized file is
+     * refused before the provider is called either way.
+     */
+    private openRecording;
+    private startSpeechRun;
+    /**
+     * Executes one stored speech run for `userId` — the `ai.audio.speech`
+     * handler's entry point, not a fork's (a fork calls `speak`, which
+     * queues). Re-runs every gate, then makes ONE provider round-trip with one
+     * usage row (`units: { characters }`).
+     *
+     * @internal
+     */
+    executeSpeechRun(userId: string, stored: StoredAiSpeechRunRequest, opts?: AiImageRunExecutionOptions): Promise<AiSpeechResult>;
+    private lazyStream;
+    private openStream;
+    private relay;
+    /** Opens the `ai.request` span and returns the once-only finisher for it. */
+    private track;
+    /**
+     * Steps 1-5 of the pipeline: everything but the key. Throws the exact
+     * `AiError` for the first gate that refuses. Decrypts nothing.
+     *
+     * @internal
+     */
+    prepare(userId: string, req: AiRequest, opts: PrepareOptions): Promise<PreparedAiCall>;
+    /**
+     * The gate pipeline for `embed`: kill switch, request shape, target,
+     * provider, then model/capability/key/reach with `embeddings` as the one
+     * capability needed. Decrypts nothing.
+     *
+     * @internal
+     */
+    prepareEmbedding(userId: string, req: AiEmbedRequest, featureId?: string, orgId?: string): Promise<PreparedAiEmbeddingCall>;
+    /**
+     * The gate pipeline for an image generation or edit: kill switch, request
+     * shape, target, provider, model with `image_generation`/`image_edit` (model
+     * AND provider port), then — for an edit — every input storage object,
+     * checked for ownership, readiness, type and size from its row alone.
+     * Decrypts nothing and reads no bytes.
+     *
+     * @internal
+     */
+    prepareImage(userId: string, operation: AiImageOperation, req: AiGenerateImageRequest | AiEditImageRequest, orgId?: string, featureId?: string): Promise<PreparedAiImageCall>;
+    /**
+     * Step 4b: every storage-object part of `input`, authorised and checked
+     * from its row alone (see the file header). Reads no bytes and presigns
+     * nothing — `startRun` calls this too, and must not.
+     *
+     * @throws NotFoundException / ForbiddenException for an unknown object or
+     *   another user's (the answers `ObjectsService` gives);
+     *   AiError('AI_INVALID_REQUEST') for a part with both `url` and
+     *   `storageObjectId`, too many parts, an object not ready, an image part
+     *   that is not an image, or an object over its modality's cap;
+     *   AiError('AI_CAPABILITY_UNSUPPORTED') when the model lacks the
+     *   modality or the provider declares no `fileInputStrategy`.
+     */
+    private planStorageInputs;
+    /**
+     * After the gates, before the key: what each planned input's delivery
+     * strategy needs, for ONE provider call — a fresh presigned URL, or a
+     * capped byte stream. A storage failure here is `AI_STORAGE_UNAVAILABLE`
+     * (nothing was sent, so no usage row).
+     *
+     * ⚠ The URLs exist only in the returned map, which only `ctx` carries.
+     */
+    private materializeStorageInputs;
+    /**
+     * The gate pipeline for a transcription: kill switch, request shape,
+     * target (an omitted model is the first usable `audio_transcription`
+     * model), provider, model with `audio_transcription` (model AND provider
+     * port), then the recording's storage object — ownership, readiness, an
+     * audio (or MP4/WebM video) type, and the port's size limit — from its row
+     * alone. Decrypts nothing and reads no bytes.
+     *
+     * @internal
+     */
+    prepareTranscription(userId: string, req: AiTranscribeRequest, orgId?: string, featureId?: string): Promise<PreparedAiTranscriptionCall>;
+    /**
+     * The gate pipeline for speech: kill switch, request shape (input at most
+     * `AI_SPEECH_INPUT_MAX_CHARS`), target (an omitted model is the first
+     * usable `audio_speech` model), provider, model with `audio_speech` (model
+     * AND provider port), then the voice — the request's, else the model's
+     * first — checked against the model's catalog `voices`, else the port's.
+     * Decrypts nothing.
+     *
+     * @internal
+     */
+    prepareSpeech(userId: string, req: AiSpeakRequest, featureId?: string, orgId?: string): Promise<PreparedAiSpeechCall>;
+    /**
+     * The gate pipeline for a realtime session (#449): kill switch,
+     * `ai.defaults.allowRealtime`, request shape, target (an omitted model is
+     * the first usable `realtime` model), provider, model with `realtime`
+     * (model AND provider port), then the voice — the request's, else the
+     * model's first — checked against the model's catalog `voices`, else the
+     * port's. The deployment's output-token cap becomes the session's initial
+     * `maxOutputTokens`. Decrypts nothing.
+     *
+     * @internal
+     */
+    prepareRealtime(userId: string, req: AiRealtimeRequest, featureId?: string, orgId?: string): Promise<PreparedAiRealtimeCall>;
+    /**
+     * The first model `userId` can use right now that declares `capability`
+     * (on `provider`, when given) — in `GET /api/ai/models` order. For an
+     * operation whose model is never the chat `ai.defaultModel`.
+     */
+    private firstUsableModel;
+    /**
+     * Step 6: resolve the key, apply the rate limits (6b) and build the
+     * adapter context. `prompt` is the
+     * request's content, rendered only for the opt-in debug line.
+     */
+    private context;
+    /**
+     * Which (provider, model) the request targets: the bound
+     * `AI_TARGET_RESOLVER` (#739), by default the base order (see `AiRequest`
+     * and `DefaultAiTargetResolver`). `null` from the resolver is "no model".
+     */
+    private resolveTarget;
+    /** The registered feature a call names, or `undefined`; an unknown id is AI_INVALID_REQUEST. */
+    private featureOf;
+}
+/**
+ * The model capabilities a request's SHAPE needs. `responses` always; the
+ * rest follow from what the request carries.
+ */
+export declare function requiredCapabilities(req: Pick<AiResponseRequest, 'structuredOutput' | 'tools' | 'reasoning' | 'input'>, streaming: boolean): AiCapability[];
+/**
+ * The effective `maxOutputTokens`: the caller's value bounded by the
+ * deployment cap and the model's own limit. With no caller value, the
+ * deployment cap still bounds the call (it "bounds every call"); the model's
+ * limit alone does not invent one.
+ */
+export declare function clampOutputTokens(requested: number | undefined, deploymentCap: number | undefined, modelMax: number | undefined): number | undefined;
+/**
+ * `providerOptions` must be a plain JSON object of at most
+ * `AI_PROVIDER_OPTIONS_MAX_BYTES` serialised bytes (PP-14.17, #935). The
+ * error names the limit and never the value: the options are passed to the
+ * adapter and nothing else.
+ */
+export declare function assertProviderOptionsShape(options: unknown): void;
+/** The outcome of a round-trip that threw. An abort is a cancellation, not a failure. */
+/**
+ * Whether `value`, serialised, contains `apiKey`: a custom operation's output
+ * must never echo the key it was called under (PP-14.17, #935). The keyless
+ * marker and an empty key are not secrets.
+ */
+export declare function containsKey(value: unknown, apiKey: string): boolean;
+/**
+ * `error`, or a generic error of the same code when its message or details
+ * carry `apiKey`. A custom operation's handler is app code, trusted less than
+ * the built-in adapters, and an error is the likeliest place a key leaks.
+ */
+export declare function scrubKey(error: AiError, apiKey: string): AiError;
+/**
+ * Normalises anything a provider call threw. An abort is reported as a
+ * cancellation (never as the raw `AbortError`), everything else via
+ * `AiError.wrap` — so nothing raw escapes the facade.
+ */
+export declare function toAiError(err: unknown, signal?: AbortSignal): AiError;
+/**
+ * Refuses a model that does not fit the feature a call is made for (#739):
+ * a missing `needs` capability or input modality, or a provider outside the
+ * feature's allow-list. AI_INVALID_REQUEST, naming what is missing.
+ */
+export declare function assertFeatureFits(feature: AiFeatureDefinition | undefined, provider: string, model: string, capabilities: AiModelCapabilities): void;
+export {};
+//# sourceMappingURL=ai.service.d.ts.map

package/dist/ai/runtime/ai.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai.service.d.ts","sourceRoot":"","sources":["../../../src/ai/runtime/ai.service.ts"],"names":[],"mappings":"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"}