@truefoundry/ai-gateway-sdk 0.0.0-stage → 0.0.2

package/dist/types/contracts.d.ts

@@ -0,0 +1,161 @@
+/**
+ * P2.1 SDK call contracts. Types only — copied `api.ts` still takes Hono Context.
+ *
+ * `path` is `URL.pathname` (`/v1/files/abc`). `search` is `URL.search`
+ * (`?api-version=2024-10-21` or `''`). Not an origin URL, not path/query
+ * param records. Provider `getEndpoint` and adapters regex path segments
+ * (`/files/`, `/batches/`, `/models/`, `converse-stream`); `getProxyEndpoint`
+ * already takes `{ reqPath, reqQuery }` (pathname + search). Absolute URLs can
+ * be reconstructed in P4 with `new URL(path + search, 'https://gateway.invalid')`
+ * if a provider still calls `new URL()`.
+ */
+import type { HeadersOverride, RetryConfig } from '../autogen/models.js';
+import type { Model } from '../entities/Model.js';
+import type { ProviderAccountEntity } from '../entities/ProviderAccount.js';
+import type { Endpoint } from '../providers/types.js';
+import type { BilledUsageOverlay } from '../utils/billedUsage.js';
+import type { CachePort } from './cache.js';
+import type { ExecutionReport } from './executionReport.js';
+import type { CatalogProviderConfigs, ProviderModelConfigs } from './modelConfig.js';
+import type { Params } from './requestBody.js';
+export type { EndReason, ExecutionFinishReason, ExecutionModelMetadata, ExecutionReport, ExecutionTimings, ExecutionToolUsage, MidStreamError, MidStreamErrorKind, MidStreamProviderErrorToken, TokenUsage, TokenUsageIteration, } from './executionReport.js';
+export type { BilledUsageOverlay, CachePort, Endpoint };
+export interface ProviderOptions {
+    model: Model | null;
+    providerAccount: ProviderAccountEntity;
+}
+/**
+ * Per-call session data. Only `tenantName` is here because `safeFetch` / SSRF
+ * logging and the gateway cache adapter (tenant prefix) read it. Do not hash
+ * `tenantName` into the SDK logical cache key. Add a field when a call site
+ * needs it — the SDK must not take the gateway's auth `Session`.
+ */
+export interface SessionContext {
+    tenantName: string;
+}
+export type SdkRequestBody = Params | FormData | ReadableStream | ArrayBuffer | Uint8Array | Blob | string;
+export interface SdkRequest {
+    body: SdkRequestBody;
+    method: string;
+    headers: Record<string, string>;
+    endpoint: Endpoint;
+    /**
+     * Incoming pathname, no scheme/host/search (`/v1/files/abc`,
+     * `/v1/responses/resp_x`).
+     */
+    path: string;
+    /**
+     * Incoming `URL.search` including `?`, or empty (`?api-version=2024-10-21`).
+     * Not a parsed record.
+     */
+    search: string;
+}
+export interface SdkExecutionConfig {
+    retry?: RetryConfig;
+    requestTimeoutMs?: number;
+    ttftTimeoutMs?: number;
+    abortSignal?: AbortSignal;
+    /**
+     * Live sync: `shouldCompleteRequestOnClientCancel` / `COMPLETE_REQUEST_ON_CLIENT_CANCEL`
+     * (`src/utils/clientCancelPolicy.ts`, set in live `tryPost`).
+     * When true, keep reading the provider after client hangup so usage can be billed
+     * (DoNotCancel, or non-stream when `COMPLETE_NON_STREAMING_ON_CLIENT_CANCEL`).
+     */
+    drainUpstream?: boolean;
+    openaiUseResponsesApi?: boolean;
+    /**
+     * When true, the gateway path may emit an internal SSE metadata frame
+     * (caller-chosen `event:` name; gateway uses e.g. `x-tfy-internal-metadata`)
+     * that must be stripped before the end user. Default / direct SDK callers
+     * leave this unset (off). P7 wires emission via
+     * `formatInternalMetadataSseFrame` — not a client-visible flag.
+     */
+    emitInternalMetadataSseFrame?: boolean;
+    /**
+     * Optional gateway overlay for billed chars / seconds / video (P7.2 can pass
+     * Context-computed values). Merged last onto ExecutionReport.usage.
+     */
+    billedUsage?: BilledUsageOverlay;
+}
+export interface ProviderCallConfig {
+    /**
+     * Client Authorization bearer for OpenAI / Anthropic subscription passthrough
+     * (`OVERRIDE_PROVIDER_BEARER_TOKEN`). Used only when the account has no stored
+     * API key. Do not plumb this for other providers — credentials come from the
+     * provider-account entity (self-hosted passthrough reads `request.headers`).
+     */
+    bearerTokenOverride?: string;
+    isCursorEndpoint?: boolean;
+    /**
+     * When true, reject Responses→CC adapter translation (leaf cannot serve Responses natively).
+     * Gateway sets this for virtual-model routes (parity with live `CONTEXT_KEYS.IS_VIRTUAL_MODEL`).
+     * `providerOptions` still names the selected leaf target.
+     */
+    rejectNonNativeResponsesThroughAdapter?: boolean;
+    anthropicBetaSuppressed?: boolean;
+    forwardHeaders?: string[];
+    /**
+     * Live `responseHandler` default is true unless `x-tfy-strict-openai === 'false'`.
+     * Execute uses `?? true` when this is omitted.
+     */
+    strictOpenAiCompliance?: boolean;
+    headersOverride?: HeadersOverride;
+    /**
+     * Provider-native response id for pinned GET/DELETE /responses paths.
+     * Origin pinning stays in the gateway; P7 sets this before execute.
+     * Replaces `c.get(CONTEXT_KEYS.RESPONSES_PROVIDER_RESPONSE_ID)`.
+     */
+    responsesProviderResponseId?: string;
+    /**
+     * Live `CONTEXT_KEYS.IS_GEMINI_ROUTER`. Combined with inbound `generateContent`
+     * and `streamGenerateContent` URLs to pick the SSE split (single newline).
+     */
+    isGeminiRouter?: boolean;
+    /**
+     * Live `c.get('passThrough')`. When true, requestHandlers must not rewrite
+     * the inbound body (e.g. transcription `model` field).
+     */
+    passThrough?: boolean;
+}
+/**
+ * Process-level SDK config. Catalog maps match V2 `MODEL_CONFIG` /
+ * `PROVIDER_CONFIG` (`commonData.modelConfig` / `commonData.providerConfig`).
+ * Pass `{}` until the first NATS push; later updates replace these maps on
+ * the instance (P2.4), they are not per-call inputs.
+ *
+ * `cache` is required: gateway injects a tenant-prefixing adapter. Provider
+ * auth call sites wire it in P4.
+ *
+ * `allowAmbientCredentials`: when true (default for open-source / self-hosted),
+ * providers may use host ADC / default cloud credential chains. When false
+ * (multi-tenant hosted runtimes where pod identity is the platform's), auth
+ * must come from explicit provider-account credentials. Gateway maps
+ * `!IS_TFY_SAAS_GATEWAY` into this field — the SDK never names a product.
+ */
+export interface SdkInitConfig {
+    allowAmbientCredentials: boolean;
+    modelConfig: ProviderModelConfigs;
+    providerConfig: CatalogProviderConfigs;
+    cache: CachePort;
+}
+export type SdkChunk = object | string | Uint8Array | ArrayBuffer;
+export interface SdkCallInputs {
+    request: SdkRequest;
+    execution: SdkExecutionConfig;
+    providerOptions: ProviderOptions;
+    callConfig: ProviderCallConfig;
+    session: SessionContext;
+}
+/**
+ * Result of {@link LlmGatewaySdk.execute} (P7).
+ *
+ * `response` is delivered for the caller to consume. `executionReport` settles
+ * when the body is fully drained, errors, or is cancelled — gateway awaits it
+ * for spans / logging / `calculateCost`. No USD amounts on the report.
+ */
+export interface SdkExecuteResult {
+    response: Response;
+    executionReport: Promise<ExecutionReport>;
+    /** Post-adapter endpoint that drove transforms / usage (`chatComplete`, `embed`, …). */
+    servedEndpoint: Endpoint;
+}

package/dist/types/contracts.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=contracts.js.map

package/dist/types/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../src/types/contracts.ts"],"names":[],"mappings":""}

package/dist/types/embedRequestBody.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * ================================
+ */
+import { BaseResponse } from '../providers/types.js';
+import { Options } from './requestBody.js';
+export type EmbedInput = {
+    text?: string;
+    image?: {
+        url?: string;
+        base64?: string;
+        text?: string;
+    };
+    video?: {
+        url?: string;
+        base64?: string;
+        start_offset?: number;
+        end_offset?: number;
+        interval?: number;
+        text?: string;
+    };
+};
+export interface EmbedParams {
+    model: string;
+    input: string | string[] | EmbedInput[];
+    user: string;
+    dimensions?: number;
+}
+export interface EmbedRequestBody {
+    config: {
+        provider?: string;
+        apiKeyName?: string;
+        apiKey?: string;
+        mode?: string;
+        options?: Options[];
+    };
+    params: EmbedParams;
+}
+export interface EmbedResponseData {
+    object: string;
+    embedding?: number[] | number[][];
+    image_embedding?: number[];
+    video_embeddings?: {
+        start_offset: number;
+        end_offset?: number;
+        embedding: number[];
+    }[];
+    index: number;
+}
+export interface EmbedResponse extends BaseResponse {
+    object: string;
+    data: EmbedResponseData[];
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+}

package/dist/types/embedRequestBody.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=embedRequestBody.js.map

package/dist/types/embedRequestBody.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedRequestBody.js","sourceRoot":"","sources":["../../src/types/embedRequestBody.ts"],"names":[],"mappings":""}

package/dist/types/executionReport.d.ts

@@ -0,0 +1,223 @@
+/**
+ * P5.2 — lifecycle facts from one SDK `execute`.
+ *
+ * Canonical return: `{ response, executionReport: Promise<ExecutionReport> }`.
+ * The promise resolves when the response body is fully consumed, errors, or is
+ * cancelled. Gateway turns this into spans and `calculateCost`.
+ *
+ * Cost **in USD** stays gateway-side. This report carries usage + cost-related
+ * model metadata only — never currency amounts or OTel span handles.
+ */
+import type { Endpoint, FINISH_REASON, PROVIDER_FINISH_REASON } from '../providers/types.js';
+/** Wall / stream timings observed during execute (milliseconds). */
+export interface ExecutionTimings {
+    /** Fetch start → response headers (or equivalent non-stream completion). */
+    latencyMs?: number;
+    /** Fetch start → first downstream chunk (streaming only). */
+    timeToFirstTokenMs?: number;
+    /** Mean gap between successive chunks when measured (streaming only). */
+    interTokenLatencyMs?: number;
+}
+/**
+ * Normalized billable usage counters for logging and gateway `calculateCost`.
+ *
+ * Maps 1:1 onto `calculateCost` numeric / video args (gateway owns model id,
+ * provider, cost metric, region, discount, toolUsage, serviceTier, finishReason):
+ *
+ * | TokenUsage            | calculateCost              |
+ * | --------------------- | -------------------------- |
+ * | input                 | numInputTokens             |
+ * | output                | numOutputTokens            |
+ * | cache_read            | numCacheReadTokens         |
+ * | cache_write           | numCacheWriteTokens        |
+ * | cache_write_1h        | numCacheWrite1hTokens      |
+ * | cache_read_image      | numCacheReadImageTokens    |
+ * | input_image           | numInputImageTokens        |
+ * | output_image          | numOutputImageTokens       |
+ * | input_audio           | numInputAudioTokens        |
+ * | output_audio          | numOutputAudioTokens       |
+ * | input_characters      | numInputCharacters         |
+ * | audio_seconds         | numAudioSeconds            |
+ * | video_seconds         | numVideoSeconds            |
+ * | video_resolution      | videoResolution            |
+ * | video_audio           | videoAudio                 |
+ * | pages                 | numPages                   |
+ * | annotated_pages       | numAnnotatedPages          |
+ *
+ * Cache write billed at 5m is `cache_write - cache_write_1h` (not a separate field).
+ * Per-attempt hops live on {@link TokenUsageIteration}, not here.
+ */
+export interface TokenUsage {
+    input?: number;
+    output?: number;
+    cache_read?: number;
+    cache_write?: number;
+    /** Subset of `cache_write` billed at Anthropic 1h TTL. */
+    cache_write_1h?: number;
+    /** Subset of `cache_read` that are cached image tokens (OpenAI modality breakdown). */
+    cache_read_image?: number;
+    input_image?: number;
+    output_image?: number;
+    /** Realtime / multimodal audio input tokens (WebSocket path). */
+    input_audio?: number;
+    output_audio?: number;
+    /** Billable input characters (Cloud TTS / text_to_speech). */
+    input_characters?: number;
+    /** Billable audio seconds (Cloud STT / audio_transcription). */
+    audio_seconds?: number;
+    /** Billable generated video seconds. */
+    video_seconds?: number;
+    /** Video resolution tier key (e.g. `"720p"`, `"1080p"`, `"4k"`). */
+    video_resolution?: string;
+    /**
+     * Whether generated video includes audio. Veo / public video pricing
+     * defaults to `true` when omitted (same as live `VIDEO_BILLED_AUDIO`).
+     */
+    video_audio?: boolean;
+    pages?: number;
+    annotated_pages?: number;
+}
+/**
+ * One attempt's usage within a request (server-side fallbacks / compaction).
+ * Hard-typed counterpart to Anthropic `usage.iterations`; gateway bills each
+ * attempt at its own model rates. Top-level {@link TokenUsage} covers only the
+ * attempt that produced the returned message.
+ */
+export interface TokenUsageIteration {
+    type: string;
+    model: string;
+    input?: number;
+    output?: number;
+    cache_read?: number;
+    cache_write?: number;
+    /** Subset of `cache_write` billed at Anthropic 1h TTL. */
+    cache_write_1h?: number;
+}
+/**
+ * Identifiers the gateway needs to select cost tables / logging dimensions.
+ * Not a flattened `Options` bag — only cost-path facts from the executed call.
+ *
+ * `provider` and `endpoint` are always known after routing. `modelId` is omitted
+ * when `ProviderOptions.model` is null (uploadFile / legacy Google RequestHandler
+ * bridges) and there is no upstream id to report — do not invent `''`.
+ */
+export interface ExecutionModelMetadata {
+    /** Actual model id sent upstream (after `getActualModelId` / foundation rewrite). */
+    modelId?: string;
+    /** Provider account name (`openai`, `anthropic`, …). */
+    provider: string;
+    /** Endpoint that drove transforms / usage extraction (`chatComplete`, `embed`, …). */
+    endpoint: Endpoint;
+}
+/**
+ * How a mid-stream failure was detected. Distinct from the provider's own
+ * `error.type` / `error.code` (see {@link MidStreamProviderErrorToken}).
+ *
+ * Sources in live gateway:
+ * - `overloaded` — Anthropic first-chunk gate (`finish_reason === 'overloaded_error'`)
+ * - `in_band_provider_error` — Responses gate (`response.failed` / `error` with type or code)
+ * - `detail_less` — Azure `response.failed` with `error: null` and no follow-up detail
+ * - `empty_stream` — Responses stream ended before any generation
+ * - `streaming_terminated` — provider socket closed mid-body (`UND_ERR_SOCKET`)
+ * - `unknown` — unclassified mid-stream failure
+ */
+export type MidStreamErrorKind = 'overloaded' | 'in_band_provider_error' | 'detail_less' | 'empty_stream' | 'streaming_terminated' | 'unknown';
+/**
+ * Known provider `error.type` / `error.code` tokens observed on mid-stream
+ * paths (Anthropic, OpenAI Responses, Azure Responses, Vertex Anthropic, …).
+ *
+ * Mirrors gateway `IN_BAND_ERROR_STATUS_BY_TOKEN` in `firstChunkGateUtils.ts`,
+ * plus `rate_limit_error` (common HTTP-body type; not in that status map today).
+ * Open `string` kept so unrecognized provider tokens still type-check.
+ */
+export type MidStreamProviderErrorToken = 'too_many_requests' | 'rate_limit_exceeded' | 'rate_limit_error' | 'no_capacity' | 'insufficient_quota' | 'credit_balance_exhausted' | 'server_error' | 'api_error' | 'overloaded_error' | 'authentication_error' | 'permission_error' | 'permission_denied' | 'not_found_error' | 'invalid_request_error' | 'invalid_prompt' | 'context_length_exceeded' | 'content_filter' | (string & {});
+/**
+ * Provider failure observed after HTTP headers were already returned.
+ * Distinct from a failed fetch status on {@link ExecutionReport.status}.
+ *
+ * `kind` is the gateway detection path; `providerErrorType` / `providerErrorCode`
+ * carry the provider tokens (Azure often sends both, e.g. type=`too_many_requests`
+ * + code=`rate_limit_exceeded`).
+ */
+export interface MidStreamError {
+    kind: MidStreamErrorKind;
+    status?: number;
+    message?: string;
+    providerErrorType?: MidStreamProviderErrorToken | null;
+    providerErrorCode?: MidStreamProviderErrorToken | null;
+    /** Raw provider error body/chunk if captured (untyped). */
+    detail?: unknown;
+}
+/**
+ * Server-side tool invocation counts for tool pricing (e.g. web_search).
+ * Keys match catalog `tool_pricing` names; values are invocation counts.
+ */
+export type ExecutionToolUsage = Record<string, number>;
+/**
+ * Finish / stop token on a completed response.
+ *
+ * Either the OpenAI-normalized `FINISH_REASON` (strict OpenAI compliance) or
+ * the provider-native `PROVIDER_FINISH_REASON` (`end_turn`, `refusal`,
+ * `MAX_TOKENS`, …). Live `calculateCost` checks both spellings
+ * (`refusalCostUtils.isAnthropicRefusal`), so the SDK reports whichever the
+ * transform emitted rather than re-normalizing. Template-literal form so plain
+ * string literals type-check without importing the enums.
+ */
+export type ExecutionFinishReason = `${FINISH_REASON}` | `${PROVIDER_FINISH_REASON}`;
+/**
+ * How execute settled. Exactly one kind — a call cannot be done, cancelled,
+ * and mid-stream-failed at once.
+ *
+ * `finishReason` is the provider token when one was observed. It is not a kind:
+ * a completed call is `done` and may also carry `finishReason`. Mid-stream
+ * failures carry their provider token on {@link MidStreamError} instead.
+ */
+export type EndReason = {
+    kind: 'done';
+    finishReason?: ExecutionFinishReason;
+} | {
+    kind: 'cancelled';
+    /**
+     * Body did not finish. Gateway must not cache truncated responses;
+     * the SDK only reports the fact.
+     */
+    truncated: boolean;
+} | {
+    kind: 'mid_stream_error';
+    error: MidStreamError;
+} | {
+    kind: 'unknown';
+};
+/**
+ * Typed lifecycle facts for one SDK execute.
+ *
+ * Required fields are always knowable at settle time. Optional fields are
+ * omitted when not observed (non-stream, no usage body, no cancel, …).
+ */
+export interface ExecutionReport {
+    /** Final HTTP status of the response returned to the caller (last attempt). */
+    status: number;
+    /**
+     * Same-target retry attempts from `retryRequest` (`undefined`/`0` on the
+     * first try when no retries fired — same semantics as live `lastAttempt`).
+     */
+    attempts: number;
+    streaming: boolean;
+    timings: ExecutionTimings;
+    /** Terminal outcome. Always set; see {@link EndReason}. */
+    endReason: EndReason;
+    usage?: TokenUsage;
+    /**
+     * Per-attempt usage (server-side fallbacks / compaction). Present when the
+     * provider reports iterations; gateway prices each hop separately.
+     */
+    iterations?: TokenUsageIteration[];
+    /** True when input/output counts were estimated rather than provider-reported. */
+    tokensEstimated?: boolean;
+    /** Selected target. Always present after routing; `modelId` may be omitted. */
+    modelMetadata: ExecutionModelMetadata;
+    /** Provider request id from response headers or body when observed. */
+    providerRequestId?: string;
+    serviceTier?: string;
+    toolUsage?: ExecutionToolUsage;
+}

package/dist/types/executionReport.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=executionReport.js.map

package/dist/types/executionReport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executionReport.js","sourceRoot":"","sources":["../../src/types/executionReport.ts"],"names":[],"mappings":""}

package/dist/types/headers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ================================
+ * Response Header Types
+ * Interfaces representing structured data sent via response headers
+ * ================================
+ */
+export type cooldownReason = 'unhealthy' | 'sla-breached';
+/** Complexity-based routing model-order reasons. */
+export type complexityRoutingReason = 'complexity-tier' | 'complexity-escalation' | 'complexity-session-pin';
+export type routingReason = 'routing-config' | 'sticky-routing-config' | cooldownReason | complexityRoutingReason;
+export interface RoutingModelOrderEntry {
+    model: string;
+    reason: routingReason;
+}
+export type ComplexityTierName = 'simple' | 'medium' | 'complex';
+export interface ComplexityAppliedConfig {
+    tier: ComplexityTierName;
+    cause: 'session_pin' | 'heuristic' | 'llm_classifier' | 'default';
+}
+/**
+ * Applied Rules Header Interface
+ * Represents the structure of the x-tfy-applied-rules response header
+ */
+export interface AppliedRulesHeader {
+    routing_config?: {
+        rule_id: string;
+        requested_model: string;
+        resolved_model?: string;
+        routing_model_order?: RoutingModelOrderEntry[];
+        complexity?: ComplexityAppliedConfig;
+    };
+    rate_limiting?: {
+        rule_id: string;
+        violated: boolean;
+    };
+    budget_limiting?: {
+        rule_id: string;
+        violated: boolean;
+        audit_mode?: boolean;
+        budget_source?: 'v1' | 'v2';
+    };
+}

package/dist/types/headers.js

@@ -0,0 +1,8 @@
+/**
+ * ================================
+ * Response Header Types
+ * Interfaces representing structured data sent via response headers
+ * ================================
+ */
+export {};
+//# sourceMappingURL=headers.js.map

package/dist/types/headers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.js","sourceRoot":"","sources":["../../src/types/headers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/types/inputList.d.ts

@@ -0,0 +1,145 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * ================================
+ */
+import * as ResponsesAPI from './modelResponses.js';
+/**
+ * A list of Response items.
+ */
+export interface ResponseItemList {
+    /**
+     * A list of items used to generate this response.
+     */
+    data: Array<ResponseItemList.Message | ResponsesAPI.ResponseOutputMessage | ResponsesAPI.ResponseFileSearchToolCall | ResponsesAPI.ResponseComputerToolCall | ResponseItemList.ComputerCallOutput | ResponsesAPI.ResponseFunctionWebSearch | ResponsesAPI.ResponseFunctionToolCall | ResponseItemList.FunctionCallOutput>;
+    /**
+     * The ID of the first item in the list.
+     */
+    first_id: string;
+    /**
+     * Whether there are more items available.
+     */
+    has_more: boolean;
+    /**
+     * The ID of the last item in the list.
+     */
+    last_id: string;
+    /**
+     * The type of object returned, must be `list`.
+     */
+    object: 'list';
+}
+export declare namespace ResponseItemList {
+    interface Message {
+        /**
+         * The unique ID of the message input.
+         */
+        id: string;
+        /**
+         * A list of one or many input items to the model, containing different content
+         * types.
+         */
+        content: ResponsesAPI.ResponseInputMessageContentList;
+        /**
+         * The role of the message input. One of `user`, `system`, or `developer`.
+         */
+        role: 'user' | 'system' | 'developer';
+        /**
+         * The status of item. One of `in_progress`, `completed`, or `incomplete`.
+         * Populated when items are returned via API.
+         */
+        status?: 'in_progress' | 'completed' | 'incomplete';
+        /**
+         * The type of the message input. Always set to `message`.
+         */
+        type?: 'message';
+    }
+    interface ComputerCallOutput {
+        /**
+         * The unique ID of the computer call tool output.
+         */
+        id: string;
+        /**
+         * The ID of the computer tool call that produced the output.
+         */
+        call_id: string;
+        /**
+         * A computer screenshot image used with the computer use tool.
+         */
+        output: ComputerCallOutput.Output;
+        /**
+         * The type of the computer tool call output. Always `computer_call_output`.
+         */
+        type: 'computer_call_output';
+        /**
+         * The safety checks reported by the API that have been acknowledged by the
+         * developer.
+         */
+        acknowledged_safety_checks?: Array<ComputerCallOutput.AcknowledgedSafetyCheck>;
+        /**
+         * The status of the message input. One of `in_progress`, `completed`, or
+         * `incomplete`. Populated when input items are returned via API.
+         */
+        status?: 'in_progress' | 'completed' | 'incomplete';
+    }
+    namespace ComputerCallOutput {
+        /**
+         * A computer screenshot image used with the computer use tool.
+         */
+        interface Output {
+            /**
+             * Specifies the event type. For a computer screenshot, this property is always set
+             * to `computer_screenshot`.
+             */
+            type: 'computer_screenshot';
+            /**
+             * The identifier of an uploaded file that contains the screenshot.
+             */
+            file_id?: string;
+            /**
+             * The URL of the screenshot image.
+             */
+            image_url?: string;
+        }
+        /**
+         * A pending safety check for the computer call.
+         */
+        interface AcknowledgedSafetyCheck {
+            /**
+             * The ID of the pending safety check.
+             */
+            id: string;
+            /**
+             * The type of the pending safety check.
+             */
+            code: string;
+            /**
+             * Details about the pending safety check.
+             */
+            message: string;
+        }
+    }
+    interface FunctionCallOutput {
+        /**
+         * The unique ID of the function call tool output.
+         */
+        id: string;
+        /**
+         * The unique ID of the function tool call generated by the model.
+         */
+        call_id: string;
+        /**
+         * A JSON string of the output of the function tool call.
+         */
+        output: string;
+        /**
+         * The type of the function tool call output. Always `function_call_output`.
+         */
+        type: 'function_call_output';
+        /**
+         * The status of the item. One of `in_progress`, `completed`, or `incomplete`.
+         * Populated when items are returned via API.
+         */
+        status?: 'in_progress' | 'completed' | 'incomplete';
+    }
+}

package/dist/types/inputList.js

@@ -0,0 +1,8 @@
+/**
+ * ================================
+ * Inherited upstream file
+ * ================================
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+export {};
+//# sourceMappingURL=inputList.js.map

package/dist/types/inputList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputList.js","sourceRoot":"","sources":["../../src/types/inputList.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,sFAAsF"}