glove-core

import { Glove, MemoryStore, Displaymanager, createAdapter } from "glove-core";
import { z } from "zod";

const agent = new Glove({
  store: new MemoryStore("session-1"),
  model: createAdapter({ provider: "anthropic" }),
  displayManager: new 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 { status: "success", data: await res.json() };
    },
  })
  .build();

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

import { Displaymanager } from "glove-core/display-manager";

const dm = new Displaymanager();

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

import { Context } from "glove-core";

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

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);

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();

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();

import { Agent } from "glove-core";

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

import { AbortError } from "glove-core";

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

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

type SubscriberEvent =
  | { type: "text_delta"; text: string }
  | { type: "tool_use"; id: string; name: string; input: unknown }
  | { type: "model_response"; text: string; tool_calls?: ToolCall[];
      stop_reason?: string; tokens_in?: number; tokens_out?: number }
  | { type: "model_response_complete"; text: string; tool_calls?: ToolCall[];
      stop_reason?: string; tokens_in?: number; tokens_out?: number }
  | { type: "tool_use_result"; tool_name: string; call_id?: string;
      result: ToolResultData }
  | { type: "compaction_start"; current_token_consumption: number }
  | { type: "compaction_end"; current_token_consumption: number;
      summary_message: Message }
  | { type: "token_consumption"; consumption: TokenConsumptionCounter }
  | { type: "hook_invoked"; name: string }
  | { type: "skill_invoked"; name: string; source: "user" | "agent"; args?: string }
  | { type: "subagent_invoked"; name: string; prompt: string }
  | { type: "subagent_completed"; name: string; status: "success" | "error"; message?: string };

type SubscriberEventDataMap = {
  [E in SubscriberEvent as E["type"]]: Omit<E, "type">;
};

// Example: SubscriberEventDataMap["text_delta"] = { text: string }

interface SubscriberAdapter {
  record: <T extends SubscriberEvent["type"]>(
    event_type: T,
    data: SubscriberEventDataMap[T],
  ) => Promise<void>;
}

import type { ModelAdapter, NotifySubscribersFunction, PromptRequest, ModelPromptResult } from "glove-core";

class MyAdapter implements ModelAdapter {
  name = "my-provider:model-name";
  private systemPrompt?: string;

  setSystemPrompt(systemPrompt: string) {
    this.systemPrompt = systemPrompt;
  }

  async prompt(
    request: PromptRequest,
    notify: NotifySubscribersFunction,
    signal?: AbortSignal,
  ): Promise<ModelPromptResult> {
    // ... call your LLM API ...

    // Non-streaming: emit a single model_response event
    await notify("model_response", {
      text: responseText,
      tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
      stop_reason: finishReason ?? undefined,
      tokens_in: usage.promptTokens,
      tokens_out: usage.completionTokens,
    });

    return { messages: [message], tokens_in: ..., tokens_out: ... };
  }
}

// During streaming — emit text fragments as they arrive
notify("text_delta", { text: chunk });

// When a tool call is fully assembled
await notify("tool_use", { id: toolCallId, name: toolName, input: parsedArgs });

// After the stream completes — emit the final aggregated response
await notify("model_response_complete", {
  text: fullText,
  tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
  stop_reason: finishReason ?? undefined,
});

interface StoreAdapter {
  identifier: string;
  getMessages(): Promise<Message[]>;
  appendMessages(msgs: Message[]): Promise<void>;
  getTokenCount(): Promise<number>;
  addTokens(args: TokenConsumptionCounter): Promise<void>;
  getTurnCount(): Promise<number>;
  incrementTurn(): Promise<void>;
  resetCounters(): Promise<void>;
  // Optional — tasks:
  getTasks?(): Promise<Task[]>;
  addTasks?(tasks: Task[]): Promise<void>;
  updateTask?(taskId: string, updates: Partial<Task>): Promise<void>;
  // Optional — permissions:
  getPermission?(toolName: string): Promise<PermissionStatus>;
  setPermission?(toolName: string, status: PermissionStatus): Promise<void>;
  // Optional — inbox:
  getInboxItems?(): Promise<InboxItem[]>;
  addInboxItem?(item: InboxItem): Promise<void>;
  updateInboxItem?(
    itemId: string,
    updates: Partial<Pick<InboxItem, "status" | "response" | "resolved_at">>,
  ): Promise<void>;
  getResolvedInboxItems?(): Promise<InboxItem[]>;
  // Optional — subagent stores:
  createSubAgentStore?(namespace: string, durable?: boolean): Promise<StoreAdapter>;
}

interface TokenConsumptionCounter {
  tokens_in: number;
  tokens_out: number;
}

import { MemoryStore } from "glove-core";

const store = new MemoryStore("session-1");

// Sub-stores
const ephemeral = await store.createSubAgentStore("reviewer");           // fresh per call
const durable = await store.createSubAgentStore("planner", true);        // cached per namespace

interface SubscriberAdapter {
  record: <T extends SubscriberEvent["type"]>(
    event_type: T,
    data: SubscriberEventDataMap[T],
  ) => Promise<void>;
}

interface Message {
  sender: "user" | "agent";
  id?: string;
  text: string;
  pre_modified_text?: string;
  content?: ContentPart[];
  tool_results?: ToolResult[];
  tool_calls?: ToolCall[];
  is_compaction?: boolean;
  is_compaction_request?: boolean;
  is_skill_injection?: boolean;
  reasoning_content?: string;
}

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

interface ToolResultData {
  status: "success" | "error" | "aborted";
  data: unknown;                 // Sent to the AI model
  message?: string;              // Error / abort message
  renderData?: unknown;          // Client-only — NOT sent to model, used by renderResult
  summary?: string;              // Set by the Executor from generateSummary — swapped in for data in older context when enableToolResultSummary is on
  generateSummaryArgs?: unknown; // Opaque args passed to the tool's generateSummary handler
}

import { z } from "zod";
import type { GloveFoldArgs } from "glove-core";

export const readFile: GloveFoldArgs<{ path: string; from?: number; to?: number }> = {
  name: "read_file",
  description: "Read a slice of a file.",
  inputSchema: z.object({
    path: z.string(),
    from: z.number().optional(),
    to: z.number().optional(),
  }),
  async do(input) {
    const content = await fs.readFile(input.path, "utf8");
    const slice = sliceLines(content, input.from, input.to);
    return {
      status: "success",
      data: slice,
      // What the summary handler needs to describe this call later.
      generateSummaryArgs: { path: input.path, from: input.from, to: input.to, lineCount: slice.split("\n").length },
    };
  },
  async generateToolSummary(args) {
    const { path, from, to, lineCount } = args as { path: string; from?: number; to?: number; lineCount: number };
    const range = from != null || to != null ? ` lines ${from ?? 1}-${to ?? "EOF"}` : "";
    return `Read ${path}${range} (${lineCount} lines).`;
  },
};

const agent = new Glove({
  store: new MemoryStore("session"),
  model: createAdapter({ provider: "anthropic" }),
  displayManager: new Displaymanager(),
  systemPrompt: "You are a helpful assistant.",
  compaction_config: { compaction_instructions: "Summarize so far." },
  enableToolResultSummary: true,
})
  .fold(readFile)
  .build();

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

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

import { createTaskTool } from "glove-core";

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

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

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", ... }, ...]

function createAdapter(opts: CreateAdapterOptions): ModelAdapter

interface OpenAICompatReasoningOptions {
  /** Wrap reasoning in <think>...</think> and prepend to visible text. Default false. */
  includeInText?: boolean;
  /** Echo Message.reasoning_content back on tool-calling turns. Default true. */
  echo?: boolean;
  /** Top-level reasoning_effort request field. */
  effort?: "minimal" | "low" | "medium" | "high";
  /** OpenRouter-style reasoning object — sent verbatim. */
  reasoningObject?: {
    effort?: "low" | "medium" | "high";
    max_tokens?: number;
    exclude?: boolean;
    enabled?: boolean;
  };
  /** Anthropic-style thinking object — for OpenAI shims that forward it. */
  thinking?: { type: "enabled" | "disabled"; budget_tokens?: number };
  /** Escape hatch — merged into request body. For Qwen3 dashscope's enable_thinking etc. */
  extraBody?: Record<string, unknown>;
}

// Sensible defaults: capture + echo on tool-calling turns.
createAdapter({ provider: "openai", reasoning: true });

// Hint thinking depth — DeepSeek V4, GLM, MiniMax, Kimi, GPT-5/o-series.
createAdapter({ provider: "openai", reasoning: { effort: "high" } });

// OpenRouter's unified reasoning object.
createAdapter({
  provider: "openrouter",
  reasoning: { reasoningObject: { effort: "high", max_tokens: 2000 } },
});

// Qwen3 dashscope's enable_thinking.
createAdapter({
  provider: "openai",
  baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
  reasoning: { extraBody: { enable_thinking: true, thinking_budget: 1024 } },
});

// Surface reasoning in the visible message text.
createAdapter({ provider: "openai", reasoning: { includeInText: true } });

// Disable echo (DeepSeek-R1 specifically — newer V4 needs echo on).
createAdapter({ provider: "openai", reasoning: { echo: false } });

function getAvailableProviders(): Array<{ id: string; name: string; available: boolean; models: string[]; defaultModel: string }>

const model = createAdapter({
  provider: "ollama",
  model: "llama3",
  baseURL: "http://localhost:9999/v1", // optional, defaults to :11434
});