feat(api): Add responses.input_tokens.count

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
-configured_endpoints: 134
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-b062c33330de7e3bbf992fd4f0799afd868c30a66c39418dd2c62f4add3b45b6.yml
-openapi_spec_hash: fe067f5b1c0e93799b5ea7fde3c4b1b3
-config_hash: 4b6f471b24d659514b86b736c90a0c0a
+configured_endpoints: 135
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai%2Fopenai-812a10f8fb54c584efc914422b574cb3f43dc238b5733b13f6a0b2308b7d9910.yml
+openapi_spec_hash: 0222041ba12a5ff6b94924a834fa91a2
+config_hash: 50ee3382a63c021a9f821a935950e926

MIGRATION.md

@@ -135,6 +135,7 @@ client.example.list(undefined, { headers: { ... } });
 - `client.batches.list()`
 - `client.responses.retrieve()`
 - `client.responses.inputItems.list()`
+- `client.responses.inputTokens.count()`
 - `client.realtime.calls.reject()`
 - `client.conversations.create()`
 - `client.conversations.items.list()`

api.md

@@ -824,6 +824,16 @@ Methods:
 
 - <code title="get /responses/{response_id}/input_items">client.responses.inputItems.<a href="./src/resources/responses/input-items.ts">list</a>(responseID, { ...params }) -> ResponseItemsPage</code>
 
+## InputTokens
+
+Types:
+
+- <code><a href="./src/resources/responses/input-tokens.ts">InputTokenCountResponse</a></code>
+
+Methods:
+
+- <code title="post /responses/input_tokens">client.responses.inputTokens.<a href="./src/resources/responses/input-tokens.ts">count</a>({ ...params }) -> InputTokenCountResponse</code>
+
 # Realtime
 
 Types:

scripts/detect-breaking-changes

@@ -47,6 +47,7 @@ TEST_PATHS=(
 	tests/api-resources/uploads/parts.test.ts
 	tests/api-resources/responses/responses.test.ts
 	tests/api-resources/responses/input-items.test.ts
+	tests/api-resources/responses/input-tokens.test.ts
 	tests/api-resources/realtime/realtime.test.ts
 	tests/api-resources/realtime/client-secrets.test.ts
 	tests/api-resources/realtime/calls.test.ts

src/resources/responses/index.ts

@@ -1,4 +1,5 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export { InputItems, type ResponseItemList, type InputItemListParams } from './input-items';
+export { InputTokens, type InputTokenCountResponse, type InputTokenCountParams } from './input-tokens';
 export { Responses } from './responses';

src/resources/responses/input-tokens.ts

@@ -0,0 +1,161 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as Shared from '../shared';
+import * as ResponsesAPI from './responses';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+
+export class InputTokens extends APIResource {
+  /**
+   * Get input token counts
+   *
+   * @example
+   * ```ts
+   * const response = await client.responses.inputTokens.count();
+   * ```
+   */
+  count(
+    body: InputTokenCountParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<InputTokenCountResponse> {
+    return this._client.post('/responses/input_tokens', { body, ...options });
+  }
+}
+
+export interface InputTokenCountResponse {
+  input_tokens: number;
+
+  object: 'response.input_tokens';
+}
+
+export interface InputTokenCountParams {
+  /**
+   * The conversation that this response belongs to. Items from this conversation are
+   * prepended to `input_items` for this response request. Input items and output
+   * items from this response are automatically added to this conversation after this
+   * response completes.
+   */
+  conversation?: string | ResponsesAPI.ResponseConversationParam | null;
+
+  /**
+   * Text, image, or file inputs to the model, used to generate a response
+   */
+  input?: string | Array<ResponsesAPI.ResponseInputItem> | null;
+
+  /**
+   * A system (or developer) message inserted into the model's context. When used
+   * along with `previous_response_id`, the instructions from a previous response
+   * will not be carried over to the next response. This makes it simple to swap out
+   * system (or developer) messages in new responses.
+   */
+  instructions?: string | null;
+
+  /**
+   * Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
+   * wide range of models with different capabilities, performance characteristics,
+   * and price points. Refer to the
+   * [model guide](https://platform.openai.com/docs/models) to browse and compare
+   * available models.
+   */
+  model?: string | null;
+
+  /**
+   * Whether to allow the model to run tool calls in parallel.
+   */
+  parallel_tool_calls?: boolean | null;
+
+  /**
+   * The unique ID of the previous response to the model. Use this to create
+   * multi-turn conversations. Learn more about
+   * [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+   * Cannot be used in conjunction with `conversation`.
+   */
+  previous_response_id?: string | null;
+
+  /**
+   * **gpt-5 and o-series models only** Configuration options for
+   * [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+   */
+  reasoning?: Shared.Reasoning | null;
+
+  /**
+   * Configuration options for a text response from the model. Can be plain text or
+   * structured JSON data. Learn more:
+   *
+   * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+   * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+   */
+  text?: InputTokenCountParams.Text | null;
+
+  /**
+   * How the model should select which tool (or tools) to use when generating a
+   * response. See the `tools` parameter to see how to specify which tools the model
+   * can call.
+   */
+  tool_choice?:
+    | ResponsesAPI.ToolChoiceOptions
+    | ResponsesAPI.ToolChoiceAllowed
+    | ResponsesAPI.ToolChoiceTypes
+    | ResponsesAPI.ToolChoiceFunction
+    | ResponsesAPI.ToolChoiceMcp
+    | ResponsesAPI.ToolChoiceCustom
+    | null;
+
+  /**
+   * An array of tools the model may call while generating a response. You can
+   * specify which tool to use by setting the `tool_choice` parameter.
+   */
+  tools?: Array<ResponsesAPI.Tool> | null;
+
+  /**
+   * The truncation strategy to use for the model response. - `auto`: If the input to
+   * this Response exceeds the model's context window size, the model will truncate
+   * the response to fit the context window by dropping items from the beginning of
+   * the conversation. - `disabled` (default): If the input size will exceed the
+   * context window size for a model, the request will fail with a 400 error.
+   */
+  truncation?: 'auto' | 'disabled';
+}
+
+export namespace InputTokenCountParams {
+  /**
+   * Configuration options for a text response from the model. Can be plain text or
+   * structured JSON data. Learn more:
+   *
+   * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+   * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+   */
+  export interface Text {
+    /**
+     * An object specifying the format that the model must output.
+     *
+     * Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+     * ensures the model will match your supplied JSON schema. Learn more in the
+     * [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+     *
+     * The default format is `{ "type": "text" }` with no additional options.
+     *
+     * **Not recommended for gpt-4o and newer models:**
+     *
+     * Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+     * ensures the message the model generates is valid JSON. Using `json_schema` is
+     * preferred for models that support it.
+     */
+    format?: ResponsesAPI.ResponseFormatTextConfig;
+
+    /**
+     * Constrains the verbosity of the model's response. Lower values will result in
+     * more concise responses, while higher values will result in more verbose
+     * responses. Currently supported values are `low`, `medium`, and `high`.
+     */
+    verbosity?: 'low' | 'medium' | 'high' | null;
+  }
+}
+
+export declare namespace InputTokens {
+  export {
+    type InputTokenCountResponse as InputTokenCountResponse,
+    type InputTokenCountParams as InputTokenCountParams,
+  };
+}

src/resources/responses/responses.ts

@@ -12,6 +12,8 @@ import * as ResponsesAPI from './responses';
 import * as Shared from '../shared';
 import * as InputItemsAPI from './input-items';
 import { InputItemListParams, InputItems, ResponseItemList } from './input-items';
+import * as InputTokensAPI from './input-tokens';
+import { InputTokenCountParams, InputTokenCountResponse, InputTokens } from './input-tokens';
 import { APIPromise } from '../../core/api-promise';
 import { CursorPage } from '../../core/pagination';
 import { Stream } from '../../core/streaming';
@@ -58,6 +60,7 @@ export type ResponseParseParams = ResponseCreateParamsNonStreaming;
 
 export class Responses extends APIResource {
   inputItems: InputItemsAPI.InputItems = new InputItemsAPI.InputItems(this._client);
+  inputTokens: InputTokensAPI.InputTokens = new InputTokensAPI.InputTokens(this._client);
 
   /**
    * Creates a model response. Provide
@@ -5763,6 +5766,7 @@ export interface ResponseRetrieveParamsStreaming extends ResponseRetrieveParamsB
 }
 
 Responses.InputItems = InputItems;
+Responses.InputTokens = InputTokens;
 
 export declare namespace Responses {
   export {
@@ -5890,4 +5894,10 @@ export declare namespace Responses {
     type ResponseItemList as ResponseItemList,
     type InputItemListParams as InputItemListParams,
   };
+
+  export {
+    InputTokens as InputTokens,
+    type InputTokenCountResponse as InputTokenCountResponse,
+    type InputTokenCountParams as InputTokenCountParams,
+  };
 }

tests/api-resources/responses/input-tokens.test.ts

@@ -0,0 +1,51 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import OpenAI from 'openai';
+
+const client = new OpenAI({
+  apiKey: 'My API Key',
+  baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010',
+});
+
+describe('resource inputTokens', () => {
+  test('count', async () => {
+    const responsePromise = client.responses.inputTokens.count();
+    const rawResponse = await responsePromise.asResponse();
+    expect(rawResponse).toBeInstanceOf(Response);
+    const response = await responsePromise;
+    expect(response).not.toBeInstanceOf(Response);
+    const dataAndResponse = await responsePromise.withResponse();
+    expect(dataAndResponse.data).toBe(response);
+    expect(dataAndResponse.response).toBe(rawResponse);
+  });
+
+  test('count: request options and params are passed correctly', async () => {
+    // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+    await expect(
+      client.responses.inputTokens.count(
+        {
+          conversation: 'string',
+          input: 'string',
+          instructions: 'instructions',
+          model: 'model',
+          parallel_tool_calls: true,
+          previous_response_id: 'resp_123',
+          reasoning: { effort: 'minimal', generate_summary: 'auto', summary: 'auto' },
+          text: { format: { type: 'text' }, verbosity: 'low' },
+          tool_choice: 'none',
+          tools: [
+            {
+              name: 'name',
+              parameters: { foo: 'bar' },
+              strict: true,
+              type: 'function',
+              description: 'description',
+            },
+          ],
+          truncation: 'auto',
+        },
+        { path: '/_stainless_unknown_path' },
+      ),
+    ).rejects.toThrow(OpenAI.NotFoundError);
+  });
+});