opik 2.0.62 → 2.0.63

package/dist/index.d.cts

@@ -371,6 +371,36 @@ interface GetLatestBlueprintRequest {
     maskId?: string;
 }
 
+/**
+ * @example
+ *     {
+ *         body: {
+ *             intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+ *             intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+ *         }
+ *     }
+ */
+interface GetSpendLaneBreakdownRequest {
+    body: SpendMetricRequest;
+}
+
+/**
+ * @example
+ *     {
+ *         body: {
+ *             intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+ *             intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+ *         }
+ *     }
+ */
+interface GetSpendUsersRequest {
+    page?: number;
+    size?: number;
+    sorting?: string;
+    name?: string;
+    body: SpendMetricRequest;
+}
+
 /**
  * @example
  *     {}
@@ -455,6 +485,7 @@ interface AnnotationQueueUpdate {
     commentsEnabled?: boolean;
     feedbackDefinitionNames?: string[];
     annotatorsPerItem?: number;
+    lockTimeoutSeconds?: number;
 }
 
 /**
@@ -475,6 +506,18 @@ interface FindAnnotationQueuesRequest {
  */
 type GetAnnotationQueueByIdRequest = {};
 
+/**
+ * @example
+ *     {}
+ */
+type GetAnnotationQueueLocksRequest = {};
+
+/**
+ * @example
+ *     {}
+ */
+type LockAnnotationQueueItemRequest = {};
+
 /**
  * @example
  *     {
@@ -1254,6 +1297,8 @@ interface ExperimentItemBulkUploadExperimentItemBulkWriteView {
     datasetName: string;
     /** Optional experiment ID. If provided, items will be added to the existing experiment and experimentName will be ignored. If not provided or experiment with that ID doesn't exist, a new experiment will be created with the given experimentName */
     experimentId?: string;
+    /** Project for traces auto-created from items that provide evaluate_task_result (i.e. without an explicit trace). If null, the default project is used; relying on this fallback is deprecated, please provide project_name explicitly. */
+    projectName?: string;
     items: ExperimentItemBulkRecordExperimentItemBulkWriteView[];
 }
 
@@ -1571,6 +1616,79 @@ declare const ProviderApiKeyWriteProvider: {
 };
 type ProviderApiKeyWriteProvider = (typeof ProviderApiKeyWriteProvider)[keyof typeof ProviderApiKeyWriteProvider];
 
+/**
+ * @example
+ *     {
+ *         clientId: "client_id",
+ *         redirectUri: "redirect_uri"
+ *     }
+ */
+interface AuthorizeRequest {
+    clientId: string;
+    redirectUri: string;
+    responseType?: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: string;
+    resource?: string;
+    state?: string;
+}
+
+/**
+ * @example
+ *     {
+ *         clientId: "client_id",
+ *         redirectUri: "redirect_uri",
+ *         codeChallenge: "code_challenge",
+ *         codeChallengeMethod: "code_challenge_method",
+ *         resource: "resource"
+ *     }
+ */
+interface ConsentRequest {
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    codeChallengeMethod: string;
+    resource: string;
+    state?: string;
+    workspaceId?: string;
+    workspaceName?: string;
+    csrf?: string;
+}
+
+/**
+ * @example
+ *     {
+ *         clientId: "client_id",
+ *         redirectUri: "redirect_uri"
+ *     }
+ */
+interface GetAuthorizeContextRequest {
+    clientId: string;
+    redirectUri: string;
+}
+
+/**
+ * @example
+ *     {}
+ */
+interface RevokeRequest {
+    token?: string;
+    clientId?: string;
+}
+
+/**
+ * @example
+ *     {}
+ */
+interface TokenRequest {
+    grantType?: string;
+    code?: string;
+    redirectUri?: string;
+    clientId?: string;
+    codeVerifier?: string;
+    refreshToken?: string;
+}
+
 /**
  * @example
  *     {}
@@ -2171,6 +2289,57 @@ interface ProjectsRedirectRequest {
     path: string;
 }
 
+/**
+ * @example
+ *     {}
+ */
+type GenerateReportRequest = {};
+
+/**
+ * @example
+ *     {}
+ */
+type GetReportPreferenceRequest = {};
+
+/**
+ * @example
+ *     {}
+ */
+interface GetReportsRequest {
+    page?: number;
+    size?: number;
+}
+
+/**
+ * @example
+ *     {
+ *         status: "pending"
+ *     }
+ */
+interface ReportCompleteRequest {
+    content?: string;
+    status: ReportCompleteRequestStatus;
+    sessionId?: string;
+    recommendedActions?: JsonNode;
+}
+
+/**
+ * @example
+ *     {
+ *         body: {}
+ *     }
+ */
+interface UpdateReportPreferenceRequest {
+    body: ReportPreference;
+}
+
+declare const ReportCompleteRequestStatus: {
+    readonly Pending: "pending";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+};
+type ReportCompleteRequestStatus = (typeof ReportCompleteRequestStatus)[keyof typeof ReportCompleteRequestStatus];
+
 /**
  * @example
  *     {}
@@ -3360,6 +3529,7 @@ interface AnnotationQueuePublic {
     commentsEnabled?: boolean;
     feedbackDefinitionNames?: string[];
     annotatorsPerItem?: number;
+    lockTimeoutSeconds?: number;
     reviewers?: AnnotationQueueReviewerPublic[];
     feedbackScores?: FeedbackScoreAveragePublic[];
     itemsCount?: number;
@@ -3393,6 +3563,7 @@ interface AnnotationQueueWrite {
     commentsEnabled?: boolean;
     feedbackDefinitionNames?: string[];
     annotatorsPerItem?: number;
+    lockTimeoutSeconds?: number;
 }
 
 declare const AnnotationQueueWriteScope: {
@@ -3493,6 +3664,25 @@ interface AudioUrlWrite {
 
 type AuthDetailsHolder = Record<string, unknown>;
 
+interface AuthorizationServerMetadata {
+    issuer?: string;
+    authorizationEndpoint?: string;
+    tokenEndpoint?: string;
+    revocationEndpoint?: string;
+    registrationEndpoint?: string;
+    responseTypesSupported?: string[];
+    grantTypesSupported?: string[];
+    codeChallengeMethodsSupported?: string[];
+    tokenEndpointAuthMethodsSupported?: string[];
+}
+
+interface AuthorizeContext {
+    clientName?: string;
+    clientLogoUri?: string;
+    workspaces?: WorkspaceInfo[];
+    csrfToken?: string;
+}
+
 interface AutomationRuleEvaluatorLlmAsJudgePublic {
     filters?: TraceFilterPublic[];
     code?: LlmAsJudgeCodePublic;
@@ -4078,6 +4268,10 @@ interface CompletionTokensDetails {
     reasoningTokens?: number;
 }
 
+interface ConsentResponse {
+    redirectTo?: string;
+}
+
 interface CountValueStatPublic {
     value?: number;
 }
@@ -5238,6 +5432,13 @@ interface FunctionCall {
     arguments?: string;
 }
 
+/**
+ * Response for report generation trigger
+ */
+interface GenerateReportResponse {
+    reportId?: string;
+}
+
 interface GroupContent {
     label?: string;
 }
@@ -5289,6 +5490,11 @@ declare const GuardrailWriteResult: {
 };
 type GuardrailWriteResult = (typeof GuardrailWriteResult)[keyof typeof GuardrailWriteResult];
 
+interface HarnessEntry {
+    key?: string;
+    label?: string;
+}
+
 interface ImageUrl {
     url: string;
     detail?: string;
@@ -5304,6 +5510,28 @@ interface ImageUrlWrite {
     detail?: string;
 }
 
+interface Item {
+    id?: string;
+    title?: string;
+    body?: string;
+    impact?: ItemImpact;
+    estimatedSavingsTokens?: number;
+    docsUrl?: string;
+    relatedLaneKey?: string;
+}
+
+declare const ItemImpact: {
+    readonly High: "high";
+    readonly Medium: "medium";
+    readonly Low: "low";
+};
+type ItemImpact = (typeof ItemImpact)[keyof typeof ItemImpact];
+
+interface ItemLockInfo {
+    activeLocks?: number;
+    lockedBy?: string[];
+}
+
 type JsonListString = Record<string, unknown> | Record<string, unknown>[] | string;
 
 type JsonListStringCompare = Record<string, unknown> | Record<string, unknown>[] | string;
@@ -5350,6 +5578,14 @@ declare const KpiMetricType: {
 };
 type KpiMetricType = (typeof KpiMetricType)[keyof typeof KpiMetricType];
 
+interface Lane {
+    key?: string;
+    label?: string;
+    totalTokens?: number;
+    byModel?: ModelTiers[];
+    hasBreakdown?: boolean;
+}
+
 interface LlmAsJudgeCode {
     model: LlmAsJudgeModelParameters;
     messages: LlmAsJudgeMessage[];
@@ -5592,6 +5828,17 @@ declare const LocalRunnerType: {
 };
 type LocalRunnerType = (typeof LocalRunnerType)[keyof typeof LocalRunnerType];
 
+interface LockResponse {
+    acquired?: boolean;
+    itemId?: string;
+    lockedBy?: string;
+    expiresAt?: Date;
+}
+
+interface LocksResponse {
+    locks?: Record<string, ItemLockInfo>;
+}
+
 interface LogItem {
     timestamp?: Date;
     ruleId?: string;
@@ -5657,6 +5904,14 @@ interface Message {
     content: JsonNode;
 }
 
+interface ModelTiers {
+    model?: string;
+    inputTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    outputTokens?: number;
+}
+
 interface MultipartUploadPart {
     eTag: string;
     partNumber: number;
@@ -5729,6 +5984,31 @@ interface OllamaModel {
     modifiedAt?: Date;
 }
 
+interface OllieReport {
+    id?: string;
+    projectId?: string;
+    sessionId?: string;
+    content?: string;
+    recommendedActions?: JsonNode;
+    status?: OllieReportStatus;
+    createdAt?: Date;
+    lastUpdatedAt?: Date;
+}
+
+interface OllieReportPage {
+    page?: number;
+    size?: number;
+    total?: number;
+    content?: OllieReport[];
+}
+
+declare const OllieReportStatus: {
+    readonly Pending: "pending";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+};
+type OllieReportStatus = (typeof OllieReportStatus)[keyof typeof OllieReportStatus];
+
 interface OptimizationPagePublic {
     page?: number;
     size?: number;
@@ -6248,12 +6528,13 @@ interface RecentActivityItemPublic {
 }
 
 declare const RecentActivityItemPublicType: {
+    readonly TraceDaily: "trace_daily";
     readonly Experiment: "experiment";
     readonly DatasetVersion: "dataset_version";
     readonly TestSuiteVersion: "test_suite_version";
     readonly AlertEvent: "alert_event";
     readonly Optimization: "optimization";
-    readonly AgentConfigVersion: "agent_config_version";
+    readonly PromptVersion: "prompt_version";
 };
 type RecentActivityItemPublicType = (typeof RecentActivityItemPublicType)[keyof typeof RecentActivityItemPublicType];
 
@@ -6264,6 +6545,15 @@ interface RecentActivityPagePublic {
     content?: RecentActivityItemPublic[];
 }
 
+interface ReportPreference {
+    projectId?: string;
+    enabled?: boolean;
+    scheduleTime?: string;
+    customPrompt?: string;
+    createdAt?: Date;
+    lastUpdatedAt?: Date;
+}
+
 interface ResponseFormat {
     type?: ResponseFormatType;
     jsonSchema?: JsonSchema;
@@ -6362,7 +6652,9 @@ interface ServiceTogglesConfig {
     customllmProviderEnabled: boolean;
     ollamaProviderEnabled: boolean;
     ollieEnabled: boolean;
+    projectHomepageEnabled: boolean;
     agenticToolsEnabled: boolean;
+    agentInsightsEnabled: boolean;
     v2WorkspaceAllowlistIds: string[];
     v1WorkspaceAllowlistIds: string[];
     forceWorkspaceVersion: string;
@@ -6371,6 +6663,11 @@ interface ServiceTogglesConfig {
     v1WorkspaceAllowlist?: string;
 }
 
+interface Side {
+    totalTokens?: number;
+    lanes?: Lane[];
+}
+
 interface Span$1 {
     id?: string;
     /** If null, the default project is used */
@@ -6735,6 +7032,66 @@ declare const SpanWriteType: {
 };
 type SpanWriteType = (typeof SpanWriteType)[keyof typeof SpanWriteType];
 
+interface SpendBreakdownResponse {
+    laneKey?: string;
+    title?: string;
+    subtitle?: string;
+    totalTokens?: number;
+    byModel?: ModelTiers[];
+    itemCount?: number;
+    itemUnit?: string;
+    items?: Item[];
+}
+
+interface SpendCompositionResponse {
+    input?: Side;
+    harness?: HarnessEntry[];
+    output?: Side;
+}
+
+interface SpendMetricRequest {
+    projectId?: string;
+    projectName?: string;
+    intervalStart: Date;
+    intervalEnd: Date;
+    userId?: string;
+    startBeforeEnd?: boolean;
+    projectProvided?: boolean;
+}
+
+interface SpendRecommendationsResponse {
+    totalSavingsTokens?: number;
+    items?: Item[];
+}
+
+interface SpendSummaryResponse {
+    results?: Result[];
+    spendCurrent?: ModelTiers[];
+    spendPrevious?: ModelTiers[];
+}
+
+interface SpendUserPage {
+    page?: number;
+    size?: number;
+    total?: number;
+    content?: SpendUserRow[];
+    sortableBy?: string[];
+}
+
+interface SpendUserRow {
+    userUuid?: string;
+    userEmail?: string;
+    userDisplayName?: string;
+    byModel?: ModelTiers[];
+    totalTokens?: number;
+    requests?: number;
+    skills?: number;
+    mcps?: number;
+    mcpCalls?: number;
+    repositories?: string[];
+    flags?: string[];
+}
+
 interface StartMultipartUploadResponse {
     uploadId: string;
     preSignUrls: string[];
@@ -6800,6 +7157,15 @@ interface StudioPromptWrite {
     messages: StudioMessageWrite[];
 }
 
+interface TokenResponse {
+    accessToken?: string;
+    refreshToken?: string;
+    tokenType?: string;
+    expiresIn?: number;
+    workspaceId?: string;
+    workspaceName?: string;
+}
+
 interface TokenUsageNames {
     names?: string[];
 }
@@ -7430,6 +7796,11 @@ interface WorkspaceConfiguration {
     colorMap?: Record<string, string>;
 }
 
+interface WorkspaceInfo {
+    id?: string;
+    name?: string;
+}
+
 interface WorkspaceMetricResponse {
     results?: Result[];
 }
@@ -7768,6 +8139,104 @@ declare class AgentConfigsClient {
     private __removeConfigKeys;
 }
 
+declare namespace AiSpendClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+/**
+ * Coding-agent spend analytics
+ */
+declare class AiSpendClient {
+    protected readonly _options: NormalizedClientOptions<AiSpendClient.Options>;
+    constructor(options?: AiSpendClient.Options);
+    /**
+     * Get coding-agent token-flow composition (Sankey)
+     *
+     * @param {OpikApi.SpendMetricRequest} request
+     * @param {AiSpendClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.BadRequestError}
+     *
+     * @example
+     *     await client.aiSpend.getSpendComposition({
+     *         intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+     *         intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+     *     })
+     */
+    getSpendComposition(request: SpendMetricRequest, requestOptions?: AiSpendClient.RequestOptions): HttpResponsePromise<SpendCompositionResponse>;
+    private __getSpendComposition;
+    /**
+     * Get the per-item breakdown for a composition lane
+     *
+     * @param {string} laneKey
+     * @param {OpikApi.GetSpendLaneBreakdownRequest} request
+     * @param {AiSpendClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.BadRequestError}
+     *
+     * @example
+     *     await client.aiSpend.getSpendLaneBreakdown("laneKey", {
+     *         body: {
+     *             intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+     *             intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+     *         }
+     *     })
+     */
+    getSpendLaneBreakdown(laneKey: string, request: GetSpendLaneBreakdownRequest, requestOptions?: AiSpendClient.RequestOptions): HttpResponsePromise<SpendBreakdownResponse>;
+    private __getSpendLaneBreakdown;
+    /**
+     * Get coding-agent cost-saving recommendations
+     *
+     * @param {OpikApi.SpendMetricRequest} request
+     * @param {AiSpendClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.BadRequestError}
+     *
+     * @example
+     *     await client.aiSpend.getSpendRecommendations({
+     *         intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+     *         intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+     *     })
+     */
+    getSpendRecommendations(request: SpendMetricRequest, requestOptions?: AiSpendClient.RequestOptions): HttpResponsePromise<SpendRecommendationsResponse>;
+    private __getSpendRecommendations;
+    /**
+     * Get coding-agent spend KPI summary
+     *
+     * @param {OpikApi.SpendMetricRequest} request
+     * @param {AiSpendClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.BadRequestError}
+     *
+     * @example
+     *     await client.aiSpend.getSpendSummary({
+     *         intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+     *         intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+     *     })
+     */
+    getSpendSummary(request: SpendMetricRequest, requestOptions?: AiSpendClient.RequestOptions): HttpResponsePromise<SpendSummaryResponse>;
+    private __getSpendSummary;
+    /**
+     * Get coding-agent spend per user
+     *
+     * @param {OpikApi.GetSpendUsersRequest} request
+     * @param {AiSpendClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.BadRequestError}
+     *
+     * @example
+     *     await client.aiSpend.getSpendUsers({
+     *         body: {
+     *             intervalStart: new Date("2024-01-15T09:30:00.000Z"),
+     *             intervalEnd: new Date("2024-01-15T09:30:00.000Z")
+     *         }
+     *     })
+     */
+    getSpendUsers(request: GetSpendUsersRequest, requestOptions?: AiSpendClient.RequestOptions): HttpResponsePromise<SpendUserPage>;
+    private __getSpendUsers;
+}
+
 declare namespace AlertsClient {
     type Options = BaseClientOptions;
     interface RequestOptions extends BaseRequestOptions {
@@ -8012,6 +8481,31 @@ declare class AnnotationQueuesClient {
      */
     updateAnnotationQueue(id: string, request?: AnnotationQueueUpdate, requestOptions?: AnnotationQueuesClient.RequestOptions): HttpResponsePromise<void>;
     private __updateAnnotationQueue;
+    /**
+     * Returns lock status for all actively locked items in the queue
+     *
+     * @param {string} queueId
+     * @param {OpikApi.GetAnnotationQueueLocksRequest} request
+     * @param {AnnotationQueuesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.annotationQueues.getAnnotationQueueLocks("queueId")
+     */
+    getAnnotationQueueLocks(queueId: string, request?: GetAnnotationQueueLocksRequest, requestOptions?: AnnotationQueuesClient.RequestOptions): HttpResponsePromise<LocksResponse>;
+    private __getAnnotationQueueLocks;
+    /**
+     * Claim an annotation queue item for the current user, or extend an existing lock
+     *
+     * @param {string} queueId
+     * @param {string} itemId
+     * @param {OpikApi.LockAnnotationQueueItemRequest} request
+     * @param {AnnotationQueuesClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.annotationQueues.lockAnnotationQueueItem("queueId", "itemId")
+     */
+    lockAnnotationQueueItem(queueId: string, itemId: string, request?: LockAnnotationQueueItemRequest, requestOptions?: AnnotationQueuesClient.RequestOptions): HttpResponsePromise<LockResponse>;
+    private __lockAnnotationQueueItem;
     /**
      * Remove items from annotation queue
      *
@@ -9731,6 +10225,98 @@ declare class ManualEvaluationClient {
     private __evaluateTraces;
 }
 
+declare namespace McpOAuthClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+/**
+ * MCP OAuth 2.1 Authorization Server resources
+ */
+declare class McpOAuthClient {
+    protected readonly _options: NormalizedClientOptions<McpOAuthClient.Options>;
+    constructor(options?: McpOAuthClient.Options);
+    /**
+     * OAuth 2.1 authorization endpoint (RFC 6749 §3.1). Validates the client and PKCE parameters, then redirects to the login or consent page
+     *
+     * @param {OpikApi.AuthorizeRequest} request
+     * @param {McpOAuthClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.mcpOAuth.authorize({
+     *         clientId: "client_id",
+     *         redirectUri: "redirect_uri"
+     *     })
+     */
+    authorize(request: AuthorizeRequest, requestOptions?: McpOAuthClient.RequestOptions): HttpResponsePromise<void>;
+    private __authorize;
+    /**
+     * Submit the user's consent, issue an authorization code, and return the client redirect target
+     *
+     * @param {OpikApi.ConsentRequest} request
+     * @param {McpOAuthClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.mcpOAuth.consent({
+     *         clientId: "client_id",
+     *         redirectUri: "redirect_uri",
+     *         codeChallenge: "code_challenge",
+     *         codeChallengeMethod: "code_challenge_method",
+     *         resource: "resource"
+     *     })
+     */
+    consent(request: ConsentRequest, requestOptions?: McpOAuthClient.RequestOptions): HttpResponsePromise<ConsentResponse>;
+    private __consent;
+    /**
+     * Get the client details, eligible workspaces, and a CSRF token used to render the consent screen
+     *
+     * @param {OpikApi.GetAuthorizeContextRequest} request
+     * @param {McpOAuthClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.mcpOAuth.getAuthorizeContext({
+     *         clientId: "client_id",
+     *         redirectUri: "redirect_uri"
+     *     })
+     */
+    getAuthorizeContext(request: GetAuthorizeContextRequest, requestOptions?: McpOAuthClient.RequestOptions): HttpResponsePromise<AuthorizeContext>;
+    private __getAuthorizeContext;
+    /**
+     * Get OAuth 2.1 Authorization Server Metadata (RFC 8414)
+     *
+     * @param {McpOAuthClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.mcpOAuth.getOAuthAuthorizationServerMetadata()
+     */
+    getOAuthAuthorizationServerMetadata(requestOptions?: McpOAuthClient.RequestOptions): HttpResponsePromise<AuthorizationServerMetadata>;
+    private __getOAuthAuthorizationServerMetadata;
+    /**
+     * OAuth 2.0 token revocation endpoint (RFC 7009). Always returns 200, whether the token was revoked, never existed, or was invalid
+     *
+     * @param {OpikApi.RevokeRequest} request
+     * @param {McpOAuthClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.mcpOAuth.revoke()
+     */
+    revoke(request?: RevokeRequest, requestOptions?: McpOAuthClient.RequestOptions): HttpResponsePromise<void>;
+    private __revoke;
+    /**
+     * OAuth 2.1 token endpoint (RFC 6749 §4.1.3, §6). Exchanges an authorization code with PKCE or a refresh token for an access/refresh token pair
+     *
+     * @param {OpikApi.TokenRequest} request
+     * @param {McpOAuthClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.BadRequestError}
+     *
+     * @example
+     *     await client.mcpOAuth.token()
+     */
+    token(request?: TokenRequest, requestOptions?: McpOAuthClient.RequestOptions): HttpResponsePromise<TokenResponse>;
+    private __token;
+}
+
 declare namespace OllamaClient {
     type Options = BaseClientOptions;
     interface RequestOptions extends BaseRequestOptions {
@@ -10658,6 +11244,89 @@ declare class RedirectClient {
     private __projectsRedirect;
 }
 
+declare namespace ReportsClient {
+    type Options = BaseClientOptions;
+    interface RequestOptions extends BaseRequestOptions {
+    }
+}
+/**
+ * Ollie daily report management
+ */
+declare class ReportsClient {
+    protected readonly _options: NormalizedClientOptions<ReportsClient.Options>;
+    constructor(options?: ReportsClient.Options);
+    /**
+     * Callback from Ollie to update report status and content after generation.
+     *
+     * @param {string} projectId
+     * @param {string} reportId
+     * @param {OpikApi.ReportCompleteRequest} request
+     * @param {ReportsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.NotFoundError}
+     *
+     * @example
+     *     await client.reports.completeReport("projectId", "reportId", {
+     *         status: "pending"
+     *     })
+     */
+    completeReport(projectId: string, reportId: string, request: ReportCompleteRequest, requestOptions?: ReportsClient.RequestOptions): HttpResponsePromise<void>;
+    private __completeReport;
+    /**
+     * Creates a pending report and triggers asynchronous generation via the orchestrator.
+     *
+     * @param {string} projectId
+     * @param {OpikApi.GenerateReportRequest} request
+     * @param {ReportsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link OpikApi.UnauthorizedError}
+     * @throws {@link OpikApi.ForbiddenError}
+     *
+     * @example
+     *     await client.reports.generateReport("projectId")
+     */
+    generateReport(projectId: string, request?: GenerateReportRequest, requestOptions?: ReportsClient.RequestOptions): HttpResponsePromise<GenerateReportResponse>;
+    private __generateReport;
+    /**
+     * Returns report preferences for a project, or null if none have been set.
+     *
+     * @param {string} projectId
+     * @param {OpikApi.GetReportPreferenceRequest} request
+     * @param {ReportsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.reports.getReportPreference("projectId")
+     */
+    getReportPreference(projectId: string, request?: GetReportPreferenceRequest, requestOptions?: ReportsClient.RequestOptions): HttpResponsePromise<ReportPreference>;
+    private __getReportPreference;
+    /**
+     * Enable or disable daily report generation for a project.
+     *
+     * @param {string} projectId
+     * @param {OpikApi.UpdateReportPreferenceRequest} request
+     * @param {ReportsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.reports.updateReportPreference("projectId", {
+     *         body: {}
+     *     })
+     */
+    updateReportPreference(projectId: string, request: UpdateReportPreferenceRequest, requestOptions?: ReportsClient.RequestOptions): HttpResponsePromise<ReportPreference>;
+    private __updateReportPreference;
+    /**
+     * Returns a paginated list of reports, newest first.
+     *
+     * @param {string} projectId
+     * @param {OpikApi.GetReportsRequest} request
+     * @param {ReportsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.reports.getReports("projectId")
+     */
+    getReports(projectId: string, request?: GetReportsRequest, requestOptions?: ReportsClient.RequestOptions): HttpResponsePromise<OllieReportPage>;
+    private __getReports;
+}
+
 declare namespace RetentionRulesClient {
     type Options = BaseClientOptions;
     interface RequestOptions extends BaseRequestOptions {
@@ -12063,8 +12732,10 @@ declare namespace OpikApiClient {
 }
 declare class OpikApiClient {
     protected readonly _options: NormalizedClientOptions<OpikApiClient.Options>;
+    protected _mcpOAuth: McpOAuthClient | undefined;
     protected _systemUsage: SystemUsageClient | undefined;
     protected _agentConfigs: AgentConfigsClient | undefined;
+    protected _aiSpend: AiSpendClient | undefined;
     protected _alerts: AlertsClient | undefined;
     protected _annotationQueues: AnnotationQueuesClient | undefined;
     protected _assertionResults: AssertionResultsClient | undefined;
@@ -12090,6 +12761,7 @@ declare class OpikApiClient {
     protected _pairing: PairingClient | undefined;
     protected _projects: ProjectsClient | undefined;
     protected _prompts: PromptsClient | undefined;
+    protected _reports: ReportsClient | undefined;
     protected _retentionRules: RetentionRulesClient | undefined;
     protected _serviceToggles: ServiceTogglesClient | undefined;
     protected _spans: SpansClient | undefined;
@@ -12099,8 +12771,10 @@ declare class OpikApiClient {
     protected _workspaces: WorkspacesClient | undefined;
     protected _redirect: RedirectClient | undefined;
     constructor(options?: OpikApiClient.Options);
+    get mcpOAuth(): McpOAuthClient;
     get systemUsage(): SystemUsageClient;
     get agentConfigs(): AgentConfigsClient;
+    get aiSpend(): AiSpendClient;
     get alerts(): AlertsClient;
     get annotationQueues(): AnnotationQueuesClient;
     get assertionResults(): AssertionResultsClient;
@@ -12126,6 +12800,7 @@ declare class OpikApiClient {
     get pairing(): PairingClient;
     get projects(): ProjectsClient;
     get prompts(): PromptsClient;
+    get reports(): ReportsClient;
     get retentionRules(): RetentionRulesClient;
     get serviceToggles(): ServiceTogglesClient;
     get spans(): SpansClient;