glove-foundry 0.5.1 → 0.5.2

package/templates/travel-concierge/agents/concierge/composition.ts

@@ -3,15 +3,22 @@ import calendar from "./apps/calendar.app.js";
 import tripContext from "./layers/trip-context.layer.js";
 import travellerMemory from "./memory/traveller.memory.js";
 import usage from "./subscribers/usage.subscriber.js";
-import findFlights from "./tools/find-flights.tool.js";
+import convertCurrency from "./tools/convert-currency.tool.js";
 
 /**
+ * The catalogue: everything this agent's instances are *allowed* to use.
+ *
+ * - `calendar` and `convertCurrency` are installable. They mount only on an
+ *   instance that installs them (see instances.ts).
+ * - `travellerMemory`, `tripContext` and `usage` are definition surfaces; they
+ *   are also selected in agent.ts (`memory`, `layers`, `subscribers`).
+ *
  * Composition is by value, not by string id. Rename a file and the import
  * breaks at compile time instead of failing at runtime.
  */
 export const conciergeComponents = composeAgent(
   calendar,
-  findFlights,
+  convertCurrency,
   travellerMemory,
   tripContext,
   usage,

package/templates/travel-concierge/agents/concierge/flights.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+
+/**
+ * Searching flights is the concierge's core job, so the tool lives in the
+ * agent's `tools` field: every instance has it, nothing to install. Compare
+ * `tools/convert-currency.tool.ts`, which an instance opts into.
+ *
+ * The sample data is deliberately local so a fresh project runs offline.
+ * Replace `search` with a call to your own inventory or a provider API.
+ */
+const SAMPLE_FLIGHTS = [
+  { carrier: "Kestrel Air", from: "LIS", to: "NBO", depart: "08:40", hours: 9.5, price: 612 },
+  { carrier: "Meridian", from: "LIS", to: "NBO", depart: "13:15", hours: 11, price: 494 },
+  { carrier: "Northwind", from: "LIS", to: "NBO", depart: "22:05", hours: 9, price: 738 },
+] as const;
+
+function search(from: string, to: string, maxPrice: number) {
+  const origin = from.trim().toUpperCase();
+  const destination = to.trim().toUpperCase();
+  return SAMPLE_FLIGHTS.filter((flight) =>
+    (!origin || flight.from === origin) &&
+    (!destination || flight.to === destination) &&
+    flight.price <= maxPrice
+  );
+}
+
+export const findFlights = {
+  name: "find_flights",
+  description:
+    "Search flights between two IATA airport codes. Returns carrier, departure time, duration and price in USD.",
+  inputSchema: z.object({
+    from: z.string().describe("Origin IATA code, for example LIS"),
+    to: z.string().describe("Destination IATA code, for example NBO"),
+    maxPrice: z.number().default(5_000).describe("Highest acceptable price in USD"),
+  }),
+  async do({ from, to, maxPrice }: { from: string; to: string; maxPrice: number }) {
+    const matches = search(from, to, maxPrice);
+    if (matches.length === 0) {
+      return { status: "success" as const, data: { matches: [], note: "No flight matched those constraints." } };
+    }
+    return { status: "success" as const, data: { matches } };
+  },
+};

package/templates/travel-concierge/agents/concierge/instances.ts

@@ -0,0 +1,42 @@
+import { defineAgentInstance, defineBinding, install } from "glove-foundry";
+import concierge from "./agent.js";
+import calendar from "./apps/calendar.app.js";
+import convertCurrency from "./tools/convert-currency.tool.js";
+import { travellerAccount, travellerOutbound } from "./topology.js";
+import messaging, { sendMessage } from "./transmissions/messaging.transmission.js";
+
+/**
+ * A ready-made instance, seeded into the data adapter on first start
+ * (foundry.application.ts). It has what a new instance created from the
+ * inspector does not: installed capabilities and permission to reply.
+ *
+ * Choose `concierge-demo` in the inspector's run drawer or WebChat to use it.
+ */
+export const conciergeDemo = defineAgentInstance(concierge, {
+  id: "concierge-demo",
+  workspaceId: "demo",
+  context: { budgetUsd: 2_500 },
+  installations: [
+    install(convertCurrency, { home: "EUR" }),
+    install(calendar, { calendarId: "primary", timezone: "Europe/Lisbon" }, { account: travellerAccount }),
+  ],
+  // Filled in by agent.ts's `playbooks` resolver on this instance's first run.
+  playbooks: [],
+});
+
+/**
+ * Outbound messages need a binding: the runtime's record that this instance
+ * may send through this route. Without one, a reply fails with
+ * "agent has no enabled bindings".
+ */
+export const conciergeDemoReplies = defineBinding({
+  id: "concierge-demo-replies",
+  agent: conciergeDemo,
+  application: calendar,
+  transmission: messaging,
+  account: travellerAccount,
+  route: travellerOutbound,
+  capabilities: [sendMessage],
+  reply: { mode: "route", route: travellerOutbound },
+  enabled: true,
+});

package/templates/travel-concierge/agents/concierge/memory/traveller.memory.ts

@@ -1,19 +1,24 @@
 import { Effect } from "effect";
 import { defineMemory } from "glove-foundry";
-import { MemorySchema } from "glove-memory/core";
-import { InMemoryContextAdapter } from "glove-memory/in-memory";
+import { fileURLToPath } from "node:url";
+import { FileContextAdapter } from "../../../lib/file-context.js";
 
 /**
- * Ambient context the concierge should carry between conversations: seat
- * preference, home airport, who is travelling. The adapter is replaceable —
- * point it at a durable store when you outgrow the in-memory one.
+ * Ambient context the concierge carries between conversations: seat
+ * preference, home airport, who is travelling. One file per agent instance, so
+ * two travellers never share a profile. The model reads it every turn and can
+ * update it with the context tools.
  */
-const schema = new MemorySchema();
-const context = new InMemoryContextAdapter({ schema });
+const directory = new URL("../../../.data/memory/", import.meta.url);
 
 const travellerMemory = defineMemory({
   description: "What we already know about this traveller",
-  context: { adapter: () => Effect.succeed(context) },
+  context: {
+    adapter: ({ agentId }) =>
+      Effect.promise(() =>
+        FileContextAdapter.open(fileURLToPath(new URL(`${encodeURIComponent(agentId)}.json`, directory))),
+      ),
+  },
 });
 
 export default travellerMemory;

package/templates/travel-concierge/agents/concierge/tools/convert-currency.tool.ts

@@ -0,0 +1,34 @@
+import { Effect } from "effect";
+import { defineSharedTool } from "glove-foundry";
+import { z } from "zod";
+
+/**
+ * A shared tool is installable: it is in the agent's catalogue (composition.ts)
+ * but mounts only on instances that install it — see `instances.ts`, where the
+ * demo instance installs it with a home currency. One file, one default export,
+ * and the filename is the id: `convert-currency`.
+ *
+ * The rates are fixed sample values. Replace `RATES` with a live rate source.
+ */
+const RATES: Readonly<Record<string, number>> = { USD: 1, EUR: 0.92, GBP: 0.79, KES: 129 };
+
+const convertCurrency = defineSharedTool({
+  description: "Convert a USD price into the traveller's home currency",
+  config: z.object({ home: z.enum(["USD", "EUR", "GBP", "KES"]).default("USD") }),
+  create: ({ config }) => Effect.sync(() => {
+    const rate = RATES[config.home]!;
+    return {
+      name: "convert_currency",
+      description: `Convert an amount in USD into ${config.home}, the traveller's home currency.`,
+      inputSchema: z.object({ amountUsd: z.number().describe("Price in USD") }),
+      async do({ amountUsd }: { amountUsd: number }) {
+        return {
+          status: "success" as const,
+          data: { currency: config.home, amount: Math.round(amountUsd * rate * 100) / 100, rate },
+        };
+      },
+    };
+  }),
+});
+
+export default convertCurrency;

package/templates/travel-concierge/agents/concierge/workbench.ts

@@ -1,5 +1,5 @@
 import { JsSession, defineFn } from "glove-js";
-import { defineRepl, defineWorkingEnvironment } from "glove-foundry";
+import { defineRepl, defineWorkingEnvironment, foundryDataEnvironmentPersistence } from "glove-foundry";
 import { z } from "zod";
 
 /**
@@ -11,6 +11,9 @@ import { z } from "zod";
  */
 export const conciergeWorkspace = defineWorkingEnvironment({
   options: { limits: { maxVfsBytes: 16 * 1024 * 1024 } },
+  // The environment closes after every run; this snapshots its files into the
+  // data adapter and restores them on the next run of the same instance.
+  persistence: foundryDataEnvironmentPersistence({ scope: "agent" }),
 });
 
 export function conciergeRepl(actor: string, budgetUsd: number) {

package/templates/travel-concierge/foundry.application.ts

@@ -1,18 +1,27 @@
-import { MemoryFoundryDataAdapter, defineApplication } from "glove-foundry";
+import { FileFoundryDataAdapter, defineApplication } from "glove-foundry";
+import { fileURLToPath } from "node:url";
+import { conciergeDemo, conciergeDemoReplies } from "./agents/concierge/instances.js";
 import { travellerAccount, travellerInbound, travellerOutbound } from "./agents/concierge/topology.js";
 
 /**
  * The application is where runtime data enters: which adapter persists
- * instances, which accounts and routes exist. `MemoryFoundryDataAdapter` keeps
- * everything in process, so restarting `pnpm dev` starts clean. Swap it for
- * your own adapter to persist across restarts.
+ * instances, which accounts, routes and bindings exist.
+ *
+ * Instances, conversations, schedules, workspace data and the concierge's VFS
+ * are saved to `.data/foundry.json`, so they survive restarts — including the
+ * restart `dev` performs every time you save a file. `conciergeDemo` is seeded
+ * on first start. Delete `.data/` to start fresh. Use a database-backed adapter
+ * when several hosts share one runtime.
  */
-export const data = new MemoryFoundryDataAdapter();
+export const data = new FileFoundryDataAdapter({
+  file: fileURLToPath(new URL("./.data/foundry.json", import.meta.url)),
+  agents: [conciergeDemo],
+});
 
 export default defineApplication({
   name: "{{projectName}}",
   data,
   accounts: [travellerAccount],
   routes: [travellerInbound, travellerOutbound],
-  bindings: [],
+  bindings: [conciergeDemoReplies],
 });

package/templates/travel-concierge/gitignore

@@ -1,3 +1,4 @@
 node_modules
 .env.local
 .foundry/manifest.json
+.data

package/templates/travel-concierge/lib/demo-model.ts

@@ -12,8 +12,41 @@ import type {
  * project runs end to end — real runs, real tool calls, a real event trace in
  * the inspector — before you have configured a provider.
  *
+ * Each turn it searches flights, then answers. When the message arrived over
+ * the chat transport (see README, "Send it a chat message"), it also replies
+ * through the installed calendar app's messaging tool, which is what a real
+ * model does when the playbook asks it to.
+ *
  * Delete this file and the `model()` fallback in agent.ts once you have a key.
  */
+const SEND_TOOL = "glove_app_calendar__messaging_send";
+
+interface Inbound {
+  readonly threadId: string;
+  readonly text: string;
+  readonly routeId: string;
+}
+
+function unescapeXml(value: string): string {
+  return value
+    .replaceAll(""", '"')
+    .replaceAll("'", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&");
+}
+
+/** Read the event Foundry serialized into the turn for an inbound transmission. */
+function inboundFrom(text: string): Inbound | undefined {
+  if (!text.includes('<transmission direction="inbound"')) return undefined;
+  const payload = /<payload format="json">([\s\S]*?)<\/payload>/.exec(text)?.[1];
+  const routeId = /<outbound route="([^"]+)"/.exec(text)?.[1];
+  if (!payload || !routeId) return undefined;
+  const event = JSON.parse(unescapeXml(payload)) as { threadId?: string; text?: string };
+  if (!event.threadId) return undefined;
+  return { threadId: event.threadId, text: event.text ?? "", routeId: unescapeXml(routeId) };
+}
+
 export class DemoModel implements ModelAdapter {
   readonly name = "demo-model";
   private systemPrompt = "";
@@ -26,38 +59,49 @@ export class DemoModel implements ModelAdapter {
     request: PromptRequest,
     notify: NotifySubscribersFunction,
   ): Promise<ModelPromptResult> {
-    const toolCompleted = request.messages.some(
-      (message) => Array.isArray(message.tool_results) && message.tool_results.length > 0,
+    // Only this turn matters: everything from the latest user message onward.
+    let userIndex = request.messages.length - 1;
+    while (userIndex >= 0) {
+      const message = request.messages[userIndex]!;
+      if (message.sender === "user" && !message.tool_results?.length && !message.framework_context) break;
+      userIndex--;
+    }
+    const turn = request.messages.slice(Math.max(userIndex, 0));
+    const asked = request.messages[userIndex]?.text ?? "";
+    const called = new Set(
+      turn.flatMap((message) => message.tool_calls?.map((call) => call.tool_name) ?? []),
     );
+    const inbound = inboundFrom(asked);
+    const answer = [
+      `Here is what I found for "${inbound?.text ?? asked}".`,
+      "Three flights match. Meridian at 13:15 is the cheapest at $494; Northwind at 22:05 is the fastest at 9h.",
+      "Tell me your dates and I will check the calendar and hold them.",
+    ].join(" ");
 
-    if (!toolCompleted) {
-      // First turn: call a real tool so the trace shows tool_use -> result.
-      // ToolCall's fields are optional, so notify() reads the local literals.
-      const callId = "call_demo_flights";
-      const toolName = "find_flights";
-      const input = { from: "LIS", to: "NBO", maxPrice: 5_000 };
-      const call: ToolCall = { id: callId, tool_name: toolName, input_args: input };
-      await notify("tool_use", { id: callId, name: toolName, input });
-      await notify("model_response_complete", {
-        text: "",
-        tool_calls: [call],
-        stop_reason: "tool_use",
-        tokens_in: 14,
-        tokens_out: 6,
+    if (!called.has("find_flights")) {
+      return this.callTool(notify, "call_demo_flights", "find_flights", {
+        from: "LIS",
+        to: "NBO",
+        maxPrice: 5_000,
+      });
+    }
+
+    const canReply = request.tools?.some((tool) => tool.name === SEND_TOOL) ?? false;
+    if (inbound && canReply && !called.has(SEND_TOOL)) {
+      return this.callTool(notify, "call_demo_reply", SEND_TOOL, {
+        routeId: inbound.routeId,
+        payload: { threadId: inbound.threadId, text: answer },
       });
-      const message: Message = { sender: "agent", text: "", tool_calls: [call] };
-      return { messages: [message], tokens_in: 14, tokens_out: 6 };
     }
 
-    const asked = [...request.messages]
-      .reverse()
-      .find((message) => message.sender === "user" && !message.tool_results?.length)?.text;
     const text = [
-      `Here is what I found for "${asked ?? "your trip"}".`,
-      "Three flights match. Meridian at 13:15 is the cheapest at $494; Northwind at 22:05 is the fastest at 9h.",
-      "Tell me your dates and I will check the calendar and hold them.",
+      answer,
       "",
-      "(This is the built-in demo model. Set OPENROUTER_API_KEY in .env.local for real answers.)",
+      inbound
+        ? canReply
+          ? "(Replied to the traveller's chat thread — see the [telegram] line in the terminal.)"
+          : "(This instance cannot reply over chat: install the calendar app and add a binding, as concierge-demo has.)"
+        : "(This is the built-in demo model. Set OPENROUTER_API_KEY in .env.local for real answers.)",
     ].join("\n");
     await notify("text_delta", { text });
     await notify("model_response_complete", {
@@ -69,4 +113,24 @@ export class DemoModel implements ModelAdapter {
     void this.systemPrompt;
     return { messages: [{ sender: "agent", text }], tokens_in: 32, tokens_out: 48 };
   }
+
+  private async callTool(
+    notify: NotifySubscribersFunction,
+    id: string,
+    name: string,
+    input: Record<string, unknown>,
+  ): Promise<ModelPromptResult> {
+    // ToolCall's fields are optional, so notify() reads the local values.
+    const call: ToolCall = { id, tool_name: name, input_args: input };
+    await notify("tool_use", { id, name, input });
+    await notify("model_response_complete", {
+      text: "",
+      tool_calls: [call],
+      stop_reason: "tool_use",
+      tokens_in: 14,
+      tokens_out: 6,
+    });
+    const message: Message = { sender: "agent", text: "", tool_calls: [call] };
+    return { messages: [message], tokens_in: 14, tokens_out: 6 };
+  }
 }

package/templates/travel-concierge/lib/file-context.ts

@@ -0,0 +1,60 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import {
+  InMemoryContextAdapter,
+  MemorySchema,
+  type ContextEntryInput,
+  type ContextEntryPatch,
+  type Provenance,
+} from "glove-memory";
+
+type ContextMemoryState = ReturnType<InMemoryContextAdapter["snapshot"]>;
+
+/**
+ * Ambient context (preferences, home airport, who is travelling) saved to a
+ * JSON file. Like transcripts, memory has to live outside the run's process to
+ * be there on the next message. Single host; use a database adapter for more.
+ */
+export class FileContextAdapter extends InMemoryContextAdapter {
+  private constructor(private readonly file: string, state?: ContextMemoryState) {
+    super({ schema: new MemorySchema(), identifier: `file-context:${file}`, ...(state ? { state } : {}) });
+  }
+
+  static async open(file: string): Promise<FileContextAdapter> {
+    try {
+      return new FileContextAdapter(file, JSON.parse(await readFile(file, "utf8")) as ContextMemoryState);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return new FileContextAdapter(file);
+      throw error;
+    }
+  }
+
+  private async save(): Promise<void> {
+    await mkdir(dirname(this.file), { recursive: true });
+    const temporary = `${this.file}.${process.pid}.tmp`;
+    await writeFile(temporary, JSON.stringify(this.snapshot()));
+    await rename(temporary, this.file);
+  }
+
+  override async set(entry: ContextEntryInput, provenance: Provenance) {
+    const result = await super.set(entry, provenance);
+    await this.save();
+    return result;
+  }
+  override async update(id: string, patch: ContextEntryPatch, provenance: Provenance) {
+    await super.update(id, patch, provenance);
+    await this.save();
+  }
+  override async unset(id: string, provenance: Provenance) {
+    await super.unset(id, provenance);
+    await this.save();
+  }
+  override async setSection(section: string, entries: Array<Omit<ContextEntryInput, "section">>, provenance: Provenance) {
+    await super.setSection(section, entries, provenance);
+    await this.save();
+  }
+  override async unsetSection(section: string, provenance: Provenance) {
+    await super.unsetSection(section, provenance);
+    await this.save();
+  }
+}

package/templates/travel-concierge/lib/file-store.ts

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  MemoryStore,
+  type InboxItem,
+  type Message,
+  type Task,
+  type TokenConsumptionCounter,
+} from "glove-core";
+
+/** Transcripts live in `.data/transcripts`, beside this project's `lib` folder. */
+const TRANSCRIPTS = fileURLToPath(new URL("../.data/transcripts/", import.meta.url));
+
+interface SavedConversation {
+  readonly messages: Message[];
+  readonly turns: number;
+  readonly tokens: TokenConsumptionCounter;
+  readonly tasks: Task[];
+  readonly inbox: InboxItem[];
+}
+
+/**
+ * Foundry runs every message in a fresh process, so a plain `MemoryStore`
+ * would start each turn with no history. This one loads the conversation from
+ * a JSON file and rewrites it after every change.
+ *
+ * One host, one active run per conversation. Replace it with a database-backed
+ * StoreAdapter when several hosts share conversations.
+ */
+export class FileStore extends MemoryStore {
+  private restoring = false;
+
+  private constructor(conversationId: string, private readonly file: string) {
+    super(conversationId);
+  }
+
+  static async open(conversationId: string, directory = TRANSCRIPTS): Promise<FileStore> {
+    const name = createHash("sha256").update(conversationId).digest("hex").slice(0, 32);
+    const store = new FileStore(conversationId, join(directory, `${name}.json`));
+    await store.restore();
+    return store;
+  }
+
+  private async restore(): Promise<void> {
+    let saved: SavedConversation;
+    try {
+      saved = JSON.parse(await readFile(this.file, "utf8")) as SavedConversation;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return;
+      throw error;
+    }
+    this.restoring = true;
+    try {
+      await this.appendMessages(saved.messages);
+      await this.addTokens(saved.tokens);
+      for (let turn = 0; turn < saved.turns; turn++) await this.incrementTurn();
+      await this.addTasks(saved.tasks);
+      for (const item of saved.inbox) await this.addInboxItem(item);
+    } finally {
+      this.restoring = false;
+    }
+  }
+
+  private async save(): Promise<void> {
+    if (this.restoring) return;
+    const saved: SavedConversation = {
+      messages: await this.getMessages(),
+      turns: await this.getTurnCount(),
+      tokens: await this.getTokenConsumption(),
+      tasks: await this.getTasks(),
+      inbox: await this.getInboxItems(),
+    };
+    await mkdir(dirname(this.file), { recursive: true });
+    const temporary = `${this.file}.${process.pid}.tmp`;
+    await writeFile(temporary, JSON.stringify(saved));
+    await rename(temporary, this.file);
+  }
+
+  override async appendMessages(messages: Message[]) { await super.appendMessages(messages); await this.save(); }
+  override async addTokens(usage: TokenConsumptionCounter) { await super.addTokens(usage); await this.save(); }
+  override async incrementTurn() { await super.incrementTurn(); await this.save(); }
+  override async resetCounters() { await super.resetCounters(); await this.save(); }
+  override async addTasks(tasks: Task[]) { await super.addTasks(tasks); await this.save(); }
+  override async updateTask(id: string, updates: Partial<Pick<Task, "status" | "content" | "activeForm">>) {
+    await super.updateTask(id, updates);
+    await this.save();
+  }
+  override async addInboxItem(item: InboxItem) { await super.addInboxItem(item); await this.save(); }
+  override async updateInboxItem(id: string, updates: Partial<Pick<InboxItem, "status" | "response" | "resolved_at">>) {
+    await super.updateInboxItem(id, updates);
+    await this.save();
+  }
+}

package/templates/minimal/agents/assistant/tools/current-time.tool.ts

@@ -1,17 +0,0 @@
-import { defineSharedTool } from "glove-foundry";
-import { z } from "zod";
-
-/** One file, one default export. The filename is the id: `current-time`. */
-const currentTime = defineSharedTool({
-  description: "Return the current ISO timestamp",
-  tool: {
-    name: "current_time",
-    description: "Return the current ISO timestamp",
-    inputSchema: z.object({}),
-    async do() {
-      return { status: "success" as const, data: new Date().toISOString() };
-    },
-  },
-});
-
-export default currentTime;

package/templates/travel-concierge/agents/concierge/tools/find-flights.tool.ts

@@ -1,49 +0,0 @@
-import { defineSharedTool } from "glove-foundry";
-import { z } from "zod";
-
-/**
- * A shared tool is the smallest Foundry capability: one file, one default
- * export, and an id taken from the filename (`find-flights`). Nothing here
- * knows which agent will mount it.
- *
- * The sample data is deliberately local so a fresh project runs offline.
- * Replace `search` with a call to your own inventory or a provider API.
- */
-const SAMPLE_FLIGHTS = [
-  { carrier: "Kestrel Air", from: "LIS", to: "NBO", depart: "08:40", hours: 9.5, price: 612 },
-  { carrier: "Meridian", from: "LIS", to: "NBO", depart: "13:15", hours: 11, price: 494 },
-  { carrier: "Northwind", from: "LIS", to: "NBO", depart: "22:05", hours: 9, price: 738 },
-] as const;
-
-function search(from: string, to: string, maxPrice: number) {
-  const origin = from.trim().toUpperCase();
-  const destination = to.trim().toUpperCase();
-  return SAMPLE_FLIGHTS.filter((flight) =>
-    (!origin || flight.from === origin) &&
-    (!destination || flight.to === destination) &&
-    flight.price <= maxPrice
-  );
-}
-
-const findFlights = defineSharedTool({
-  description: "Search available flights between two airports",
-  tool: {
-    name: "find_flights",
-    description:
-      "Search flights between two IATA airport codes. Returns carrier, departure time, duration and price.",
-    inputSchema: z.object({
-      from: z.string().describe("Origin IATA code, for example LIS"),
-      to: z.string().describe("Destination IATA code, for example NBO"),
-      maxPrice: z.number().default(5_000).describe("Highest acceptable price in USD"),
-    }),
-    async do({ from, to, maxPrice }) {
-      const matches = search(from, to, maxPrice);
-      if (matches.length === 0) {
-        return { status: "success" as const, data: { matches: [], note: "No flight matched those constraints." } };
-      }
-      return { status: "success" as const, data: { matches } };
-    },
-  },
-});
-
-export default findFlights;