@db3.ai/app 0.1.0-beta.1 → 0.1.0-beta.4

package/dist/ai/Agent.d.ts

@@ -5,6 +5,7 @@ import { AiConversation } from './AiConversation.js';
 import { AiRequest } from './AiRequest.js';
 import { type AIProviderSelection } from './index.js';
 import type { AIUsageCharge } from './contracts/AI.js';
+import type { AIServiceTier } from './contracts/AIServiceTier.js';
 import type * as agent from './contracts/Agent.js';
 /**
  * Context passed into the complete provider-input builder.
@@ -20,7 +21,8 @@ export interface AgentInputContext {
  */
 export declare abstract class Agent<TContext extends agent.BaseAgentContext = agent.BaseAgentContext> implements Serializable<TContext> {
     protected readonly context: TContext;
-    protected readonly maxTurns: number;
+    /** Maximum model turns per run; null lets the agent finish without a turn ceiling. */
+    protected readonly maxTurns: number | null;
     protected readonly maxPreviousMessages: number;
     /** Provider reasoning effort used for every run of this agent. */
     protected readonly reasoningEffort: agent.AgentReasoningEffort | null;
@@ -29,6 +31,8 @@ export declare abstract class Agent<TContext extends agent.BaseAgentContext = ag
     protected readonly workflowName: string;
     /** Optional agent-specific model. Omit to use the global `app().ai.model`. */
     protected readonly model?: string;
+    /** OpenAI processing tier for this agent. Override to opt into local Flex experiments. */
+    protected readonly serviceTier: AIServiceTier;
     private currentInput;
     /**
      * Creates a persisted agent runtime for the supplied app context.
@@ -401,6 +405,7 @@ export declare abstract class Agent<TContext extends agent.BaseAgentContext = ag
      * @param rootState - Logical run root and shared conversation state.
      * @param attempt - Provider and model selected for this execution.
      * @param startedAtMs - Attempt start timestamp in milliseconds.
+     * @param serviceTier - Requested tier retained alongside this attempt.
      * @returns Persistence state scoped to the new provider attempt.
      */
     private startTrackedAttempt;
@@ -550,12 +555,7 @@ export declare abstract class Agent<TContext extends agent.BaseAgentContext = ag
      * @returns Recursive usage, settled credits, and complete provider cost.
      */
     private settleFinalizedTrackedRun;
-    /**
-     * Keeps a quota-blocked queued run pending and records its next retry.
-     *
-     * @param state - Active run persistence state.
-     * @param quotaRetry - Bounded exponential quota retry decision.
-     */
+    /** Keeps unstarted queued work visibly pending on the shared account deadline. */
     private deferTrackedRun;
     /**
      * Marks the tracked AI request as failed.

package/dist/ai/Agent.js

@@ -1,3 +1,4 @@
+import { AIProviderDeferredError, AIProviderStoppedError } from './AIProviderAdmission.js';
 import { aiExecutionContext } from './AiExecutionContext.js';
 import { Agent as SdkAgent, Runner, generateTraceId } from '@openai/agents';
 import { isQueueRetryLaterError } from '@db3.ai/app/queue';
@@ -5,12 +6,13 @@ import { agentMarkdownWithCitations, normalizedAgentCitations } from '@db3.ai/pu
 import { app } from '../server/appContext.js';
 import { AI_MESSAGE_ROLE, AI_MESSAGE_TOOL_STATE } from './AiMessage.js';
 import { AI_REQUEST_STATUS } from './AiRequest.js';
-import { AI_PROVIDER, AIQuotaDeferredError, AIRateLimitDeferredError, isFailoverableFailure, openAIProviderError, responsesRateLimitEndpoint, simulatedProviderOutage } from './index.js';
+import { AI_PROVIDER, isFailoverableFailure, openAIProviderError, responsesRateLimitEndpoint, simulatedProviderOutage } from './index.js';
 import { AIAllowanceExceededError } from './AIErrors.js';
 import { estimateTokensFromText } from './Estimates.js';
-import { calculateAIHostedToolCost, calculateAIRequestCostUSD, calculateAIRequestEntriesCostUSD, combineAIRequestCostUSD } from './Models.js';
+import { assertAIServiceTier, effectiveAIServiceTier } from './aiServiceTier.js';
+import { calculateAIHostedToolCost, calculateAIRequestCostUSD, calculateAIRequestEntriesCostUSD, combineAIRequestCostUSD } from './modelPricing.js';
 import { AgentRunJob } from './AgentRunJob.js';
-import { openAIQuotaRetryDecision, withOpenAIQuotaRetryMetadata, withoutOpenAIQuotaRetryMetadata } from './OpenAIQuotaRetry.js';
+import { withoutOpenAIQuotaRetryMetadata } from './OpenAIQuotaRetry.js';
 import { agentCitationFromStreamRecord, agentCitationsFromFinalModelResponse, rememberAgentCitation } from './agentCitations.js';
 import { serializeQueuedAgent } from './registry.js';
 import { agentToolResultFromStructuredOutput } from './toolHelpers.js';
@@ -20,6 +22,7 @@ import { INTERRUPTED_TOOL_CALL_MESSAGE, unresolvedToolCallIds } from './toolCall
  */
 export class Agent {
     context;
+    /** Maximum model turns per run; null lets the agent finish without a turn ceiling. */
     maxTurns = 8;
     maxPreviousMessages = 50;
     /** Provider reasoning effort used for every run of this agent. */
@@ -29,6 +32,8 @@ export class Agent {
     workflowName = this.constructor.name;
     /** Optional agent-specific model. Omit to use the global `app().ai.model`. */
     model;
+    /** OpenAI processing tier for this agent. Override to opt into local Flex experiments. */
+    serviceTier = 'default';
     currentInput = null;
     /**
      * Creates a persisted agent runtime for the supplied app context.
@@ -224,17 +229,13 @@ export class Agent {
             return await this.executePreparedRun(prepared, async () => { });
         }
         catch (error) {
-            if (isQueueRetryLaterError(error))
+            if (error instanceof AIProviderDeferredError) {
+                await this.deferTrackedRun(prepared.state, error);
                 throw error;
-            const quotaRetry = openAIQuotaRetryDecision(error, prepared.state.aiRequest);
-            if (quotaRetry && !quotaRetry.expired) {
-                await this.deferTrackedRun(prepared.state, quotaRetry);
-                throw new AIQuotaDeferredError(quotaRetry.delaySeconds, quotaRetry.retryAt, quotaRetry.retryUntil, quotaRetry.deferralCount, quotaRetry.message);
             }
+            if (isQueueRetryLaterError(error))
+                throw error;
             const providerError = openAIProviderError(error);
-            if (quotaRetry) {
-                prepared.state.aiRequest.metadata = withOpenAIQuotaRetryMetadata(prepared.state.aiRequest.metadata, quotaRetry.metadata);
-            }
             await this.failTrackedRun(prepared.state, error instanceof Error ? error.message : `Unable to run ${this.agentName}.`, providerError.code);
             throw error;
         }
@@ -493,7 +494,7 @@ export class Agent {
             input: invocation.input,
             maxTurns: this.maxTurns,
             model,
-            modelSettings: invocation.modelSettings,
+            modelSettings: modelSettingsForProvider(invocation.modelSettings, AI_PROVIDER.openai, this.serviceTier),
         });
     }
     /**
@@ -664,6 +665,7 @@ export class Agent {
         return {
             message,
             model,
+            serviceTier: this.serviceTier,
             traceId,
             previousMessages,
             invocation,
@@ -688,6 +690,7 @@ export class Agent {
         return {
             message: payload.message,
             model: payload.model,
+            serviceTier: payload.serviceTier ?? 'default',
             traceId: payload.traceId,
             previousMessages,
             invocation,
@@ -721,6 +724,8 @@ export class Agent {
         const instructions = invocation.instructions;
         const modelInput = invocation.input;
         const attempts = app().ai.resolveProviders(this.provider(), prepared.model);
+        for (const attempt of attempts)
+            assertAIServiceTier(attempt.provider, prepared.serviceTier);
         const attemptFailures = [];
         await this.attachPromptRequestPayload(state, {
             instructions,
@@ -739,12 +744,14 @@ export class Agent {
             const attemptStartMs = Date.now();
             let rateLimitLease = null;
             let sawStreamEvent = false;
+            let completedModelTurn = false;
             let activeUsage = null;
             let attemptState = null;
             let attemptSettled = false;
             let providerStarted = false;
+            const responsePricing = [];
             try {
-                attemptState = await this.startTrackedAttempt(state, attempt, attemptStartMs);
+                attemptState = await this.startTrackedAttempt(state, attempt, attemptStartMs, prepared.serviceTier);
                 rateLimitLease = await this.acquireProviderCapacity(prepared, instructions, modelInput, attempt, attemptState);
                 const simulatedOutage = simulatedProviderOutage(attempt.provider);
                 if (simulatedOutage)
@@ -754,8 +761,20 @@ export class Agent {
                     providerStarted = true;
                     const runner = new Runner({
                         model: attempt.model,
-                        modelProvider: app().ai.createAgentProvider(attempt, rateLimitLease),
-                        modelSettings: modelSettingsForProvider(invocation.modelSettings, attempt.provider),
+                        modelProvider: app().ai.createAgentProvider(attempt, rateLimitLease, prepared.serviceTier),
+                        modelSettings: {
+                            ...modelSettingsForProvider(invocation.modelSettings, attempt.provider, prepared.serviceTier),
+                            retry: {
+                                maxRetries: 8,
+                                /** Retains completed tools in this SDK run; never restarts the whole agent. */
+                                policy: ({ error }) => {
+                                    if (!completedModelTurn)
+                                        return false;
+                                    const delayMs = app().ai.providerAdmission.requestRetryDelay(attempt, agentRateLimitError(error));
+                                    return delayMs === null ? false : { retry: true, delayMs };
+                                },
+                            },
+                        },
                         tracingDisabled: process.env.OPENAI_AGENTS_TRACING_DISABLED === 'true',
                         traceIncludeSensitiveData: false,
                         workflowName: this.workflowName,
@@ -775,6 +794,14 @@ export class Agent {
                     let assistantText = '';
                     for await (const event of stream) {
                         sawStreamEvent = true;
+                        if (event.type === 'raw_model_stream_event' && event.data.type === 'response_done') {
+                            completedModelTurn = true;
+                            const providerData = recordValue(event.data.response.providerData);
+                            responsePricing.push({
+                                ...(typeof providerData?.model === 'string' ? { model: providerData.model } : {}),
+                                serviceTier: effectiveAIServiceTier(providerData?.service_tier, prepared.serviceTier),
+                            });
+                        }
                         const streamEvent = await this.streamEventFromSdkEvent(executionState, event);
                         if (!streamEvent)
                             continue;
@@ -784,6 +811,9 @@ export class Agent {
                         await emit(streamEvent);
                     }
                     await stream.completed;
+                    const streamFailure = app().ai.providerAdmission?.requestFailure(attempt, null);
+                    if (streamFailure)
+                        throw streamFailure;
                     const rawFinalOutput = this.finalOutputText(stream.finalOutput, assistantText);
                     const finalResponseCitations = agentCitationsFromFinalModelResponse(stream.rawResponses);
                     const citations = finalResponseCitations ?? normalizedAgentCitations(executionState.citations);
@@ -795,7 +825,7 @@ export class Agent {
                             citation,
                         });
                     }
-                    await this.completeTrackedAttempt(executionState, activeUsage, stream.lastResponseId ?? null);
+                    await this.completeTrackedAttempt(executionState, activeUsage, stream.lastResponseId ?? null, responsePricing);
                     attemptSettled = true;
                     const structuredOutput = this.structuredFinalOutput(stream.finalOutput);
                     const finalOutput = agentMarkdownWithCitations(rawFinalOutput, citations);
@@ -841,9 +871,14 @@ export class Agent {
                 });
             }
             catch (caught) {
-                const error = agentRateLimitError(caught);
+                const restored = agentRateLimitError(caught);
+                const failure = app().ai.providerAdmission?.requestFailure(attempt, restored) ?? restored;
+                // Restarting a turn after streamed output/tools can repeat completed work.
+                const error = failure instanceof AIProviderDeferredError && sawStreamEvent ? new AIProviderStoppedError('outage', failure.providerCode, { ...failure.diagnostics, stopStage: 'stream-output' }) : failure;
+                if (failure instanceof AIProviderDeferredError && error instanceof AIProviderStoppedError)
+                    error.providerStarted = failure.providerStarted;
                 if (attemptState && !attemptSettled) {
-                    await this.failTrackedAttempt(attemptState, activeUsage, providerStarted, error);
+                    await this.failTrackedAttempt(attemptState, activeUsage, providerStarted, error, responsePricing);
                 }
                 // Failover is only safe before the SDK has streamed anything: once
                 // events arrive, tool calls and partial output may already be
@@ -880,9 +915,10 @@ export class Agent {
      * @param rootState - Logical run root and shared conversation state.
      * @param attempt - Provider and model selected for this execution.
      * @param startedAtMs - Attempt start timestamp in milliseconds.
+     * @param serviceTier - Requested tier retained alongside this attempt.
      * @returns Persistence state scoped to the new provider attempt.
      */
-    async startTrackedAttempt(rootState, attempt, startedAtMs) {
+    async startTrackedAttempt(rootState, attempt, startedAtMs, serviceTier) {
         const aiRequest = await new (app().ai.models.request)({
             conversation: rootState.conversation,
             parentAiRequest: rootState.rootAiRequest,
@@ -893,6 +929,7 @@ export class Agent {
             operation: 'agents.run.attempt',
             status: AI_REQUEST_STATUS.pending,
             request: {
+                serviceTier,
                 rootAiRequestId: rootState.rootAiRequest.id,
                 traceId: rootState.traceId,
             },
@@ -923,10 +960,10 @@ export class Agent {
      * @param sdkUsage - Complete Agents SDK usage for this attempt.
      * @param lastResponseId - Last provider response id in the attempt.
      */
-    async completeTrackedAttempt(state, sdkUsage, lastResponseId) {
+    async completeTrackedAttempt(state, sdkUsage, lastResponseId, responsePricing) {
         const usage = agentRunUsage(sdkUsage);
-        const requestUsageEntries = agentRequestCostUsageEntries(sdkUsage);
-        const cost = agentAttemptCost(state.aiRequest.provider, state.model, usage, requestUsageEntries, state.hostedToolUsage);
+        const requestUsageEntries = agentRequestCostUsageEntries(sdkUsage, responsePricing, recordValue(state.aiRequest.request)?.serviceTier);
+        const cost = agentAttemptCost(state.aiRequest.provider, state.model, usage, requestUsageEntries, state.hostedToolUsage, recordValue(state.aiRequest.request)?.serviceTier);
         state.aiRequest.assign({
             response: agentAttemptResponse(usage, requestUsageEntries, cost, state.hostedToolUsage, {
                 lastResponseId,
@@ -955,14 +992,14 @@ export class Agent {
      * @param providerStarted - Whether execution crossed the provider boundary.
      * @param error - Error that ended the attempt.
      */
-    async failTrackedAttempt(state, sdkUsage, providerStarted, error) {
+    async failTrackedAttempt(state, sdkUsage, providerStarted, error, responsePricing) {
         const usage = sdkUsage ? agentRunUsage(sdkUsage) : emptyAgentRunUsage();
-        const requestUsageEntries = sdkUsage ? agentRequestCostUsageEntries(sdkUsage) : [];
+        const requestUsageEntries = sdkUsage ? agentRequestCostUsageEntries(sdkUsage, responsePricing, recordValue(state.aiRequest.request)?.serviceTier) : [];
         const hasBillableUsage = sdkUsage
             ? hasBillableAgentAttemptUsage(sdkUsage, state.hostedToolUsage)
             : Object.values(state.hostedToolUsage).some(count => Number.isFinite(count) && count > 0);
         const cost = hasBillableUsage
-            ? agentAttemptCost(state.aiRequest.provider, state.model, usage, requestUsageEntries, state.hostedToolUsage)
+            ? agentAttemptCost(state.aiRequest.provider, state.model, usage, requestUsageEntries, state.hostedToolUsage, recordValue(state.aiRequest.request)?.serviceTier)
             : emptyAgentAttemptCost(providerStarted);
         const message = error instanceof Error ? error.message : `Unable to run ${this.agentName}.`;
         state.aiRequest.assign({
@@ -1504,29 +1541,13 @@ export class Agent {
             costUSD: run.unpricedRequestCount > 0 ? null : run.totalCostUSD,
         };
     }
-    /**
-     * Keeps a quota-blocked queued run pending and records its next retry.
-     *
-     * @param state - Active run persistence state.
-     * @param quotaRetry - Bounded exponential quota retry decision.
-     */
-    async deferTrackedRun(state, quotaRetry) {
-        state.aiRequest.assign({
-            status: AI_REQUEST_STATUS.pending,
-            completedAt: null,
-            durationMs: null,
-            errorCode: quotaRetry.code,
-            errorMessage: quotaRetry.message,
-            metadata: withOpenAIQuotaRetryMetadata(state.aiRequest.metadata, quotaRetry.metadata),
-        });
-        await state.aiRequest.save();
-        await this.touchConversation(state, {
-            lastTraceId: state.traceId,
-            lastStatus: AI_REQUEST_STATUS.pending,
-            lastError: quotaRetry.message,
-            nextRetryAt: quotaRetry.retryAt.toISOString(),
-            retryUntil: quotaRetry.retryUntil.toISOString(),
+    /** Keeps unstarted queued work visibly pending on the shared account deadline. */
+    async deferTrackedRun(state, error) {
+        state.rootAiRequest.assign({ status: AI_REQUEST_STATUS.pending, completedAt: null, errorCode: 'ai_provider_deferred', errorMessage: error.message,
+            metadata: { ...(state.rootAiRequest.metadata ?? {}), providerAdmission: { retryAt: error.retryAt.toISOString(), retryUntil: error.retryUntil.toISOString() } },
         });
+        await state.rootAiRequest.save();
+        await this.touchConversation(state, { lastTraceId: state.traceId, lastStatus: AI_REQUEST_STATUS.pending, lastError: error.message, nextRetryAt: error.retryAt.toISOString(), retryUntil: error.retryUntil.toISOString() });
     }
     /**
      * Marks the tracked AI request as failed.
@@ -1617,6 +1638,7 @@ export class Agent {
             aiRequestId: prepared.state.aiRequest.id ? String(prepared.state.aiRequest.id) : null,
             traceId: prepared.traceId,
             model: prepared.model,
+            serviceTier: prepared.serviceTier,
         };
     }
     /**
@@ -1675,7 +1697,7 @@ function agentRateLimitError(error) {
     const seen = new Set();
     let current = error;
     while (current instanceof Error && !seen.has(current)) {
-        if (current instanceof AIRateLimitDeferredError)
+        if (isQueueRetryLaterError(current) || current instanceof AIProviderStoppedError)
             return current;
         seen.add(current);
         current = current.cause;
@@ -2698,10 +2720,13 @@ function agentRunUsage(usage) {
  * Normalizes the SDK's individual provider-request usage for accurate pricing.
  *
  * @param usage - Agents SDK aggregate usage object.
+ * @param responsePricing - Terminal response metadata in SDK request order.
+ * @param requestedTier - Saved selection used only for legacy Standard fallback.
  * @returns Individual request entries with cached-input details preserved.
  */
-function agentRequestCostUsageEntries(usage) {
-    return (usage.requestUsageEntries ?? []).map(entry => ({
+function agentRequestCostUsageEntries(usage, responsePricing, requestedTier) {
+    return (usage.requestUsageEntries ?? []).map((entry, index) => ({
+        ...(responsePricing.length === usage.requestUsageEntries?.length ? responsePricing[index] : { serviceTier: effectiveAIServiceTier(undefined, requestedTier) }),
         inputTokens: numberOrNull(entry.inputTokens),
         outputTokens: numberOrNull(entry.outputTokens),
         cachedTokens: tokenDetailValue(entry.inputTokensDetails, 'cached_tokens'),
@@ -2721,9 +2746,10 @@ function agentRequestCostUsageEntries(usage) {
  * @param usage - Aggregate attempt usage.
  * @param requestUsageEntries - Per-provider-request usage entries.
  * @param hostedToolUsage - Completed hosted provider-tool calls.
+ * @param requestedTier - Saved selection used for single-request Standard fallback.
  * @returns Complete attempt cost and any unpriced dimensions.
  */
-function agentAttemptCost(provider, model, usage, requestUsageEntries, hostedToolUsage) {
+function agentAttemptCost(provider, model, usage, requestUsageEntries, hostedToolUsage, requestedTier) {
     const usesPerRequestUsage = usage.requests > 0
         && requestUsageEntries.length === usage.requests;
     const usesSingleRequestAggregate = usage.requests === 1
@@ -2732,7 +2758,7 @@ function agentAttemptCost(provider, model, usage, requestUsageEntries, hostedToo
         ? usesPerRequestUsage
             ? calculateAIRequestEntriesCostUSD(model, requestUsageEntries)
             : usesSingleRequestAggregate
-                ? calculateAIRequestCostUSD(model, usage)
+                ? calculateAIRequestCostUSD(model, { ...usage, serviceTier: effectiveAIServiceTier(undefined, requestedTier) })
                 : null
         : null;
     const hostedToolCost = provider === AI_PROVIDER.openai
@@ -2834,20 +2860,22 @@ function emptyAgentRunUsage() {
     };
 }
 /**
- * Applies Standard service tier only to direct OpenAI provider requests.
+ * Applies the explicitly selected service tier only to direct OpenAI requests.
  *
  * @param settings - Agent-owned model settings.
  * @param provider - Provider selected for the current attempt.
- * @returns Provider-safe settings with deterministic OpenAI billing tier.
+ * @param serviceTier - Explicit class selection, frozen in queued run payloads.
+ * @returns Provider-safe settings with the selected OpenAI tier.
  */
-function modelSettingsForProvider(settings, provider) {
+function modelSettingsForProvider(settings, provider, serviceTier) {
+    assertAIServiceTier(provider, serviceTier);
     if (provider !== AI_PROVIDER.openai)
         return settings;
     return {
         ...settings,
         providerData: {
             ...(settings.providerData ?? {}),
-            service_tier: 'default',
+            service_tier: serviceTier,
         },
     };
 }

package/dist/ai/Ai.d.ts

@@ -1,9 +1,12 @@
 /// <reference path="./sdkNodeCompatibility.d.ts" preserve="true" />
+import type { GenerateEmbeddingOptions } from './contracts/AI.js';
+import { AIProviderAdmission } from './AIProviderAdmission.js';
 import { type ModelProvider } from '@openai/agents';
 import { AI_PROVIDER } from './contracts/AI.js';
 import { type AIProviderAttempt } from './AIProviders.js';
 import { AIRateLimiter, type AIProviderResponseMetadata, type AIRateLimitLease } from './AIRateLimiter.js';
-import type { AIAllowanceCheckInput, AIRecordIdentity, AIModels, AIConfig, AIOptions, AIProviderSelection, AIResponseLogOptions, GenerateEmbeddingResult, GenerateImageInput, GenerateImageOptions, GenerateImageResult, GenerateStructuredInput, GenerateTextInput, GenerateTextResult, RequestLogOptions } from './contracts/AI.js';
+import type { AIServiceTier } from './contracts/AIServiceTier.js';
+import type { AIAllowanceCheckInput, AIRecordIdentity, AIModels, AIConfig, AIOptions, AIProviderSelection, AIResponseLogOptions, GenerateEmbeddingResult, GenerateImageInput, GenerateImageOptions, GenerateImageResult, GenerateStructuredInput, GenerateTextInput, GenerateTextResult } from './contracts/AI.js';
 /**
  * Raised when exact provider usage could not be made durable after bounded retries.
  *
@@ -38,6 +41,7 @@ export declare class Ai {
     /** Logical ownership field used by this application. */
     readonly scopeField: string;
     private readonly rateLimiter;
+    readonly providerAdmission: AIProviderAdmission;
     /**
      * Create an AI service instance.
      *
@@ -290,7 +294,7 @@ export declare class Ai {
      * @param initialLease - Optional preflight reservation consumed by the first request.
      * @returns SDK provider using the service's transport and rate-limit lifecycle.
      */
-    createAgentProvider(attempt: AIProviderAttempt, initialLease?: AIRateLimitLease | null): ModelProvider;
+    createAgentProvider(attempt: AIProviderAttempt, initialLease?: AIRateLimitLease | null, serviceTier?: AIServiceTier): ModelProvider;
     /**
      * Reserves each SDK model turn and observes headers before streaming or tool execution.
      *
@@ -304,6 +308,10 @@ export declare class Ai {
      * @returns Transport that maintains provider capacity and request diagnostics.
      */
     private agentFetcher;
+    /** Resolves the account connection for OpenAI-only images and embeddings. */
+    private openAIAdmissionAttempt;
+    /** Resolves a tier-aware request timeout while respecting an explicit service override. */
+    private requestTimeoutMs;
     /**
      * Fetch implementation used by provider calls.
      */
@@ -368,7 +376,7 @@ export declare class Ai {
      * @param options - Optional AI request logging context.
      * @returns Embedding vector, model, and saved request id when tracking is enabled.
      */
-    generateEmbedding(input: string, model?: string, options?: RequestLogOptions): Promise<GenerateEmbeddingResult>;
+    generateEmbedding(input: string, model?: string, options?: GenerateEmbeddingOptions): Promise<GenerateEmbeddingResult>;
 }
 export { AIAllowanceExceededError, AIConfigurationError, AIRequestError } from './AIErrors.js';
 export { AI_PROVIDER };