spawnfile 0.1.14 → 0.1.18

package/dist/manifest/schemas.js

@@ -2,10 +2,11 @@ import { z } from "zod";
 import { agentScheduleSchema } from "./scheduleSchemas.js";
 import { executionSchema } from "./executionSchemas.js";
 import { memoryBanksSchema } from "./memorySchemas.js";
-import { mcpServerSchema } from "./mcpSchemas.js";
+import { mcpServerEntrySchema, sharedMcpServerSchema } from "./mcpSchemas.js";
 import { surfacesSchema } from "./surfaceSchemas.js";
+import { trainingDeclarationSchema } from "./trainingSchemas.js";
 import { externalParticipantServiceSchema } from "./externalParticipantSchemas.js";
-import { teamNetworkSchema, teamWorkspaceSchema } from "./teamNetworkSchemas.js";
+import { isDeclaredPairedRemoteRoomMember, teamNetworkSchema, teamWorkspaceSchema } from "./teamNetworkSchemas.js";
 const skillRequirementSchema = z
     .object({
     mcp: z.array(z.string()).optional()
@@ -62,10 +63,10 @@ const packageSchema = z
         });
     }
 });
-const environmentSchema = z
+const createEnvironmentSchema = (serverSchema) => z
     .object({
     env: z.record(z.string(), z.string()).optional(),
-    mcp_servers: z.array(mcpServerSchema).optional(),
+    mcp_servers: z.array(serverSchema).optional(),
     packages: z.array(packageSchema).optional(),
     secrets: z.array(secretSchema).optional()
 })
@@ -79,6 +80,10 @@ const environmentSchema = z
         });
     }
 });
+// Team `shared.environment` declares complete servers; agent scope may also
+// narrow an inherited server with a transport-less override entry.
+const sharedEnvironmentSchema = createEnvironmentSchema(sharedMcpServerSchema);
+const environmentSchema = createEnvironmentSchema(mcpServerEntrySchema);
 const commonManifestSchema = z
     .object({
     description: z.string().optional(),
@@ -102,7 +107,8 @@ const subagentSchema = z
     .strict();
 const sharedSurfaceSchema = z
     .object({
-    environment: environmentSchema.optional(),
+    environment: sharedEnvironmentSchema.optional(),
+    training: trainingDeclarationSchema.optional(),
     workspace: teamWorkspaceSchema.optional()
 })
     .strict();
@@ -134,6 +140,7 @@ const inlineAgentMemberSchema = z
     runtime: runtimeBindingSchema.optional(),
     schedule: agentScheduleSchema.optional(),
     surfaces: surfacesSchema.optional(),
+    training: trainingDeclarationSchema.optional(),
     workspace: teamWorkspaceSchema
 })
     .strict()
@@ -162,6 +169,7 @@ const agentManifestSchema = commonManifestSchema
     runtime: runtimeBindingSchema.optional(),
     schedule: agentScheduleSchema.optional(),
     subagents: z.array(subagentSchema).optional(),
+    training: trainingDeclarationSchema.optional(),
     workspace: teamWorkspaceSchema.optional()
 })
     .superRefine(refineAgentMemoryAccess)
@@ -217,7 +225,9 @@ const teamManifestSchema = commonManifestSchema
                 .map((participant) => participant.id) ?? []);
             for (const room of network.rooms) {
                 for (const memberId of room.members) {
-                    if (!memberIds.has(memberId) && !externalRoomMembers.has(memberId)) {
+                    if (!memberIds.has(memberId)
+                        && !externalRoomMembers.has(memberId)
+                        && !isDeclaredPairedRemoteRoomMember(network, room, memberId)) {
                         context.addIssue({
                             code: z.ZodIssueCode.custom,
                             message: `network ${network.id} room ${room.id} references unknown member ${memberId}`
@@ -256,6 +266,9 @@ export const manifestSchema = z.discriminatedUnion("kind", [
     agentManifestSchema,
     teamManifestSchema
 ]);
+export { isMcpServerDeclaration } from "./mcpSchemas.js";
+export { isDeclaredPairedRemoteRoomMember } from "./teamNetworkSchemas.js";
+export { FEED_CLOCK_PATTERN, FEED_REF_PLACEHOLDER, isFeedTimeZone } from "./volumeFeedSchemas.js";
 export const isAgentManifest = (manifest) => manifest.kind === "agent";
 export const isTeamManifest = (manifest) => manifest.kind === "team";
 export const isInlineAgentMember = (member) => !("ref" in member);

package/dist/manifest/teamNetworkAccessSchemas.d.ts

@@ -1,9 +1,13 @@
 import { z } from "zod";
 export declare const teamNetworkAgentRegistrationSchema: z.ZodEnum<{
-    token: "token";
     disabled: "disabled";
+    token: "token";
     open: "open";
 }>;
+export declare const teamNetworkRoomFederationSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    none: "none";
+    all: "all";
+}>, z.ZodArray<z.ZodString>]>;
 export declare const teamNetworkRoomVisibilitySchema: z.ZodEnum<{
     private: "private";
     public: "public";

package/dist/manifest/teamNetworkAccessSchemas.js

@@ -1,5 +1,16 @@
 import { z } from "zod";
 export const teamNetworkAgentRegistrationSchema = z.enum(["disabled", "token", "open"]);
+export const teamNetworkRoomFederationSchema = z.union([
+    z.enum(["none", "all"]),
+    z.array(z.string().trim().min(1)).min(1).superRefine((value, context) => {
+        if (new Set(value).size !== value.length) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "room federation pairing ids must be unique"
+            });
+        }
+    })
+]);
 export const teamNetworkRoomVisibilitySchema = z.enum(["public", "private"]);
 export const teamNetworkRoomWritePolicySchema = z.enum([
     "members",

package/dist/manifest/teamNetworkAuthSchemas.d.ts

@@ -15,8 +15,8 @@ declare const teamNetworkAuthTokenSchema: z.ZodObject<{
 export declare const isTopologyOperatorToken: (token: z.infer<typeof teamNetworkAuthTokenSchema>) => boolean;
 export declare const teamNetworkAuthSchema: z.ZodObject<{
     agent_registration: z.ZodOptional<z.ZodEnum<{
-        token: "token";
         disabled: "disabled";
+        token: "token";
         open: "open";
     }>>;
     client: z.ZodOptional<z.ZodObject<{

package/dist/manifest/teamNetworkSchemas.d.ts

@@ -1,9 +1,13 @@
 import { z } from "zod";
 export { teamWorkspaceDocsSchema, teamWorkspaceSchema } from "./workspaceSchemas.js";
-export type { TeamWorkspace, TeamWorkspaceDocs, TeamWorkspaceResource, TeamWorkspaceResource as TeamNetworkResource } from "./workspaceSchemas.js";
+export type { TeamWorkspace, TeamWorkspaceDocs, TeamWorkspaceResource, TeamWorkspaceResource as TeamNetworkResource, WorkspaceBundleBuild } from "./workspaceSchemas.js";
 export type { TeamNetworkAuth } from "./teamNetworkAuthSchemas.js";
 export type { TeamNetworkServer, TeamNetworkStore } from "./teamNetworkServerSchemas.js";
 declare const teamNetworkRoomSchema: z.ZodObject<{
+    federation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        none: "none";
+        all: "all";
+    }>, z.ZodArray<z.ZodString>]>>;
     id: z.ZodString;
     members: z.ZodArray<z.ZodString>;
     name: z.ZodOptional<z.ZodString>;
@@ -22,6 +26,10 @@ export declare const teamNetworkSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     provider: z.ZodLiteral<"moltnet">;
     rooms: z.ZodArray<z.ZodObject<{
+        federation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            none: "none";
+            all: "all";
+        }>, z.ZodArray<z.ZodString>]>>;
         id: z.ZodString;
         members: z.ZodArray<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
@@ -39,8 +47,8 @@ export declare const teamNetworkSchema: z.ZodObject<{
         allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
         auth: z.ZodObject<{
             agent_registration: z.ZodOptional<z.ZodEnum<{
-                token: "token";
                 disabled: "disabled";
+                token: "token";
                 open: "open";
             }>>;
             client: z.ZodOptional<z.ZodObject<{
@@ -84,7 +92,12 @@ export declare const teamNetworkSchema: z.ZodObject<{
         mode: z.ZodLiteral<"managed">;
         pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
-            remote_base_url: z.ZodString;
+            relay: z.ZodOptional<z.ZodObject<{
+                room: z.ZodString;
+                token_secret: z.ZodString;
+                url: z.ZodString;
+            }, z.core.$strict>>;
+            remote_base_url: z.ZodOptional<z.ZodString>;
             remote_network_id: z.ZodString;
             remote_network_name: z.ZodString;
             token_secret: z.ZodString;
@@ -122,8 +135,8 @@ export declare const teamNetworkSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         auth: z.ZodObject<{
             agent_registration: z.ZodOptional<z.ZodEnum<{
-                token: "token";
                 disabled: "disabled";
+                token: "token";
                 open: "open";
             }>>;
             client: z.ZodOptional<z.ZodObject<{
@@ -157,3 +170,4 @@ export declare const teamNetworkSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type TeamNetwork = z.infer<typeof teamNetworkSchema>;
 export type TeamNetworkRoom = z.infer<typeof teamNetworkRoomSchema>;
+export declare const isDeclaredPairedRemoteRoomMember: (network: TeamNetwork, room: TeamNetworkRoom, memberId: string) => boolean;

package/dist/manifest/teamNetworkSchemas.js

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { teamNetworkRoomVisibilitySchema, teamNetworkRoomWritePolicySchema } from "./teamNetworkAccessSchemas.js";
+import { teamNetworkRoomFederationSchema, teamNetworkRoomVisibilitySchema, teamNetworkRoomWritePolicySchema } from "./teamNetworkAccessSchemas.js";
 import { teamNetworkServerSchema } from "./teamNetworkServerSchemas.js";
 export { teamWorkspaceDocsSchema, teamWorkspaceSchema } from "./workspaceSchemas.js";
 const teamNetworkRoomSchema = z
     .object({
+    federation: teamNetworkRoomFederationSchema.optional(),
     id: z.string().trim().min(1),
     members: z.array(z.string().trim().min(1)),
     name: z.string().trim().min(1).optional(),
@@ -29,3 +30,20 @@ export const teamNetworkSchema = z
         });
     }
 });
+export const isDeclaredPairedRemoteRoomMember = (network, room, memberId) => {
+    const separator = memberId.indexOf(":");
+    if (separator <= 0 || separator === memberId.length - 1) {
+        return false;
+    }
+    const remoteNetworkId = memberId.slice(0, separator).trim();
+    const remoteAgentId = memberId.slice(separator + 1).trim();
+    if (!remoteNetworkId || !remoteAgentId || network.server?.mode !== "managed") {
+        return false;
+    }
+    const pairing = network.server.pairings?.find((candidate) => candidate.remote_network_id === remoteNetworkId);
+    if (!pairing) {
+        return false;
+    }
+    return room.federation === "all"
+        || (Array.isArray(room.federation) && room.federation.includes(pairing.id));
+};

package/dist/manifest/teamNetworkServerSchemas.d.ts

@@ -31,8 +31,8 @@ export declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
     auth: z.ZodObject<{
         agent_registration: z.ZodOptional<z.ZodEnum<{
-            token: "token";
             disabled: "disabled";
+            token: "token";
             open: "open";
         }>>;
         client: z.ZodOptional<z.ZodObject<{
@@ -76,7 +76,12 @@ export declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     mode: z.ZodLiteral<"managed">;
     pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        remote_base_url: z.ZodString;
+        relay: z.ZodOptional<z.ZodObject<{
+            room: z.ZodString;
+            token_secret: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>>;
+        remote_base_url: z.ZodOptional<z.ZodString>;
         remote_network_id: z.ZodString;
         remote_network_name: z.ZodString;
         token_secret: z.ZodString;
@@ -114,8 +119,8 @@ export declare const teamNetworkServerSchema: z.ZodDiscriminatedUnion<[z.ZodObje
 }, z.core.$strict>, z.ZodObject<{
     auth: z.ZodObject<{
         agent_registration: z.ZodOptional<z.ZodEnum<{
-            token: "token";
             disabled: "disabled";
+            token: "token";
             open: "open";
         }>>;
         client: z.ZodOptional<z.ZodObject<{

package/dist/manifest/teamNetworkServerSchemas.js

@@ -68,15 +68,31 @@ const teamNetworkListenSchema = z
     port: z.number().int().min(1).max(65535)
 })
     .strict();
+const teamNetworkPairingRelaySchema = z
+    .object({
+    room: z.string().trim().min(1),
+    token_secret: z.string().trim().min(1),
+    url: z.string().trim().min(1)
+})
+    .strict();
 const teamNetworkPairingSchema = z
     .object({
     id: z.string().trim().min(1),
-    remote_base_url: z.string().trim().min(1),
+    relay: teamNetworkPairingRelaySchema.optional(),
+    remote_base_url: z.string().trim().min(1).optional(),
     remote_network_id: z.string().trim().min(1),
     remote_network_name: z.string().trim().min(1),
     token_secret: z.string().trim().min(1)
 })
-    .strict();
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.remote_base_url === undefined) === (value.relay === undefined)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "managed Moltnet pairing requires exactly one of remote_base_url or relay"
+        });
+    }
+});
 const teamNetworkManagedServerSchema = z
     .object({
     allowed_origins: z.array(z.string().trim().min(1)).optional(),

package/dist/manifest/trainingDataSchemas.d.ts

@@ -0,0 +1,357 @@
+import { z } from "zod";
+export declare const trainingInstantSchema: z.ZodISODateTime;
+export declare const trainingWakeSchema: z.ZodObject<{
+    surface: z.ZodLiteral<"moltnet">;
+    room: z.ZodString;
+    from: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export declare const trainingDatasetSchema: z.ZodObject<{
+    examples: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        at: z.ZodISODateTime;
+        wake: z.ZodObject<{
+            surface: z.ZodLiteral<"moltnet">;
+            room: z.ZodString;
+            from: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>;
+        memory: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            access: z.ZodOptional<z.ZodObject<{
+                members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            consolidation: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                    disabled: "disabled";
+                    on_threshold: "on_threshold";
+                    scheduled: "scheduled";
+                }>>>;
+                schedule: z.ZodOptional<z.ZodString>;
+                summarize_after_events: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            id: z.ZodString;
+            index: z.ZodOptional<z.ZodObject<{
+                graph: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    kind: z.ZodOptional<z.ZodEnum<{
+                        entity_graph: "entity_graph";
+                        temporal_kg: "temporal_kg";
+                    }>>;
+                }, z.core.$strict>>;
+                lexical: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    engine: z.ZodOptional<z.ZodEnum<{
+                        sqlite_fts: "sqlite_fts";
+                        bm25: "bm25";
+                    }>>;
+                }, z.core.$strict>>;
+                rerank: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                }, z.core.$strict>>;
+                vector: z.ZodOptional<z.ZodObject<{
+                    base_url: z.ZodOptional<z.ZodString>;
+                    dimensions: z.ZodOptional<z.ZodNumber>;
+                    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                    model: z.ZodOptional<z.ZodString>;
+                    provider: z.ZodOptional<z.ZodEnum<{
+                        ollama: "ollama";
+                    }>>;
+                    timeout_ms: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            retention: z.ZodOptional<z.ZodObject<{
+                forgetting: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                    manual: "manual";
+                    decay: "decay";
+                    ttl: "ttl";
+                }>>>;
+                ttl: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"sqlite">;
+                path: z.ZodOptional<z.ZodString>;
+                persistence: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        durable: "durable";
+                        ephemeral: "ephemeral";
+                    }>;
+                    mount: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"json">;
+                path: z.ZodOptional<z.ZodString>;
+                persistence: z.ZodOptional<z.ZodObject<{
+                    mode: z.ZodEnum<{
+                        durable: "durable";
+                        ephemeral: "ephemeral";
+                    }>;
+                    mount: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"postgres">;
+                dsn_secret: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"memory">;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>>;
+        resources: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            auth: z.ZodOptional<z.ZodObject<{
+                ssh_key: z.ZodOptional<z.ZodString>;
+                ssh_key_env: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            branch: z.ZodOptional<z.ZodString>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fetch: z.ZodOptional<z.ZodEnum<{
+                start: "start";
+                build: "build";
+            }>>;
+            id: z.ZodString;
+            kind: z.ZodLiteral<"git">;
+            mount: z.ZodString;
+            mode: z.ZodEnum<{
+                readonly: "readonly";
+                mutable: "mutable";
+            }>;
+            ref: z.ZodOptional<z.ZodString>;
+            sharing: z.ZodOptional<z.ZodEnum<{
+                per_agent: "per_agent";
+                team: "team";
+            }>>;
+            tag: z.ZodOptional<z.ZodString>;
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            build: z.ZodOptional<z.ZodObject<{
+                dependencies: z.ZodOptional<z.ZodObject<{
+                    check: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    dev: z.ZodOptional<z.ZodBoolean>;
+                    directory: z.ZodString;
+                    image: z.ZodString;
+                    manager: z.ZodOptional<z.ZodLiteral<"npm">>;
+                    scripts: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strict>>;
+                files: z.ZodOptional<z.ZodObject<{
+                    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ref: z.ZodOptional<z.ZodString>;
+                    root: z.ZodString;
+                }, z.core.$strict>>;
+                generated: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodArray<z.ZodString>;
+                    cwd: z.ZodOptional<z.ZodString>;
+                    image: z.ZodOptional<z.ZodString>;
+                    inputs: z.ZodArray<z.ZodObject<{
+                        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        ref: z.ZodOptional<z.ZodString>;
+                        root: z.ZodString;
+                    }, z.core.$strict>>;
+                    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+                    tools: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            id: z.ZodString;
+            kind: z.ZodLiteral<"bundle">;
+            mount: z.ZodString;
+            mode: z.ZodLiteral<"readonly">;
+            sha256: z.ZodOptional<z.ZodString>;
+            sharing: z.ZodOptional<z.ZodLiteral<"per_agent">>;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            feed: z.ZodOptional<z.ZodObject<{
+                directory: z.ZodOptional<z.ZodString>;
+                freeze: z.ZodOptional<z.ZodObject<{
+                    after: z.ZodString;
+                    timezone: z.ZodString;
+                }, z.core.$strict>>;
+                git: z.ZodOptional<z.ZodObject<{
+                    fetch: z.ZodOptional<z.ZodBoolean>;
+                    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    ref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        command: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        fallback: z.ZodOptional<z.ZodString>;
+                        template: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>]>>;
+                    repo: z.ZodString;
+                }, z.core.$strict>>;
+                include: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    from: z.ZodString;
+                    to: z.ZodString;
+                }, z.core.$strict>>>;
+                keep: z.ZodOptional<z.ZodNumber>;
+                owner: z.ZodOptional<z.ZodString>;
+                prepare: z.ZodOptional<z.ZodObject<{
+                    command: z.ZodArray<z.ZodString>;
+                    host: z.ZodOptional<z.ZodLiteral<true>>;
+                    image: z.ZodOptional<z.ZodString>;
+                    network: z.ZodOptional<z.ZodBoolean>;
+                    platform: z.ZodOptional<z.ZodEnum<{
+                        "linux/amd64": "linux/amd64";
+                        "linux/arm64": "linux/arm64";
+                    }>>;
+                    timeout_seconds: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+                validate: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            id: z.ZodString;
+            kind: z.ZodLiteral<"volume">;
+            mount: z.ZodString;
+            mode: z.ZodEnum<{
+                readonly: "readonly";
+                mutable: "mutable";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            sharing: z.ZodOptional<z.ZodEnum<{
+                per_agent: "per_agent";
+                team: "team";
+            }>>;
+        }, z.core.$strict>], "kind">>>;
+        networks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            provider: z.ZodLiteral<"moltnet">;
+            rooms: z.ZodArray<z.ZodObject<{
+                federation: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                    none: "none";
+                    all: "all";
+                }>, z.ZodArray<z.ZodString>]>>;
+                id: z.ZodString;
+                members: z.ZodArray<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    private: "private";
+                    public: "public";
+                }>>;
+                write_policy: z.ZodOptional<z.ZodEnum<{
+                    members: "members";
+                    registered_agents: "registered_agents";
+                    operators: "operators";
+                }>>;
+            }, z.core.$strict>>;
+            server: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                allowed_origins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                auth: z.ZodObject<{
+                    agent_registration: z.ZodOptional<z.ZodEnum<{
+                        disabled: "disabled";
+                        token: "token";
+                        open: "open";
+                    }>>;
+                    client: z.ZodOptional<z.ZodObject<{
+                        static_token: z.ZodOptional<z.ZodBoolean>;
+                        token_env: z.ZodOptional<z.ZodString>;
+                        token_id: z.ZodOptional<z.ZodString>;
+                        token_path: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    mode: z.ZodEnum<{
+                        none: "none";
+                        bearer: "bearer";
+                        open: "open";
+                    }>;
+                    public_read: z.ZodOptional<z.ZodBoolean>;
+                    tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        id: z.ZodString;
+                        secret: z.ZodString;
+                        scopes: z.ZodArray<z.ZodEnum<{
+                            observe: "observe";
+                            write: "write";
+                            admin: "admin";
+                            attach: "attach";
+                            pair: "pair";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+                console: z.ZodOptional<z.ZodObject<{
+                    analytics: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        provider: z.ZodLiteral<"google">;
+                        measurement_id: z.ZodString;
+                    }, z.core.$strict>], "provider">>;
+                }, z.core.$strict>>;
+                debug_events: z.ZodOptional<z.ZodBoolean>;
+                direct_messages: z.ZodOptional<z.ZodBoolean>;
+                human_ingress: z.ZodOptional<z.ZodBoolean>;
+                listen: z.ZodObject<{
+                    bind: z.ZodString;
+                    port: z.ZodNumber;
+                }, z.core.$strict>;
+                mode: z.ZodLiteral<"managed">;
+                pairings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    relay: z.ZodOptional<z.ZodObject<{
+                        room: z.ZodString;
+                        token_secret: z.ZodString;
+                        url: z.ZodString;
+                    }, z.core.$strict>>;
+                    remote_base_url: z.ZodOptional<z.ZodString>;
+                    remote_network_id: z.ZodString;
+                    remote_network_name: z.ZodString;
+                    token_secret: z.ZodString;
+                }, z.core.$strict>>>;
+                store: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    persistence: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            durable: "durable";
+                            ephemeral: "ephemeral";
+                        }>;
+                        mount: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    kind: z.ZodLiteral<"sqlite">;
+                }, z.core.$strict>, z.ZodObject<{
+                    path: z.ZodOptional<z.ZodString>;
+                    persistence: z.ZodOptional<z.ZodObject<{
+                        mode: z.ZodEnum<{
+                            durable: "durable";
+                            ephemeral: "ephemeral";
+                        }>;
+                        mount: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    kind: z.ZodLiteral<"json">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"postgres">;
+                    dsn_secret: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"memory">;
+                }, z.core.$strict>], "kind">;
+                trust_forwarded_proto: z.ZodOptional<z.ZodBoolean>;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                auth: z.ZodObject<{
+                    agent_registration: z.ZodOptional<z.ZodEnum<{
+                        disabled: "disabled";
+                        token: "token";
+                        open: "open";
+                    }>>;
+                    client: z.ZodOptional<z.ZodObject<{
+                        static_token: z.ZodOptional<z.ZodBoolean>;
+                        token_env: z.ZodOptional<z.ZodString>;
+                        token_id: z.ZodOptional<z.ZodString>;
+                        token_path: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                    mode: z.ZodEnum<{
+                        none: "none";
+                        bearer: "bearer";
+                        open: "open";
+                    }>;
+                    public_read: z.ZodOptional<z.ZodBoolean>;
+                    tokens: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        agents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        id: z.ZodString;
+                        secret: z.ZodString;
+                        scopes: z.ZodArray<z.ZodEnum<{
+                            observe: "observe";
+                            write: "write";
+                            admin: "admin";
+                            attach: "attach";
+                            pair: "pair";
+                        }>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+                mode: z.ZodLiteral<"external">;
+                url: z.ZodString;
+            }, z.core.$strict>], "mode">>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TrainingDataset = z.infer<typeof trainingDatasetSchema>;