@glexir/sdk 0.0.0-stage → 0.2.0

package/dist/types/chat.d.ts

@@ -0,0 +1,316 @@
+import type { ChatModel, CustomToolInputFormat, ErrorObject, FunctionDefinition, Metadata, ModerationConfig, ModerationError, ModerationResults, PromptCacheBreakpoint, PromptCacheOptions, ReasoningEffort, ResponseFormatJSONObject, ResponseFormatJSONSchema, ResponseFormatText, ServiceTier, Verbosity } from './shared.js';
+export interface ChatCompletionContentPartText {
+    type: 'text';
+    text: string;
+    prompt_cache_breakpoint?: PromptCacheBreakpoint;
+}
+/** Image input (vision): an http(s) URL or a `data:` URL. */
+export interface ChatCompletionContentPartImage {
+    type: 'image_url';
+    image_url: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high' | 'original';
+    };
+    prompt_cache_breakpoint?: PromptCacheBreakpoint;
+}
+/** File input such as a PDF, as base64 `file_data` or an uploaded `file_id`. */
+export interface ChatCompletionContentPartFile {
+    type: 'file';
+    file: {
+        file_data?: string;
+        file_id?: string;
+        filename?: string;
+    };
+    prompt_cache_breakpoint?: PromptCacheBreakpoint;
+}
+export interface ChatCompletionContentPartRefusal {
+    type: 'refusal';
+    refusal: string;
+}
+export type ChatCompletionContentPart = ChatCompletionContentPartText | ChatCompletionContentPartImage | ChatCompletionContentPartFile;
+export interface ChatCompletionDeveloperMessageParam {
+    role: 'developer';
+    content: string | ChatCompletionContentPartText[];
+    name?: string;
+}
+export interface ChatCompletionSystemMessageParam {
+    role: 'system';
+    content: string | ChatCompletionContentPartText[];
+    name?: string;
+}
+export interface ChatCompletionUserMessageParam {
+    role: 'user';
+    content: string | ChatCompletionContentPart[];
+    name?: string;
+}
+export interface ChatCompletionMessageFunctionToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ChatCompletionMessageCustomToolCall {
+    id: string;
+    type: 'custom';
+    custom: {
+        name: string;
+        input: string;
+    };
+}
+export type ChatCompletionMessageToolCall = ChatCompletionMessageFunctionToolCall | ChatCompletionMessageCustomToolCall;
+export interface ChatCompletionAssistantMessageParam {
+    role: 'assistant';
+    content?: string | Array<ChatCompletionContentPartText | ChatCompletionContentPartRefusal> | null;
+    name?: string;
+    refusal?: string | null;
+    tool_calls?: ChatCompletionMessageToolCall[];
+}
+export interface ChatCompletionToolMessageParam {
+    role: 'tool';
+    content: string | ChatCompletionContentPartText[];
+    tool_call_id: string;
+}
+export type ChatCompletionMessageParam = ChatCompletionDeveloperMessageParam | ChatCompletionSystemMessageParam | ChatCompletionUserMessageParam | ChatCompletionAssistantMessageParam | ChatCompletionToolMessageParam;
+export interface ChatCompletionFunctionTool {
+    type: 'function';
+    function: FunctionDefinition;
+}
+export interface ChatCompletionCustomTool {
+    type: 'custom';
+    custom: {
+        name: string;
+        description?: string;
+        format?: ChatCustomToolFormat;
+    };
+}
+/** Chat Completions nests the grammar under `grammar`, unlike the Responses API. */
+export type ChatCustomToolFormat = {
+    type: 'text';
+} | {
+    type: 'grammar';
+    grammar: {
+        definition: string;
+        syntax: 'lark' | 'regex';
+    };
+};
+export type ChatCompletionTool = ChatCompletionFunctionTool | ChatCompletionCustomTool;
+export type ChatCompletionToolChoiceOption = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | {
+    type: 'custom';
+    custom: {
+        name: string;
+    };
+} | {
+    type: 'allowed_tools';
+    allowed_tools: {
+        mode: 'auto' | 'required';
+        tools: Array<Record<string, unknown>>;
+    };
+};
+export interface ChatCompletionCreateParamsBase {
+    model: ChatModel;
+    messages: ChatCompletionMessageParam[];
+    /**
+     * Note: on GPT-5.4+ Chat Completions only supports tools with `reasoning_effort: "none"`,
+     * and gpt-6-astra / gpt-6.1-sol need the Responses API for tool calling.
+     */
+    tools?: ChatCompletionTool[];
+    tool_choice?: ChatCompletionToolChoiceOption;
+    parallel_tool_calls?: boolean;
+    response_format?: ResponseFormatText | ResponseFormatJSONSchema | ResponseFormatJSONObject;
+    reasoning_effort?: ReasoningEffort | null;
+    verbosity?: Verbosity | null;
+    /** Upper bound on generated tokens, including reasoning tokens. */
+    max_completion_tokens?: number | null;
+    /** @deprecated Use `max_completion_tokens`; rejected by reasoning models. */
+    max_tokens?: number | null;
+    n?: number | null;
+    stop?: string | string[] | null;
+    temperature?: number | null;
+    top_p?: number | null;
+    frequency_penalty?: number | null;
+    presence_penalty?: number | null;
+    logit_bias?: Record<string, number> | null;
+    logprobs?: boolean | null;
+    top_logprobs?: number | null;
+    prediction?: {
+        type: 'content';
+        content: string | ChatCompletionContentPartText[];
+    } | null;
+    /** Store for later retrieval via the stored-completion endpoints. Glexir defaults this to `false`. */
+    store?: boolean | null;
+    metadata?: Metadata | null;
+    service_tier?: ServiceTier | null;
+    stream_options?: {
+        include_usage?: boolean;
+        include_obfuscation?: boolean;
+    } | null;
+    moderation?: ModerationConfig | null;
+    prompt_cache_key?: string | null;
+    prompt_cache_options?: PromptCacheOptions | null;
+    /** @deprecated Use `prompt_cache_options.ttl`. */
+    prompt_cache_retention?: 'in_memory' | '24h' | null;
+    /** Stable hashed end-user ID used for abuse detection. */
+    safety_identifier?: string | null;
+    /** @deprecated */
+    seed?: number | null;
+    /** @deprecated Use `safety_identifier` and `prompt_cache_key`. */
+    user?: string;
+    web_search_options?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface ChatCompletionCreateParamsNonStreaming extends ChatCompletionCreateParamsBase {
+    stream?: false | null;
+}
+export interface ChatCompletionCreateParamsStreaming extends ChatCompletionCreateParamsBase {
+    stream: true;
+}
+export type ChatCompletionCreateParams = ChatCompletionCreateParamsNonStreaming | ChatCompletionCreateParamsStreaming;
+export interface ChatCompletionTokenLogprob {
+    token: string;
+    bytes: number[] | null;
+    logprob: number;
+    top_logprobs: Array<{
+        token: string;
+        bytes: number[] | null;
+        logprob: number;
+    }>;
+}
+export interface ChatCompletionMessage {
+    role: 'assistant';
+    content: string | null;
+    refusal: string | null;
+    tool_calls?: ChatCompletionMessageToolCall[];
+    annotations?: Array<{
+        type: 'url_citation';
+        url_citation: {
+            start_index: number;
+            end_index: number;
+            title: string;
+            url: string;
+        };
+    }>;
+}
+export type ChatCompletionFinishReason = 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
+export interface CompletionUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+        cache_write_tokens?: number;
+        image_tokens?: number;
+        text_tokens?: number;
+        audio_tokens?: number;
+        [key: string]: unknown;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+        accepted_prediction_tokens?: number;
+        rejected_prediction_tokens?: number;
+        text_tokens?: number;
+        audio_tokens?: number;
+        [key: string]: unknown;
+    };
+}
+export interface ChatCompletionChoice {
+    index: number;
+    finish_reason: ChatCompletionFinishReason;
+    logprobs: {
+        content: ChatCompletionTokenLogprob[] | null;
+        refusal: ChatCompletionTokenLogprob[] | null;
+    } | null;
+    message: ChatCompletionMessage;
+}
+export interface ChatCompletion {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage?: CompletionUsage;
+    /** The tier actually used to serve (and bill) this completion. */
+    service_tier?: ServiceTier | null;
+    metadata?: Metadata | null;
+    moderation?: {
+        input: ModerationResults | ModerationError;
+        output: ModerationResults | ModerationError;
+    } | null;
+    /** @deprecated */
+    system_fingerprint?: string;
+    _request_id?: string | null;
+}
+export interface ChatCompletionChunkToolCallDelta {
+    index: number;
+    id?: string;
+    type?: 'function' | 'custom';
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+    custom?: {
+        name?: string;
+        input?: string;
+    };
+}
+export interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
+            content?: string | null;
+            refusal?: string | null;
+            tool_calls?: ChatCompletionChunkToolCallDelta[];
+        };
+        finish_reason: ChatCompletionFinishReason | null;
+        logprobs?: {
+            content: ChatCompletionTokenLogprob[] | null;
+            refusal: ChatCompletionTokenLogprob[] | null;
+        } | null;
+    }>;
+    /** Present only on the final chunk when `stream_options.include_usage` is set. */
+    usage?: CompletionUsage | null;
+    service_tier?: ServiceTier | null;
+    moderation?: Record<string, unknown> | null;
+    obfuscation?: string;
+    /** @deprecated */
+    system_fingerprint?: string;
+    error?: ErrorObject;
+}
+export interface ChatCompletionUpdateParams {
+    metadata: Metadata | null;
+}
+export interface ChatCompletionListParams {
+    after?: string;
+    limit?: number;
+    /** Filter by metadata key/value pairs. */
+    metadata?: Metadata | null;
+    model?: string;
+    /** Defaults to `asc`. */
+    order?: 'asc' | 'desc';
+}
+export interface ChatCompletionDeleted {
+    id: string;
+    deleted: boolean;
+    object: 'chat.completion.deleted';
+}
+export interface ChatCompletionStoreMessage extends ChatCompletionMessage {
+    id: string;
+    content_parts?: Array<ChatCompletionContentPartText | ChatCompletionContentPartImage> | null;
+}
+export interface MessageListParams {
+    after?: string;
+    limit?: number;
+    order?: 'asc' | 'desc';
+}
+export type { CustomToolInputFormat };

package/dist/types/chat.js

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

package/dist/types/chat.js.map

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

package/dist/types/conversations.d.ts

@@ -0,0 +1,46 @@
+import type { Metadata } from './shared.js';
+import type { ResponseIncludable, ResponseInputItem, ResponseItem } from './responses.js';
+export interface Conversation {
+    id: string;
+    object: 'conversation';
+    created_at: number;
+    metadata: Metadata | null;
+    _request_id?: string | null;
+}
+export interface ConversationCreateParams {
+    /** Initial items, at most 20 per call. */
+    items?: ResponseInputItem[] | null;
+    metadata?: Metadata | null;
+}
+export interface ConversationUpdateParams {
+    metadata: Metadata | null;
+}
+export interface ConversationDeleted {
+    id: string;
+    deleted: boolean;
+    object: 'conversation.deleted';
+}
+/** Items persisted in a conversation. Conversation messages may also use a plain `text` content part. */
+export type ConversationItem = ResponseItem;
+export interface ConversationItemList {
+    object: 'list';
+    data: ConversationItem[];
+    first_id: string;
+    last_id: string;
+    has_more: boolean;
+}
+export interface ItemCreateParams {
+    /** At most 20 items per call. */
+    items: ResponseInputItem[];
+    include?: ResponseIncludable[];
+}
+export interface ItemListParams {
+    after?: string;
+    limit?: number;
+    /** Defaults to `desc`. */
+    order?: 'asc' | 'desc';
+    include?: ResponseIncludable[];
+}
+export interface ItemRetrieveParams {
+    include?: ResponseIncludable[];
+}

package/dist/types/conversations.js

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

package/dist/types/conversations.js.map

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

package/dist/types/platform.d.ts

@@ -0,0 +1,151 @@
+import type { Uploadable } from '../core/multipart.js';
+import type { Metadata } from './shared.js';
+export type EmbeddingModel = 'text-embedding-3-small' | 'text-embedding-3-large' | 'text-embedding-ada-002' | (string & {});
+export interface EmbeddingCreateParams {
+    model: EmbeddingModel;
+    /** Each input ≤8192 tokens; arrays ≤2048 entries; ≤300,000 tokens per request. */
+    input: string | string[] | number[] | number[][];
+    /** Output size (text-embedding-3 models only). */
+    dimensions?: number;
+    /**
+     * Omit to receive `number[]` vectors: the SDK requests compact base64 and decodes it.
+     * Pass `"base64"` to receive the raw base64 strings.
+     */
+    encoding_format?: 'float' | 'base64';
+    user?: string;
+    [key: string]: unknown;
+}
+export interface Embedding<TVector = number[]> {
+    object: 'embedding';
+    index: number;
+    embedding: TVector;
+}
+export interface CreateEmbeddingResponse<TVector = number[]> {
+    object: 'list';
+    data: Array<Embedding<TVector>>;
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+    _request_id?: string | null;
+}
+/** `user_data` for model inputs (PDFs, images), `batch` for batch JSONL. */
+export type FilePurpose = 'user_data' | 'batch' | 'vision' | 'assistants' | 'fine-tune' | 'evals' | (string & {});
+export interface FileObject {
+    id: string;
+    object: 'file';
+    bytes: number;
+    created_at: number;
+    filename: string;
+    purpose: 'user_data' | 'batch' | 'batch_output' | 'vision' | 'assistants' | 'assistants_output' | 'fine-tune' | 'fine-tune-results' | (string & {});
+    expires_at?: number;
+    /** @deprecated */
+    status?: 'uploaded' | 'processed' | 'error';
+    /** @deprecated */
+    status_details?: string;
+    _request_id?: string | null;
+}
+export interface FileCreateParams {
+    /** At most 512 MB; batch input must be `.jsonl` and ≤200 MB. */
+    file: Uploadable;
+    purpose: FilePurpose;
+    /** Batch files expire after 30 days by default; others persist until deleted. */
+    expires_after?: {
+        anchor: 'created_at';
+        seconds: number;
+    };
+}
+export interface FileListParams {
+    after?: string;
+    limit?: number;
+    order?: 'asc' | 'desc';
+    purpose?: string;
+}
+export interface FileDeleted {
+    id: string;
+    deleted: boolean;
+    object: 'file';
+}
+/** Endpoints Glexir accepts in batch input files. */
+export type BatchEndpoint = '/v1/responses' | '/v1/chat/completions' | '/v1/embeddings';
+export interface BatchCreateParams {
+    /** A `.jsonl` file uploaded with purpose `batch`. One model per file, ≤50,000 requests. */
+    input_file_id: string;
+    endpoint: BatchEndpoint;
+    completion_window: '24h';
+    metadata?: Metadata | null;
+    output_expires_after?: {
+        anchor: 'created_at';
+        seconds: number;
+    };
+}
+export type BatchStatus = 'validating' | 'failed' | 'in_progress' | 'finalizing' | 'completed' | 'expired' | 'cancelling' | 'cancelled';
+export interface Batch {
+    id: string;
+    object: 'batch';
+    endpoint: string;
+    input_file_id: string;
+    completion_window: string;
+    status: BatchStatus;
+    created_at: number;
+    output_file_id?: string;
+    error_file_id?: string;
+    errors?: {
+        object?: string;
+        data?: Array<{
+            code?: string;
+            line?: number | null;
+            message?: string;
+            param?: string | null;
+        }>;
+    };
+    request_counts?: {
+        total: number;
+        completed: number;
+        failed: number;
+    };
+    usage?: {
+        input_tokens: number;
+        input_tokens_details: {
+            cached_tokens: number;
+        };
+        output_tokens: number;
+        output_tokens_details: {
+            reasoning_tokens: number;
+        };
+        total_tokens: number;
+    };
+    model?: string;
+    metadata?: Metadata | null;
+    in_progress_at?: number;
+    finalizing_at?: number;
+    completed_at?: number;
+    failed_at?: number;
+    expired_at?: number;
+    expires_at?: number;
+    cancelling_at?: number;
+    cancelled_at?: number;
+    _request_id?: string | null;
+}
+export interface BatchListParams {
+    after?: string;
+    limit?: number;
+}
+/** One line of a batch input file. */
+export interface BatchRequestLine<TBody = Record<string, unknown>> {
+    /** Unique within the file; output lines may come back in any order, so join on this. */
+    custom_id: string;
+    method: 'POST';
+    url: BatchEndpoint;
+    body: TBody;
+}
+export interface Model {
+    id: string;
+    object: 'model';
+    created: number;
+    owned_by: string;
+    /** Set when the model is scheduled to shut down. */
+    shutdown_date?: string | null;
+    _request_id?: string | null;
+}

package/dist/types/platform.js

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

package/dist/types/platform.js.map

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