@glexir/sdk 0.0.0-stage → 0.2.0

package/dist/types/responses.d.ts

@@ -0,0 +1,640 @@
+import type { CustomToolInputFormat, ErrorObject, Metadata, ModerationConfig, ModerationResult, ModerationError, PromptCacheBreakpoint, ReasoningEffort, ResponsesModel, ServiceTier, Verbosity } from './shared.js';
+export interface ResponseInputText {
+    type: 'input_text';
+    text: string;
+    prompt_cache_breakpoint?: PromptCacheBreakpoint;
+}
+/** Image input (vision). Pass a URL or a `data:` URL. */
+export interface ResponseInputImage {
+    type: 'input_image';
+    detail: 'low' | 'high' | 'auto' | 'original';
+    image_url?: string | null;
+    /** A file uploaded through `client.files` with purpose `user_data` or `vision`. */
+    file_id?: string | null;
+    prompt_cache_breakpoint?: PromptCacheBreakpoint;
+}
+/** File input such as a PDF: a URL, base64 `file_data`, or an uploaded `file_id`. */
+export interface ResponseInputFile {
+    type: 'input_file';
+    detail?: 'auto' | 'low' | 'high';
+    file_data?: string;
+    file_id?: string | null;
+    file_url?: string;
+    filename?: string;
+    prompt_cache_breakpoint?: PromptCacheBreakpoint;
+}
+export type ResponseInputContent = ResponseInputText | ResponseInputImage | ResponseInputFile;
+export interface FileCitation {
+    type: 'file_citation';
+    file_id: string;
+    filename: string;
+    index: number;
+}
+export interface URLCitation {
+    type: 'url_citation';
+    url: string;
+    title: string;
+    start_index: number;
+    end_index: number;
+}
+export interface ContainerFileCitation {
+    type: 'container_file_citation';
+    container_id: string;
+    file_id: string;
+    filename: string;
+    start_index: number;
+    end_index: number;
+}
+export interface FilePath {
+    type: 'file_path';
+    file_id: string;
+    index: number;
+}
+export type Annotation = FileCitation | URLCitation | ContainerFileCitation | FilePath;
+export interface Logprob {
+    token: string;
+    bytes: number[];
+    logprob: number;
+    top_logprobs: Array<{
+        token: string;
+        bytes: number[];
+        logprob: number;
+    }>;
+}
+export interface ResponseOutputText {
+    type: 'output_text';
+    text: string;
+    annotations: Annotation[];
+    logprobs?: Logprob[];
+}
+export interface ResponseOutputRefusal {
+    type: 'refusal';
+    refusal: string;
+}
+export type MessagePhase = 'commentary' | 'final_answer';
+/** The simplest way to write a message: `{ role: "user", content: "Hi" }`. */
+export interface EasyInputMessage {
+    role: 'user' | 'assistant' | 'system' | 'developer';
+    content: string | ResponseInputContent[];
+    /** Preserve this on assistant messages you replay (gpt-5.3+ use it). */
+    phase?: MessagePhase | null;
+    type?: 'message';
+}
+export interface ResponseInputMessage {
+    type?: 'message';
+    role: 'user' | 'system' | 'developer';
+    content: ResponseInputContent[];
+    status?: 'in_progress' | 'completed' | 'incomplete';
+}
+export interface ResponseOutputMessage {
+    type: 'message';
+    id: string;
+    role: 'assistant';
+    status: 'in_progress' | 'completed' | 'incomplete';
+    content: Array<ResponseOutputText | ResponseOutputRefusal>;
+    phase?: MessagePhase | null;
+}
+export interface ResponseReasoningItem {
+    type: 'reasoning';
+    id: string;
+    summary: Array<{
+        type: 'summary_text';
+        text: string;
+    }>;
+    content?: Array<{
+        type: 'reasoning_text';
+        text: string;
+    }>;
+    /**
+     * Opaque reasoning state, returned by default. Replay the item unchanged in stateless
+     * (`store: false`) conversations; it is only valid on the account that produced it.
+     */
+    encrypted_content?: string | null;
+    status?: 'in_progress' | 'completed' | 'incomplete';
+}
+export type ToolCaller = {
+    type: 'direct';
+} | {
+    type: 'program';
+    caller_id: string;
+};
+export interface ResponseFunctionToolCall {
+    type: 'function_call';
+    call_id: string;
+    name: string;
+    /** JSON-encoded arguments. */
+    arguments: string;
+    id?: string;
+    namespace?: string;
+    async?: boolean;
+    caller?: ToolCaller | null;
+    status?: 'in_progress' | 'completed' | 'incomplete';
+}
+export interface ResponseFunctionCallOutput {
+    type: 'function_call_output';
+    call_id: string;
+    /** A string, or multimodal content (text, images, files). */
+    output: string | ResponseInputContent[];
+    id?: string | null;
+    name?: string;
+    namespace?: string;
+    caller?: ToolCaller | null;
+    status?: 'in_progress' | 'completed' | 'incomplete' | null;
+}
+export interface ResponseCustomToolCall {
+    type: 'custom_tool_call';
+    call_id: string;
+    name: string;
+    /** Free-form input produced by the model (matches the tool's grammar if one is set). */
+    input: string;
+    id?: string;
+    namespace?: string;
+    async?: boolean;
+    caller?: ToolCaller | null;
+}
+export interface ResponseCustomToolCallOutput {
+    type: 'custom_tool_call_output';
+    call_id: string;
+    output: string | ResponseInputContent[];
+    id?: string;
+}
+/** Compacted conversation context. Opaque; replay it unchanged. */
+export interface ResponseCompactionItem {
+    type: 'compaction';
+    encrypted_content: string;
+    id?: string;
+    created_by?: string;
+}
+/** Asks the model to compact the context now. Must be the final input item. */
+export interface ResponseCompactionTrigger {
+    type: 'compaction_trigger';
+    id?: string;
+}
+/** References a stored item by ID (only with server-side state). */
+export interface ResponseItemReference {
+    type?: 'item_reference' | null;
+    id: string;
+}
+/** Changes the reasoning effort for subsequent turns mid-conversation. */
+export interface ResponseConfigurationUpdate {
+    type: 'configuration_update';
+    reasoning?: {
+        effort?: ReasoningEffort;
+    };
+    id?: string;
+}
+export type ResponseInputItem = EasyInputMessage | ResponseInputMessage | ResponseOutputMessage | ResponseReasoningItem | ResponseFunctionToolCall | ResponseFunctionCallOutput | ResponseCustomToolCall | ResponseCustomToolCallOutput | ResponseCompactionItem | ResponseCompactionTrigger | ResponseItemReference | ResponseConfigurationUpdate;
+export type ResponseInput = string | ResponseInputItem[];
+export type ResponseOutputItem = ResponseOutputMessage | ResponseReasoningItem | ResponseFunctionToolCall | ResponseFunctionCallOutput | ResponseCustomToolCall | ResponseCustomToolCallOutput | ResponseCompactionItem;
+/** A persisted item, as returned by `responses.inputItems.list()` and conversation item endpoints. */
+export type ResponseItem = (ResponseInputMessage & {
+    id: string;
+    status?: 'in_progress' | 'completed' | 'incomplete';
+}) | ResponseOutputMessage | ResponseReasoningItem | (ResponseFunctionToolCall & {
+    id: string;
+}) | (ResponseFunctionCallOutput & {
+    id: string;
+}) | ResponseCustomToolCall | ResponseCustomToolCallOutput | ResponseCompactionItem;
+/**
+ * A function the model can call; your code runs it. Glexir supports function, custom and
+ * namespace tools only. OpenAI-hosted tools (web search, file search, code interpreter,
+ * MCP, image generation, shell, computer use) are rejected by the gateway.
+ */
+export interface FunctionTool {
+    type: 'function';
+    name: string;
+    description?: string | null;
+    /** JSON Schema for the arguments. */
+    parameters?: Record<string, unknown> | null;
+    /** Enforce the schema exactly. Omitted means best-effort strict. */
+    strict?: boolean | null;
+    output_schema?: Record<string, unknown> | null;
+    defer_loading?: boolean;
+    async?: boolean;
+}
+/** A tool that takes free-form text input, optionally constrained by a grammar. */
+export interface CustomTool {
+    type: 'custom';
+    name: string;
+    description?: string;
+    format?: CustomToolInputFormat;
+    defer_loading?: boolean;
+    async?: boolean;
+}
+/** Groups related tools; calls carry the `namespace`. */
+export interface NamespaceTool {
+    type: 'namespace';
+    name: string;
+    description: string;
+    tools: Array<Omit<FunctionTool, 'type'> & {
+        type: 'function';
+    } | CustomTool>;
+}
+export type Tool = FunctionTool | CustomTool | NamespaceTool;
+export type ToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    name: string;
+} | {
+    type: 'custom';
+    name: string;
+} | {
+    type: 'allowed_tools';
+    mode: 'auto' | 'required';
+    tools: Array<Record<string, unknown>>;
+};
+export interface ResponseFormatTextJSONSchemaConfig {
+    type: 'json_schema';
+    /** a-z, A-Z, 0-9, underscores and dashes; max 64 characters. */
+    name: string;
+    schema: Record<string, unknown>;
+    description?: string;
+    strict?: boolean | null;
+}
+export type ResponseFormatTextConfig = {
+    type: 'text';
+} | {
+    type: 'json_object';
+} | ResponseFormatTextJSONSchemaConfig;
+export interface ResponseTextConfig {
+    format?: ResponseFormatTextConfig;
+    verbosity?: Verbosity | null;
+}
+export interface Reasoning {
+    effort?: ReasoningEffort | null;
+    summary?: 'auto' | 'concise' | 'detailed' | null;
+    /** How much prior reasoning the model sees (gpt-5.6 defaults to `all_turns`). */
+    context?: 'auto' | 'current_turn' | 'all_turns' | null;
+    mode?: 'standard' | 'pro' | (string & {}) | null;
+}
+export type ResponseIncludable = 'reasoning.encrypted_content' | 'message.output_text.logprobs' | 'message.input_image.image_url' | (string & {});
+export interface ResponsePromptCacheOptions {
+    mode?: 'implicit' | 'explicit';
+    ttl?: '30m' | (string & {});
+    prewarm?: boolean;
+    comparison_response_id?: string;
+}
+export interface ContextManagement {
+    type: 'compaction';
+    /** Auto-compact when the rendered context exceeds this many tokens. */
+    compact_threshold?: number;
+}
+export interface ResponseCreateParamsBase {
+    model: ResponsesModel;
+    input?: ResponseInput;
+    /** System/developer instructions. Not carried over by `previous_response_id`; resend each turn. */
+    instructions?: string | null;
+    /** Continue from a stored response. Cannot be combined with `conversation`. */
+    previous_response_id?: string | null;
+    /** Conversation whose items are prepended and appended to automatically. */
+    conversation?: string | {
+        id: string;
+    } | null;
+    /** Store the response for later retrieval. Glexir defaults this to `false`. */
+    store?: boolean | null;
+    /** Run asynchronously; poll with `retrieve` or stream with `stream: true`. */
+    background?: boolean | null;
+    include?: ResponseIncludable[] | null;
+    reasoning?: Reasoning | null;
+    text?: ResponseTextConfig;
+    tools?: Tool[];
+    tool_choice?: ToolChoice;
+    parallel_tool_calls?: boolean | null;
+    /** Includes reasoning tokens. */
+    max_output_tokens?: number | null;
+    max_tool_calls?: number | null;
+    metadata?: Metadata | null;
+    temperature?: number | null;
+    top_p?: number | null;
+    /** 0–20; requires `include: ["message.output_text.logprobs"]`. */
+    top_logprobs?: number | null;
+    service_tier?: ServiceTier | null;
+    prompt?: {
+        id: string;
+        version?: string | null;
+        variables?: Record<string, string | ResponseInputContent> | null;
+    } | null;
+    prompt_cache_key?: string;
+    prompt_cache_options?: ResponsePromptCacheOptions | null;
+    /** @deprecated Use `prompt_cache_options.ttl`. */
+    prompt_cache_retention?: 'in_memory' | '24h' | null;
+    context_management?: ContextManagement[] | null;
+    /** @deprecated Use `context_management`. */
+    truncation?: 'auto' | 'disabled' | null;
+    moderation?: ModerationConfig | null;
+    /** Stable hashed end-user ID used for abuse detection. Glexir sets one per API key if omitted. */
+    safety_identifier?: string;
+    stream_options?: {
+        include_obfuscation?: boolean;
+    } | null;
+    /** @deprecated Use `safety_identifier` and `prompt_cache_key`. */
+    user?: string;
+    /** Unknown fields are forwarded unchanged, so new API parameters work before the SDK types catch up. */
+    [key: string]: unknown;
+}
+export interface ResponseCreateParamsNonStreaming extends ResponseCreateParamsBase {
+    stream?: false | null;
+}
+export interface ResponseCreateParamsStreaming extends ResponseCreateParamsBase {
+    stream: true;
+}
+export type ResponseCreateParams = ResponseCreateParamsNonStreaming | ResponseCreateParamsStreaming;
+export interface ResponseRetrieveParams {
+    include?: ResponseIncludable[];
+    include_obfuscation?: boolean;
+    /** With `stream: true`, replay events after this sequence number (background responses only). */
+    starting_after?: number;
+}
+export interface InputItemListParams {
+    after?: string;
+    limit?: number;
+    order?: 'asc' | 'desc';
+    include?: ResponseIncludable[];
+}
+export interface InputTokenCountParams {
+    model?: ResponsesModel | null;
+    input?: ResponseInput | null;
+    instructions?: string | null;
+    previous_response_id?: string | null;
+    conversation?: string | {
+        id: string;
+    } | null;
+    reasoning?: Reasoning | null;
+    text?: ResponseTextConfig | null;
+    tools?: Tool[] | null;
+    tool_choice?: ToolChoice | null;
+    parallel_tool_calls?: boolean | null;
+    truncation?: 'auto' | 'disabled';
+    [key: string]: unknown;
+}
+export interface InputTokenCountResponse {
+    object: 'response.input_tokens';
+    input_tokens: number;
+}
+export interface ResponseCompactParams {
+    model: ResponsesModel | null;
+    input?: ResponseInput | null;
+    instructions?: string | null;
+    previous_response_id?: string | null;
+    prompt_cache_key?: string | null;
+    prompt_cache_options?: {
+        mode?: 'implicit' | 'explicit';
+        ttl?: string;
+    } | null;
+    service_tier?: ServiceTier | null;
+    [key: string]: unknown;
+}
+export interface CompactedResponse {
+    id: string;
+    object: 'response.compaction';
+    created_at: number;
+    output: ResponseOutputItem[];
+    usage: ResponseUsage;
+}
+export type ResponseStatus = 'queued' | 'in_progress' | 'completed' | 'incomplete' | 'failed' | 'cancelled';
+export interface ResponseUsage {
+    input_tokens: number;
+    input_tokens_details: {
+        cached_tokens: number;
+        /** Tokens written to the prompt cache (billed at a premium on gpt-5.6+). */
+        cache_write_tokens?: number;
+        [key: string]: unknown;
+    };
+    output_tokens: number;
+    output_tokens_details: {
+        reasoning_tokens: number;
+        [key: string]: unknown;
+    };
+    total_tokens: number;
+}
+export interface ResponseError {
+    code: string;
+    message: string;
+    [key: string]: unknown;
+}
+export interface Response {
+    id: string;
+    object: 'response';
+    created_at: number;
+    model: string;
+    status?: ResponseStatus;
+    output: ResponseOutputItem[];
+    /**
+     * Concatenated text of every `output_text` part. Computed by the SDK; not sent by the API.
+     */
+    output_text: string;
+    error: ResponseError | null;
+    incomplete_details: {
+        reason?: 'max_output_tokens' | 'max_messages' | 'content_filter' | 'steered' | (string & {});
+    } | null;
+    instructions: string | ResponseInputItem[] | null;
+    metadata: Metadata | null;
+    parallel_tool_calls: boolean;
+    temperature: number | null;
+    top_p: number | null;
+    tool_choice: ToolChoice;
+    tools: Tool[];
+    background?: boolean | null;
+    completed_at?: number | null;
+    conversation?: {
+        id: string;
+    } | null;
+    previous_response_id?: string | null;
+    max_output_tokens?: number | null;
+    max_tool_calls?: number | null;
+    moderation?: {
+        input: ModerationResult | ModerationError;
+        output: ModerationResult | ModerationError;
+    } | null;
+    prompt_cache_key?: string;
+    reasoning?: Reasoning | null;
+    safety_identifier?: string;
+    /** The tier actually used to serve (and bill) this response. */
+    service_tier?: ServiceTier | null;
+    text?: ResponseTextConfig;
+    top_logprobs?: number | null;
+    truncation?: 'auto' | 'disabled' | null;
+    usage?: ResponseUsage;
+    /** `x-request-id` of the HTTP response. */
+    _request_id?: string | null;
+    [key: string]: unknown;
+}
+interface BaseEvent {
+    sequence_number: number;
+}
+interface LifecycleEvent<T extends string> extends BaseEvent {
+    type: T;
+    response: Response;
+}
+export type ResponseQueuedEvent = LifecycleEvent<'response.queued'>;
+export type ResponseCreatedEvent = LifecycleEvent<'response.created'>;
+export type ResponseInProgressEvent = LifecycleEvent<'response.in_progress'>;
+export type ResponseCompletedEvent = LifecycleEvent<'response.completed'>;
+export type ResponseIncompleteEvent = LifecycleEvent<'response.incomplete'>;
+export type ResponseFailedEvent = LifecycleEvent<'response.failed'>;
+export interface ResponseOutputItemAddedEvent extends BaseEvent {
+    type: 'response.output_item.added';
+    output_index: number;
+    item: ResponseOutputItem;
+}
+export interface ResponseOutputItemDoneEvent extends BaseEvent {
+    type: 'response.output_item.done';
+    output_index: number;
+    /** Take `encrypted_content` from this event, not from `.added`. */
+    item: ResponseOutputItem;
+}
+export interface ResponseContentPartAddedEvent extends BaseEvent {
+    type: 'response.content_part.added';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    part: ResponseOutputText | ResponseOutputRefusal | {
+        type: 'reasoning_text';
+        text: string;
+    };
+}
+export interface ResponseContentPartDoneEvent extends BaseEvent {
+    type: 'response.content_part.done';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    part: ResponseOutputText | ResponseOutputRefusal | {
+        type: 'reasoning_text';
+        text: string;
+    };
+}
+export interface ResponseTextDeltaEvent extends BaseEvent {
+    type: 'response.output_text.delta';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    delta: string;
+    logprobs: Logprob[];
+    obfuscation?: string;
+}
+export interface ResponseTextDoneEvent extends BaseEvent {
+    type: 'response.output_text.done';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    text: string;
+    logprobs: Logprob[];
+}
+export interface ResponseOutputTextAnnotationAddedEvent extends BaseEvent {
+    type: 'response.output_text.annotation.added';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    annotation_index: number;
+    annotation: Annotation;
+}
+export interface ResponseRefusalDeltaEvent extends BaseEvent {
+    type: 'response.refusal.delta';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    delta: string;
+}
+export interface ResponseRefusalDoneEvent extends BaseEvent {
+    type: 'response.refusal.done';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    refusal: string;
+}
+export interface ResponseReasoningSummaryPartAddedEvent extends BaseEvent {
+    type: 'response.reasoning_summary_part.added';
+    item_id: string;
+    output_index: number;
+    summary_index: number;
+    part: {
+        type: 'summary_text';
+        text: string;
+    };
+}
+export interface ResponseReasoningSummaryPartDoneEvent extends BaseEvent {
+    type: 'response.reasoning_summary_part.done';
+    item_id: string;
+    output_index: number;
+    summary_index: number;
+    part: {
+        type: 'summary_text';
+        text: string;
+    };
+    status?: 'completed' | 'incomplete';
+}
+export interface ResponseReasoningSummaryTextDeltaEvent extends BaseEvent {
+    type: 'response.reasoning_summary_text.delta';
+    item_id: string;
+    output_index: number;
+    summary_index: number;
+    delta: string;
+    obfuscation?: string;
+}
+export interface ResponseReasoningSummaryTextDoneEvent extends BaseEvent {
+    type: 'response.reasoning_summary_text.done';
+    item_id: string;
+    output_index: number;
+    summary_index: number;
+    text: string;
+}
+export interface ResponseReasoningTextDeltaEvent extends BaseEvent {
+    type: 'response.reasoning_text.delta';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    delta: string;
+    obfuscation?: string;
+}
+export interface ResponseReasoningTextDoneEvent extends BaseEvent {
+    type: 'response.reasoning_text.done';
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    text: string;
+}
+export interface ResponseFunctionCallArgumentsDeltaEvent extends BaseEvent {
+    type: 'response.function_call_arguments.delta';
+    item_id: string;
+    output_index: number;
+    delta: string;
+    obfuscation?: string;
+}
+export interface ResponseFunctionCallArgumentsDoneEvent extends BaseEvent {
+    type: 'response.function_call_arguments.done';
+    item_id: string;
+    output_index: number;
+    name?: string;
+    arguments: string;
+}
+export interface ResponseCustomToolCallInputDeltaEvent extends BaseEvent {
+    type: 'response.custom_tool_call_input.delta';
+    item_id: string;
+    output_index: number;
+    delta: string;
+    obfuscation?: string;
+}
+export interface ResponseCustomToolCallInputDoneEvent extends BaseEvent {
+    type: 'response.custom_tool_call_input.done';
+    item_id: string;
+    output_index: number;
+    input: string;
+}
+export interface ResponseCompactionCompactingEvent extends BaseEvent {
+    type: 'response.compaction.compacting';
+    output_index?: number;
+    item_id?: string;
+}
+/** An error after the stream started. The SDK throws these as status-less `APIError`s. */
+export interface ResponseErrorEvent extends BaseEvent {
+    type: 'error';
+    code: string | null;
+    message: string;
+    param: string | null;
+    error?: ErrorObject;
+}
+/** Sent on long-running streams to keep the connection open; carries no content. */
+export interface ResponseKeepaliveEvent extends BaseEvent {
+    type: 'keepalive';
+}
+export type ResponseStreamEvent = ResponseQueuedEvent | ResponseCreatedEvent | ResponseInProgressEvent | ResponseCompletedEvent | ResponseIncompleteEvent | ResponseFailedEvent | ResponseOutputItemAddedEvent | ResponseOutputItemDoneEvent | ResponseContentPartAddedEvent | ResponseContentPartDoneEvent | ResponseTextDeltaEvent | ResponseTextDoneEvent | ResponseOutputTextAnnotationAddedEvent | ResponseRefusalDeltaEvent | ResponseRefusalDoneEvent | ResponseReasoningSummaryPartAddedEvent | ResponseReasoningSummaryPartDoneEvent | ResponseReasoningSummaryTextDeltaEvent | ResponseReasoningSummaryTextDoneEvent | ResponseReasoningTextDeltaEvent | ResponseReasoningTextDoneEvent | ResponseFunctionCallArgumentsDeltaEvent | ResponseFunctionCallArgumentsDoneEvent | ResponseCustomToolCallInputDeltaEvent | ResponseCustomToolCallInputDoneEvent | ResponseCompactionCompactingEvent | ResponseErrorEvent | ResponseKeepaliveEvent;
+export {};

package/dist/types/responses.js

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

package/dist/types/responses.js.map

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