Tools, MCP and memory

import { Effect } from "effect";
import { defineSharedTool } from "glove-foundry";
import { z } from "zod";

const lookupOrder = defineSharedTool({
  description: "Look up an order in a regional order system",
  config: z.object({
    region: z.enum(["us", "eu"]),
    includeHistory: z.boolean().default(false),
  }),
  create: ({ config, agentId }) =>
    Effect.succeed({
      name: "lookup_order",
      description: `Look up an order in the ${config.region.toUpperCase()} order system`,
      inputSchema: z.object({ orderId: z.string() }),
      async do({ orderId }) {
        // your code: call the order API for config.region
        return { status: "success" as const, data: { orderId, region: config.region, agentId } };
      },
    }),
});

export default lookupOrder;

import { Effect } from "effect";
import { defineApp } from "glove-foundry";
import { z } from "zod";

const helpdesk = defineApp({
  description: "Read and update tickets in one helpdesk queue",
  config: z.object({ queue: z.string(), retries: z.number().default(2) }),
  // inbound: [tickets], outbound: [tickets] — see Apps & transmissions
  install: ({ config }) =>
    Effect.succeed({
      tools: [{
        name: "helpdesk_queue",
        description: "Return the helpdesk queue this agent works",
        inputSchema: z.object({}),
        async do() {
          return { status: "success" as const, data: { queue: config.queue, retries: config.retries } };
        },
      }],
    }),
});

export default helpdesk;

import { defineMcp } from "glove-foundry";

const docsSearch = defineMcp({
  description: "Search the public product documentation",
  entry: {
    name: "Docs search",
    description: "Search and read product documentation pages",
    url: "https://mcp.example.com/docs",
    includeTools: ["search_*", "read_page"],
    prompts: false,
    requestTimeoutMs: 30_000,
  },
});

export default docsSearch;

import { defineMcp } from "glove-foundry";

const kb = defineMcp({
  description: "Internal knowledge base over stdio",
  entry: {
    name: "Knowledge base",
    description: "Read internal support articles",
    transport: { kind: "stdio", command: "/opt/mcp/kb-server", args: ["--stdio"] },
    excludeTools: ["delete_*", "write_*"],
    connectTimeoutMs: 15_000,
    idleTimeoutMs: 15 * 60_000,
    maxLifetimeMs: 24 * 60 * 60_000,
  },
});

export default kb;

import { defineMcp } from "glove-foundry";
import { z } from "zod";

const tracker = defineMcp({
  description: "Issue tracker scoped to one project",
  config: z.object({ project: z.string() }),
  entry: ({ config }) => ({
    name: "Issue tracker",
    description: `Issues for project ${config.project}`,
    url: `https://tracker.example.com/mcp?project=${encodeURIComponent(config.project)}`,
  }),
});

export default tracker;

import { Effect } from "effect";
import { defineAgent } from "glove-foundry";

export default defineAgent({
  // ...description, components, model, systemPrompt
  mcpAdapter: ({ agentId, resolved }) =>
    Effect.succeed({
      identifier: `support:${agentId}`,
      getActive: async () => resolved.map((item) => item.definition.id),
      activate: async () => {},
      deactivate: async () => {},
      // HTTP: headers (or getAccessToken for a bearer token), resolved per connection
      getAuthHeaders: async (id: string): Promise<Record<string, string>> =>
        id === "docs-search" ? { authorization: `Bearer ${process.env.DOCS_MCP_TOKEN ?? ""}` } : {},
      // stdio: environment for the child process, resolved at every (re)spawn
      getStdioEnvironment: async (id: string): Promise<Record<string, string>> =>
        id === "kb" ? { KB_TOKEN: process.env.KB_TOKEN ?? "" } : {},
    }),
});

import { composeAgent } from "glove-foundry";
import helpdesk from "./apps/helpdesk.app.js";
import tenantContext from "./layers/tenant.layer.js";
import docsSearch from "./mcp/docs-search.mcp.js";
import kb from "./mcp/kb.mcp.js";
import tracker from "./mcp/tracker.mcp.js";
import customerMemory from "./memory/customer.memory.js";
import audit from "./subscribers/audit.subscriber.js";
import lookupOrder from "./tools/lookup-order.tool.js";

export const components = composeAgent(
  lookupOrder, helpdesk, docsSearch, kb, tracker, // installable per instance
  customerMemory, tenantContext, audit,           // selected by the definition
);

import { defineAgentInstance, install } from "glove-foundry";
import support from "./agent.js";
import helpdesk from "./apps/helpdesk.app.js";
import docsSearch from "./mcp/docs-search.mcp.js";
import tracker from "./mcp/tracker.mcp.js";
import lookupOrder from "./tools/lookup-order.tool.js";

export const acmeSupport = defineAgentInstance(support, {
  id: "support-acme",
  workspaceId: "acme",
  context: { tenant: "Acme", canRefund: true },
  installations: [
    install(lookupOrder, { region: "eu" }), // includeHistory defaults to false
    install(helpdesk, { queue: "billing" }),
    install(docsSearch),                    // no config schema, no config
    install(tracker, { project: "SUP" }),
  ],
});

import { createFoundryClient } from "glove-foundry/client";
import type { FoundryRoutes } from "../.foundry/routes.js";

const foundry = createFoundryClient<FoundryRoutes>({ baseUrl: "http://127.0.0.1:4141" });

const agent = await foundry.agent("support").create({
  workspaceId: "globex",
  installations: [{ kind: "application", id: "helpdesk", config: { queue: "sales" } }],
});
await foundry.install(agent.id, { kind: "tool", id: "lookup-order", config: { region: "us" } });
await foundry.uninstall(agent.id, { kind: "application", id: "helpdesk" });
console.log(await foundry.installations(agent.id));

PUT /api/installations
content-type: application/json

{ "agentId": "support-acme", "kind": "mcp", "id": "tracker", "config": { "project": "OPS" } }

DELETE /api/installations
content-type: application/json

{ "agentId": "support-acme", "kind": "mcp", "id": "tracker" }

GET /api/installations?agent=support-acme

install(helpdesk, { queue: "billing" });           // ok: retries defaults to 2
// @ts-expect-error queue must be a string
install(helpdesk, { queue: 42 });
// @ts-expect-error lookupOrder declares a config schema, so config is required
install(lookupOrder);
// @ts-expect-error docsSearch has no config schema
install(docsSearch, { anything: true });

import { Effect } from "effect";
import { defineMemory } from "glove-foundry";
import { MemorySchema } from "glove-memory/core";
import { InMemoryContextAdapter, InMemoryEntityAdapter } from "glove-memory/in-memory";

const schema = new MemorySchema();

const customerMemory = defineMemory({
  description: "What we know about customers and this conversation",
  context: {
    adapter: ({ agentId }) =>
      Effect.succeed(new InMemoryContextAdapter({ schema, identifier: `support-context:${agentId}` })),
  },
  entity: {
    access: "curator", // read + write tools; "reader" (default) is read-only
    adapter: () => Effect.succeed(new InMemoryEntityAdapter({ schema })),
  },
});

export default customerMemory;

import { Effect } from "effect";
import { defineLayer } from "glove-foundry";
import { z } from "zod";

const tenantContext = defineLayer({
  description: "Pin the tenant name into every model iteration",
  config: z.object({ tenant: z.string() }),
  setup: ({ glove, config }) =>
    Effect.sync(() => {
      const remove = glove.addContextProvider(() => `Tenant: ${config.tenant}`);
      return remove; // cleanup when the run ends
    }),
});

export default tenantContext;

import { defineSubscriber } from "glove-foundry";

const audit = defineSubscriber({
  description: "Record every tool result as a custom run event",
  create: ({ emit }) => ({
    async record(type) {
      if (type === "tool_use_result") emit({ type: "support.audit.tool-result" });
    },
  }),
});

export default audit;

import { createAdapter } from "glove-core/models/providers";
import { configureLayer, defineAgent } from "glove-foundry";
import { components } from "./composition.js";
import tenantContext from "./layers/tenant.layer.js";
import customerMemory from "./memory/customer.memory.js";
import audit from "./subscribers/audit.subscriber.js";
import { FileStore } from "../../lib/file-store.js"; // durable transcript — see Persistence

export default defineAgent({
  description: "Answers customer questions about orders",
  components,
  store: ({ conversationId }) => FileStore.open(conversationId),
  model: () => createAdapter({ provider: "openrouter", model: "openai/gpt-4.1-mini", stream: true }),
  systemPrompt: (_agent, { installations }) =>
    `You are a support agent. Installed: ${installations.map((i) => `${i.kind}:${i.id}`).join(", ") || "nothing"}.`,

  memory: [customerMemory],
  layers: (_agent, { agentInstance }) => [
    configureLayer(tenantContext, { tenant: String(agentInstance.context.tenant ?? "default") }),
  ],
  subscribers: [
    audit,
    // a plain Glove SubscriberAdapter needs no catalogue entry
    { async record(type) { if (type === "model_response_complete") console.log("model turn done"); } },
  ],
});

import { defineAgent, defineCall } from "glove-foundry";
import { z } from "zod";

export default defineAgent({
  // ...description, components, model, systemPrompt
  calls: [
    defineCall({
      name: "escalate",
      description: "Escalate the conversation to a human with a reason",
      input: z.object({ reason: z.string().min(5) }),
      output: z.object({ ticketId: z.string() }),
      handler: ({ reason }, ctx) => ({ ticketId: `esc-${ctx.conversationId}-${reason.length}` }),
    }),
    defineCall({
      name: "audit_note",
      description: "Internal: record an audit note",
      input: z.object({ note: z.string() }),
      output: z.object({ ok: z.literal(true) }),
      exposeToAgent: false,
      handler: () => ({ ok: true as const }),
    }),
  ],
  run: async (_agent, ctx) => {
    await ctx.invoke("audit_note", { note: `run ${ctx.runId}` });
    return ctx.defaultRun();
  },
});