glove-core

Complete API reference for the core runtime package. Contains the agent loop, tool execution engine, display manager, context management, model adapters, and all foundational types.

Glove

The top-level builder and runtime entry point. Use the builder pattern to register tools and subscribers, then call build() to produce a runnable agent.

import { Glove } from "glove-core";
import { z } from "zod";

const agent = new Glove({
  store,
  model,
  displayManager,
  systemPrompt: "You are a helpful assistant.",
  compaction_config: {
    compaction_instructions: "Summarize the conversation.",
    max_turns: 30,
  },
})
  .fold({
    name: "get_weather",
    description: "Get weather for a city.",
    inputSchema: z.object({ city: z.string() }),
    async do(input) {
      const res = await fetch(`https://api.weather.example/v1?city=${input.city}`);
      return res.json();
    },
  })
  .build();

const result = await agent.processRequest("What is the weather in Tokyo?");

Constructor

new Glove(config: GloveConfig)

GloveConfig

Methods

Properties

GloveFoldArgs

IGloveRunnable

The interface returned by build(). Represents a fully configured, ready-to-run agent.

DisplayManager

Manages the display stack: a ordered collection of UI slots that tools push and users resolve. Implements DisplayManagerAdapter.

import { DisplayManager } from "glove-core";

const dm = new DisplayManager();

dm.subscribe((stack) => {
  console.log("Display stack changed:", stack);
});

Methods

DisplayManagerAdapter Interface

The interface that DisplayManager implements. Any custom display manager must conform to this shape.

Slot

Represents a single entry on the display stack. Pushed by tools, rendered by the UI layer.

Renderer

A named renderer definition registered with the display manager.

Context

Wraps a StoreAdapter and provides a simplified interface for reading and writing conversation data, messages, and tasks.

import { Context } from "glove-core";

const ctx = new Context(store);
const messages = await ctx.getMessages();
await ctx.appendMessages([{ sender: "user", text: "Hello" }]);

Constructor

new Context(store: StoreAdapter)

Methods

PromptMachine

Manages model prompting: sends messages and tool definitions to the model adapter and collects the response. Notifies subscribers of streaming events.

import { PromptMachine } from "glove-core";

const pm = new PromptMachine(model, ctx, "You are a helpful assistant.");
pm.addSubscriber(subscriber);
const result = await pm.run(messages, tools);

Constructor

new PromptMachine(model: ModelAdapter, ctx: Context, systemPrompt: string)

Methods

Executor

The tool execution engine. Maintains a registry of tools and a call stack. Executes tool calls from the model, validates inputs, handles errors, and returns results.

import { Executor } from "glove-core";

const executor = new Executor(3, store);
executor.registerTool(myTool);
executor.addSubscriber(subscriber);

executor.addToolCallToStack({ tool_name: "get_weather", input_args: { city: "Tokyo" } });
const results = await executor.executeToolStack();

Constructor

new Executor(MAX_RETRIES?: number, store?: StoreAdapter)

Properties

Methods

Observer

Monitors the context window size and triggers compaction when limits are exceeded. Tracks turn counts and token consumption.

import { Observer } from "glove-core";

const observer = new Observer(
  store,
  ctx,
  promptMachine,
  "Summarize the conversation so far.",
  30,   // max turns
  100000 // context compaction token limit
);

await observer.turnComplete();
await observer.tryCompaction();

Constructor

new Observer(store: StoreAdapter, ctx: Context, prompt: PromptMachine, compaction_instructions: string, max_turns?: number, context_compaction_limit?: number)

Properties

Methods

Agent

Orchestrates the core agent loop: prompt the model, check for tool calls, execute tools, feed results back, repeat until the model responds with text only.

import { Agent } from "glove-core";

const agent = new Agent(store, executor, context, observer, promptMachine);
const result = await agent.ask(userMessage);

Constructor

new Agent(store: StoreAdapter, executor: Executor, context: Context, observer: Observer, prompt_machine: PromptMachine)

Methods

AbortError

Custom error class thrown when an agent request is aborted via an AbortSignal. Has name set to "AbortError".

import { AbortError } from "glove-core";

try {
  await agent.processRequest("Hello", signal);
} catch (err) {
  if (err instanceof AbortError) {
    console.log("Request was aborted.");
  }
}

Constructor

new AbortError(message?: string)

ModelAdapter

Interface for language model providers. Implement this to connect any LLM to Glove.

interface ModelAdapter {
  name: string;
  prompt(
    request: PromptRequest,
    notify: NotifySubscribersFunction,
    signal?: AbortSignal
  ): Promise<ModelPromptResult>;
  setSystemPrompt(systemPrompt: string): void;
}

PromptRequest

ModelPromptResult

StoreAdapter

Interface for conversation persistence. Implement this to store messages, token counts, tasks, and permissions in any backend.

interface StoreAdapter {
  identifier: string;
  getMessages(): Promise<Message[]>;
  appendMessages(msgs: Message[]): Promise<void>;
  getTokenCount(): Promise<number>;
  addTokens(count: number): Promise<void>;
  getTurnCount(): Promise<number>;
  incrementTurn(): Promise<void>;
  resetHistory(): Promise<void>;
  // Optional:
  getTasks?(): Promise<Task[]>;
  addTasks?(tasks: Task[]): Promise<void>;
  updateTask?(taskId: string, updates: Partial<Task>): Promise<void>;
  getPermission?(toolName: string): Promise<PermissionStatus>;
  setPermission?(toolName: string, status: PermissionStatus): Promise<void>;
}

SubscriberAdapter

Interface for observing agent events. Subscribers receive streaming text deltas, tool invocations, tool results, and model response completions.

interface SubscriberAdapter {
  record(event_type: string, data: any): Promise<void>;
}

Subscriber Events

The following events are emitted by the system and received by subscribers via the record method.

Message

Represents a single message in the conversation history.

interface Message {
  sender: "user" | "agent";
  id?: string;
  text: string;
  content?: ContentPart[];
  tool_results?: ToolResult[];
  tool_calls?: ToolCall[];
}

ContentPart

Represents a multimodal content element within a message.

interface ContentPart {
  type: "text" | "image" | "video" | "document";
  text?: string;
  source?: {
    type: string;
    media_type: string;
    data?: string;
    url?: string;
  };
}

Tool

The core tool interface used by the Executor. This is the runtime representation, distinct from ToolConfig in glove-react which adds the render property.

ToolCall

ToolResult

Task

Represents a tracked task in the agent's task list.

TaskStatus

type TaskStatus = "pending" | "in_progress" | "completed";

PermissionStatus

type PermissionStatus = "granted" | "denied" | "unset";

Function Types

CompactionConfig

Built-in Task Tool

The framework provides a built-in tool for task management. It is automatically registered when the store supports tasks (implements getTasks, addTasks, updateTask).

import { createTaskTool } from "glove-core";

const taskTool = createTaskTool(context);
// taskTool.name === "glove_update_tasks"

Signature

function createTaskTool(context: Context): Tool<TaskToolInput>

TaskToolInput

The tool name is glove_update_tasks. The model calls it to create, update, or complete tasks. Each invocation sends the full current task list, enabling additions, status changes, and removals in a single call.

Providers

The glove-core/models/providers module exports factory functions for creating model adapters from supported providers.

import { createAdapter, getAvailableProviders } from "glove-core/models/providers";

const model = createAdapter({
  provider: "anthropic",
  model: "claude-sonnet-4-20250514",
  maxTokens: 4096,
  stream: true,
});

const available = getAvailableProviders();
// [{ id: "openai", name: "OpenAI", ... }, ...]

createAdapter

function createAdapter(opts: CreateAdapterOptions): ModelAdapter

CreateAdapterOptions

getAvailableProviders

Returns an array of provider configurations that have API keys available in the current environment.

function getAvailableProviders(): ProviderConfig[]

Supported Providers

Each provider has properties: id, name, baseURL, envVar, defaultModel, models[], format (either "openai" or "anthropic"), and defaultMaxTokens.