@finalai/agent-definition 0.1.0

package/dist/modules/manifest.mjs

@@ -0,0 +1,67 @@
+import {
+  BaseCapability,
+  DynamicEvent,
+  InstructionRole,
+  MANIFEST_VERSION,
+  McpServerBindingKind,
+  SandboxAccess,
+  SandboxAttach,
+  ScheduleTarget,
+  ToolApproval,
+  agentManifestSchema,
+  baseToolsSchema,
+  bundleSchema,
+  channelBindingSchema,
+  dynamicSlotSchema,
+  emptyManifest,
+  findDynamicSlots,
+  harnessBindingSchema,
+  hookBindingSchema,
+  httpMcpServerBindingSchema,
+  identitySchema,
+  instructionFragmentSchema,
+  isDynamicSlot,
+  mcpAuthSchema,
+  mcpServerBindingSchema,
+  resolvedAgentManifestSchema,
+  sandboxBindingSchema,
+  scheduleDefinitionSchema,
+  skillBundleSchema,
+  skillFileSchema,
+  toolDescriptorSchema,
+  workerMcpServerBindingSchema
+} from "@finalai/agent-provider";
+export {
+  BaseCapability,
+  DynamicEvent,
+  InstructionRole,
+  MANIFEST_VERSION,
+  McpServerBindingKind,
+  SandboxAccess,
+  SandboxAttach,
+  ScheduleTarget,
+  ToolApproval,
+  agentManifestSchema,
+  baseToolsSchema,
+  bundleSchema,
+  channelBindingSchema,
+  dynamicSlotSchema,
+  emptyManifest,
+  findDynamicSlots,
+  harnessBindingSchema,
+  hookBindingSchema,
+  httpMcpServerBindingSchema,
+  identitySchema,
+  instructionFragmentSchema,
+  isDynamicSlot,
+  mcpAuthSchema,
+  mcpServerBindingSchema,
+  resolvedAgentManifestSchema,
+  sandboxBindingSchema,
+  scheduleDefinitionSchema,
+  skillBundleSchema,
+  skillFileSchema,
+  toolDescriptorSchema,
+  workerMcpServerBindingSchema
+};
+//# sourceMappingURL=manifest.mjs.map

package/dist/modules/manifest.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/manifest.ts"],
+  "sourcesContent": ["// The Agent Manifest lives in the provider contract (harnesses, sandboxes and\n// channels receive it); this package compiles directories into it.\nexport {\n  BaseCapability,\n  DynamicEvent,\n  InstructionRole,\n  MANIFEST_VERSION,\n  McpServerBindingKind,\n  SandboxAccess,\n  SandboxAttach,\n  ScheduleTarget,\n  ToolApproval,\n  agentManifestSchema,\n  baseToolsSchema,\n  bundleSchema,\n  channelBindingSchema,\n  dynamicSlotSchema,\n  emptyManifest,\n  findDynamicSlots,\n  harnessBindingSchema,\n  hookBindingSchema,\n  httpMcpServerBindingSchema,\n  identitySchema,\n  instructionFragmentSchema,\n  isDynamicSlot,\n  mcpAuthSchema,\n  mcpServerBindingSchema,\n  resolvedAgentManifestSchema,\n  sandboxBindingSchema,\n  scheduleDefinitionSchema,\n  skillBundleSchema,\n  skillFileSchema,\n  toolDescriptorSchema,\n  workerMcpServerBindingSchema,\n} from '@finalai/agent-provider';\nexport type {\n  AgentManifestIface,\n  BaseToolsIface,\n  BundleIface,\n  ChannelBindingIface,\n  DynamicSlotIface,\n  DynamicSlotLocationIface,\n  HarnessBindingIface,\n  HookBindingIface,\n  HttpMcpServerBindingIface,\n  IdentityIface,\n  InstructionFragmentIface,\n  McpAuth,\n  McpServerBinding,\n  ResolvedAgentManifestIface,\n  ResolvedSandboxBindingIface,\n  SandboxBindingIface,\n  ScheduleDefinitionIface,\n  SkillBundleIface,\n  ToolDescriptorIface,\n  WorkerMcpServerBindingIface,\n} from '@finalai/agent-provider';\n"],
+  "mappings": "AAEA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
+  "names": []
+}

package/dist/modules/resolve.d.mts

@@ -0,0 +1,24 @@
+import { type AgentManifestIface, type DynamicEvent, type DynamicSlotIface, type JsonValue, type ResolvedAgentManifestIface } from '@finalai/agent-provider';
+export type ResolveSlot = (slot: DynamicSlotIface, path: string) => Promise<JsonValue | null>;
+export interface ResolveManifestArgsIface {
+    manifest: AgentManifestIface;
+    event: DynamicEvent;
+    resolve: ResolveSlot;
+    previous?: Record<string, JsonValue | null>;
+}
+export interface ResolvedManifestDetailIface {
+    manifest: ResolvedAgentManifestIface;
+    values: Record<string, JsonValue | null>;
+}
+export declare enum SlotValueKind {
+    InstructionFragment = "instruction-fragment",
+    SkillBundle = "skill-bundle",
+    McpServers = "mcp-servers",
+    Sandboxes = "sandboxes",
+    SandboxEnvironment = "sandbox-environment",
+    Opaque = "opaque"
+}
+export declare const slotKindOf: (path: string) => SlotValueKind;
+export declare const validateSlotValue: (path: string, value: JsonValue | null, manifest?: AgentManifestIface) => JsonValue | null;
+export declare const resolveManifestDetailed: (args: ResolveManifestArgsIface) => Promise<ResolvedManifestDetailIface>;
+export declare const resolveManifest: (args: ResolveManifestArgsIface) => Promise<ResolvedAgentManifestIface>;

package/dist/modules/resolve.mjs

@@ -0,0 +1,176 @@
+import {
+  findDynamicSlots,
+  formatProviderRef,
+  instructionFragmentSchema,
+  isDynamicSlot,
+  jsonObjectSchema,
+  jsonValueSchema,
+  mcpServerBindingSchema,
+  ProviderRefKind,
+  providerRefSchema,
+  resolvedAgentManifestSchema,
+  sandboxBindingSchema,
+  skillBundleSchema
+} from "@finalai/agent-provider";
+import * as z from "zod";
+var SlotValueKind = /* @__PURE__ */ ((SlotValueKind2) => {
+  SlotValueKind2["InstructionFragment"] = "instruction-fragment";
+  SlotValueKind2["SkillBundle"] = "skill-bundle";
+  SlotValueKind2["McpServers"] = "mcp-servers";
+  SlotValueKind2["Sandboxes"] = "sandboxes";
+  SlotValueKind2["SandboxEnvironment"] = "sandbox-environment";
+  SlotValueKind2["Opaque"] = "opaque";
+  return SlotValueKind2;
+})(SlotValueKind || {});
+const slotKindOf = (path) => {
+  if (/^harness\.config\.instructions\[\d+\]$/.test(path)) return "instruction-fragment" /* InstructionFragment */;
+  if (/^harness\.config\.skills\[\d+\]$/.test(path)) return "skill-bundle" /* SkillBundle */;
+  if (path === "mcpServers") return "mcp-servers" /* McpServers */;
+  if (path === "sandboxes") return "sandboxes" /* Sandboxes */;
+  if (/^sandboxes\.[^.]+\.environment$/.test(path)) return "sandbox-environment" /* SandboxEnvironment */;
+  return "opaque" /* Opaque */;
+};
+const resolvedSandboxesSchema = z.record(
+  z.string(),
+  sandboxBindingSchema.extend({ environment: jsonValueSchema })
+);
+const issueText = (error) => error.issues.map((issue) => `${issue.path.join(".") || "value"}: ${issue.message}`).join("; ");
+const invalid = (path, detail) => new Error(`dynamic slot ${path} resolved to an invalid value: ${detail}`);
+const parseAs = (schema, value, path) => {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) throw invalid(path, issueText(parsed.error));
+  return jsonValueSchema.parse(parsed.data);
+};
+const isRecord = (value) => jsonObjectSchema.safeParse(value).success;
+const roleless = z.looseObject({ role: z.null().optional() });
+const environmentResultSchema = z.looseObject({
+  providerName: z.string(),
+  providerRef: jsonValueSchema.optional(),
+  options: jsonValueSchema.optional(),
+  openOptions: jsonValueSchema.optional()
+});
+const validateSlotValue = (path, value, manifest) => {
+  if (value == null) return null;
+  switch (slotKindOf(path)) {
+    case "instruction-fragment" /* InstructionFragment */: {
+      if (isRecord(value) && roleless.safeParse(value).success) {
+        return parseAs(instructionFragmentSchema, { ...value, role: "system" }, path);
+      }
+      return parseAs(instructionFragmentSchema, value, path);
+    }
+    case "skill-bundle" /* SkillBundle */:
+      return Array.isArray(value) ? parseAs(z.array(skillBundleSchema), value, path) : parseAs(skillBundleSchema, value, path);
+    case "mcp-servers" /* McpServers */:
+      return parseAs(z.array(mcpServerBindingSchema), value, path);
+    case "sandboxes" /* Sandboxes */:
+      return parseAs(resolvedSandboxesSchema, value, path);
+    case "sandbox-environment" /* SandboxEnvironment */:
+      if (manifest != null) checkEnvironmentProvider(manifest, path, value);
+      const environment = environmentResultSchema.safeParse(value);
+      if (environment.success && environment.data.openOptions != null)
+        parseAs(
+          sandboxBindingSchema.pick({ access: true, attach: true }).partial(),
+          environment.data.openOptions,
+          path
+        );
+      return environment.success ? environment.data.options ?? null : value;
+    case "opaque" /* Opaque */:
+      return value;
+  }
+};
+const childPath = (parent, key) => {
+  if (z.number().safeParse(key).success) return `${parent}[${key}]`;
+  return parent.length === 0 ? `${key}` : `${parent}.${key}`;
+};
+const splice = (value, values, path) => {
+  if (isDynamicSlot(value)) return values[path] ?? null;
+  if (Array.isArray(value)) {
+    const out = [];
+    value.forEach((item, index) => {
+      const itemPath = childPath(path, index);
+      if (isDynamicSlot(item)) {
+        const resolved = values[itemPath];
+        if (resolved == null) return;
+        if (Array.isArray(resolved) && slotKindOf(itemPath) === "skill-bundle" /* SkillBundle */)
+          out.push(...resolved);
+        else out.push(resolved);
+        return;
+      }
+      out.push(splice(item, values, itemPath));
+    });
+    return out;
+  }
+  if (isRecord(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      const itemPath = childPath(path, key);
+      if (isDynamicSlot(item) && values[itemPath] == null && !KEEP_NULL.test(itemPath)) continue;
+      out[key] = splice(item, values, itemPath);
+    }
+    return out;
+  }
+  return value;
+};
+const KEEP_NULL = /^(sandboxes\.[^.]+\.environment)$/;
+const FIELD_DEFAULTS = /* @__PURE__ */ new Map([
+  ["mcpServers", []],
+  ["sandboxes", {}],
+  ["harness.config", {}]
+]);
+const checkEnvironmentProvider = (manifest, path, value) => {
+  if (slotKindOf(path) !== "sandbox-environment" /* SandboxEnvironment */ || value == null) return;
+  const returned = environmentResultSchema.safeParse(value);
+  if (!returned.success) return;
+  const target = path.slice("sandboxes.".length, -".environment".length);
+  const sandboxes = z.record(z.string(), sandboxBindingSchema).safeParse(manifest.sandboxes);
+  const provider = sandboxes.success ? sandboxes.data[target]?.provider : void 0;
+  if (provider == null) return;
+  const returnedRef = providerRefSchema.safeParse(returned.data.providerRef);
+  const mismatch = returnedRef.success ? formatProviderRef(returnedRef.data) !== formatProviderRef(provider) : (
+    // A bundle provider's environment carries only its name; installed ones are named for their specifier.
+    provider.kind === ProviderRefKind.Package
+  );
+  if (mismatch) {
+    throw invalid(
+      path,
+      `returned a ${returned.data.providerName} environment for a ${formatProviderRef(provider)} target`
+    );
+  }
+};
+const resolveManifestDetailed = async (args) => {
+  const manifestJson = jsonValueSchema.parse(args.manifest);
+  const slots = findDynamicSlots(manifestJson);
+  const values = {};
+  const normalized = {};
+  for (const found of slots) {
+    const subscribed = found.slot.$dynamic.events.includes(args.event);
+    const raw = subscribed ? await args.resolve(found.slot, found.path) : args.previous?.[found.path] ?? null;
+    if (subscribed) checkEnvironmentProvider(args.manifest, found.path, raw);
+    normalized[found.path] = validateSlotValue(found.path, raw) ?? FIELD_DEFAULTS.get(found.path) ?? null;
+    values[found.path] = slotKindOf(found.path) === "sandbox-environment" /* SandboxEnvironment */ ? raw : normalized[found.path] ?? null;
+  }
+  const spliced = splice(manifestJson, normalized, "");
+  const parsed = resolvedAgentManifestSchema.safeParse(spliced);
+  if (!parsed.success) throw new Error(`resolved manifest is invalid: ${issueText(parsed.error)}`);
+  const openOptionsSchema = sandboxBindingSchema.pick({ access: true, attach: true }).partial();
+  for (const [path, raw] of Object.entries(values)) {
+    if (slotKindOf(path) !== "sandbox-environment" /* SandboxEnvironment */) continue;
+    const environment = environmentResultSchema.safeParse(raw);
+    if (!environment.success || environment.data.openOptions == null) continue;
+    const options = openOptionsSchema.safeParse(environment.data.openOptions);
+    if (!options.success) throw invalid(path, issueText(options.error));
+    const target = path.slice("sandboxes.".length, -".environment".length);
+    const binding = parsed.data.sandboxes[target];
+    if (binding != null) parsed.data.sandboxes[target] = { ...binding, ...options.data };
+  }
+  return { manifest: parsed.data, values };
+};
+const resolveManifest = async (args) => (await resolveManifestDetailed(args)).manifest;
+export {
+  SlotValueKind,
+  resolveManifest,
+  resolveManifestDetailed,
+  slotKindOf,
+  validateSlotValue
+};
+//# sourceMappingURL=resolve.mjs.map

package/dist/modules/resolve.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/resolve.ts"],
+  "sourcesContent": ["import {\n  findDynamicSlots,\n  formatProviderRef,\n  instructionFragmentSchema,\n  isDynamicSlot,\n  jsonObjectSchema,\n  jsonValueSchema,\n  mcpServerBindingSchema,\n  ProviderRefKind,\n  providerRefSchema,\n  resolvedAgentManifestSchema,\n  sandboxBindingSchema,\n  skillBundleSchema,\n  type AgentManifestIface,\n  type DynamicEvent,\n  type DynamicSlotIface,\n  type JsonValue,\n  type ResolvedAgentManifestIface,\n} from '@finalai/agent-provider';\nimport * as z from 'zod';\n\n// Resolves a static manifest's dynamic slots for one session. The session service runs each resolver in the agent's isolate; this\n// helper decides which slots run at a boundary, validates each output against\n// the static field's schema, and splices the results in.\n\nexport type ResolveSlot = (slot: DynamicSlotIface, path: string) => Promise<JsonValue | null>;\n\nexport interface ResolveManifestArgsIface {\n  manifest: AgentManifestIface;\n  event: DynamicEvent;\n  resolve: ResolveSlot;\n  // Values from an earlier boundary (session.started values at turn.started),\n  // used for slots that do not resolve at this event.\n  previous?: Record<string, JsonValue | null>;\n}\n\nexport interface ResolvedManifestDetailIface {\n  manifest: ResolvedAgentManifestIface;\n  // Slot path \u2192 resolved value, for agent.session_manifests and later boundaries.\n  values: Record<string, JsonValue | null>;\n}\n\nexport enum SlotValueKind {\n  InstructionFragment = 'instruction-fragment',\n  SkillBundle = 'skill-bundle',\n  McpServers = 'mcp-servers',\n  Sandboxes = 'sandboxes',\n  SandboxEnvironment = 'sandbox-environment',\n  Opaque = 'opaque',\n}\n\nexport const slotKindOf = (path: string): SlotValueKind => {\n  if (/^harness\\.config\\.instructions\\[\\d+\\]$/.test(path)) return SlotValueKind.InstructionFragment;\n  if (/^harness\\.config\\.skills\\[\\d+\\]$/.test(path)) return SlotValueKind.SkillBundle;\n  if (path === 'mcpServers') return SlotValueKind.McpServers;\n  if (path === 'sandboxes') return SlotValueKind.Sandboxes;\n  if (/^sandboxes\\.[^.]+\\.environment$/.test(path)) return SlotValueKind.SandboxEnvironment;\n  return SlotValueKind.Opaque;\n};\n\nconst resolvedSandboxesSchema = z.record(\n  z.string(),\n  sandboxBindingSchema.extend({ environment: jsonValueSchema }),\n);\n\nconst issueText = (error: z.ZodError): string =>\n  error.issues.map((issue) => `${issue.path.join('.') || 'value'}: ${issue.message}`).join('; ');\n\nconst invalid = (path: string, detail: string): Error =>\n  new Error(`dynamic slot ${path} resolved to an invalid value: ${detail}`);\n\nconst parseAs = <T extends z.ZodType>(schema: T, value: JsonValue, path: string): JsonValue => {\n  const parsed = schema.safeParse(value);\n  if (!parsed.success) throw invalid(path, issueText(parsed.error));\n  return jsonValueSchema.parse(parsed.data);\n};\n\nconst isRecord = (value: JsonValue): value is { [key: string]: JsonValue } =>\n  jsonObjectSchema.safeParse(value).success;\n\nconst roleless = z.looseObject({ role: z.null().optional() });\nconst environmentResultSchema = z.looseObject({\n  providerName: z.string(),\n  providerRef: jsonValueSchema.optional(),\n  options: jsonValueSchema.optional(),\n  openOptions: jsonValueSchema.optional(),\n});\n\n// Instruction results without a role ({ content }) default to system;\n// environment-shaped results normalize to their options.\nexport const validateSlotValue = (\n  path: string,\n  value: JsonValue | null,\n  manifest?: AgentManifestIface,\n): JsonValue | null => {\n  if (value == null) return null;\n  switch (slotKindOf(path)) {\n    case SlotValueKind.InstructionFragment: {\n      if (isRecord(value) && roleless.safeParse(value).success) {\n        return parseAs(instructionFragmentSchema, { ...value, role: 'system' }, path);\n      }\n      return parseAs(instructionFragmentSchema, value, path);\n    }\n    case SlotValueKind.SkillBundle:\n      return Array.isArray(value)\n        ? parseAs(z.array(skillBundleSchema), value, path)\n        : parseAs(skillBundleSchema, value, path);\n    case SlotValueKind.McpServers:\n      return parseAs(z.array(mcpServerBindingSchema), value, path);\n    case SlotValueKind.Sandboxes:\n      return parseAs(resolvedSandboxesSchema, value, path);\n    case SlotValueKind.SandboxEnvironment:\n      if (manifest != null) checkEnvironmentProvider(manifest, path, value);\n      const environment = environmentResultSchema.safeParse(value);\n      if (environment.success && environment.data.openOptions != null)\n        parseAs(\n          sandboxBindingSchema.pick({ access: true, attach: true }).partial(),\n          environment.data.openOptions,\n          path,\n        );\n      return environment.success ? (environment.data.options ?? null) : value;\n    case SlotValueKind.Opaque:\n      return value;\n  }\n};\n\nconst childPath = (parent: string, key: string | number): string => {\n  if (z.number().safeParse(key).success) return `${parent}[${key}]`;\n  return parent.length === 0 ? `${key}` : `${parent}.${key}`;\n};\n\n// Like replaceDynamicSlots, except that an array-item slot that resolved to\n// an array (several skills from one resolver) splices all of them in, and an\n// object field that resolved to null is omitted.\nconst splice = (\n  value: JsonValue,\n  values: Record<string, JsonValue | null>,\n  path: string,\n): JsonValue => {\n  if (isDynamicSlot(value)) return values[path] ?? null;\n  if (Array.isArray(value)) {\n    const out: JsonValue[] = [];\n    value.forEach((item, index) => {\n      const itemPath = childPath(path, index);\n      if (isDynamicSlot(item)) {\n        const resolved = values[itemPath];\n        if (resolved == null) return;\n        if (Array.isArray(resolved) && slotKindOf(itemPath) === SlotValueKind.SkillBundle)\n          out.push(...resolved);\n        else out.push(resolved);\n        return;\n      }\n      out.push(splice(item, values, itemPath));\n    });\n    return out;\n  }\n  if (isRecord(value)) {\n    const out: { [key: string]: JsonValue } = {};\n    for (const [key, item] of Object.entries(value)) {\n      const itemPath = childPath(path, key);\n      // A config field whose resolver returned null is left out, so the\n      // harness applies its own default; required fields keep their value.\n      if (isDynamicSlot(item) && values[itemPath] == null && !KEEP_NULL.test(itemPath)) continue;\n      out[key] = splice(item, values, itemPath);\n    }\n    return out;\n  }\n  return value;\n};\n\nconst KEEP_NULL = /^(sandboxes\\.[^.]+\\.environment)$/;\n\nconst FIELD_DEFAULTS = new Map<string, JsonValue>([\n  ['mcpServers', []],\n  ['sandboxes', {}],\n  ['harness.config', {}],\n]);\n\n// A dynamic sandbox environment must be one of its binding's provider (the\n// compiler may have inferred that provider).\n\nconst checkEnvironmentProvider = (\n  manifest: AgentManifestIface,\n  path: string,\n  value: JsonValue | null,\n): void => {\n  if (slotKindOf(path) !== SlotValueKind.SandboxEnvironment || value == null) return;\n  const returned = environmentResultSchema.safeParse(value);\n  if (!returned.success) return;\n  const target = path.slice('sandboxes.'.length, -'.environment'.length);\n  const sandboxes = z.record(z.string(), sandboxBindingSchema).safeParse(manifest.sandboxes);\n  const provider = sandboxes.success ? sandboxes.data[target]?.provider : undefined;\n  if (provider == null) return;\n  const returnedRef = providerRefSchema.safeParse(returned.data.providerRef);\n  const mismatch = returnedRef.success\n    ? formatProviderRef(returnedRef.data) !== formatProviderRef(provider)\n    : // A bundle provider's environment carries only its name; installed ones are named for their specifier.\n      provider.kind === ProviderRefKind.Package;\n  if (mismatch) {\n    throw invalid(\n      path,\n      `returned a ${returned.data.providerName} environment for a ${formatProviderRef(provider)} target`,\n    );\n  }\n};\n\nexport const resolveManifestDetailed = async (\n  args: ResolveManifestArgsIface,\n): Promise<ResolvedManifestDetailIface> => {\n  const manifestJson = jsonValueSchema.parse(args.manifest);\n  const slots = findDynamicSlots(manifestJson);\n  const values: Record<string, JsonValue | null> = {};\n  const normalized: Record<string, JsonValue | null> = {};\n  for (const found of slots) {\n    const subscribed = found.slot.$dynamic.events.includes(args.event);\n    const raw = subscribed\n      ? await args.resolve(found.slot, found.path)\n      : (args.previous?.[found.path] ?? null);\n    if (subscribed) checkEnvironmentProvider(args.manifest, found.path, raw);\n    normalized[found.path] =\n      validateSlotValue(found.path, raw) ?? FIELD_DEFAULTS.get(found.path) ?? null;\n    // Retain the descriptor so a later boundary preserves its open options too.\n    values[found.path] =\n      slotKindOf(found.path) === SlotValueKind.SandboxEnvironment\n        ? raw\n        : (normalized[found.path] ?? null);\n  }\n  const spliced = splice(manifestJson, normalized, '');\n  const parsed = resolvedAgentManifestSchema.safeParse(spliced);\n  if (!parsed.success) throw new Error(`resolved manifest is invalid: ${issueText(parsed.error)}`);\n  const openOptionsSchema = sandboxBindingSchema.pick({ access: true, attach: true }).partial();\n  for (const [path, raw] of Object.entries(values)) {\n    if (slotKindOf(path) !== SlotValueKind.SandboxEnvironment) continue;\n    const environment = environmentResultSchema.safeParse(raw);\n    if (!environment.success || environment.data.openOptions == null) continue;\n    const options = openOptionsSchema.safeParse(environment.data.openOptions);\n    if (!options.success) throw invalid(path, issueText(options.error));\n    const target = path.slice('sandboxes.'.length, -'.environment'.length);\n    const binding = parsed.data.sandboxes[target];\n    if (binding != null) parsed.data.sandboxes[target] = { ...binding, ...options.data };\n  }\n  return { manifest: parsed.data, values };\n};\n\nexport const resolveManifest = async (\n  args: ResolveManifestArgsIface,\n): Promise<ResolvedAgentManifestIface> => (await resolveManifestDetailed(args)).manifest;\n"],
+  "mappings": "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",
+  "names": ["SlotValueKind"]
+}

package/dist/modules/runtime/bundle.d.mts

@@ -0,0 +1,12 @@
+import { type IsolateRuntimeIface } from "./isolate.mjs";
+import { type LayoutModuleIface } from "./layout.mjs";
+import type { AuthoredRecord } from "./values.mjs";
+export interface AgentBundleIface {
+    modules: AuthoredRecord;
+    runtime: IsolateRuntimeIface;
+    describe(): string;
+}
+export declare const createAgentBundle: (args: {
+    layout: LayoutModuleIface[];
+    namespaces: AuthoredRecord[];
+}) => AgentBundleIface;

package/dist/modules/runtime/bundle.mjs

@@ -0,0 +1,48 @@
+import { registerToolName } from "../authoring/tools.mjs";
+import {
+  COMBINED_MCP_SERVERS_EXPORT,
+  describeBundle,
+  needsCombinedMcpServers,
+  synthesizedExports
+} from "./describe.mjs";
+import { combineMcpServers, createIsolateRuntime } from "./isolate.mjs";
+import { namedExportName, SlotKind } from "./layout.mjs";
+const createAgentBundle = (args) => {
+  const entries = args.layout.map((layout, index) => ({
+    layout,
+    namespace: { ...args.namespaces[index] }
+  }));
+  const modules = {};
+  for (const entry of entries) {
+    for (const [name, value] of Object.entries(entry.namespace)) {
+      modules[namedExportName(entry.layout.base, name)] = value;
+    }
+    if (entry.layout.slot === SlotKind.Tool)
+      registerToolName(entry.namespace["default"], entry.layout.key);
+  }
+  const synthesized = synthesizedExports(entries);
+  for (const item of synthesized) modules[item.name] = item.value;
+  const names = synthesized.map((item) => item.name);
+  if (needsCombinedMcpServers(entries)) {
+    modules[COMBINED_MCP_SERVERS_EXPORT] = combineMcpServers(
+      entries.filter(
+        (entry) => entry.layout.slot === SlotKind.Tool || entry.layout.slot === SlotKind.Connection
+      ).filter((entry) => entry.namespace["default"] != null).map((entry) => ({
+        kind: entry.layout.slot === SlotKind.Tool ? "tool" : "connection",
+        key: entry.layout.key,
+        exportName: entry.layout.base,
+        value: entry.namespace["default"]
+      }))
+    );
+    names.push(COMBINED_MCP_SERVERS_EXPORT);
+  }
+  return {
+    modules,
+    runtime: createIsolateRuntime(modules),
+    describe: () => JSON.stringify(describeBundle(entries, names))
+  };
+};
+export {
+  createAgentBundle
+};
+//# sourceMappingURL=bundle.mjs.map

package/dist/modules/runtime/bundle.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/runtime/bundle.ts"],
+  "sourcesContent": ["import { registerToolName } from \"../authoring/tools.mjs\";\nimport {\n  COMBINED_MCP_SERVERS_EXPORT,\n  describeBundle,\n  needsCombinedMcpServers,\n  synthesizedExports,\n  type NamespaceEntryIface,\n} from \"./describe.mjs\";\nimport { combineMcpServers, createIsolateRuntime, type IsolateRuntimeIface } from \"./isolate.mjs\";\nimport { namedExportName, SlotKind, type LayoutModuleIface } from \"./layout.mjs\";\nimport type { AuthoredRecord } from \"./values.mjs\";\n\nexport interface AgentBundleIface {\n  // Export name \u2192 authored value: default exports under their module base\n  // ('tools/lookup_release_notes'), named exports as '<base>#<name>', plus\n  // synthesized exports ('agent:<path>', 'pending:<n>', 'final:mcpServers').\n  modules: AuthoredRecord;\n  runtime: IsolateRuntimeIface;\n  // The static description as JSON, for the compiler.\n  describe(): string;\n}\n\n// Called by the generated bundle entry once every authored module evaluated.\nexport const createAgentBundle = (args: {\n  layout: LayoutModuleIface[];\n  namespaces: AuthoredRecord[];\n}): AgentBundleIface => {\n  const entries: NamespaceEntryIface[] = args.layout.map((layout, index) => ({\n    layout,\n    namespace: { ...args.namespaces[index] },\n  }));\n  const modules: AuthoredRecord = {};\n  for (const entry of entries) {\n    for (const [name, value] of Object.entries(entry.namespace)) {\n      modules[namedExportName(entry.layout.base, name)] = value;\n    }\n    if (entry.layout.slot === SlotKind.Tool)\n      registerToolName(entry.namespace['default'], entry.layout.key);\n  }\n  const synthesized = synthesizedExports(entries);\n  for (const item of synthesized) modules[item.name] = item.value;\n  const names = synthesized.map((item) => item.name);\n  if (needsCombinedMcpServers(entries)) {\n    modules[COMBINED_MCP_SERVERS_EXPORT] = combineMcpServers(\n      entries\n        .filter(\n          (entry) =>\n            entry.layout.slot === SlotKind.Tool || entry.layout.slot === SlotKind.Connection,\n        )\n        .filter((entry) => entry.namespace['default'] != null)\n        .map((entry) => ({\n          kind: entry.layout.slot === SlotKind.Tool ? 'tool' : 'connection',\n          key: entry.layout.key,\n          exportName: entry.layout.base,\n          value: entry.namespace['default'],\n        })),\n    );\n    names.push(COMBINED_MCP_SERVERS_EXPORT);\n  }\n  return {\n    modules,\n    runtime: createIsolateRuntime(modules),\n    describe: () => JSON.stringify(describeBundle(entries, names)),\n  };\n};\n"],
+  "mappings": "AAAA,SAAS,wBAAwB;AACjC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,mBAAmB,4BAAsD;AAClF,SAAS,iBAAiB,gBAAwC;AAc3D,MAAM,oBAAoB,CAAC,SAGV;AACtB,QAAM,UAAiC,KAAK,OAAO,IAAI,CAAC,QAAQ,WAAW;AAAA,IACzE;AAAA,IACA,WAAW,EAAE,GAAG,KAAK,WAAW,KAAK,EAAE;AAAA,EACzC,EAAE;AACF,QAAM,UAA0B,CAAC;AACjC,aAAW,SAAS,SAAS;AAC3B,eAAW,CAAC,MAAM,KAAK,KAAK,OAAO,QAAQ,MAAM,SAAS,GAAG;AAC3D,cAAQ,gBAAgB,MAAM,OAAO,MAAM,IAAI,CAAC,IAAI;AAAA,IACtD;AACA,QAAI,MAAM,OAAO,SAAS,SAAS;AACjC,uBAAiB,MAAM,UAAU,SAAS,GAAG,MAAM,OAAO,GAAG;AAAA,EACjE;AACA,QAAM,cAAc,mBAAmB,OAAO;AAC9C,aAAW,QAAQ,YAAa,SAAQ,KAAK,IAAI,IAAI,KAAK;AAC1D,QAAM,QAAQ,YAAY,IAAI,CAAC,SAAS,KAAK,IAAI;AACjD,MAAI,wBAAwB,OAAO,GAAG;AACpC,YAAQ,2BAA2B,IAAI;AAAA,MACrC,QACG;AAAA,QACC,CAAC,UACC,MAAM,OAAO,SAAS,SAAS,QAAQ,MAAM,OAAO,SAAS,SAAS;AAAA,MAC1E,EACC,OAAO,CAAC,UAAU,MAAM,UAAU,SAAS,KAAK,IAAI,EACpD,IAAI,CAAC,WAAW;AAAA,QACf,MAAM,MAAM,OAAO,SAAS,SAAS,OAAO,SAAS;AAAA,QACrD,KAAK,MAAM,OAAO;AAAA,QAClB,YAAY,MAAM,OAAO;AAAA,QACzB,OAAO,MAAM,UAAU,SAAS;AAAA,MAClC,EAAE;AAAA,IACN;AACA,UAAM,KAAK,2BAA2B;AAAA,EACxC;AACA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,qBAAqB,OAAO;AAAA,IACrC,UAAU,MAAM,KAAK,UAAU,eAAe,SAAS,KAAK,CAAC;AAAA,EAC/D;AACF;",
+  "names": []
+}

package/dist/modules/runtime/describe.d.mts

@@ -0,0 +1,19 @@
+import type { DescribedBundleIface, DescribedDynamicIface } from "./described.mjs";
+import { COMBINED_MCP_SERVERS_EXPORT, type LayoutModuleIface } from "./layout.mjs";
+import { type AuthoredRecord, type AuthoredValue } from "./values.mjs";
+export interface NamespaceEntryIface {
+    layout: LayoutModuleIface;
+    namespace: AuthoredRecord;
+}
+export declare const describeDynamic: (value: AuthoredValue) => DescribedDynamicIface;
+export declare const collectAgentDynamics: (agent: AuthoredValue) => {
+    path: string;
+    value: AuthoredValue;
+}[];
+export declare const describeBundle: (entries: NamespaceEntryIface[], synthesized: string[]) => DescribedBundleIface;
+export declare const synthesizedExports: (entries: NamespaceEntryIface[]) => {
+    name: string;
+    value: AuthoredValue;
+}[];
+export declare const needsCombinedMcpServers: (entries: NamespaceEntryIface[]) => boolean;
+export { COMBINED_MCP_SERVERS_EXPORT };