glove-foundry 0.0.0

package/dist/index.js

@@ -0,0 +1,402 @@
+import {
+  AccountDirectory,
+  AccountId,
+  AccountNotFound,
+  AccountReference,
+  AccountSessionUnavailable,
+  AccountSummary,
+  AgentBinding,
+  AgentDefinitionId,
+  AgentId,
+  BindingId,
+  BindingNotFound,
+  CapabilityId,
+  EMPTY_AGENT_COMPOSITION,
+  EventId,
+  EventNotFound,
+  EventReference,
+  EventStore,
+  FoundryApplicationManifest,
+  FoundryManifestCapability,
+  FoundryManifestTransmission,
+  FoundryRuntime,
+  FoundryRuntimeError,
+  FoundryServer,
+  GrantResolutionError,
+  GrantResolver,
+  InboundRoute,
+  ManifestCompilationError,
+  MemoryObservabilityAdapter,
+  OutboundRoute,
+  ReplyPolicy,
+  Route,
+  RouteId,
+  RouteNotFound,
+  RunGrant,
+  RunId,
+  TopologyConflict,
+  TopologyStore,
+  TransmissionId,
+  compileApplicationManifest,
+  composeAgent,
+  grantResolverLive,
+  memoryAccountDirectory,
+  memoryEventStore,
+  memoryTopologyStore,
+  serializeInboundTransmissionXml,
+  writeGeneratedTypes
+} from "./chunk-UNHGCCSA.js";
+import {
+  FoundryClient,
+  FoundryRunHandle,
+  createFoundryClient
+} from "./chunk-3GCUECPA.js";
+import {
+  defineConfig
+} from "./chunk-ZFNMFE3T.js";
+import {
+  EMPTY_CAPABILITY_REGISTRY,
+  EMPTY_FOUNDRY_APPLICATION,
+  EMPTY_NATIVE_REGISTRY,
+  FOUNDRY_AGENT_APPLICATION_BRAND,
+  FOUNDRY_AGENT_BRAND,
+  FOUNDRY_AGENT_DEFINITION_BRAND,
+  FOUNDRY_AGENT_FILE_ENV,
+  FOUNDRY_AGENT_ROUTE_ENV,
+  FOUNDRY_APPLICATION_BRAND,
+  FOUNDRY_APPLICATION_ENV,
+  FOUNDRY_COMPOSED_PLAYBOOK_BRAND,
+  FOUNDRY_CONNECTION_BRAND,
+  FOUNDRY_CORE_COMMAND_EVENT,
+  FOUNDRY_EVENT_PREFIX,
+  FOUNDRY_EXECUTION_MARKER,
+  FOUNDRY_LAYER_BRAND,
+  FOUNDRY_MCP_BRAND,
+  FOUNDRY_MEMORY_BRAND,
+  FOUNDRY_PLAYBOOK_ACTION_BRAND,
+  FOUNDRY_REPL_BRAND,
+  FOUNDRY_SCHEDULE_BRAND,
+  FOUNDRY_SHARED_TOOL_BRAND,
+  FOUNDRY_SUBSCRIBER_BRAND,
+  FOUNDRY_TRANSMISSION_BRAND,
+  FOUNDRY_TRANSMISSION_EVENT_BRAND,
+  FOUNDRY_TRANSMISSION_PREDICATE_BRAND,
+  FOUNDRY_WORKING_ENVIRONMENT_BRAND,
+  MemoryFoundryDataAdapter,
+  composePlaybook,
+  configureLayer,
+  configureMemory,
+  createAgentInstance,
+  createConversation,
+  createFoundryCoreTools,
+  createInstalledApplicationTransmissionTools,
+  createManifest,
+  defineAgent,
+  defineAgentApplication,
+  defineAgentFromModule,
+  defineAgentInstance,
+  defineApp,
+  defineApplication,
+  defineCall,
+  defineConnection,
+  defineLayer,
+  defineMcp,
+  defineMemory,
+  definePlaybookAction,
+  definePlaybookSubscription,
+  defineRepl,
+  defineRoutes,
+  defineSchedule,
+  defineSharedTool,
+  defineSubagent,
+  defineSubscriber,
+  defineTransmission,
+  defineTransmissionEvent,
+  defineTransmissionPredicate,
+  defineWorkingEnvironment,
+  discoverAgents,
+  findAgentFiles,
+  foundryDataEnvironmentPersistence,
+  install,
+  installRegistry,
+  installationKey,
+  internalAgentName,
+  isFoundryAgent,
+  isFoundryAgentDefinition,
+  isFoundryApplication,
+  isFoundryCapability,
+  isFoundryLayer,
+  isFoundrySchedule,
+  isFoundrySubscriber,
+  isFoundryTransmission,
+  isInboxCapableStore,
+  mountAgentDefinitionMemory,
+  mountFoundrySurfaces,
+  reconstructAgentInstance,
+  reconstructPlaybook,
+  reconstructPlaybookSubscription,
+  routeFromAgentFile,
+  routeFromInternalAgentName,
+  toGloveMessage,
+  toGloveRequestInput,
+  transmissionPredicate
+} from "./chunk-CRWY7M66.js";
+
+// src/authoring.ts
+import { Schema } from "effect";
+var accountTransmissions = /* @__PURE__ */ new WeakMap();
+var routeTransmissions = /* @__PURE__ */ new WeakMap();
+function defineAccount(options) {
+  const { transmission, ...data } = options;
+  if (!transmission.account) {
+    throw new Error("The referenced transmission has no account contract.");
+  }
+  const metadata = Schema.decodeUnknownSync(transmission.account.metadata)(data.metadata);
+  const decoded = Schema.decodeUnknownSync(AccountReference)({
+    ...data,
+    metadata,
+    transmissionId: "pending"
+  });
+  const account = { ...decoded };
+  Object.defineProperty(account, "transmissionId", {
+    enumerable: true,
+    get: () => transmission.id
+  });
+  accountTransmissions.set(account, transmission);
+  return Object.freeze(account);
+}
+function defineInboundRoute(options) {
+  const { transmission, account, ...data } = options;
+  if (!transmission.inbound) {
+    throw new Error("The referenced transmission has no inbound contract.");
+  }
+  if (account && accountTransmissions.get(account) !== transmission) {
+    throw new Error(`Account "${account.id}" belongs to another transmission.`);
+  }
+  const config = Schema.decodeUnknownSync(transmission.inbound.config)(data.config);
+  const decoded = Schema.decodeUnknownSync(InboundRoute)({
+    ...data,
+    config,
+    direction: "inbound",
+    transmissionId: "pending",
+    ...account ? { accountId: account.id } : {}
+  });
+  const route = { ...decoded };
+  Object.defineProperty(route, "transmissionId", {
+    enumerable: true,
+    get: () => transmission.id
+  });
+  routeTransmissions.set(route, transmission);
+  return Object.freeze(route);
+}
+function defineOutboundRoute(options) {
+  const { transmission, account, ...data } = options;
+  if (!transmission.outbound) {
+    throw new Error("The referenced transmission has no outbound contract.");
+  }
+  if (account && accountTransmissions.get(account) !== transmission) {
+    throw new Error(`Account "${account.id}" belongs to another transmission.`);
+  }
+  const config = Schema.decodeUnknownSync(transmission.outbound.config)(data.config);
+  const decoded = Schema.decodeUnknownSync(OutboundRoute)({
+    ...data,
+    config,
+    direction: "outbound",
+    transmissionId: "pending",
+    ...account ? { accountId: account.id } : {}
+  });
+  const route = { ...decoded };
+  Object.defineProperty(route, "transmissionId", {
+    enumerable: true,
+    get: () => transmission.id
+  });
+  routeTransmissions.set(route, transmission);
+  return Object.freeze(route);
+}
+function defineBinding(options) {
+  const {
+    agent,
+    application,
+    transmission,
+    account,
+    route,
+    capabilities,
+    reply,
+    ...data
+  } = options;
+  if (application && !application.transmissions?.some(
+    (candidate) => candidate === transmission
+  )) {
+    throw new Error(
+      `Application "${application.id}" does not own transmission "${transmission.id}".`
+    );
+  }
+  if (route && routeTransmissions.get(route) !== transmission) {
+    throw new Error(
+      `Route "${route.id}" does not belong to the referenced transmission.`
+    );
+  }
+  if (account && accountTransmissions.get(account) !== transmission) {
+    throw new Error(
+      `Account "${account.id}" does not belong to the referenced transmission.`
+    );
+  }
+  const decoded = Schema.decodeUnknownSync(AgentBinding)({
+    ...data,
+    agentId: agent.id,
+    transmissionId: "pending",
+    ...account ? { accountId: account.id } : {},
+    ...route ? { routeId: route.id } : {},
+    capabilities: capabilities.map((capability) => capability.id),
+    ...reply ? {
+      reply: reply.mode === "route" ? { mode: "route", routeId: reply.route.id } : reply
+    } : {}
+  });
+  const binding = { ...decoded };
+  Object.defineProperty(binding, "transmissionId", {
+    enumerable: true,
+    get: () => transmission.id
+  });
+  return Object.freeze(binding);
+}
+export {
+  AccountDirectory,
+  AccountId,
+  AccountNotFound,
+  AccountReference,
+  AccountSessionUnavailable,
+  AccountSummary,
+  AgentBinding,
+  AgentDefinitionId,
+  AgentId,
+  BindingId,
+  BindingNotFound,
+  CapabilityId,
+  EMPTY_AGENT_COMPOSITION,
+  EMPTY_CAPABILITY_REGISTRY,
+  EMPTY_FOUNDRY_APPLICATION,
+  EMPTY_NATIVE_REGISTRY,
+  EventId,
+  EventNotFound,
+  EventReference,
+  EventStore,
+  FOUNDRY_AGENT_APPLICATION_BRAND,
+  FOUNDRY_AGENT_BRAND,
+  FOUNDRY_AGENT_DEFINITION_BRAND,
+  FOUNDRY_AGENT_FILE_ENV,
+  FOUNDRY_AGENT_ROUTE_ENV,
+  FOUNDRY_APPLICATION_BRAND,
+  FOUNDRY_APPLICATION_ENV,
+  FOUNDRY_COMPOSED_PLAYBOOK_BRAND,
+  FOUNDRY_CONNECTION_BRAND,
+  FOUNDRY_CORE_COMMAND_EVENT,
+  FOUNDRY_EVENT_PREFIX,
+  FOUNDRY_EXECUTION_MARKER,
+  FOUNDRY_LAYER_BRAND,
+  FOUNDRY_MCP_BRAND,
+  FOUNDRY_MEMORY_BRAND,
+  FOUNDRY_PLAYBOOK_ACTION_BRAND,
+  FOUNDRY_REPL_BRAND,
+  FOUNDRY_SCHEDULE_BRAND,
+  FOUNDRY_SHARED_TOOL_BRAND,
+  FOUNDRY_SUBSCRIBER_BRAND,
+  FOUNDRY_TRANSMISSION_BRAND,
+  FOUNDRY_TRANSMISSION_EVENT_BRAND,
+  FOUNDRY_TRANSMISSION_PREDICATE_BRAND,
+  FOUNDRY_WORKING_ENVIRONMENT_BRAND,
+  FoundryApplicationManifest,
+  FoundryClient,
+  FoundryManifestCapability,
+  FoundryManifestTransmission,
+  FoundryRunHandle,
+  FoundryRuntime,
+  FoundryRuntimeError,
+  FoundryServer,
+  GrantResolutionError,
+  GrantResolver,
+  InboundRoute,
+  ManifestCompilationError,
+  MemoryFoundryDataAdapter,
+  MemoryObservabilityAdapter,
+  OutboundRoute,
+  ReplyPolicy,
+  Route,
+  RouteId,
+  RouteNotFound,
+  RunGrant,
+  RunId,
+  TopologyConflict,
+  TopologyStore,
+  TransmissionId,
+  compileApplicationManifest,
+  composeAgent,
+  composePlaybook,
+  configureLayer,
+  configureMemory,
+  createAgentInstance,
+  createConversation,
+  createFoundryClient,
+  createFoundryCoreTools,
+  createInstalledApplicationTransmissionTools,
+  createManifest,
+  defineAccount,
+  defineAgent,
+  defineAgentApplication,
+  defineAgentFromModule,
+  defineAgentInstance,
+  defineApp,
+  defineApplication,
+  defineBinding,
+  defineCall,
+  defineConfig,
+  defineConnection,
+  defineInboundRoute,
+  defineLayer,
+  defineMcp,
+  defineMemory,
+  defineOutboundRoute,
+  definePlaybookAction,
+  definePlaybookSubscription,
+  defineRepl,
+  defineRoutes,
+  defineSchedule,
+  defineSharedTool,
+  defineSubagent,
+  defineSubscriber,
+  defineTransmission,
+  defineTransmissionEvent,
+  defineTransmissionPredicate,
+  defineWorkingEnvironment,
+  discoverAgents,
+  findAgentFiles,
+  foundryDataEnvironmentPersistence,
+  grantResolverLive,
+  install,
+  installRegistry,
+  installationKey,
+  internalAgentName,
+  isFoundryAgent,
+  isFoundryAgentDefinition,
+  isFoundryApplication,
+  isFoundryCapability,
+  isFoundryLayer,
+  isFoundrySchedule,
+  isFoundrySubscriber,
+  isFoundryTransmission,
+  isInboxCapableStore,
+  memoryAccountDirectory,
+  memoryEventStore,
+  memoryTopologyStore,
+  mountAgentDefinitionMemory,
+  mountFoundrySurfaces,
+  reconstructAgentInstance,
+  reconstructPlaybook,
+  reconstructPlaybookSubscription,
+  routeFromAgentFile,
+  routeFromInternalAgentName,
+  serializeInboundTransmissionXml,
+  toGloveMessage,
+  toGloveRequestInput,
+  transmissionPredicate,
+  writeGeneratedTypes
+};

package/docs/README.md

@@ -0,0 +1,13 @@
+# Glove Foundry documentation
+
+The published, task-oriented handbook lives at
+[glove.dterminal.net/foundry/docs](https://glove.dterminal.net/foundry/docs).
+These package-local documents provide the implementation-level companion reference.
+
+- [Building with Foundry](./building-with-foundry.md): project layout and complete authoring flow.
+- [Architecture](./architecture.md): definitions, instances, subscriptions, connections, and adapter boundaries.
+- [Inspector](./inspector.md): page hierarchy, run traces, live updates, and the operator API.
+- [Evaluation checklist](./evaluation-checklist.md): concrete review criteria and verification commands.
+- [Implementation backlog](./implementation-backlog.md): remaining follow-up work, if any.
+
+The runnable reference is [`examples/foundry-agent`](../../../examples/foundry-agent).

package/docs/architecture.md

@@ -0,0 +1,175 @@
+# Architecture
+
+## Boundary rule
+
+Foundry exposes concepts that belong to an agentic application. Its execution engine is private and replaceable.
+
+```text
+file-routed code definitions           durable data
+────────────────                       ────────────
+agent definition ────────────────┐      agent instance
+application + transmissions ─────┼──▶   installations + playbooks
+tools / MCP / memory / layers ───┤      conversations + workspace state
+working environment / REPL ──────┘      VFS snapshots + artifacts
+                                        subscriptions + delivery claims
+
+              resolve file identity and serialize here
+```
+
+No public config, client, HTTP route, manifest, or inspector component requires knowledge of the private runner.
+
+## Definition versus instance
+
+An agent definition is immutable code. Its convention filename owns its identity; the definition never repeats that route as an `id`. It describes the catalogue and lazy assembly functions available to all instances of that route. Applications, transmissions, predicates, connections, shared tools, MCPs, memory profiles, layers, subscribers, and playbook actions are reusable code primitives. Playbooks are runtime policy composed by an agent resolver or frontend. Schedules are agent-local definition values reconciled into runtime activation data; neither playbooks nor schedules have a global static registry.
+
+An agent instance is mutable desired-state data:
+
+```ts
+interface AgentInstance {
+  id: string
+  definitionId: string
+  workspaceId: string
+  provisioningKey?: string
+  context: Record<string, unknown>
+  installations: AgentInstallation[]
+  playbooks: AgentPlaybook[]
+  createdAt: string
+  updatedAt: string
+}
+```
+
+`FoundryDataAdapter` is the source of truth. Every run reloads the instance and conversation, then assembles a fresh Glove from the referenced definition and current message. Lazy `playbooks` and `schedules` resolvers reconcile desired runtime data before Foundry executes subsequent activations. `configureAgent` atomically replaces frontend-editable context, installations, and playbooks.
+
+Definitions never accept an invocation input or output schema. Foundry owns those contracts.
+
+## Reference normalization
+
+Code references values:
+
+```ts
+composePlaybook({
+  name: "mention-response",
+  transmission: messages,
+  match: { event: messageReceived, routes: [inbound], predicate: { definition: isMention } },
+  directives: [{ action: respond, instruction: "Answer the message." }],
+  applications: [chatApp],
+})
+```
+
+Persisted records reference ids:
+
+```ts
+{
+  transmissionId: "messages",
+  match: { event: "message-received", routeIds: ["chat-inbound"], predicate: { name: "is-mention" } },
+  directives: [{ action: "respond", instruction: "Answer the message." }],
+  applications: ["chat-app"]
+}
+```
+
+File-routed definition helpers retain direct references for reusable code primitives. `composePlaybook` instead runs inside lazy assembly: Foundry derives a stable instance-scoped id, converts its imported references to strings, and persists the resulting policy. Reconstruction accepts the value-only storage/API form.
+
+Runtime records are different: account, route, binding, agent-instance, and conversation IDs are data-owned because those records can be created or edited by a UI or adapter.
+
+## Typed config flow
+
+Config schemas belong to the definition that consumes them. Zod schemas infer the input accepted by `install`, `configureLayer`, and `configureMemory`, and infer decoded config inside their callbacks. Effect transmission schemas infer account metadata, route config, inbound events, and outbound input/output. All schemas are decoded again at runtime boundaries.
+
+`defineConfig` keeps the exact inferred configuration type and rejects unknown framework keys, including nested server, execution, and observability keys.
+
+## Applications and transmissions
+
+An application owns one or many transmission definitions. A transmission may define:
+
+- account metadata schema;
+- capability declarations;
+- inbound config/event schemas, authentication, normalization, classification, predicates, and serialization; and
+- outbound config/input/output schemas and a delivery adapter.
+
+Applications are not installed by default. Their optional install hook is a headless factory that may contribute tools without receiving the Glove runtime or store. Foundry passes an operation-scoped account-session function when the user provided one; it never passes raw credentials.
+
+## Inbound activation
+
+```text
+application connection / HTTP fire
+              │
+              ▼
+ authenticate + normalize + classify
+              │
+              ▼
+ match instance playbooks and durable subscriptions
+              │
+              ├── existing instances
+              └── atomically provision zero, one, or many instances
+                          │
+                          ▼
+              merge serialized event into a conversation
+                          │
+                          ▼
+                    enqueue agent runs
+```
+
+The delivery key is `routeId:eventId`. The data adapter claims it before provisioning. A completed claim stores run ids; a retry returns those runs. Failed dispatch releases the pending claim.
+
+## Playbook subscription
+
+A subscription is durable data containing one playbook and one or more targets. It is evaluated even if no matching instance exists.
+
+Each target selects a provisioning policy. The built-in policies derive deterministic `provisioningKey` values. A custom policy calls the application-owned provisioner, which can return multiple instance seeds. `provisionAgent` is atomic at the adapter boundary.
+
+The subscription target also carries desired installations and initial context because these are instance data chosen by a frontend/operator, not static agent-definition defaults.
+
+## Application connections
+
+A connection is colocated with its application and names the inbound transmissions it may emit. It receives a narrow context:
+
+- application/connection/definition/workspace identity;
+- safe account metadata and routes;
+- an abort signal;
+- `ready()`;
+- `receive()`; and
+- optional user-owned `withAccountSession()`.
+
+The supervisor derives desired connections from installed application + active playbook combinations. It starts, stops, retries, and observes them. Its implementation can use any backend; retry/worker topology is not exposed as an authoring primitive.
+
+## Conversations and workspaces
+
+Conversations are independent data records owned by an instance. Transmission conversations derive stable ids from route, instance, and external thread. Direct conversations can be created freely.
+
+Workspace entries, inbox items, tasks, scoped environment values, and optional working-environment snapshots share the data adapter. They are suitable for document handles and coordination state across agents.
+
+## Working environment and REPL boundary
+
+Foundry owns contextual selection, mounting, lifecycle, and observability. The native packages retain their own semantics:
+
+- `glove-working-environment` owns the guarded VFS, script sandbox, tools, snapshots, limits, adapters, and cleanup;
+- `glove-js`, `glove-python`, and `glove-lisp` own their interpreter sessions and capability catalogs; and
+- consumer adapters own remote VFS storage, locking, credentials, and persistence policy.
+
+An agent can resolve either surface from its current instance, conversation, workspace, or message. Foundry exposes the mounted environment and guarded VFS to execution contexts, snapshots before cleanup when a persistence adapter is present, and emits safe mount/save telemetry. It permits one REPL per assembled agent to prevent colliding execution and discovery tool names.
+
+The durable boundary is the VFS. Native REPL interpreter bindings are run-scoped and are not serialized by Foundry.
+
+## Lazy assembly
+
+Every run resolves model, system prompt, tools, memory, inboxes, subscribers, layers, calls, playbooks, schedules, mesh, working environment, REPL, and custom build/run functions against `AgentAssemblyContext`. Resolvers can use both the instance and the current message, which makes message-dependent provisioning a first-class behavior rather than an environment switch.
+
+Installable applications, shared tools, and MCPs are filtered by the current instance desired state. Memory belongs to the definition but can be selected lazily. Inboxes must always be lazy functions.
+
+## Observability
+
+All public events use Foundry categories: agent, run, model, tool, extension, application, inbox, memory, MCP, activation, system, and log. Each event may correlate definition id, run id, sequence, timestamp, and safe data.
+
+The inspector presents the causal chain rather than backend logs. Raw event data remains available behind each run for debugging.
+
+## Credential boundary
+
+Foundry stores only account metadata and opaque access references. It does not:
+
+- acquire credentials;
+- refresh tokens;
+- persist secret values in manifests;
+- choose an account for a user; or
+- expose credential material to prompts or the inspector.
+
+Applications define account-session and provider adapters. Playbooks and instance installation data select account references.