@relayfx/test 0.1.0

package/dist/types/schema/agent-schema.d.ts

@@ -0,0 +1,658 @@
+import { Schema } from "effect";
+import { AgentId, SkillDefinitionId } from "./ids-schema";
+import { Metadata, NonEmptyString } from "./shared-schema";
+import { Permission } from "./tool-schema";
+export declare const DefinitionRevision: Schema.Int;
+export type DefinitionRevision = typeof DefinitionRevision.Type;
+export declare const ModelSelection: Schema.Struct<{
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly registration_key: Schema.optionalKey<Schema.String>;
+    readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface ModelSelection extends Schema.Schema.Type<typeof ModelSelection> {
+}
+export declare const ChildRunWorkspacePolicy: Schema.Struct<{
+    readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+    readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+}>;
+export interface ChildRunWorkspacePolicy extends Schema.Schema.Type<typeof ChildRunWorkspacePolicy> {
+}
+export declare const ChildRunPreset: Schema.Struct<{
+    readonly instructions: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.optionalKey<Schema.Struct<{
+        readonly provider: Schema.String;
+        readonly model: Schema.String;
+        readonly registration_key: Schema.optionalKey<Schema.String>;
+        readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+        readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+    }>>;
+    readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface ChildRunPreset extends Schema.Schema.Type<typeof ChildRunPreset> {
+}
+export declare const HandoffTarget: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly preset_name: Schema.String;
+}>;
+export interface HandoffTarget extends Schema.Schema.Type<typeof HandoffTarget> {
+}
+export declare const PermissionLevel: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+export type PermissionLevel = typeof PermissionLevel.Type;
+export declare const PermissionRule: Schema.Struct<{
+    readonly pattern: Schema.String;
+    readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>;
+export interface PermissionRule extends Schema.Schema.Type<typeof PermissionRule> {
+}
+export declare const PermissionRuleset: Schema.Struct<{
+    readonly rules: Schema.$Array<Schema.Struct<{
+        readonly pattern: Schema.String;
+        readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        readonly reason: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+}>;
+export interface PermissionRuleset extends Schema.Schema.Type<typeof PermissionRuleset> {
+}
+export declare const ToolInputSchemaDigests: Schema.$Record<Schema.String, Schema.String>;
+export interface ToolInputSchemaDigests extends Schema.Schema.Type<typeof ToolInputSchemaDigests> {
+}
+export interface RecursTurnPolicySnapshot {
+    readonly kind: "recurs";
+    readonly count: number;
+}
+export interface UntilToolCallTurnPolicySnapshot {
+    readonly kind: "until-tool-call";
+    readonly name: string;
+}
+export interface BothTurnPolicySnapshot {
+    readonly kind: "both";
+    readonly first: TurnPolicySnapshot;
+    readonly second: TurnPolicySnapshot;
+}
+export type TurnPolicySnapshot = RecursTurnPolicySnapshot | UntilToolCallTurnPolicySnapshot | BothTurnPolicySnapshot;
+export declare const maxTurnPolicySnapshotDepth = 16;
+export declare const maxTurnPolicySnapshotNodes = 64;
+export declare const TurnPolicySnapshot: Schema.Codec<TurnPolicySnapshot>;
+export declare const defaultMaxToolTurns = 8;
+export declare const defaultMaxWaitTurns = 8;
+declare const DefinitionSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly instructions: Schema.optionalKey<Schema.String>;
+    readonly model: Schema.Struct<{
+        readonly provider: Schema.String;
+        readonly model: Schema.String;
+        readonly registration_key: Schema.optionalKey<Schema.String>;
+        readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly tool_names: Schema.$Array<Schema.String>;
+    readonly permissions: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly skill_definition_ids: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+    }>>;
+    readonly permission_rules: Schema.optionalKey<Schema.Struct<{
+        readonly rules: Schema.$Array<Schema.Struct<{
+            readonly pattern: Schema.String;
+            readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+            readonly reason: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+    }>>;
+    readonly turn_policy: Schema.optionalKey<Schema.Codec<TurnPolicySnapshot, TurnPolicySnapshot, never, never>>;
+    readonly max_tool_turns: Schema.optionalKey<Schema.Int>;
+    readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
+    readonly token_budget: Schema.optionalKey<Schema.Int>;
+    readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: Schema.optionalKey<Schema.Struct<{
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly registration_key: Schema.optionalKey<Schema.String>;
+            readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+            readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+        }>>;
+        readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>>;
+    readonly handoff_targets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly preset_name: Schema.String;
+    }>>>;
+    readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Definition extends Schema.Schema.Type<typeof DefinitionSchema> {
+}
+export declare const Definition: Schema.Codec<Definition, Schema.Codec.Encoded<typeof DefinitionSchema>>;
+export type ToolRef = {
+    readonly name: string;
+} | ({
+    readonly name: string;
+} & Readonly<Record<string, unknown>>);
+export interface DefineInput {
+    readonly id: AgentId;
+    readonly name: NonEmptyString;
+    readonly instructions?: string;
+    readonly model: ModelSelection;
+    readonly tools?: ReadonlyArray<ToolRef>;
+    readonly permissions: ReadonlyArray<Permission>;
+    readonly skill_definition_ids?: ReadonlyArray<SkillDefinitionId>;
+    readonly permission_rules?: PermissionRuleset;
+    readonly turn_policy?: TurnPolicySnapshot;
+    readonly max_tool_turns?: number;
+    readonly max_wait_turns?: number;
+    readonly token_budget?: number;
+    readonly child_run_presets?: Readonly<Record<string, ChildRunPreset>>;
+    readonly handoff_targets?: ReadonlyArray<HandoffTarget>;
+    readonly output_schema_ref?: string;
+    readonly metadata?: Metadata;
+}
+export declare const define: (input: DefineInput) => RegisterDefinitionPayload;
+export declare const DefinitionRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+    readonly current_revision: Schema.Int;
+    readonly definition: Schema.Codec<Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+            readonly name: Schema.String;
+            readonly preset_name: Schema.String;
+        }, "Encoded">[];
+    }, never, never>;
+    readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface DefinitionRecord extends Schema.Schema.Type<typeof DefinitionRecord> {
+}
+export declare const DefinitionRevisionRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+    readonly revision: Schema.Int;
+    readonly definition: Schema.Codec<Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+            readonly name: Schema.String;
+            readonly preset_name: Schema.String;
+        }, "Encoded">[];
+    }, never, never>;
+    readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly created_at: Schema.Int;
+}>;
+export interface DefinitionRevisionRecord extends Schema.Schema.Type<typeof DefinitionRevisionRecord> {
+}
+export declare const RegisterDefinitionPayload: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+    readonly definition: Schema.Codec<Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+            readonly name: Schema.String;
+            readonly preset_name: Schema.String;
+        }, "Encoded">[];
+    }, never, never>;
+}>;
+export interface RegisterDefinitionPayload extends Schema.Schema.Type<typeof RegisterDefinitionPayload> {
+}
+export declare const DefinitionRegistered: Schema.Struct<{
+    readonly record: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        };
+        readonly current_revision: Schema.Int;
+        readonly definition: Schema.Codec<Definition, {
+            readonly name: string;
+            readonly permissions: readonly {
+                readonly name: string;
+                readonly value: Schema.Json;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            }[];
+            readonly model: {
+                readonly provider: string;
+                readonly model: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+            readonly tool_names: readonly string[];
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly instructions?: string;
+            readonly output_schema_ref?: string;
+            readonly skill_definition_ids?: readonly string[];
+            readonly permission_rules?: {
+                readonly rules: readonly {
+                    readonly pattern: string;
+                    readonly level: "allow" | "deny" | "ask";
+                    readonly reason?: string;
+                }[];
+                readonly fallback?: "allow" | "deny" | "ask";
+            };
+            readonly turn_policy?: TurnPolicySnapshot;
+            readonly max_tool_turns?: number;
+            readonly max_wait_turns?: number;
+            readonly token_budget?: number;
+            readonly child_run_presets?: {
+                readonly [x: string]: {
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly permissions?: readonly string[];
+                    readonly model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
+                    readonly instructions?: string;
+                    readonly tool_names?: readonly string[];
+                    readonly workspace_policy?: {
+                        readonly mode: "share" | "fork";
+                        readonly fallback?: "fail" | "fresh";
+                    };
+                    readonly output_schema_ref?: string;
+                };
+            };
+            readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+                readonly name: Schema.String;
+                readonly preset_name: Schema.String;
+            }, "Encoded">[];
+        }, never, never>;
+        readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>;
+}>;
+export interface DefinitionRegistered extends Schema.Schema.Type<typeof DefinitionRegistered> {
+}
+export declare const DefinitionList: Schema.Struct<{
+    readonly records: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        };
+        readonly current_revision: Schema.Int;
+        readonly definition: Schema.Codec<Definition, {
+            readonly name: string;
+            readonly permissions: readonly {
+                readonly name: string;
+                readonly value: Schema.Json;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            }[];
+            readonly model: {
+                readonly provider: string;
+                readonly model: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+            readonly tool_names: readonly string[];
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly instructions?: string;
+            readonly output_schema_ref?: string;
+            readonly skill_definition_ids?: readonly string[];
+            readonly permission_rules?: {
+                readonly rules: readonly {
+                    readonly pattern: string;
+                    readonly level: "allow" | "deny" | "ask";
+                    readonly reason?: string;
+                }[];
+                readonly fallback?: "allow" | "deny" | "ask";
+            };
+            readonly turn_policy?: TurnPolicySnapshot;
+            readonly max_tool_turns?: number;
+            readonly max_wait_turns?: number;
+            readonly token_budget?: number;
+            readonly child_run_presets?: {
+                readonly [x: string]: {
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly permissions?: readonly string[];
+                    readonly model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
+                    readonly instructions?: string;
+                    readonly tool_names?: readonly string[];
+                    readonly workspace_policy?: {
+                        readonly mode: "share" | "fork";
+                        readonly fallback?: "fail" | "fresh";
+                    };
+                    readonly output_schema_ref?: string;
+                };
+            };
+            readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+                readonly name: Schema.String;
+                readonly preset_name: Schema.String;
+            }, "Encoded">[];
+        }, never, never>;
+        readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly created_at: Schema.Int;
+        readonly updated_at: Schema.Int;
+    }>>;
+}>;
+export interface DefinitionList extends Schema.Schema.Type<typeof DefinitionList> {
+}
+export declare const DefinitionRevisionList: Schema.Struct<{
+    readonly records: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+        };
+        readonly revision: Schema.Int;
+        readonly definition: Schema.Codec<Definition, {
+            readonly name: string;
+            readonly permissions: readonly {
+                readonly name: string;
+                readonly value: Schema.Json;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            }[];
+            readonly model: {
+                readonly provider: string;
+                readonly model: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+            readonly tool_names: readonly string[];
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly instructions?: string;
+            readonly output_schema_ref?: string;
+            readonly skill_definition_ids?: readonly string[];
+            readonly permission_rules?: {
+                readonly rules: readonly {
+                    readonly pattern: string;
+                    readonly level: "allow" | "deny" | "ask";
+                    readonly reason?: string;
+                }[];
+                readonly fallback?: "allow" | "deny" | "ask";
+            };
+            readonly turn_policy?: TurnPolicySnapshot;
+            readonly max_tool_turns?: number;
+            readonly max_wait_turns?: number;
+            readonly token_budget?: number;
+            readonly child_run_presets?: {
+                readonly [x: string]: {
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly permissions?: readonly string[];
+                    readonly model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
+                    readonly instructions?: string;
+                    readonly tool_names?: readonly string[];
+                    readonly workspace_policy?: {
+                        readonly mode: "share" | "fork";
+                        readonly fallback?: "fail" | "fresh";
+                    };
+                    readonly output_schema_ref?: string;
+                };
+            };
+            readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+                readonly name: Schema.String;
+                readonly preset_name: Schema.String;
+            }, "Encoded">[];
+        }, never, never>;
+        readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly created_at: Schema.Int;
+    }>>;
+}>;
+export interface DefinitionRevisionList extends Schema.Schema.Type<typeof DefinitionRevisionList> {
+}
+export {};