@db3.ai/app 0.1.0-beta.1

package/dist/ai/AiConversation.d.ts

@@ -0,0 +1,17 @@
+import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db/ActiveRecord';
+/** Durable conversation that applications may extend with ownership and domain fields. */
+export declare class AiConversation extends ActiveRecord {
+    static table: string;
+    static primaryKey: string;
+    static comment: string;
+    /** Defines conversation identity, optional ownership and metadata. */
+    static fields(field: FieldBuilder): ReturnType<typeof ActiveRecord.fields>;
+    id: string | null;
+    user: unknown;
+    scope: unknown;
+    agent: string | null;
+    title: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+}

package/dist/ai/AiConversation.js

@@ -0,0 +1,38 @@
+import { ActiveRecord } from '@db3.ai/app/db/ActiveRecord';
+/** Durable conversation that applications may extend with ownership and domain fields. */
+export class AiConversation extends ActiveRecord {
+    static table = 'ai_conversations';
+    static primaryKey = 'id';
+    static comment = 'Groups AI messages and provider requests into one app-level conversation or generated workflow run.';
+    /** Defines conversation identity, optional ownership and metadata. */
+    static fields(field) {
+        return {
+            id: field.ulid({
+                comment: 'Stable id for this AI conversation.',
+            }),
+            user: field.string({ column: 'user_id', index: true, comment: 'Application user identifier, when available.' }),
+            scope: field.string({ column: 'scope_id', index: true, comment: 'Application-owned scope identifier, such as a team or project.' }),
+            agent: field.string({
+                required: false,
+                index: true,
+                comment: 'Local agent or feature name that created this conversation.',
+            }),
+            title: field.string({
+                required: false,
+                comment: 'Short human-readable title for debugging or future UI display.',
+            }),
+            metadata: field.jsonString({
+                required: false,
+                comment: 'Structured application metadata for this AI conversation.',
+            }),
+            createdAt: field.timestamp({
+                column: 'created_at',
+                auto: 'create',
+            }),
+            updatedAt: field.timestamp({
+                column: 'updated_at',
+                auto: 'update',
+            }),
+        };
+    }
+}

package/dist/ai/AiExecutionContext.d.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { AgentPersistenceState } from './contracts/Agent.js';
+import type { AIResponseLogOptions } from './contracts/AI.js';
+/** Request-local parentage for provider calls made by tools or nested agents. */
+export declare const aiExecutionContext: AsyncLocalStorage<AgentPersistenceState>;
+/** Inherits the active attempt without allowing nested work to create a second root debit. */
+export declare function scopedAiOptions<T extends AIResponseLogOptions>(options: T, scopeField: string): T;

package/dist/ai/AiExecutionContext.js

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** Request-local parentage for provider calls made by tools or nested agents. */
+export const aiExecutionContext = new AsyncLocalStorage();
+/** Inherits the active attempt without allowing nested work to create a second root debit. */
+export function scopedAiOptions(options, scopeField) {
+    const state = aiExecutionContext.getStore();
+    if (!state)
+        return options;
+    return {
+        conversation: state.conversation,
+        parentAiRequest: state.aiRequest,
+        user: state.aiRequest.user,
+        [scopeField]: state.aiRequest[scopeField],
+        ...options,
+    };
+}

package/dist/ai/AiMessage.d.ts

@@ -0,0 +1,43 @@
+import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db/ActiveRecord';
+import type { EntityRef } from '@db3.ai/app/db/fields/LinkField';
+import { AiConversation } from './AiConversation.js';
+import { AiRequest } from './AiRequest.js';
+export declare const AI_MESSAGE_ROLE: {
+    readonly system: "system";
+    readonly user: "user";
+    readonly assistant: "assistant";
+    readonly tool: "tool";
+};
+export declare const AI_MESSAGE_TOOL_STATE: {
+    readonly calling: "calling";
+    readonly success: "success";
+    readonly error: "error";
+};
+export type AiMessageRole = typeof AI_MESSAGE_ROLE[keyof typeof AI_MESSAGE_ROLE];
+export type AiMessageToolState = typeof AI_MESSAGE_TOOL_STATE[keyof typeof AI_MESSAGE_TOOL_STATE];
+export declare class AiMessage extends ActiveRecord {
+    static table: string;
+    static primaryKey: string;
+    static comment: string;
+    /**
+     * Defines the persisted message fields used by tracked AI conversations and tool calls.
+     */
+    static fields(field: FieldBuilder): ReturnType<typeof ActiveRecord.fields>;
+    id: string | null;
+    conversation: EntityRef<AiConversation> | null;
+    aiRequest: EntityRef<AiRequest> | null;
+    user: unknown;
+    scope: unknown;
+    role: AiMessageRole | null;
+    sequence: number | null;
+    content: string | null;
+    contentJson: unknown | null;
+    toolCallId: string | null;
+    toolName: string | null;
+    toolState: AiMessageToolState | null;
+    provider: string | null;
+    model: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+}

package/dist/ai/AiMessage.js

@@ -0,0 +1,105 @@
+import { ActiveRecord } from '@db3.ai/app/db/ActiveRecord';
+import { AiConversation } from './AiConversation.js';
+import { AiRequest } from './AiRequest.js';
+export const AI_MESSAGE_ROLE = {
+    system: 'system',
+    user: 'user',
+    assistant: 'assistant',
+    tool: 'tool',
+};
+export const AI_MESSAGE_TOOL_STATE = {
+    calling: 'calling',
+    success: 'success',
+    error: 'error',
+};
+export class AiMessage extends ActiveRecord {
+    static table = 'ai_messages';
+    static primaryKey = 'id';
+    static comment = 'Normalized AI conversation messages for prompts, assistant output, and tool messages.';
+    /**
+     * Defines the persisted message fields used by tracked AI conversations and tool calls.
+     */
+    static fields(field) {
+        return {
+            id: field.ulid({
+                comment: 'Stable id for this AI message.',
+            }),
+            conversation: field.link(() => AiConversation, {
+                column: 'conversation_id',
+                required: true,
+                onDelete: 'CASCADE',
+                index: true,
+                comment: 'Conversation this message belongs to.',
+            }),
+            aiRequest: field.link(() => AiRequest, {
+                column: 'ai_request_id',
+                required: false,
+                onDelete: 'SET NULL',
+                index: true,
+                comment: 'Provider request that produced or used this message, when available.',
+            }),
+            user: field.string({ column: 'user_id', index: true, comment: 'Application user identifier, when available.' }),
+            scope: field.string({ column: 'scope_id', index: true, comment: 'Application-owned scope identifier, such as a team or project.' }),
+            role: field.choice({
+                required: true,
+                choices: Object.values(AI_MESSAGE_ROLE),
+                comment: 'Message role in the AI conversation.',
+            }),
+            sequence: field.integer({
+                required: true,
+                unsigned: true,
+                comment: 'Monotonic message order within the conversation.',
+            }),
+            content: field.text({
+                required: false,
+                comment: 'Text content for this AI message.',
+            }),
+            contentJson: field.json({
+                column: 'content_json',
+                required: false,
+                comment: 'Structured content for this AI message, when the response is not plain text.',
+            }),
+            toolCallId: field.string({
+                column: 'tool_call_id',
+                required: false,
+                index: true,
+                comment: 'Provider or SDK call id for a tool invocation represented by this message.',
+            }),
+            toolName: field.string({
+                column: 'tool_name',
+                required: false,
+                index: true,
+                comment: 'Tool name for tool-call messages.',
+            }),
+            toolState: field.choice({
+                column: 'tool_state',
+                required: false,
+                choices: Object.values(AI_MESSAGE_TOOL_STATE),
+                index: true,
+                comment: 'Execution state for a tool-call message.',
+            }),
+            provider: field.string({
+                required: false,
+                index: true,
+                comment: 'AI provider associated with this message.',
+            }),
+            model: field.string({
+                required: false,
+                index: true,
+                comment: 'AI model associated with this message.',
+            }),
+            metadata: field.json({
+                required: false,
+                comment: 'Structured application metadata for this message.',
+            }),
+            createdAt: field.timestamp({
+                column: 'created_at',
+                auto: 'create',
+            }),
+            updatedAt: field.timestamp({
+                column: 'updated_at',
+                auto: 'update',
+            }),
+        };
+    }
+}

package/dist/ai/AiRateLimitBucket.d.ts

@@ -0,0 +1,69 @@
+import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db/ActiveRecord';
+export declare const AI_RATE_LIMIT_ENDPOINT: {
+    readonly responses: "responses";
+    readonly embeddings: "embeddings";
+    readonly images: "images";
+};
+export type AiRateLimitEndpoint = typeof AI_RATE_LIMIT_ENDPOINT[keyof typeof AI_RATE_LIMIT_ENDPOINT];
+/**
+ * Current OpenAI rate-limit state for one provider endpoint/model bucket.
+ *
+ * Buckets are intentionally current-state rows, not historical usage rows. The
+ * latest OpenAI response headers replace the request/token counters on this
+ * model, while individual `ai_requests` keep the per-request audit snapshots.
+ *
+ * Keep bucket identity aligned to provider limits: provider + endpoint family +
+ * model/shared limit key. Responses, Embeddings, and Images have different
+ * OpenAI limits, so they must have different bucket keys even when the app
+ * operation looks related. Do not split buckets by app operation unless the
+ * provider exposes a separate limit for that operation.
+ *
+ * Active reservations are subtracted from these remaining counts before a worker
+ * starts another provider call. This lets multiple queue workers share one
+ * current bucket without racing past the observed provider capacity.
+ */
+export declare class AiRateLimitBucket extends ActiveRecord {
+    static table: string;
+    static primaryKey: string;
+    static comment: string;
+    static fields(field: FieldBuilder): {
+        id: import("../db/index.js").UlidField;
+        bucketKey: import("../db/index.js").StringField;
+        provider: import("../db/index.js").StringField;
+        endpoint: import("../db/index.js").ChoiceStringField;
+        limitKey: import("../db/index.js").StringField;
+        limitRequests: import("../db/index.js").IntegerField;
+        remainingRequests: import("../db/index.js").IntegerField;
+        requestsResetAt: import("../db/index.js").TimestampField;
+        limitTokens: import("../db/index.js").IntegerField;
+        remainingTokens: import("../db/index.js").IntegerField;
+        tokensResetAt: import("../db/index.js").TimestampField;
+        limitProjectTokens: import("../db/index.js").IntegerField;
+        remainingProjectTokens: import("../db/index.js").IntegerField;
+        projectTokensResetAt: import("../db/index.js").TimestampField;
+        lastProviderRequestId: import("../db/index.js").StringField;
+        lastObservedAt: import("../db/index.js").TimestampField;
+        metadata: import("../db/index.js").JsonStringField<Record<string, unknown>>;
+        createdAt: import("../db/index.js").TimestampField;
+        updatedAt: import("../db/index.js").TimestampField;
+    };
+    id: string | null;
+    bucketKey: string | null;
+    provider: string | null;
+    endpoint: AiRateLimitEndpoint | null;
+    limitKey: string | null;
+    limitRequests: number | null;
+    remainingRequests: number | null;
+    requestsResetAt: Date | null;
+    limitTokens: number | null;
+    remainingTokens: number | null;
+    tokensResetAt: Date | null;
+    limitProjectTokens: number | null;
+    remainingProjectTokens: number | null;
+    projectTokensResetAt: Date | null;
+    lastProviderRequestId: string | null;
+    lastObservedAt: Date | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+}

package/dist/ai/AiRateLimitBucket.js

@@ -0,0 +1,138 @@
+import { ActiveRecord } from '@db3.ai/app/db/ActiveRecord';
+export const AI_RATE_LIMIT_ENDPOINT = {
+    responses: 'responses',
+    embeddings: 'embeddings',
+    images: 'images',
+};
+/**
+ * Current OpenAI rate-limit state for one provider endpoint/model bucket.
+ *
+ * Buckets are intentionally current-state rows, not historical usage rows. The
+ * latest OpenAI response headers replace the request/token counters on this
+ * model, while individual `ai_requests` keep the per-request audit snapshots.
+ *
+ * Keep bucket identity aligned to provider limits: provider + endpoint family +
+ * model/shared limit key. Responses, Embeddings, and Images have different
+ * OpenAI limits, so they must have different bucket keys even when the app
+ * operation looks related. Do not split buckets by app operation unless the
+ * provider exposes a separate limit for that operation.
+ *
+ * Active reservations are subtracted from these remaining counts before a worker
+ * starts another provider call. This lets multiple queue workers share one
+ * current bucket without racing past the observed provider capacity.
+ */
+export class AiRateLimitBucket extends ActiveRecord {
+    static table = 'ai_rate_limit_buckets';
+    static primaryKey = 'id';
+    static comment = 'Current AI provider rate-limit state by provider endpoint and model/shared limit key; not a historical usage table.';
+    static fields(field) {
+        return {
+            id: field.ulid({
+                comment: 'Stable id for this rate-limit bucket.',
+            }),
+            bucketKey: field.string({
+                column: 'bucket_key',
+                required: true,
+                unique: true,
+                index: true,
+                comment: 'Stable provider:endpoint:limit-key identifier, for example openai:responses:gpt-5.4-nano.',
+            }),
+            provider: field.string({
+                required: true,
+                default: 'openai',
+                index: true,
+                comment: 'AI provider this bucket belongs to.',
+            }),
+            endpoint: field.choice({
+                required: true,
+                choices: Object.values(AI_RATE_LIMIT_ENDPOINT),
+                index: true,
+                comment: 'Provider endpoint family this bucket tracks; responses and embeddings are separate limit pools.',
+            }),
+            limitKey: field.string({
+                column: 'limit_key',
+                required: true,
+                index: true,
+                comment: 'Model or shared provider limit key used for throttling, not the app operation name.',
+            }),
+            limitRequests: field.integer({
+                column: 'limit_requests',
+                required: false,
+                unsigned: true,
+                comment: 'Maximum requests allowed for the current provider window.',
+            }),
+            remainingRequests: field.integer({
+                column: 'remaining_requests',
+                required: false,
+                unsigned: true,
+                comment: 'Remaining requests from the latest provider headers before subtracting active reservations.',
+            }),
+            requestsResetAt: field.timestamp({
+                column: 'requests_reset_at',
+                required: false,
+                index: true,
+                comment: 'Time when the request limit window should reset.',
+            }),
+            limitTokens: field.integer({
+                column: 'limit_tokens',
+                required: false,
+                unsigned: true,
+                comment: 'Maximum tokens allowed for the current provider window.',
+            }),
+            remainingTokens: field.integer({
+                column: 'remaining_tokens',
+                required: false,
+                unsigned: true,
+                comment: 'Remaining tokens from the latest provider headers before subtracting active reservations.',
+            }),
+            tokensResetAt: field.timestamp({
+                column: 'tokens_reset_at',
+                required: false,
+                index: true,
+                comment: 'Time when the token limit window should reset.',
+            }),
+            limitProjectTokens: field.integer({
+                column: 'limit_project_tokens',
+                required: false,
+                unsigned: true,
+                comment: 'Maximum project-scoped tokens allowed for the current provider window.',
+            }),
+            remainingProjectTokens: field.integer({
+                column: 'remaining_project_tokens',
+                required: false,
+                unsigned: true,
+                comment: 'Remaining project-scoped tokens from the latest provider headers before subtracting active reservations.',
+            }),
+            projectTokensResetAt: field.timestamp({
+                column: 'project_tokens_reset_at',
+                required: false,
+                index: true,
+                comment: 'Time when the project token limit window should reset.',
+            }),
+            lastProviderRequestId: field.string({
+                column: 'last_provider_request_id',
+                required: false,
+                index: true,
+                comment: 'Most recent provider request id observed for this bucket.',
+            }),
+            lastObservedAt: field.timestamp({
+                column: 'last_observed_at',
+                required: false,
+                index: true,
+                comment: 'Time this bucket was last updated from provider headers.',
+            }),
+            metadata: field.jsonString({
+                required: false,
+                comment: 'Structured provider metadata for this bucket.',
+            }),
+            createdAt: field.timestamp({
+                column: 'created_at',
+                auto: 'create',
+            }),
+            updatedAt: field.timestamp({
+                column: 'updated_at',
+                auto: 'update',
+            }),
+        };
+    }
+}

package/dist/ai/AiRateLimitReservation.d.ts

@@ -0,0 +1,56 @@
+import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db/ActiveRecord';
+import type { EntityRef } from '@db3.ai/app/db/fields/LinkField';
+import { AiRequest } from './AiRequest.js';
+import { AiRateLimitBucket } from './AiRateLimitBucket.js';
+/**
+ * In-flight reservation against an AI rate-limit bucket.
+ *
+ * Reservations let multiple queue workers coordinate against the latest
+ * provider capacity before the provider returns updated response headers. They
+ * are short-lived coordination rows, not historical usage records; completed or
+ * failed provider calls should release their reservation, and stale reservations
+ * stop counting after `expires_at`.
+ */
+export declare class AiRateLimitReservation extends ActiveRecord {
+    static table: string;
+    static primaryKey: string;
+    static comment: string;
+    /**
+     * Deletes reservation rows that no longer affect provider capacity.
+     *
+     * Released rows have already stopped counting, and expired rows are treated
+     * as abandoned in-flight work. Durable audit data remains on `ai_requests`.
+     *
+     * @param now - Current time used to identify expired reservations.
+     * @returns Number of reservation rows removed.
+     */
+    static cleanupReleasedAndExpired(now?: Date): Promise<number>;
+    /**
+     * Declares the persisted rate-limit reservation fields.
+     *
+     * @param field - ActiveRecord field builder.
+     * @returns Field definitions for schema generation and value conversion.
+     */
+    static fields(field: FieldBuilder): {
+        id: import("../db/index.js").UlidField;
+        bucket: import("@db3.ai/app/db/fields/LinkField").LinkField<AiRateLimitBucket>;
+        aiRequest: import("@db3.ai/app/db/fields/LinkField").LinkField<AiRequest>;
+        operation: import("../db/index.js").StringField;
+        reservedRequests: import("../db/index.js").IntegerField;
+        reservedTokens: import("../db/index.js").IntegerField;
+        expiresAt: import("../db/index.js").TimestampField;
+        releasedAt: import("../db/index.js").TimestampField;
+        createdAt: import("../db/index.js").TimestampField;
+        updatedAt: import("../db/index.js").TimestampField;
+    };
+    id: string | null;
+    bucket: EntityRef<AiRateLimitBucket> | null;
+    aiRequest: EntityRef<AiRequest> | null;
+    operation: string | null;
+    reservedRequests: number | null;
+    reservedTokens: number | null;
+    expiresAt: Date | null;
+    releasedAt: Date | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+}

package/dist/ai/AiRateLimitReservation.js

@@ -0,0 +1,101 @@
+import { ActiveRecord } from '@db3.ai/app/db/ActiveRecord';
+import { AiRequest } from './AiRequest.js';
+import { AiRateLimitBucket } from './AiRateLimitBucket.js';
+/**
+ * In-flight reservation against an AI rate-limit bucket.
+ *
+ * Reservations let multiple queue workers coordinate against the latest
+ * provider capacity before the provider returns updated response headers. They
+ * are short-lived coordination rows, not historical usage records; completed or
+ * failed provider calls should release their reservation, and stale reservations
+ * stop counting after `expires_at`.
+ */
+export class AiRateLimitReservation extends ActiveRecord {
+    static table = 'ai_rate_limit_reservations';
+    static primaryKey = 'id';
+    static comment = 'Short-lived in-flight reservations subtracted from current AI rate-limit buckets.';
+    /**
+     * Deletes reservation rows that no longer affect provider capacity.
+     *
+     * Released rows have already stopped counting, and expired rows are treated
+     * as abandoned in-flight work. Durable audit data remains on `ai_requests`.
+     *
+     * @param now - Current time used to identify expired reservations.
+     * @returns Number of reservation rows removed.
+     */
+    static async cleanupReleasedAndExpired(now = new Date()) {
+        const deleted = await ActiveRecord.getDb()(this.table)
+            .where(query => {
+            query
+                .whereNotNull('released_at')
+                .orWhere('expires_at', '<=', now);
+        })
+            .delete();
+        return Number(deleted);
+    }
+    /**
+     * Declares the persisted rate-limit reservation fields.
+     *
+     * @param field - ActiveRecord field builder.
+     * @returns Field definitions for schema generation and value conversion.
+     */
+    static fields(field) {
+        return {
+            id: field.ulid({
+                comment: 'Stable id for this rate-limit reservation.',
+            }),
+            bucket: field.link(() => AiRateLimitBucket, {
+                column: 'bucket_id',
+                required: true,
+                onDelete: 'CASCADE',
+                index: true,
+                comment: 'Rate-limit bucket this reservation consumes capacity from.',
+            }),
+            aiRequest: field.link(() => AiRequest, {
+                column: 'ai_request_id',
+                required: false,
+                onDelete: 'SET NULL',
+                index: true,
+                comment: 'Tracked AI request associated with this reservation, when available.',
+            }),
+            operation: field.string({
+                required: false,
+                index: true,
+                comment: 'Application operation this reservation protects; bucket identity still comes from provider endpoint and limit key.',
+            }),
+            reservedRequests: field.integer({
+                column: 'reserved_requests',
+                required: true,
+                unsigned: true,
+                default: 1,
+                comment: 'Number of requests reserved against the bucket.',
+            }),
+            reservedTokens: field.integer({
+                column: 'reserved_tokens',
+                required: false,
+                unsigned: true,
+                comment: 'Estimated tokens reserved against the bucket.',
+            }),
+            expiresAt: field.timestamp({
+                column: 'expires_at',
+                required: true,
+                index: true,
+                comment: 'Time this reservation stops counting if it is not explicitly released.',
+            }),
+            releasedAt: field.timestamp({
+                column: 'released_at',
+                required: false,
+                index: true,
+                comment: 'Time this reservation was released after provider completion or failure.',
+            }),
+            createdAt: field.timestamp({
+                column: 'created_at',
+                auto: 'create',
+            }),
+            updatedAt: field.timestamp({
+                column: 'updated_at',
+                auto: 'update',
+            }),
+        };
+    }
+}

package/dist/ai/AiRequest.d.ts

@@ -0,0 +1,78 @@
+import { ActiveRecord, type FieldBuilder } from '@db3.ai/app/db/ActiveRecord';
+import type { EntityRef } from '@db3.ai/app/db/fields/LinkField';
+import { AiConversation } from './AiConversation.js';
+import { AiRateLimitBucket } from './AiRateLimitBucket.js';
+export declare const AI_REQUEST_STATUS: {
+    readonly pending: "pending";
+    readonly completed: "completed";
+    readonly failed: "failed";
+};
+import type { AiRequestRunCostSummary } from './contracts/AiRequestRunCostSummary.js';
+export type { AiRequestRunCostSummary } from './contracts/AiRequestRunCostSummary.js';
+/** Auditable provider request with recursive usage and cost reporting. */
+export declare class AiRequest extends ActiveRecord {
+    #private;
+    static table: string;
+    static primaryKey: string;
+    static comment: string;
+    static readonly STATES: {
+        readonly pending: "pending";
+        readonly completed: "completed";
+        readonly failed: "failed";
+    };
+    /**
+     * Totals one root request and every recursively linked descendant exactly once.
+     *
+     * The self-referencing relationship supports image generation, embeddings,
+     * and future nested agent runs without relying on conversation or timestamp
+     * heuristics.
+     *
+     * @param rootAiRequestId - Root request id for the run.
+     * @returns Recursive request-tree cost summary, or null when the root is absent.
+     *
+     * @example
+     * const cost = await AiRequest.runCostSummary(articleAiRequestId);
+     * console.log(cost?.totalCostUSD);
+     */
+    static runCostSummary(rootAiRequestId: string | null | undefined): Promise<AiRequestRunCostSummary | null>;
+    /**
+     * Totals multiple known root requests and their descendants in one batched walk.
+     *
+     * @param roots - Root request records to aggregate.
+     * @returns Cost summaries keyed by root request id.
+     */
+    static runCostSummaries(roots: AiRequest[]): Promise<Map<string, AiRequestRunCostSummary>>;
+    /** Defines the durable request, response, rate-limit and measured usage fields. */
+    static fields(field: FieldBuilder): ReturnType<typeof ActiveRecord.fields>;
+    id: string | null;
+    conversation: EntityRef<AiConversation> | null;
+    parentAiRequest: EntityRef<AiRequest> | null;
+    request: unknown | null;
+    response: unknown | null;
+    providerRequestId: string | null;
+    providerProcessingMs: number | null;
+    rateLimitBucket: EntityRef<AiRateLimitBucket> | null;
+    rateLimitSnapshot: Record<string, unknown> | null;
+    user: unknown;
+    scope: unknown;
+    status: typeof AI_REQUEST_STATUS[keyof typeof AI_REQUEST_STATUS] | null;
+    provider: string | null;
+    model: string | null;
+    operation: string | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    totalTokens: number | null;
+    reasoningTokens: number | null;
+    cachedTokens: number | null;
+    cacheWriteTokens: number | null;
+    costUSD: number | null;
+    knownCostUSD: number | null;
+    durationMs: number | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+    startedAt: Date | null;
+    completedAt: Date | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+}