Chat Completions

Chat Completions generates a model reply from a list of messages. Glexir supports it for compatibility with existing code. For new work, use the Responses API: it is required for -pro models and for tool calling on gpt-6-astra and gpt-6.1-sol.

The endpoint is OpenAI-compatible: POST https://api.glexir.com/v1/chat/completions.

Create a completion

import Glexir from "@glexir/sdk";

const glexir = new Glexir({ apiKey: process.env.GLEXIR_API_KEY });

const completion = await glexir.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [
    { role: "developer", content: "You are terse." },
    { role: "user", content: "Name three planets." },
  ],
});

console.log(completion.choices[0]?.message.content);
console.log(completion.usage);

glexir.chat.completions.create(body, options?) returns APIPromise<ChatCompletion>. With stream: true it returns APIPromise<Stream<ChatCompletionChunk>>.

Operations

Every method takes request options as its last argument: { signal, timeout, maxRetries, headers, idempotencyKey }.

Create parameters

ChatCompletionCreateParams is ChatCompletionCreateParamsNonStreaming | ChatCompletionCreateParamsStreaming. Both extend ChatCompletionCreateParamsBase. Unknown fields are sent unchanged.

The gateway also rejects audio and modalities that include "audio" (audio output is not supported).

Messages

Every role except tool takes an optional name. User content parts:

• { type: "text", text }
• { type: "image_url", image_url: { url, detail? } }, where url is an http(s) URL or a data: URL and detail is auto, low, high or original.
• { type: "file", file: { file_data?, file_id?, filename? } } for PDFs and other files. file_id must be a file you uploaded through Glexir; any other ID returns 404.

Text, image and file parts accept prompt_cache_breakpoint: { mode: "explicit" }.

import Glexir from "@glexir/sdk";

const glexir = new Glexir();

const completion = await glexir.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "What is in this image?" },
        { type: "image_url", image_url: { url: "https://example.com/cat.png", detail: "auto" } },
      ],
    },
  ],
});

console.log(completion.choices[0]?.message.content);

The gateway returns 400 unsupported_on_glexir for messages with an audio field and for input_audio content parts. An empty messages array returns 400.

The ChatCompletion object

Streaming

Set stream: true on create() for a raw Stream<ChatCompletionChunk>, or use chat.completions.stream() for a helper that assembles the final completion. Both are covered in Streaming.

import Glexir from "@glexir/sdk";

const glexir = new Glexir();

const stream = await glexir.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [{ role: "user", content: "Count to five." }],
  stream: true,
  stream_options: { include_usage: true },
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta.content ?? "");
  if (chunk.usage) console.log("\n", chunk.usage);
}

curl -N https://api.glexir.com/v1/chat/completions \
  -H "Authorization: Bearer $GLEXIR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [{ "role": "user", "content": "Count to five." }],
    "stream": true,
    "stream_options": { "include_usage": true }
  }'

include_usage

With stream_options: { include_usage: true }, the last chunk before [DONE] has an empty choices array and a usage object. Guard chunk.choices[0] as above.

Glexir always turns include_usage on when it talks to OpenAI, because it bills streams from that chunk. If you didn't ask for it, the gateway removes the usage chunk before it reaches you. If a stream ends without usage (for example, the upstream fails), Glexir bills an estimate of the input tokens only.

ChatCompletionChunk has id, object: "chat.completion.chunk", created, model, choices (each with index, delta, finish_reason and logprobs?), and usage?, service_tier?, obfuscation? and error?. A delta has role?, content?, refusal? and tool_calls? fragments.

Tools

Chat Completions accepts function and custom tools:

• ChatCompletionFunctionTool: { type: "function", function: { name, description?, parameters?, strict? } }. Chat Completions is non-strict unless you set strict: true.
• ChatCompletionCustomTool: { type: "custom", custom: { name, description?, format? } }. format is { type: "text" } or { type: "grammar", grammar: { definition, syntax: "lark" | "regex" } }. The grammar is nested under grammar, unlike the Responses API.

Any other tool type, and any tool_choice type other than function, custom or allowed_tools, returns 400 unsupported_on_glexir. That includes OpenAI-hosted tools such as web search.

import Glexir, { type ChatCompletionMessageParam, type ChatCompletionTool } from "@glexir/sdk";

const glexir = new Glexir();

const tools: ChatCompletionTool[] = [
  {
    type: "function",
    function: {
      name: "get_weather",
      description: "Current temperature for a city.",
      parameters: {
        type: "object",
        properties: { city: { type: "string" } },
        required: ["city"],
        additionalProperties: false,
      },
      strict: true,
    },
  },
];

const messages: ChatCompletionMessageParam[] = [{ role: "user", content: "What's the weather in Lagos?" }];
const first = await glexir.chat.completions.create({ model: "gpt-5.4-mini", reasoning_effort: "none", messages, tools });
const reply = first.choices[0]?.message;

if (reply?.tool_calls) {
  messages.push({ role: "assistant", content: reply.content, tool_calls: reply.tool_calls });
  for (const call of reply.tool_calls) {
    if (call.type !== "function") continue;
    const { city } = JSON.parse(call.function.arguments) as { city: string };
    messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify({ city, celsius: 31 }) });
  }
  const second = await glexir.chat.completions.create({ model: "gpt-5.4-mini", reasoning_effort: "none", messages, tools });
  console.log(second.choices[0]?.message.content);
}

Structured output

chat.completions.parse(body, options?) creates a completion and parses each choice's message.content when response_format.type is json_schema or json_object. It also parses the arguments of function tools that have strict: true.

import Glexir, { toStrictJsonSchema } from "@glexir/sdk";

const glexir = new Glexir();

interface City {
  name: string;
  country: string;
}

const schema = toStrictJsonSchema({
  type: "object",
  properties: { name: { type: "string" }, country: { type: "string" } },
  required: ["name", "country"],
});

const completion = await glexir.chat.completions.parse<City>({
  model: "gpt-5.4-mini",
  messages: [{ role: "user", content: "Which city is the Eiffel Tower in?" }],
  response_format: { type: "json_schema", json_schema: { name: "city", schema, strict: true } },
});

console.log(completion.choices[0]?.message.parsed?.country);

It returns ParsedChatCompletion<T>:

• Each choices[].message is a ParsedChatCompletionMessage<T> with parsed: T | null. parsed is null when the model refused or the format is not JSON.
• Function tool calls are ParsedFunctionToolCall: { id, type: "function", function: { name, arguments, parsed_arguments } }. parsed_arguments is the parsed JSON for strict tools and null otherwise.
• It throws LengthFinishReasonError if any choice has finish_reason: "length", and ContentFilterFinishReasonError for "content_filter".
• options is ParseOptions<T>: request options plus validate?: (value: unknown) => T.

Stored completions

Create a completion with store: true to keep it. You can then retrieve, update, list and delete it, and list its messages. These endpoints only see completions created through your Glexir organization; any other ID returns 404 (No chat completion found with id '...').

Glexir tags each stored completion with one metadata key, glexir_customer, to keep your list separate from other organizations. It removes that key from every response, and it counts toward the 16-key limit: a stored completion can have at most 15 of your own keys, or the request returns 400.

import Glexir from "@glexir/sdk";

const glexir = new Glexir();

const created = await glexir.chat.completions.create({
  model: "gpt-5.4-mini",
  messages: [{ role: "user", content: "Hello" }],
  store: true,
  metadata: { project: "onboarding" },
});

const stored = await glexir.chat.completions.retrieve(created.id);
await glexir.chat.completions.update(created.id, { metadata: { project: "onboarding", reviewed: "yes" } });

for await (const completion of glexir.chat.completions.list({ metadata: { project: "onboarding" } })) {
  console.log(completion.id);
}

for await (const message of glexir.chat.completions.messages.list(created.id)) {
  console.log(message.id, message.content);
}

const deleted = await glexir.chat.completions.delete(created.id);
console.log(stored.id, deleted.deleted);

Errors

See HTTP error codes and Errors & retries.