glove-foundry 0.0.0

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2026 dterminal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# Glove Foundry
+
+Glove Foundry is an Effect-native application framework for typed, observable Glove agents. It gives agent projects the conventions that Next.js gives web projects: file routes, colocated composition, a development server, generated types, durable runtime data, and a stable client/API.
+
+**[Read the Foundry handbook](https://glove.dterminal.net/foundry/docs)** for the guided architecture, installation, composition, applications, automation, workspaces, multi-agent, observability, and deployment documentation.
+
+The development server includes a hierarchical inspector for definitions, instances, runs, automations, integrations, and shared workspaces. See the [inspector guide](./docs/inspector.md).
+
+```bash
+npx glove-foundry init my-agent-app
+cd my-agent-app
+pnpm install
+pnpm dev
+```
+
+Inside an installed project, the framework binary also supports `glove foundry dev`
+and `glove foundry start`.
+
+## The mental model
+
+Foundry keeps code and data deliberately separate.
+
+| Kind | Lives in | Purpose |
+| --- | --- | --- |
+| Agent definition | `agents/<route>/agent.ts` | Reusable behavior and lazy assembly |
+| Application, transmission, tool, MCP, memory, layer | Beside the owning agent | Reusable capability catalogue |
+| Agent instance | `FoundryDataAdapter` | Workspace identity, context, installations, playbooks |
+| Conversation | `FoundryDataAdapter` | One conversation owned by one instance |
+| Playbook subscription | `FoundryDataAdapter` | Background policy that may provision zero, one, or many instances |
+| Route/account/binding | Application data or topology adapter | External integration topology without credential material |
+| Application connection | Application definition | Long-lived inbound provider worker |
+| Schedule definition | Lazy agent resolver | Agent-local desired timing policy |
+| Scheduled activation | `FoundryDataAdapter` | Reconstructed trigger created from a definition or agent tool |
+
+An agent definition never declares request input or output. Foundry owns the `FoundryRequest` and `FoundryResult` contracts. An instance can be changed and reconstructed without editing its definition.
+
+## Colocated agent composition
+
+```text
+agents/
+  support-lead/
+    agent.ts
+    composition.ts
+    apps/helpdesk.app.ts
+    actions/respond.action.ts
+    events/message-received.event.ts
+    transmissions/messages.transmission.ts
+    predicates/is-urgent.predicate.ts
+    connections/provider-events.connection.ts
+    tools/customer-context.tool.ts
+    mcp/knowledge.mcp.ts
+    memory/customer.memory.ts
+    inboxes/work.inbox.ts
+    layers/audit.layer.ts
+    subscribers/metrics.subscriber.ts
+foundry.application.ts
+foundry.config.ts
+```
+
+```ts
+// agents/support-lead/agent.ts
+import { defineAgent } from "glove-foundry"
+import { components } from "./composition.js"
+
+export default defineAgent({
+  description: "Owns difficult support conversations",
+  components,
+  model: (_agent, ctx) => chooseModel(ctx.message),
+  systemPrompt: (_agent, ctx) => promptFor(ctx.agentInstance, ctx.message),
+  tools: async (_agent, ctx) => toolsAllowedFor(ctx.agentInstance, ctx.message),
+  memory: (_agent, ctx) => memoryFor(ctx.agentInstance, ctx.conversation),
+  inboxes: (_agent, ctx) => loadInbox(ctx.agentId, ctx.conversationId),
+})
+```
+
+Every lazy resolver receives the current native Glove `Message`, prior messages, request, definition id, instance id, conversation id, workspace id, instance context, and current installations.
+
+## Filenames own code identity; data owns runtime identity
+
+Every static primitive default-exports one definition. Foundry derives its id
+from the convention path: `agents/support-lead/tools/calendar/today.tool.ts`
+becomes `calendar/today`. Static definitions do not repeat an `id` string.
+
+Code-authored relationships use imported values. Runtime policies are composed lazily by the agent definition and normalized only when they become instance data.
+
+```ts
+const inbound = defineInboundRoute({
+  id: "helpdesk-inbound",
+  transmission: helpdeskTransmission,
+  account: supportAccount,
+  visibility: "workspace",
+  enabled: true,
+  config: {},
+})
+
+export default defineAgent({
+  description: "Support lead",
+  playbooks: (_agent, ctx) => [composePlaybook({
+    name: "urgent-support",
+    transmission: helpdeskTransmission,
+    match: {
+      event: messageReceived,
+      routes: [inbound],
+      predicate: { definition: isUrgent, parameters: { minimum: ctx.agentInstance.context.minimum ?? 3 } },
+    },
+    directives: [{ action: respond, instruction: "Resolve the request." }],
+    applications: [helpdeskApp],
+  })],
+  // model, tools, and other lazy surfaces...
+})
+```
+
+The stored instance contains `definitionId`, installation ids, transmission ids, event ids, action ids, account ids, and route ids because JSON and databases cannot preserve object identity. Reconstructors validate and freeze that data on load. Raw string references remain appropriate at HTTP, database, and frontend boundaries. Accounts, routes, bindings, instances, and conversations also keep explicit IDs because they are dynamic records that a UI or adapter may create. Code points to those dynamic records through the record value, such as `{ account: supportAccount }`; it does not copy their ids.
+
+Definition config is followed through the imported value. Zod config schemas infer `install(...)` and decoded install-hook config; Effect transmission schemas infer account metadata, route config, inbound events, and outbound input/output. `defineConfig` preserves its exact type and rejects unknown framework keys.
+
+## Applications, transmissions, and connections
+
+Applications are headless, installable capability definitions. They may own multiple inbound and outbound transmissions. Outbound transmissions become tools only when the application is installed on an instance.
+
+```ts
+// connections/provider-events.connection.ts
+export default defineConnection({
+  description: "Receives provider events",
+  transmissions: [messageTransmission, reactionTransmission],
+  connect: (ctx) => Effect.gen(function* () {
+    const session = yield* openUserOwnedProviderAdapter(ctx.account)
+    yield* ctx.ready()
+    yield* session.consume((event) => ctx.receive({
+      route: chooseRoute(ctx.routes, event),
+      eventId: event.id,
+      threadKey: event.threadId,
+      raw: event,
+    }))
+  }),
+})
+```
+
+Foundry supervises connection lifetime and retry, but never acquires or refreshes credentials. Account references contain only metadata and an opaque `accessRef`. Your `accountSessions` or provider adapter owns credential material and refresh.
+
+Connections are desired only when:
+
+- an instance has installed the application and has a matching inbound playbook; or
+- an enabled playbook subscription targets the application installation.
+
+This covers webhook/socket ingestion and long-lived provider bots without exposing the execution backend as a framework primitive.
+
+## Background playbooks and lazy provisioning
+
+A playbook is serializable runtime policy. It is composed by an agent resolver or frontend from transmission primitives, then persisted on the instance. Executable normalization, authentication, predicates, serialization, and delivery live on the transmission definition.
+
+```ts
+const [urgentSupport] = agentInstance.playbooks
+await runtime.putPlaybookSubscription({
+  id: subscriptionId, // runtime data id from your UI/data layer
+  workspaceId: agentInstance.workspaceId,
+  enabled: true,
+  playbook: urgentSupport,
+  targets: runtimeSelectedTargets,
+  createdAt: now,
+  updatedAt: now,
+})
+```
+
+Provisioning modes:
+
+- `singleton`: one stable instance for the subscription target.
+- `per-thread`: one instance per inbound route/thread.
+- `per-event`: a new stable instance per external event id.
+- `existing`: deliver only to listed persisted instance ids.
+- `custom`: delegate one-to-many selection to the application `provisioner` adapter.
+
+The data adapter atomically enforces `provisioningKey`. Inbound delivery claims are also adapter-backed, so retrying the same route/event does not create duplicate runs.
+
+## Conversations and shared work
+
+One agent instance can own many conversations. Foundry also provides adapter-backed workspace entries, shared inbox items, tasks, and scoped environment values. These are data primitives, not prompt conventions, so agents can pass documents and work records by reference instead of copying context.
+
+## Immediate work, future work, and sleep
+
+Schedules are composable agent-local primitives, never a root registry. A lazy `schedules(agent, ctx)` resolver loads desired schedules into Foundry, while running agents can manage their persisted triggers through framework-owned tools:
+
+- `glove_foundry_spawn` invokes work immediately.
+- `glove_foundry_schedule` creates a one-time (`at` or `after`), interval (`every`), or calendar-aware (`cron`) activation.
+- `glove_foundry_schedules` lists, updates, or cancels triggers owned by the current instance.
+- `glove_foundry_sleep` suspends the current logical run until an absolute time or for a duration, then wakes the same instance and conversation with a resolution message.
+
+Both operations persist adapter-backed activation data before the execution backend is armed. Pending wake-ups and recurring work are reconstructed when the runtime starts; the bundled memory adapter is for development, while a durable `FoundryDataAdapter` supplies production persistence.
+
+Durations accept compact forms such as `30s`, `20m`, and `2h`, as well as Effect duration forms such as `20 minutes`. The execution backend remains private; agent projects see only these purpose-built tools and correlated activation events.
+
+## Development and inspection
+
+```bash
+pnpm dev
+```
+
+The inspector presents a causal activation path:
+
+```text
+arrival → matching playbook → provisioned workforce → runs and outcomes
+```
+
+It also shows instance installations, active playbook subscriptions, application connections, and the correlated trace for each run. Backend-specific runner concepts are not part of the Foundry UI or public client.
+
+Useful endpoints:
+
+```text
+GET  /api/manifest
+GET  /api/agent-instances
+PATCH /api/agent-instances/:id
+GET  /api/playbook-subscriptions
+PUT  /api/playbook-subscriptions
+GET  /api/application-connections
+POST /api/transmissions/:routeId/fire
+GET  /api/runs
+GET  /api/events
+```
+
+See [Building with Foundry](./docs/building-with-foundry.md), [Architecture](./docs/architecture.md), and the runnable [`examples/foundry-agent`](../../examples/foundry-agent).

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,28 @@
+# Third-party notices
+
+## Phosphor Icons
+
+The Foundry inspector includes a curated subset of SVG paths from
+`@phosphor-icons/core` 2.1.1.
+
+MIT License
+
+Copyright (c) 2023 Phosphor Icons
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-3GCUECPA.js

@@ -0,0 +1,368 @@
+// src/client.ts
+async function readResponse(response) {
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(payload.error ?? `Foundry request failed (${response.status}).`);
+  }
+  return payload;
+}
+function routePath(route) {
+  return route.split("/").map(encodeURIComponent).join("/");
+}
+var FoundryRunHandle = class {
+  id;
+  initial;
+  client;
+  constructor(id, initial, client) {
+    this.id = id;
+    this.initial = initial;
+    this.client = client;
+  }
+  get() {
+    return this.client.getRun(this.id);
+  }
+  cancel() {
+    return this.client.cancelRun(this.id);
+  }
+  events() {
+    return this.client.getEvents({ runId: this.id });
+  }
+  async wait(options = {}) {
+    const pollMs = options.pollMs ?? 150;
+    const timeoutMs = options.timeoutMs ?? 6e4;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (options.signal?.aborted) {
+        throw new Error("Waiting for Foundry run was aborted.");
+      }
+      const run = await this.get();
+      if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") {
+        return run;
+      }
+      await new Promise((resolve, reject) => {
+        const onAbort = () => {
+          clearTimeout(timer);
+          reject(new Error("Waiting for Foundry run was aborted."));
+        };
+        const timer = setTimeout(() => {
+          options.signal?.removeEventListener("abort", onAbort);
+          resolve();
+        }, pollMs);
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    }
+    throw new Error(`Timed out waiting for Foundry run "${this.id}".`);
+  }
+};
+var FoundryClient = class {
+  baseUrl;
+  fetcher;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? "http://127.0.0.1:4141").replace(
+      /\/$/,
+      ""
+    );
+    this.fetcher = options.fetch ?? globalThis.fetch;
+  }
+  async health() {
+    return readResponse(await this.fetcher(`${this.baseUrl}/health`));
+  }
+  agent(route) {
+    return {
+      create: (options) => this.createAgent(route, options),
+      request: async (request) => {
+        const response = await this.fetcher(
+          `${this.baseUrl}/api/agents/${routePath(route)}/runs`,
+          {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(request)
+          }
+        );
+        const run = await readResponse(response);
+        return new FoundryRunHandle(run.id, run, this.asUntyped());
+      }
+    };
+  }
+  async createAgent(definitionId, options = {}) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/agent-instances`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ definitionId, ...options })
+    }));
+  }
+  async agentInstances(definitionId) {
+    const query = definitionId ? `?definition=${encodeURIComponent(definitionId)}` : "";
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/agent-instances${query}`));
+  }
+  async configureAgent(agentId, options) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/agent-instances/${encodeURIComponent(agentId)}`, {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(options)
+    }));
+  }
+  async setAgentPlaybooks(agentId, playbooks) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/agent-instances/${encodeURIComponent(agentId)}/playbooks`, {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ playbooks })
+    }));
+  }
+  async createConversation(agentId, options = {}) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/conversations`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ agentId, ...options })
+    }));
+  }
+  async conversations(agentId) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/conversations?agent=${encodeURIComponent(agentId)}`));
+  }
+  async workspaceEntries(workspaceId) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/entries`));
+  }
+  async putWorkspaceEntry(workspaceId, key, value) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/entries`, {
+      method: "PUT",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ key, value })
+    }));
+  }
+  async sharedInbox(workspaceId) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/inbox`));
+  }
+  async postSharedInbox(workspaceId, input) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/inbox`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(input)
+    }));
+  }
+  async updateSharedInbox(workspaceId, itemId, status) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/inbox/${encodeURIComponent(itemId)}`, {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ status })
+    }));
+  }
+  async tasks(workspaceId) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/tasks`));
+  }
+  async createTask(workspaceId, input) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/tasks`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(input)
+    }));
+  }
+  async updateTask(workspaceId, taskId, status) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/tasks/${encodeURIComponent(taskId)}`, {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ status })
+    }));
+  }
+  async dataEnvironment(workspaceId, scope) {
+    const query = new URLSearchParams();
+    if (scope?.agentId) query.set("agent", scope.agentId);
+    if (scope?.conversationId) query.set("conversation", scope.conversationId);
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/workspaces/${encodeURIComponent(workspaceId)}/environment${query.size ? `?${query}` : ""}`));
+  }
+  async dispatchInbound(input) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/transmissions/${encodeURIComponent(input.routeId)}/fire`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(input)
+    }));
+  }
+  async playbookSubscriptions(workspaceId) {
+    const query = workspaceId ? `?workspace=${encodeURIComponent(workspaceId)}` : "";
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/playbook-subscriptions${query}`)
+    );
+  }
+  async activations(workspaceId) {
+    const query = workspaceId ? `?workspace=${encodeURIComponent(workspaceId)}` : "";
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/activations${query}`)
+    );
+  }
+  async putPlaybookSubscription(subscription) {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/playbook-subscriptions`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(subscription)
+      })
+    );
+  }
+  async deletePlaybookSubscription(id) {
+    const result = await readResponse(
+      await this.fetcher(
+        `${this.baseUrl}/api/playbook-subscriptions/${encodeURIComponent(id)}`,
+        { method: "DELETE" }
+      )
+    );
+    return result.removed;
+  }
+  async applicationConnections() {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/application-connections`));
+  }
+  async reconnectApplicationConnection(id) {
+    await readResponse(
+      await this.fetcher(
+        `${this.baseUrl}/api/application-connections/${encodeURIComponent(id)}/reconnect`,
+        { method: "POST" }
+      )
+    );
+  }
+  async dispatchOutbound(input) {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/transmissions/${encodeURIComponent(input.routeId)}/deliver`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(input)
+    }));
+  }
+  async send(agentId, conversationId, message, options = {}) {
+    const run = await readResponse(
+      await this.fetcher(`${this.baseUrl}/api/conversations/${encodeURIComponent(conversationId)}/messages`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ agentId, message, ...options })
+      })
+    );
+    return new FoundryRunHandle(run.id, run, this.asUntyped());
+  }
+  async getRun(runId) {
+    const response = await this.fetcher(
+      `${this.baseUrl}/api/runs/${encodeURIComponent(runId)}`
+    );
+    return readResponse(response);
+  }
+  async runs(route) {
+    const query = route ? `?agent=${encodeURIComponent(route)}` : "";
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/runs${query}`));
+  }
+  async cancelRun(runId) {
+    const response = await this.fetcher(
+      `${this.baseUrl}/api/runs/${encodeURIComponent(runId)}/cancel`,
+      { method: "POST" }
+    );
+    const payload = await readResponse(response);
+    return payload.cancelled;
+  }
+  async getEvents(filter) {
+    const query = new URLSearchParams();
+    if (filter?.runId) query.set("runId", filter.runId);
+    if (filter?.agent) query.set("agent", filter.agent);
+    if (filter?.after !== void 0) query.set("after", String(filter.after));
+    if (filter?.category) query.set("category", filter.category);
+    const suffix = query.size > 0 ? `?${query}` : "";
+    const response = await this.fetcher(
+      `${this.baseUrl}/api/events${suffix}`,
+      { headers: { accept: "application/json" } }
+    );
+    return readResponse(response);
+  }
+  async manifest() {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/manifest`)
+    );
+  }
+  async capabilities(definitionId) {
+    const query = new URLSearchParams({ definition: definitionId });
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/capabilities?${query}`));
+  }
+  async surfaces(definitionId) {
+    const query = new URLSearchParams({ definition: definitionId });
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/surfaces?${query}`));
+  }
+  async installations(agentId) {
+    const query = new URLSearchParams({ agent: agentId });
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/installations?${query}`)
+    );
+  }
+  async install(agentId, installation) {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/installations`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ agentId, ...installation })
+      })
+    );
+  }
+  async uninstall(agentId, installation) {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/installations`, {
+        method: "DELETE",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ agentId, ...installation })
+      })
+    );
+  }
+  async accounts() {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/accounts`));
+  }
+  async routes() {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/routes`));
+  }
+  async putRoute(route) {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/routes`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(route)
+      })
+    );
+  }
+  async removeRoute(id) {
+    await readResponse(
+      await this.fetcher(`${this.baseUrl}/api/routes/${encodeURIComponent(id)}`, {
+        method: "DELETE"
+      })
+    );
+  }
+  async bindings() {
+    return readResponse(await this.fetcher(`${this.baseUrl}/api/bindings`));
+  }
+  async putBinding(binding) {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/bindings`, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(binding)
+      })
+    );
+  }
+  async removeBinding(id) {
+    await readResponse(
+      await this.fetcher(
+        `${this.baseUrl}/api/bindings/${encodeURIComponent(id)}`,
+        { method: "DELETE" }
+      )
+    );
+  }
+  async resolveGrant(request) {
+    return readResponse(
+      await this.fetcher(`${this.baseUrl}/api/grants/resolve`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(request)
+      })
+    );
+  }
+  asUntyped() {
+    return this;
+  }
+};
+function createFoundryClient(options) {
+  return new FoundryClient(options);
+}
+
+export {
+  FoundryRunHandle,
+  FoundryClient,
+  createFoundryClient
+};