@robota-sdk/agent-provider-openai 3.0.0-beta.63 → 3.0.0-beta.82

package/src/openai/provider.ts

@@ -0,0 +1,392 @@
+import { AbstractAIProvider } from '@robota-sdk/agent-core';
+import { createModelEffortOutcome } from '@robota-sdk/agent-core';
+import { PERMISSIVE_TOOL_SCHEMA_PROFILE, STRICT_TOOL_SCHEMA_PROFILE } from '@robota-sdk/agent-core';
+import { resolveModelEffort } from '@robota-sdk/agent-core';
+import { SilentLogger } from '@robota-sdk/agent-core';
+import { traceHeadersFor } from '@robota-sdk/agent-core';
+import OpenAI from 'openai';
+
+import {
+  chatStreamWithOpenAIChatCompletions,
+  chatWithOpenAIChatCompletions,
+} from './chat-completions-chat';
+import { OPENAI_MODEL_EFFORT_TABLE } from './model-effort-table';
+import { OpenAIResponseParser } from './parsers/response-parser';
+import { chatStreamWithOpenAIResponsesApi, chatWithOpenAIResponsesApi } from './responses-chat';
+
+import type { IPayloadLogger } from './interfaces/payload-logger';
+import type { IOpenAIProviderOptions, TOpenAIApiSurface } from './types';
+import type {
+  TUniversalMessage,
+  IChatOptions,
+  IAssistantMessage,
+  IProviderCapabilities,
+  IProviderModelEffortTable,
+  IToolSchemaProjectionProfile,
+  TTextDeltaCallback,
+} from '@robota-sdk/agent-core';
+
+/**
+ * OpenAI provider implementation for Robota
+ *
+ * Provides integration with OpenAI models through the Robota provider contract.
+ * Uses OpenAI SDK native types internally for optimal performance and feature support.
+ *
+ * @public
+ */
+export class OpenAIProvider extends AbstractAIProvider {
+  override readonly name = 'openai';
+  override readonly version = '1.0.0';
+
+  private readonly client?: OpenAI;
+  private readonly options: IOpenAIProviderOptions;
+  private readonly apiSurface: TOpenAIApiSurface;
+  private readonly payloadLogger: IPayloadLogger | undefined;
+  private readonly responseParser: OpenAIResponseParser;
+
+  /**
+   * Optional callback for text deltas during streaming.
+   * Set by the consumer (e.g., Session) to receive real-time text chunks.
+   * When set, chat() uses streaming internally while still returning
+   * the complete assembled message.
+   */
+  onTextDelta?: TTextDeltaCallback;
+
+  constructor(options: IOpenAIProviderOptions) {
+    super(options.logger || SilentLogger);
+    this.options = options;
+    this.apiSurface = resolveApiSurface(options);
+    validateOpenAIProviderNativeWebTools(this.apiSurface, options.nativeWebTools);
+
+    if (options.executor) {
+      this.executor = options.executor;
+    }
+
+    if (!this.executor) {
+      if (options.client) {
+        this.client = options.client;
+      } else if (options.apiKey) {
+        this.client = new OpenAI({
+          apiKey: options.apiKey,
+          ...(options.organization && { organization: options.organization }),
+          ...(options.timeout && { timeout: options.timeout }),
+          ...(options.baseURL && { baseURL: options.baseURL }),
+        });
+      } else {
+        throw new Error('Either OpenAI client, apiKey, or executor is required');
+      }
+    }
+
+    this.responseParser = new OpenAIResponseParser(this.logger);
+    this.payloadLogger = options.payloadLogger;
+  }
+
+  override async chat(
+    messages: TUniversalMessage[],
+    options?: IChatOptions,
+  ): Promise<TUniversalMessage> {
+    this.validateMessages(messages);
+    this.validateNativeWebTools(options?.nativeWebTools);
+    const resolvedOptions = this.resolveEffortOptions(options);
+
+    if (this.executor) {
+      try {
+        const result = await this.executeViaExecutorOrDirect(messages, resolvedOptions);
+        if (result.modelEffortOutcome === undefined) {
+          this.publishModelEffortOutcome(resolvedOptions, 'opaque-executor');
+        }
+        return result.message;
+      } catch (error) {
+        this.logger.error(
+          'OpenAI Provider executor chat error:',
+          error instanceof Error ? error.message : String(error),
+        );
+        throw error;
+      }
+    }
+
+    if (this.apiSurface === 'responses') {
+      const response = await chatWithOpenAIResponsesApi({
+        client: this.client,
+        messages,
+        chatOptions: this.projectChatOptions(resolvedOptions),
+        providerOptions: this.options,
+        onTextDelta: this.onTextDelta,
+        requestHeaders: this.traceRequestHeaders(resolvedOptions),
+      });
+      this.publishModelEffortOutcome(resolvedOptions);
+      return response;
+    }
+
+    const response = await chatWithOpenAIChatCompletions({
+      client: this.client,
+      messages,
+      chatOptions: this.projectChatOptions(resolvedOptions),
+      providerOptions: this.options,
+      payloadLogger: this.payloadLogger,
+      responseParser: this.responseParser,
+      onTextDelta: this.onTextDelta,
+      requestHeaders: this.traceRequestHeaders(resolvedOptions),
+    });
+    this.publishModelEffortOutcome(resolvedOptions);
+    return response;
+  }
+
+  override async *chatStream(
+    messages: TUniversalMessage[],
+    options?: IChatOptions,
+  ): AsyncIterable<TUniversalMessage> {
+    this.validateNativeWebTools(options?.nativeWebTools);
+    const resolvedOptions = this.resolveEffortOptions(options);
+
+    if (this.executor) {
+      try {
+        let executorOutcomeSeen = false;
+        for await (const event of this.executeStreamViaExecutorOrDirect(
+          messages,
+          resolvedOptions,
+        )) {
+          if (event.kind === 'message') {
+            yield event.message;
+          } else {
+            executorOutcomeSeen = event.modelEffortOutcome !== undefined;
+          }
+        }
+        if (!executorOutcomeSeen) {
+          this.publishModelEffortOutcome(resolvedOptions, 'opaque-executor');
+        }
+        return;
+      } catch (error) {
+        this.logger.error(
+          'OpenAI Provider executor stream error:',
+          error instanceof Error ? error.message : String(error),
+        );
+        throw error;
+      }
+    }
+
+    yield* this.streamDirect(messages, resolvedOptions);
+  }
+
+  private async *streamDirect(
+    messages: TUniversalMessage[],
+    resolvedOptions: IChatOptions | undefined,
+  ): AsyncIterable<TUniversalMessage> {
+    if (this.apiSurface === 'responses') {
+      yield* chatStreamWithOpenAIResponsesApi({
+        client: this.client,
+        messages,
+        chatOptions: this.projectChatOptions(resolvedOptions),
+        providerOptions: this.options,
+        onTextDelta: this.onTextDelta,
+        requestHeaders: this.traceRequestHeaders(resolvedOptions),
+      });
+      this.publishModelEffortOutcome(resolvedOptions);
+      return;
+    }
+
+    yield* chatStreamWithOpenAIChatCompletions({
+      client: this.client,
+      messages,
+      chatOptions: this.projectChatOptions(resolvedOptions),
+      providerOptions: this.options,
+      payloadLogger: this.payloadLogger,
+      responseParser: this.responseParser,
+      onTextDelta: this.onTextDelta,
+      requestHeaders: this.traceRequestHeaders(resolvedOptions),
+    });
+    this.publishModelEffortOutcome(resolvedOptions);
+  }
+
+  /**
+   * CORE-043: this provider declares no capability table — nobody has verified one for OpenAI, and
+   * inventing one would be a fabricated claim. It can still answer THIS question honestly, which is
+   * why the endpoint signal is not a field on the table.
+   *
+   * It matters most here of all the providers: setting `baseURL` also switches the API surface to
+   * `chat-completions` (see `resolveApiSurface`), so the advertised gateway configuration is exactly
+   * the one where a structured request is least likely to be enforced by whatever is on the far end.
+   */
+  endpointIsVendorDefault(): boolean {
+    return this.options.baseURL === undefined;
+  }
+
+  /**
+   * The client's own base URL is the origin every request goes to (the SDK has already applied a
+   * constructor option or `OPENAI_BASE_URL`). An executor sends elsewhere, and an injected client
+   * whose base URL cannot be read gives no origin to compare, so neither can propagate.
+   */
+  canPropagateTraceContext(): boolean {
+    return !this.executor && this.effectiveBaseUrl() !== undefined;
+  }
+
+  private effectiveBaseUrl(): string | undefined {
+    const baseURL: unknown = (this.client as { baseURL?: unknown } | undefined)?.baseURL;
+    return typeof baseURL === 'string' && baseURL.length > 0 ? baseURL : undefined;
+  }
+
+  private traceRequestHeaders(options: IChatOptions | undefined): Readonly<Record<string, string>> {
+    if (!this.canPropagateTraceContext()) return {};
+    return traceHeadersFor(this.effectiveBaseUrl(), options?.outboundTraceContext);
+  }
+
+  override effortTable(): IProviderModelEffortTable | undefined {
+    return this.endpointIsVendorDefault() && this.apiSurface === 'responses'
+      ? OPENAI_MODEL_EFFORT_TABLE
+      : undefined;
+  }
+
+  private resolveEffortOptions(options: IChatOptions | undefined): IChatOptions | undefined {
+    if (options?.effort === undefined || options.effortResolution !== undefined) return options;
+    const model = options.model ?? this.options.defaultModel;
+    if (model === undefined) return options;
+    return {
+      ...options,
+      effortResolution: resolveModelEffort(this.effortTable(), model, options.effort),
+    };
+  }
+
+  /**
+   * MCP-005: strict mode's supported subset is documented; non-strict accepts standard JSON Schema.
+   * Both the Responses and Chat Completions surfaces honor `strictTools` identically (§ Profiles).
+   */
+  protected override projectionProfile(): IToolSchemaProjectionProfile | undefined {
+    return this.options.strictTools
+      ? { ...STRICT_TOOL_SCHEMA_PROFILE, providerName: 'openai' }
+      : { ...PERMISSIVE_TOOL_SCHEMA_PROFILE, providerName: 'openai' };
+  }
+
+  /**
+   * Project `chatOptions.tools` through `projectionProfile()` before either request-building module
+   * (`responses-chat.ts`, `chat-completions-chat.ts`) sees them — the module helpers receive the
+   * projected array as a parameter; `options.tools` itself is never mutated. An empty projected array
+   * (every tool quarantined) becomes `undefined` so the downstream `tools &&` truthiness checks treat
+   * it the same as "no tools", not as a zero-length `tools: []` request field.
+   */
+  private projectChatOptions(chatOptions: IChatOptions | undefined): IChatOptions | undefined {
+    if (!chatOptions?.tools) {
+      return chatOptions;
+    }
+    const model = chatOptions.model ?? this.options.defaultModel ?? '';
+    const projected = this.projectTools(chatOptions.tools, model);
+    return {
+      ...chatOptions,
+      tools: projected && projected.length > 0 ? projected : undefined,
+    };
+  }
+
+  private publishModelEffortOutcome(
+    options: IChatOptions | undefined,
+    opaqueReason?: string,
+  ): void {
+    const resolution = options?.effortResolution;
+    const observer = options?.onModelEffortOutcome;
+    if (resolution === undefined || observer === undefined) return;
+
+    const nativeControl =
+      opaqueReason !== undefined
+        ? { state: 'omitted' as const, reason: opaqueReason }
+        : resolution.effective !== null && resolution.disposition !== 'model-default'
+          ? { state: 'sent' as const, id: 'responses.reasoning.effort' }
+          : {
+              state: 'omitted' as const,
+              reason:
+                resolution.disposition === 'model-default'
+                  ? 'provider-default-selection'
+                  : 'model-effort-not-applied',
+            };
+    const providerDispatch =
+      opaqueReason !== undefined
+        ? { state: 'not-dispatched' as const, reason: opaqueReason }
+        : { state: 'sent' as const };
+    try {
+      observer(createModelEffortOutcome(resolution, { nativeControl, providerDispatch }));
+    } catch (error) {
+      this.logger.warn('Model-effort outcome observer failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  override supportsTools(): boolean {
+    return true;
+  }
+
+  override getCapabilities(): IProviderCapabilities {
+    const source =
+      this.apiSurface === 'chat-completions'
+        ? 'openai-compatible-chat-completions'
+        : 'openai-responses';
+    return {
+      functionCalling: { supported: true },
+      nativeWebTools: {
+        webSearch: {
+          supported: false,
+          enabled: false,
+          source,
+          reason: getOpenAIUnsupportedNativeWebReason(this.apiSurface, 'search'),
+        },
+        webFetch: {
+          supported: false,
+          enabled: false,
+          source,
+          reason: getOpenAIUnsupportedNativeWebReason(this.apiSurface, 'fetch'),
+        },
+      },
+    };
+  }
+
+  override validateConfig(): boolean {
+    return !!this.client && !!this.options;
+  }
+
+  override async dispose(): Promise<void> {
+    // OpenAI client doesn't need explicit cleanup
+  }
+
+  protected override validateMessages(messages: TUniversalMessage[]): void {
+    super.validateMessages(messages);
+
+    for (const message of messages) {
+      if (message.role === 'assistant') {
+        const assistantMsg = message as IAssistantMessage;
+        if (
+          assistantMsg.toolCalls &&
+          assistantMsg.toolCalls.length > 0 &&
+          assistantMsg.content === ''
+        ) {
+          continue;
+        }
+      }
+    }
+  }
+}
+
+function resolveApiSurface(options: IOpenAIProviderOptions): TOpenAIApiSurface {
+  if (options.apiSurface !== undefined) {
+    return options.apiSurface;
+  }
+  return options.baseURL ? 'chat-completions' : 'responses';
+}
+
+function getOpenAIUnsupportedNativeWebReason(
+  apiSurface: TOpenAIApiSurface,
+  toolKind: 'search' | 'fetch',
+): string {
+  if (apiSurface === 'chat-completions') {
+    return `OpenAI-compatible Chat Completions endpoints support declared function tools, not provider-native web ${toolKind}.`;
+  }
+  return `OpenAI Responses native web ${toolKind} is not wired in this Robota provider version.`;
+}
+
+function validateOpenAIProviderNativeWebTools(
+  apiSurface: TOpenAIApiSurface,
+  nativeWebTools: IOpenAIProviderOptions['nativeWebTools'],
+): void {
+  if (nativeWebTools?.webSearch !== true && nativeWebTools?.webFetch !== true) {
+    return;
+  }
+  throw new Error(
+    `Provider openai native web search/fetch is not supported for apiSurface ${apiSurface} in this Robota provider version.`,
+  );
+}

package/src/openai/reasoning-effort.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { OpenAIProvider } from './provider';
+import {
+  mapEffortToOpenAIReasoningEffort,
+  resolveOpenAIReasoningOptions,
+} from './reasoning-effort';
+import { OPENAI_MODEL_EFFORT_TABLE } from './model-effort-table';
+
+import {
+  resolveModelEffort,
+  type IExecutor,
+  type IModelEffortOutcome,
+  type TUniversalMessage,
+} from '@robota-sdk/agent-core';
+
+// Mock OpenAI SDK (mirror provider.test.ts so chat() never hits the network).
+vi.mock('openai', () => {
+  const MockOpenAI = vi.fn().mockImplementation(() => ({
+    chat: { completions: { create: vi.fn() } },
+    responses: { create: vi.fn() },
+  }));
+  return { default: MockOpenAI };
+});
+
+function createUserMessage(content: string): TUniversalMessage {
+  return { id: 'msg-1', state: 'complete' as const, role: 'user', content, timestamp: new Date() };
+}
+
+function getResponsesClient(provider: OpenAIProvider): {
+  responses: { create: ReturnType<typeof vi.fn> };
+} {
+  return (provider as unknown as { client: { responses: { create: ReturnType<typeof vi.fn> } } })
+    .client;
+}
+
+function stubResponsesResolve(create: ReturnType<typeof vi.fn>): void {
+  create.mockResolvedValue({
+    id: 'resp-effort',
+    model: 'gpt-5.1',
+    output_text: 'ok',
+    output: [],
+    status: 'completed',
+  });
+}
+
+const REMOTE_EXECUTOR_OUTCOME: IModelEffortOutcome = {
+  resolution: {
+    selection: 'high',
+    effective: 'high',
+    disposition: 'exact',
+    fingerprint: 'gpt-5.1|high|high|exact|responses.reasoning.effort|2026-09-11',
+  },
+  nativeControl: { state: 'sent', id: 'responses.reasoning.effort' },
+  providerDispatch: { state: 'sent' },
+};
+
+describe('PRESET-008 reasoning-effort wiring', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('mapEffortToOpenAIReasoningEffort', () => {
+    it('serializes the documented Responses vocabulary without framework-side clamping', () => {
+      expect(mapEffortToOpenAIReasoningEffort('none')).toBe('none');
+      expect(mapEffortToOpenAIReasoningEffort('minimal')).toBe('minimal');
+      expect(mapEffortToOpenAIReasoningEffort('low')).toBe('low');
+      expect(mapEffortToOpenAIReasoningEffort('medium')).toBe('medium');
+      expect(mapEffortToOpenAIReasoningEffort('high')).toBe('high');
+      expect(mapEffortToOpenAIReasoningEffort('xhigh')).toBe('xhigh');
+      expect(mapEffortToOpenAIReasoningEffort('max')).toBe('max');
+    });
+  });
+
+  describe('resolveOpenAIReasoningOptions', () => {
+    it('returns undefined when no effort and no static reasoning', () => {
+      expect(resolveOpenAIReasoningOptions(undefined, undefined)).toBeUndefined();
+    });
+
+    it('merges a verified resolution over static non-control reasoning fields', () => {
+      expect(
+        resolveOpenAIReasoningOptions(
+          { summary: 'auto' },
+          resolveModelEffort(OPENAI_MODEL_EFFORT_TABLE, 'gpt-5.1', 'max'),
+        ),
+      ).toEqual({
+        summary: 'auto',
+        effort: 'high',
+      });
+    });
+
+    it('omits the native control for auto and rejects a conflicting static effort', () => {
+      expect(
+        resolveOpenAIReasoningOptions(
+          undefined,
+          resolveModelEffort(OPENAI_MODEL_EFFORT_TABLE, 'gpt-5.1', 'auto'),
+        ),
+      ).toBeUndefined();
+      expect(() =>
+        resolveOpenAIReasoningOptions(
+          { effort: 'low' },
+          resolveModelEffort(OPENAI_MODEL_EFFORT_TABLE, 'gpt-5.1', 'high'),
+        ),
+      ).toThrow('conflicts with static reasoning.effort');
+    });
+
+    it('rejects a static native effort when auto would otherwise falsely report omission', () => {
+      expect(() =>
+        resolveOpenAIReasoningOptions(
+          { effort: 'low', summary: 'concise' },
+          resolveModelEffort(OPENAI_MODEL_EFFORT_TABLE, 'gpt-5.1', 'auto'),
+        ),
+      ).toThrow('provider-default selection');
+    });
+  });
+
+  // TC-01: a call with effort set on a native-effort provider → the built request
+  // carries that effort value on reasoning.effort.
+  it('TC-01: threads effort onto the OpenAI Responses reasoning.effort param', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const client = getResponsesClient(provider);
+    stubResponsesResolve(client.responses.create);
+
+    await provider.chat([createUserMessage('Hello')], { model: 'gpt-5.1', effort: 'max' });
+
+    expect(client.responses.create).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reasoning: expect.objectContaining({ effort: 'high' }),
+      }),
+      undefined,
+    );
+  });
+
+  it('TC-01: passes a low effort straight through to reasoning.effort', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const client = getResponsesClient(provider);
+    stubResponsesResolve(client.responses.create);
+
+    await provider.chat([createUserMessage('Hello')], { model: 'gpt-5.1', effort: 'low' });
+
+    expect(client.responses.create).toHaveBeenCalledWith(
+      expect.objectContaining({ reasoning: expect.objectContaining({ effort: 'low' }) }),
+      undefined,
+    );
+  });
+
+  it('TC-02: an explicit high effort yields reasoning.effort === high', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const client = getResponsesClient(provider);
+    stubResponsesResolve(client.responses.create);
+
+    await provider.chat([createUserMessage('Hello')], { model: 'gpt-5.1', effort: 'high' });
+
+    expect(client.responses.create).toHaveBeenCalledWith(
+      expect.objectContaining({ reasoning: expect.objectContaining({ effort: 'high' }) }),
+      undefined,
+    );
+  });
+
+  it('TC-02: auto resolves the documented model default while omitting reasoning.effort', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const client = getResponsesClient(provider);
+    stubResponsesResolve(client.responses.create);
+
+    await provider.chat([createUserMessage('Hello')], { model: 'gpt-5.1', effort: 'auto' });
+
+    const [requestParams] = client.responses.create.mock.calls[0] as [Record<string, unknown>];
+    expect(requestParams).not.toHaveProperty('reasoning');
+  });
+
+  it('publishes one terminal outcome with separate resolution, native-control, and dispatch facts', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const client = getResponsesClient(provider);
+    stubResponsesResolve(client.responses.create);
+    const outcomes: unknown[] = [];
+
+    await provider.chat([createUserMessage('Hello')], {
+      model: 'gpt-5.1',
+      effort: 'max',
+      onModelEffortOutcome: (outcome) => outcomes.push(outcome),
+    });
+
+    expect(outcomes).toEqual([
+      expect.objectContaining({
+        resolution: expect.objectContaining({
+          selection: 'max',
+          effective: 'high',
+          disposition: 'clamped',
+        }),
+        nativeControl: { state: 'sent', id: 'responses.reasoning.effort' },
+        providerDispatch: { state: 'sent' },
+      }),
+    ]);
+  });
+
+  it('does not replace a remote executor outcome with a competing opaque-executor result', async () => {
+    const executor: IExecutor = {
+      name: 'remote-test',
+      version: '1.0.0',
+      async executeChat(request) {
+        request.options?.onModelEffortOutcome?.(REMOTE_EXECUTOR_OUTCOME);
+        return {
+          message: {
+            id: 'remote-response',
+            role: 'assistant',
+            content: 'ok',
+            state: 'complete',
+            timestamp: new Date(),
+          },
+          modelEffortOutcome: REMOTE_EXECUTOR_OUTCOME,
+        };
+      },
+      supportsTools: () => true,
+      validateConfig: () => true,
+    };
+    const provider = new OpenAIProvider({ executor });
+    const outcomes: IModelEffortOutcome[] = [];
+
+    await provider.chat([createUserMessage('Hello')], {
+      model: 'gpt-5.1',
+      effort: 'high',
+      onModelEffortOutcome: (outcome) => outcomes.push(outcome),
+    });
+
+    expect(outcomes).toEqual([REMOTE_EXECUTOR_OUTCOME]);
+  });
+
+  it('publishes one terminal outcome only after a Responses stream completes', async () => {
+    const provider = new OpenAIProvider({ apiKey: 'sk-test' });
+    const client = getResponsesClient(provider);
+    async function* responsesStream() {
+      yield { type: 'response.output_text.delta', delta: 'ok' };
+      yield {
+        type: 'response.completed',
+        response: {
+          id: 'resp-effort-stream',
+          output_text: 'ok',
+          output: [],
+          status: 'completed',
+        },
+      };
+    }
+    client.responses.create.mockResolvedValue(responsesStream());
+    const outcomes: unknown[] = [];
+
+    for await (const _chunk of provider.chatStream([createUserMessage('Hello')], {
+      model: 'gpt-5.1',
+      effort: 'max',
+      onModelEffortOutcome: (outcome) => outcomes.push(outcome),
+    })) {
+      // Consume every chunk so the terminal stream outcome is eligible to publish.
+    }
+
+    expect(outcomes).toEqual([
+      expect.objectContaining({
+        resolution: expect.objectContaining({ effective: 'high', disposition: 'clamped' }),
+        nativeControl: { state: 'sent', id: 'responses.reasoning.effort' },
+        providerDispatch: { state: 'sent' },
+      }),
+    ]);
+  });
+
+  it('reports the source-dated table only for the official Responses endpoint', () => {
+    expect(new OpenAIProvider({ apiKey: 'sk-test' }).effortTable()).toBe(OPENAI_MODEL_EFFORT_TABLE);
+    expect(
+      new OpenAIProvider({
+        apiKey: 'sk-test',
+        apiSurface: 'chat-completions',
+      }).effortTable(),
+    ).toBeUndefined();
+  });
+});