glove-foundry 0.0.0

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+export { b2 as FoundryClient, b3 as FoundryClientOptions, bb as FoundryHealth, bK as FoundryRunHandle, cP as WaitOptions, cY as createFoundryClient } from './client-CLkZREDr.js';
+import 'glove-core';
+import 'effect';
+import 'zod';
+import 'glove-mesh';
+import 'glove-mcp';
+import 'glove-memory';
+import 'glove-memory/tools';
+import 'glove-working-environment';
+import 'glove-js';
+import 'glove-lisp';
+import 'glove-python';
+import 'effect/Brand';
+import './config.js';

package/dist/client.js

@@ -0,0 +1,10 @@
+import {
+  FoundryClient,
+  FoundryRunHandle,
+  createFoundryClient
+} from "./chunk-3GCUECPA.js";
+export {
+  FoundryClient,
+  FoundryRunHandle,
+  createFoundryClient
+};

package/dist/config.d.ts

@@ -0,0 +1,49 @@
+/** Framework-level execution policy. The underlying runner is deliberately private. */
+interface FoundryExecutionConfig {
+    readonly pollIntervalMs?: number;
+    readonly idlePollIntervalMs?: number;
+    readonly maxConcurrent?: number;
+    readonly maxAttempts?: number;
+    readonly retryBackoffMs?: number;
+}
+interface FoundryConfig {
+    readonly agentsDir?: string;
+    readonly applicationFile?: string;
+    readonly server?: {
+        readonly host?: string;
+        readonly port?: number;
+    };
+    readonly execution?: FoundryExecutionConfig;
+    readonly observability?: {
+        readonly maxEvents?: number;
+    };
+    readonly strictFileRoutes?: boolean;
+}
+type NoUnknownKeys<T, Shape> = T & Record<Exclude<keyof T, keyof Shape>, never>;
+type ExactFoundryConfig<T extends FoundryConfig> = NoUnknownKeys<T, FoundryConfig> & {
+    readonly server?: T["server"] extends object ? NoUnknownKeys<T["server"], NonNullable<FoundryConfig["server"]>> : T["server"];
+    readonly execution?: T["execution"] extends object ? NoUnknownKeys<T["execution"], FoundryExecutionConfig> : T["execution"];
+    readonly observability?: T["observability"] extends object ? NoUnknownKeys<T["observability"], NonNullable<FoundryConfig["observability"]>> : T["observability"];
+};
+declare function defineConfig<const TConfig extends FoundryConfig>(config: ExactFoundryConfig<TConfig>): TConfig;
+declare const DEFAULT_FOUNDRY_CONFIG: Readonly<{
+    readonly agentsDir: "agents";
+    readonly applicationFile: "foundry.application.ts";
+    readonly server: {
+        readonly host: "127.0.0.1";
+        readonly port: 4141;
+    };
+    readonly execution: {
+        readonly pollIntervalMs: 100;
+        readonly idlePollIntervalMs: 1000;
+        readonly maxConcurrent: 5;
+        readonly maxAttempts: 1;
+        readonly retryBackoffMs: 1000;
+    };
+    readonly observability: {
+        readonly maxEvents: 10000;
+    };
+    readonly strictFileRoutes: true;
+}>;
+
+export { DEFAULT_FOUNDRY_CONFIG, type FoundryConfig, type FoundryExecutionConfig, defineConfig };

package/dist/config.js

@@ -0,0 +1,8 @@
+import {
+  DEFAULT_FOUNDRY_CONFIG,
+  defineConfig
+} from "./chunk-ZFNMFE3T.js";
+export {
+  DEFAULT_FOUNDRY_CONFIG,
+  defineConfig
+};

package/dist/eslint.d.ts

@@ -0,0 +1,122 @@
+type Node = Record<string, any>;
+type RuleContext = {
+    report(input: {
+        node: Node;
+        messageId: string;
+        data?: Record<string, string>;
+    }): void;
+};
+declare const foundryEslintPlugin: Readonly<{
+    rules: Readonly<{
+        "no-agent-contracts": {
+            meta: {
+                type: string;
+                docs: {
+                    description: string;
+                };
+                schema: never[];
+                messages: {
+                    forbidden: string;
+                };
+            };
+            create(context: RuleContext): {
+                CallExpression(node: Node): void;
+                ExportNamedDeclaration(node: Node): void;
+            };
+        };
+        "no-file-definition-id": {
+            meta: {
+                type: string;
+                docs: {
+                    description: string;
+                };
+                schema: never[];
+                messages: {
+                    filename: string;
+                };
+            };
+            create(context: RuleContext): {
+                CallExpression(node: Node): void;
+            };
+        };
+        "no-raw-definition-references": {
+            meta: {
+                type: string;
+                docs: {
+                    description: string;
+                };
+                schema: never[];
+                messages: {
+                    direct: string;
+                };
+            };
+            create(context: RuleContext): {
+                CallExpression(node: Node): void;
+            };
+        };
+    }>;
+}>;
+/** Flat-config preset. Spread it after typescript-eslint's recommended config. */
+declare const foundryEslintConfig: Readonly<{
+    name: "glove-foundry/recommended";
+    files: string[];
+    plugins: {
+        "glove-foundry": Readonly<{
+            rules: Readonly<{
+                "no-agent-contracts": {
+                    meta: {
+                        type: string;
+                        docs: {
+                            description: string;
+                        };
+                        schema: never[];
+                        messages: {
+                            forbidden: string;
+                        };
+                    };
+                    create(context: RuleContext): {
+                        CallExpression(node: Node): void;
+                        ExportNamedDeclaration(node: Node): void;
+                    };
+                };
+                "no-file-definition-id": {
+                    meta: {
+                        type: string;
+                        docs: {
+                            description: string;
+                        };
+                        schema: never[];
+                        messages: {
+                            filename: string;
+                        };
+                    };
+                    create(context: RuleContext): {
+                        CallExpression(node: Node): void;
+                    };
+                };
+                "no-raw-definition-references": {
+                    meta: {
+                        type: string;
+                        docs: {
+                            description: string;
+                        };
+                        schema: never[];
+                        messages: {
+                            direct: string;
+                        };
+                    };
+                    create(context: RuleContext): {
+                        CallExpression(node: Node): void;
+                    };
+                };
+            }>;
+        }>;
+    };
+    rules: {
+        "glove-foundry/no-agent-contracts": string;
+        "glove-foundry/no-file-definition-id": string;
+        "glove-foundry/no-raw-definition-references": string;
+    };
+}>;
+
+export { foundryEslintConfig as default, foundryEslintConfig, foundryEslintPlugin };

package/dist/eslint.js

@@ -0,0 +1,172 @@
+// src/eslint.ts
+function propertyName(property) {
+  if (property.computed) return void 0;
+  return property.key?.name ?? property.key?.value;
+}
+var noAgentContracts = {
+  meta: {
+    type: "problem",
+    docs: { description: "Keep transport input/output contracts out of agent definitions." },
+    schema: [],
+    messages: {
+      forbidden: "Agent definitions cannot export or pass '{{name}}'. Foundry owns invocation and result contracts."
+    }
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee?.type !== "Identifier" || node.callee.name !== "defineAgent") return;
+        const object = node.arguments?.[0];
+        if (object?.type !== "ObjectExpression") return;
+        for (const property of object.properties ?? []) {
+          const name = propertyName(property);
+          if (name === "input" || name === "output") {
+            context.report({ node: property, messageId: "forbidden", data: { name } });
+          }
+        }
+      },
+      ExportNamedDeclaration(node) {
+        const declaration = node.declaration;
+        if (declaration?.type !== "VariableDeclaration") return;
+        for (const item of declaration.declarations ?? []) {
+          const name = item.id?.name;
+          if (name === "input" || name === "output") {
+            context.report({ node: item, messageId: "forbidden", data: { name } });
+          }
+        }
+      }
+    };
+  }
+};
+var noRawDefinitionReferences = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require imported definition values for code-authored Foundry relationships."
+    },
+    schema: [],
+    messages: {
+      direct: "Use the imported {{replacement}} definition instead of '{{name}}'. String ids belong at JSON/API/storage reconstruction boundaries."
+    }
+  },
+  create(context) {
+    const inspectPlaybookValues = (node) => {
+      if (!node || typeof node !== "object") return;
+      if (node.type === "Property") {
+        const name = propertyName(node);
+        const replacement = name === "event" ? "event" : name === "action" ? "action" : name === "applicationAccountId" ? "applicationAccount" : void 0;
+        if (name && replacement && (node.value?.type === "Literal" || name === "applicationAccountId")) {
+          context.report({ node, messageId: "direct", data: { name, replacement } });
+        }
+      }
+      for (const key of ["properties", "elements"]) {
+        for (const child of node[key] ?? []) inspectPlaybookValues(child);
+      }
+      if (node.type === "Property") inspectPlaybookValues(node.value);
+    };
+    return {
+      CallExpression(node) {
+        if (node.callee?.type !== "Identifier") return;
+        const helper = node.callee.name;
+        if (helper === "install") {
+          const config = node.arguments?.[1];
+          if (config?.type === "ObjectExpression") {
+            for (const property of config.properties ?? []) {
+              if (propertyName(property) === "accountId") {
+                context.report({
+                  node: property,
+                  messageId: "direct",
+                  data: { name: "accountId", replacement: "account" }
+                });
+              }
+            }
+          }
+          return;
+        }
+        const object = node.arguments?.[0];
+        if (object?.type !== "ObjectExpression") return;
+        if (helper === "composePlaybook") inspectPlaybookValues(object);
+        const forbidden = helper === "composePlaybook" ? /* @__PURE__ */ new Map([
+          ["transmissionId", "transmission"],
+          ["applicationId", "application"],
+          ["routeId", "route"],
+          ["routeIds", "routes"]
+        ]) : null;
+        if (!forbidden) return;
+        for (const property of object.properties ?? []) {
+          const name = propertyName(property);
+          const replacement = name ? forbidden.get(name) : void 0;
+          if (!name || !replacement) continue;
+          context.report({
+            node: property,
+            messageId: "direct",
+            data: { name, replacement }
+          });
+        }
+      }
+    };
+  }
+};
+var FILE_ROUTED_HELPERS = /* @__PURE__ */ new Set([
+  "defineAgent",
+  "definePlaybookAction",
+  "defineAgentApplication",
+  "defineApp",
+  "defineConnection",
+  "defineLayer",
+  "defineMcp",
+  "defineMemory",
+  "definePlaybookSubscription",
+  "defineSharedTool",
+  "defineSubscriber",
+  "defineTransmission",
+  "defineTransmissionEvent",
+  "defineTransmissionPredicate"
+]);
+var noFileDefinitionId = {
+  meta: {
+    type: "problem",
+    docs: { description: "Let convention filenames own static definition identities." },
+    schema: [],
+    messages: {
+      filename: "Remove this id. Default-export the definition and Foundry will derive its stable identity from the convention filename."
+    }
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee?.type !== "Identifier" || !FILE_ROUTED_HELPERS.has(node.callee.name)) return;
+        const object = node.arguments?.[0];
+        if (object?.type !== "ObjectExpression") return;
+        for (const property of object.properties ?? []) {
+          if (propertyName(property) === "id") {
+            context.report({ node: property, messageId: "filename" });
+          }
+        }
+      }
+    };
+  }
+};
+var foundryEslintPlugin = Object.freeze({
+  rules: Object.freeze({
+    "no-agent-contracts": noAgentContracts,
+    "no-file-definition-id": noFileDefinitionId,
+    "no-raw-definition-references": noRawDefinitionReferences
+  })
+});
+var foundryEslintConfig = Object.freeze({
+  name: "glove-foundry/recommended",
+  files: ["**/*.{ts,tsx,mts,js,mjs}"],
+  plugins: { "glove-foundry": foundryEslintPlugin },
+  rules: {
+    "glove-foundry/no-agent-contracts": "error",
+    "glove-foundry/no-file-definition-id": "error",
+    "glove-foundry/no-raw-definition-references": "error"
+  }
+});
+var eslint_default = foundryEslintConfig;
+export {
+  eslint_default as default,
+  foundryEslintConfig,
+  foundryEslintPlugin
+};

package/dist/execution-agent.d.ts

@@ -0,0 +1,6 @@
+import * as station_signal from 'station-signal';
+
+/** Private execution-backend entrypoint; application modules remain definitions. */
+declare const _default: station_signal.AnySignal;
+
+export { _default as default };

package/dist/execution-agent.js

@@ -0,0 +1,23 @@
+import {
+  FOUNDRY_AGENT_FILE_ENV,
+  FOUNDRY_AGENT_ROUTE_ENV,
+  bindAgentLocalDefinitions,
+  compileAgentModule
+} from "./chunk-CRWY7M66.js";
+
+// src/execution-agent.ts
+import { pathToFileURL } from "node:url";
+import { dirname } from "node:path";
+var route = process.env[FOUNDRY_AGENT_ROUTE_ENV];
+var file = process.env[FOUNDRY_AGENT_FILE_ENV];
+if (!route || !file) {
+  throw new Error(
+    "The Foundry execution entrypoint requires GLOVE_FOUNDRY_AGENT_ROUTE and GLOVE_FOUNDRY_AGENT_FILE."
+  );
+}
+var module = await import(pathToFileURL(file).href);
+await bindAgentLocalDefinitions(dirname(file));
+var execution_agent_default = compileAgentModule(route, module);
+export {
+  execution_agent_default as default
+};

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import { A as AgentPlaybook, F as FoundryRuntime, D as DiscoveredAgent, a as FoundryManifest, b as AnyFoundryTransmission, c as AccountReference, I as InferAccountMetadata, d as AgentBinding, e as AgentInstance, f as FoundryAgentApplication, g as InboundRoute, O as OutboundRoute, C as CapabilityDefinition, h as InferInboundConfig, i as InferOutboundConfig } from './client-CLkZREDr.js';
+export { j as AccountContract, k as AccountDirectory, l as AccountFilter, m as AccountId, n as AccountNotFound, o as AccountSessionAdapter, p as AccountSessionRequest, q as AccountSessionUnavailable, r as AccountSummary, s as AgentApplicationContribution, t as AgentApplicationInstallContext, u as AgentApplicationOptions, v as AgentAssemblyContext, w as AgentAssemblyOptions, x as AgentDefinitionId, y as AgentDefinitionSurfaceContext, z as AgentFactoryContext, B as AgentHandlerContext, E as AgentId, G as AgentInstallContext, H as AgentInstallation, J as AgentInstallationKind, K as AgentPlaybookInput, L as AgentProvisioningPolicy, M as AgentRuntimeControls, N as AnyFoundryAgent, P as ApplicationConnectionContext, Q as ApplicationConnectionState, R as ApplicationConnectionStatus, S as BindingFilter, T as BindingId, U as BindingNotFound, V as CapabilityId, W as ComposedAgentPlaybook, X as ComposedAgentPlaybookInput, Y as ConnectionReceiveInput, Z as Conversation, _ as CreateAgentInstanceOptions, $ as CreateConversationOptions, a0 as CustomProvisionedAgent, a1 as CustomProvisioningContext, a2 as DefineAgentOptions, a3 as DefineConnectionOptions, a4 as DefineFoundryReplOptions, a5 as DefineFoundryScheduleOptions, a6 as DefineFoundrySubagentOptions, a7 as DefineFoundryWorkingEnvironmentOptions, a8 as DefinePlaybookSubscriptionOptions, a9 as DefinitionConfigInput, aa as EMPTY_AGENT_COMPOSITION, ab as EMPTY_CAPABILITY_REGISTRY, ac as EMPTY_FOUNDRY_APPLICATION, ad as EMPTY_NATIVE_REGISTRY, ae as EgressAdapter, af as EgressContext, ag as EnvironmentValue, ah as EventFilter, ai as EventId, aj as EventNotFound, ak as EventReference, al as EventStore, am as FOUNDRY_AGENT_APPLICATION_BRAND, an as FOUNDRY_AGENT_BRAND, ao as FOUNDRY_AGENT_DEFINITION_BRAND, ap as FOUNDRY_AGENT_FILE_ENV, aq as FOUNDRY_AGENT_ROUTE_ENV, ar as FOUNDRY_APPLICATION_BRAND, as as FOUNDRY_APPLICATION_ENV, at as FOUNDRY_COMPOSED_PLAYBOOK_BRAND, au as FOUNDRY_CONNECTION_BRAND, av as FOUNDRY_CORE_COMMAND_EVENT, aw as FOUNDRY_EVENT_PREFIX, ax as FOUNDRY_EXECUTION_MARKER, ay as FOUNDRY_LAYER_BRAND, az as FOUNDRY_MCP_BRAND, aA as FOUNDRY_MEMORY_BRAND, aB as FOUNDRY_PLAYBOOK_ACTION_BRAND, aC as FOUNDRY_REPL_BRAND, aD as FOUNDRY_SCHEDULE_BRAND, aE as FOUNDRY_SHARED_TOOL_BRAND, aF as FOUNDRY_SUBSCRIBER_BRAND, aG as FOUNDRY_TRANSMISSION_BRAND, aH as FOUNDRY_TRANSMISSION_EVENT_BRAND, aI as FOUNDRY_TRANSMISSION_PREDICATE_BRAND, aJ as FOUNDRY_WORKING_ENVIRONMENT_BRAND, aK as FoundryAccountSessionAdapter, aL as FoundryActivationRecord, aM as FoundryAgent, aN as FoundryAgentComponent, aO as FoundryAgentComposition, aP as FoundryAgentConventionModule, aQ as FoundryAgentDefinition, aR as FoundryAgentMode, aS as FoundryApp, aT as FoundryApplication, aU as FoundryApplicationConnection, aV as FoundryApplicationManifest, aW as FoundryApplicationOptions, aX as FoundryCall, aY as FoundryCallContext, aZ as FoundryCallOptions, a_ as FoundryCapabilityKind, a$ as FoundryCapabilityManifest, b0 as FoundryCapabilityManifestEntry, b1 as FoundryCapabilityRegistry, b2 as FoundryClient, b3 as FoundryClientOptions, b4 as FoundryCompositionSource, b5 as FoundryCoreCommand, b6 as FoundryDataAdapter, b7 as FoundryDomainError, b8 as FoundryEvent, b9 as FoundryEventCategory, ba as FoundryExecutionContext, bb as FoundryHealth, bc as FoundryHookDefinition, bd as FoundryInstallable, be as FoundryInstanceProvisioner, bf as FoundryJavaScriptReplDefinition, bg as FoundryLayer, bh as FoundryLayerOptions, bi as FoundryLayerReference, bj as FoundryLayerSelection, bk as FoundryLispReplDefinition, bl as FoundryListResolver, bm as FoundryManifestAgent, bn as FoundryManifestCapability, bo as FoundryManifestTransmission, bp as FoundryMcp, bq as FoundryMcpOptions, br as FoundryMemoryProfile, bs as FoundryMemoryProfileOptions, bt as FoundryMemoryReference, bu as FoundryMemorySelection, bv as FoundryMeshConfig, bw as FoundryMessageInput, bx as FoundryMountedRepl, by as FoundryNativeManifest, bz as FoundryNativeManifestEntry, bA as FoundryNativeRegistry, bB as FoundryObservabilityAdapter, bC as FoundryPlaybookAction, bD as FoundryPythonReplDefinition, bE as FoundryReplDefinition, bF as FoundryRequest, bG as FoundryResolver, bH as FoundryResult, bI as FoundryRouteMap, bJ as FoundryRun, bK as FoundryRunHandle, bL as FoundryRuntimeError, bM as FoundryRuntimeOptions, bN as FoundryScheduleDefinition, bO as FoundryScheduleTiming, bP as FoundryScheduleTimingInput, bQ as FoundrySharedTool, bR as FoundrySubscriber, bS as FoundrySubscriberOptions, bT as FoundrySubscriberSelection, bU as FoundrySurfaceContext, bV as FoundryTask, bW as FoundryTransmission, bX as FoundryTransmissionEvent, bY as FoundryTransmissionPredicate, bZ as FoundryVfs, b_ as FoundryVfsHandle, b$ as FoundryWorkingEnvironmentCreateContext, c0 as FoundryWorkingEnvironmentDefinition, c1 as FoundryWorkingEnvironmentPersistenceAdapter, c2 as FoundryWorkingEnvironmentPersistenceContext, c3 as FoundryWorkingEnvironmentSnapshotOwner, c4 as GrantResolutionError, c5 as GrantResolver, c6 as InboundContract, c7 as InboundDeliveryClaim, c8 as InferAgentInput, c9 as InferAgentOutput, ca as InferInboundEvent, cb as InferOutboundInput, cc as InferOutboundOutput, cd as IngressAdapter, ce as IngressContext, cf as InstallationSelection, cg as ManifestCompilationError, ch as McpAdapterFactory, ci as MemoryFoundryDataAdapter, cj as MemoryObservabilityAdapter, ck as OutboundContract, cl as PlaybookActionOptions, cm as PlaybookDirective, cn as PlaybookDirectiveInput, co as PlaybookMatch, cp as PlaybookMatchInput, cq as PlaybookOutboundDirective, cr as PlaybookOutboundInput, cs as PlaybookSubscription, ct as PlaybookSubscriptionTarget, cu as PlaybookSubscriptionTargetInput, cv as ProvisionAgentOptions, cw as ReplyPolicy, cx as ResolveGrantRequest, cy as Route, cz as RouteFilter, cA as RouteId, cB as RouteNotFound, cC as RunGrant, cD as RunId, cE as SharedInboxItem, cF as SharedToolOptions, cG as TopologyConflict, cH as TopologyStore, cI as TransmissionEventDirection, cJ as TransmissionEventOptions, cK as TransmissionId, cL as TransmissionOptions, cM as TransmissionPredicateOptions, cN as TransmissionSerializationContext, cO as UpdateAgentInstanceOptions, cP as WaitOptions, cQ as WorkspaceEntry, cR as compileApplicationManifest, cS as composeAgent, cT as composePlaybook, cU as configureLayer, cV as configureMemory, cW as createAgentInstance, cX as createConversation, cY as createFoundryClient, cZ as createFoundryCoreTools, c_ as createInstalledApplicationTransmissionTools, c$ as createManifest, d0 as defineAgent, d1 as defineAgentApplication, d2 as defineAgentFromModule, d3 as defineAgentInstance, d4 as defineApp, d5 as defineApplication, d6 as defineCall, d7 as defineConnection, d8 as defineLayer, d9 as defineMcp, da as defineMemory, db as definePlaybookAction, dc as definePlaybookSubscription, dd as defineRepl, de as defineRoutes, df as defineSchedule, dg as defineSharedTool, dh as defineSubagent, di as defineSubscriber, dj as defineTransmission, dk as defineTransmissionEvent, dl as defineTransmissionPredicate, dm as defineWorkingEnvironment, dn as discoverAgents, dp as findAgentFiles, dq as foundryDataEnvironmentPersistence, dr as grantResolverLive, ds as install, dt as installRegistry, du as installationKey, dv as internalAgentName, dw as isFoundryAgent, dx as isFoundryAgentDefinition, dy as isFoundryApplication, dz as isFoundryCapability, dA as isFoundryLayer, dB as isFoundrySchedule, dC as isFoundrySubscriber, dD as isFoundryTransmission, dE as isInboxCapableStore, dF as memoryAccountDirectory, dG as memoryEventStore, dH as memoryTopologyStore, dI as mountAgentDefinitionMemory, dJ as mountFoundrySurfaces, dK as reconstructAgentInstance, dL as reconstructPlaybook, dM as reconstructPlaybookSubscription, dN as routeFromAgentFile, dO as routeFromInternalAgentName, dP as toGloveMessage, dQ as toGloveRequestInput, dR as transmissionPredicate } from './client-CLkZREDr.js';
+import { AddressInfo } from 'node:net';
+export { FoundryConfig, FoundryExecutionConfig, defineConfig } from './config.js';
+import 'glove-core';
+import 'effect';
+import 'zod';
+import 'glove-mesh';
+import 'glove-mcp';
+import 'glove-memory';
+import 'glove-memory/tools';
+import 'glove-working-environment';
+import 'glove-js';
+import 'glove-lisp';
+import 'glove-python';
+import 'effect/Brand';
+
+/** Deterministic default rendering for an event merged into a Glove conversation. */
+declare function serializeInboundTransmissionXml(input: {
+    readonly transmissionId: string;
+    readonly routeId: string;
+    readonly eventId: string;
+    readonly eventName: string;
+    readonly threadKey: string;
+    readonly event: unknown;
+    readonly playbooks: ReadonlyArray<AgentPlaybook>;
+}): string;
+
+interface FoundryServerOptions {
+    host?: string;
+    port?: number;
+}
+declare class FoundryServer {
+    private readonly runtime;
+    private readonly options;
+    private readonly server;
+    private readonly eventStreams;
+    private addressInfo;
+    constructor(runtime: FoundryRuntime, options?: FoundryServerOptions);
+    listen(): Promise<{
+        host: string;
+        port: number;
+        url: string;
+    }>;
+    close(): Promise<void>;
+    address(): AddressInfo | null;
+    private handle;
+    private streamEvents;
+}
+
+declare function writeGeneratedTypes(options: {
+    rootDir: string;
+    agents: readonly DiscoveredAgent[];
+    manifest: FoundryManifest;
+}): Promise<{
+    routesFile: string;
+    manifestFile: string;
+}>;
+
+type DefineAccountOptions<TTransmission extends AnyFoundryTransmission = AnyFoundryTransmission> = Omit<AccountReference, "id" | "transmissionId" | "metadata"> & {
+    readonly id: string;
+    readonly transmission: TTransmission;
+    readonly metadata: InferAccountMetadata<TTransmission>;
+};
+declare function defineAccount<TTransmission extends AnyFoundryTransmission>(options: DefineAccountOptions<TTransmission>): AccountReference & {
+    readonly metadata: InferAccountMetadata<TTransmission>;
+};
+interface RouteReferenceOptions<TTransmission extends AnyFoundryTransmission> {
+    readonly transmission: TTransmission;
+    readonly account?: AccountReference;
+}
+type DefineInboundRouteOptions<TTransmission extends AnyFoundryTransmission = AnyFoundryTransmission> = Omit<InboundRoute, "id" | "direction" | "transmissionId" | "accountId" | "config"> & RouteReferenceOptions<TTransmission> & {
+    readonly id: string;
+    readonly config: InferInboundConfig<TTransmission>;
+};
+declare function defineInboundRoute<TTransmission extends AnyFoundryTransmission>(options: DefineInboundRouteOptions<TTransmission>): InboundRoute & {
+    readonly config: InferInboundConfig<TTransmission>;
+};
+type DefineOutboundRouteOptions<TTransmission extends AnyFoundryTransmission = AnyFoundryTransmission> = Omit<OutboundRoute, "id" | "direction" | "transmissionId" | "accountId" | "config"> & RouteReferenceOptions<TTransmission> & {
+    readonly id: string;
+    readonly config: InferOutboundConfig<TTransmission>;
+};
+declare function defineOutboundRoute<TTransmission extends AnyFoundryTransmission>(options: DefineOutboundRouteOptions<TTransmission>): OutboundRoute & {
+    readonly config: InferOutboundConfig<TTransmission>;
+};
+interface DefineBindingOptions extends Omit<AgentBinding, "id" | "agentId" | "transmissionId" | "accountId" | "routeId" | "capabilities" | "reply"> {
+    readonly id: string;
+    readonly agent: AgentInstance;
+    readonly application?: FoundryAgentApplication;
+    readonly transmission: AnyFoundryTransmission;
+    readonly account?: AccountReference;
+    readonly route?: InboundRoute | OutboundRoute;
+    readonly capabilities: ReadonlyArray<CapabilityDefinition>;
+    readonly reply?: {
+        readonly mode: "none" | "origin";
+    } | {
+        readonly mode: "route";
+        readonly route: OutboundRoute;
+    };
+}
+declare function defineBinding(options: DefineBindingOptions): AgentBinding;
+
+export { AccountReference, AgentBinding, AgentInstance, AgentPlaybook, AnyFoundryTransmission, CapabilityDefinition, type DefineAccountOptions, type DefineBindingOptions, type DefineInboundRouteOptions, type DefineOutboundRouteOptions, DiscoveredAgent, FoundryAgentApplication, FoundryManifest, FoundryRuntime, FoundryServer, type FoundryServerOptions, InboundRoute, InferAccountMetadata, InferInboundConfig, InferOutboundConfig, OutboundRoute, defineAccount, defineBinding, defineInboundRoute, defineOutboundRoute, serializeInboundTransmissionXml, writeGeneratedTypes };