llmagon

Minimal client for chat-completions style inference APIs with:

• Synchronous and streaming generation
• Tool/function calling
• Many configurable controls
• Structured response schemas
• Lightweight message builders

Quick start

import { AIConfig, Message } from "llmagon"

const ai = new AIConfig()

ai.token = process.env.OPENAI_API_KEY
ai.model = "gpt-5.3"
ai.endpoint = "https://api.openai.com/v1/chat/completions"

const response = await ai.get([
	Message.System("You are a concise assistant."),
	Message.User("Explain mutexes in one paragraph.")
])

console.log(response.reasoning)
console.log(response.content)
console.log(response.stopReason)

All exports

export type StopReason = "tool_call" | "stop" | "length" | "content_filter"

export type InferenceResponse = {content: string, stopReason: StopReason, tools: ToolCall[] | null}
type StreamResponse = {content: string, stopReason: StopReason, tools: ToolCall[] | null, stream: AsyncGenerator<string>}
type StreamResponse2 = {content: string, stopReason: StopReason, tools: ToolCall[] | null, done: Promise<StreamResponse>}

export class AIConfig{
	token: string
	endpoint: string
	model: string
	maxTokens: number
	temperature: number
	frequencyPenalty: number
	presencePenalty: number
	reasoningEffort: string
	verbosity: string
	tools: ResponseSchema[]
	responseSchema: ResponseSchema | null
	get(history: Message[]): Promise<InferenceResponse>
	/** AsyncGenerator-style */
	stream(history: Message[]): StreamResponse
	/** Callback-style (if you don't like async generators) */
	stream(history: Message[], streamCb: (type: string, content: string) => any | null): StreamResponse2

	onUsage: ((usage_object: any) => any) | null
}

export type Role = "assistant" | "user" | "system" | "tool"
export abstract class Message{
	name: string
	role: Role
	content: string

	static User(content: string, name?: string): Message
	static Assistant(content: string, reasoning?: string, name?: string): Message
	static Assistant(from: {content?: string, reasoning?: string}, name?: string): Message
	static System(content: string, name?: string): Message
	static Tool(content: string, forCall: ToolCall): Message
	static fromJson(obj: any): Message
}
export abstract class ToolCall{
	type: string
	name: string
	param: string
	id: string
}
/** Opaque */
export type ResponseSchema = string
export function ResponseSchema(name: string, description: string, param: object, strict: boolean): ResponseSchema
export namespace ResponseSchema{
	/** For response types that can be any valid JSON */
	const ANY: ResponseSchema
}