@relayfx/sdk 0.0.38 → 0.0.39

package/dist/types/relay/client.d.ts

@@ -24,7 +24,7 @@ export interface StartExecutionByAddressInput {
 export interface StartExecutionByAgentDefinitionInput {
     readonly root_address_id: Ids.AddressId;
     readonly session_id?: Ids.SessionId;
-    readonly agent_definition_id: Ids.AgentDefinitionId;
+    readonly agent_definition_id: Ids.AgentId;
     readonly input?: ReadonlyArray<Content.Part>;
     readonly idempotency_key: Shared.NonEmptyString;
     readonly execution_id?: Ids.ExecutionId;
@@ -37,12 +37,41 @@ export interface StartExecutionByAgentDefinitionInput {
 export interface RegisterAgentInput extends Agent.DefineInput {
     readonly address?: Ids.AddressId;
 }
+export interface AgentOptions extends Omit<Agent.DefineInput, "id" | "name" | "permissions"> {
+    readonly id?: Ids.AgentId;
+    readonly address?: Ids.AddressId;
+    readonly name?: Shared.NonEmptyString;
+    readonly permissions?: Agent.DefineInput["permissions"];
+}
+export interface RegisteredAgent {
+    readonly id: Ids.AgentId;
+    readonly address_id: Ids.AddressId;
+    readonly record: Agent.DefinitionRecord;
+}
+export type StartTarget = Ids.AddressId | RegisteredAgent | {
+    readonly address_id: Ids.AddressId;
+};
+export interface StartInput {
+    readonly session_id?: Ids.SessionId;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly idempotency_key?: Shared.NonEmptyString;
+    readonly execution_id?: Ids.ExecutionId;
+    readonly event_sequence?: Execution.ExecutionEventSequence;
+    readonly started_at?: Shared.TimestampMillis;
+    readonly completed_at?: Shared.TimestampMillis;
+    readonly wait_id?: Ids.WaitId;
+    readonly metadata?: Shared.Metadata;
+}
+export interface RunInput extends StartInput {
+    readonly after_cursor?: Shared.NonEmptyString;
+    readonly limit?: number;
+}
 export interface Interface {
     readonly registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
-    readonly getAgentDefinition: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
+    readonly getAgentDefinition: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
     readonly listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError>;
-    readonly listAgentDefinitionRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
+    readonly listAgentDefinitionRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
     readonly getSkillDefinition: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError>;
     readonly listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError>;
     readonly listSkillDefinitionRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, ClientError>;
@@ -84,9 +113,91 @@ export declare const layerFromRuntime: Layer.Layer<Service, never, AgentRegistry
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
 export declare const registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
-export declare const getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError, Service>;
+export declare const agent: (slug: string, input: AgentOptions) => Effect.Effect<{
+    id: string & import("effect/Brand").Brand<"Relay.AgentId">;
+    address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
+    record: {
+        readonly id: string & import("effect/Brand").Brand<"Relay.AgentId">;
+        readonly created_at: number;
+        readonly updated_at: number;
+        readonly current_revision: number;
+        readonly 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 & import("effect/Brand").Brand<"Relay.SkillDefinitionId">)[];
+            readonly permission_rules?: {
+                readonly rules: readonly {
+                    readonly pattern: string;
+                    readonly level: "allow" | "deny" | "ask";
+                    readonly reason?: string;
+                }[];
+                readonly fallback?: "allow" | "deny" | "ask";
+            };
+            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;
+            }, "Type">[];
+        };
+        readonly tool_input_schema_digests?: {
+            readonly [x: string]: string;
+        };
+    };
+}, ClientError, Service>;
+export declare const getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError, Service>;
 export declare const listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError, Service>;
-export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
+export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
 export declare const getSkillDefinition: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError, Service>;
 export declare const listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError, Service>;
 export declare const listSkillDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<Skill.DefinitionRevisionList, ClientError, Service>;
@@ -96,6 +207,8 @@ export declare const listAddressBookRoutes: () => Effect.Effect<Address.RouteLis
 export declare const startExecution: (input: Operation.StartExecutionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
 export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
 export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
+export declare const start: (target: StartTarget, input?: StartInput | undefined) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
+export declare const run: (target: StartTarget, input?: RunInput) => Stream.Stream<Execution.ExecutionEvent, ClientError, Service>;
 export declare const cancelExecution: (input: Operation.CancelExecutionInput) => Effect.Effect<Operation.CancelExecutionAccepted, ClientError, Service>;
 export declare const steer: (input: Operation.SteerInput) => Effect.Effect<Operation.SteerAccepted, ClientError, Service>;
 export declare const getExecution: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Execution.Execution | undefined, ClientError, Service>;

package/dist/types/relay/operation.d.ts

@@ -61,8 +61,8 @@ export declare const StartExecutionInput: Schema.Struct<{
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
@@ -942,8 +942,8 @@ export declare const ConversationSummary: Schema.Struct<{
     }>;
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
     readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     readonly created_at: Schema.Int;
@@ -964,8 +964,8 @@ export declare const ListExecutionsResult: Schema.Struct<{
         }>;
         readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
         readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
-        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         }>;
         readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly created_at: Schema.Int;
@@ -1046,8 +1046,8 @@ export declare const GetSessionResult: Schema.Struct<{
         }>;
         readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
         readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
-        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         }>;
         readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
         readonly created_at: Schema.Int;

package/dist/types/runtime/address/address-resolution-service.d.ts

@@ -23,8 +23,8 @@ declare const AddressAgentDefinitionNotFound_base: Schema.Class<AddressAgentDefi
     readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
-    readonly agent_definition_id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
 }>, import("effect/Cause").YieldableError>;
 export declare class AddressAgentDefinitionNotFound extends AddressAgentDefinitionNotFound_base {
@@ -50,8 +50,8 @@ export declare const LocalAgentTarget: Schema.Struct<{
         readonly route_key: Schema.String;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>;
-    readonly agent_definition_id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
     readonly agent_definition_revision: Schema.Int;
     readonly agent_definition_snapshot: Schema.Struct<{

package/dist/types/runtime/agent/agent-loop-service.d.ts

@@ -43,7 +43,7 @@ export interface RunInput {
     readonly executionId: Ids.ExecutionId;
     readonly sessionId?: Ids.SessionId;
     readonly agent: Agent.Definition;
-    readonly agentDefinitionId?: Ids.AgentDefinitionId;
+    readonly agentId?: Ids.AgentId;
     readonly agentDefinitionRevision?: Agent.DefinitionRevision;
     readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly input: ReadonlyArray<Content.Part>;
@@ -76,26 +76,7 @@ export declare class Service extends Service_base {
  * @experimental
  */
 export declare const STRUCTURED_TURN_PROMPT = "Return the final structured output for the task above.";
-/**
- * Converts a Relay `Tool.Definition` into the `Ai.Tool` Baton's toolkit
- * consumes. Exported for direct unit testing of the `needsApproval` mapping
- * (see `agent-loop-service.test.ts`) — `Tool.Definition.needs_approval` must
- * reach the constructed tool honestly so Relay tools self-describe correctly
- * even outside Relay's own durable approval gate (docs/spec/27).
- *
- * @experimental
- */
-/**
- * Build the model-facing `Ai.Tool` from a bare `Tool.Definition`, delegating to
- * the single canonical mapping in `ToolRuntime` so the parameters schema is a real
- * object AST (not the `Schema.Unknown` placeholder that breaks OpenRouter/Anthropic
- * tool preparation). Retained and exported only for the unit tests that assert the
- * `needs_approval` mapping; the run loop builds its toolkit from `RegisteredTool`s
- * (which may carry a tool's own concrete `aiTool`), not from definitions.
- *
- * @experimental
- */
-export declare const aiToolFromDefinition: (definition: Tool.Definition) => Ai.Tool.Any;
+export declare const toolFromDefinition: (definition: Tool.Definition) => Ai.Tool.Any;
 /** Map a Baton run failure (or an upstream model error) to the public error types. */
 export declare const mapBoundaryError: (error: unknown, current: Execution.ExecutionEventSequence) => AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
 export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLog.Service | ToolRuntime.Service | LanguageModelService.Service | ModelCallPolicy.Service | SchemaRegistry.Service | PromptAssembler.Service>;

package/dist/types/runtime/agent/agent-registry-service.d.ts

@@ -13,10 +13,10 @@ export declare class AgentRegistryError extends AgentRegistryError_base {
 }
 export interface Interface {
     readonly register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError>;
-    readonly get: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError>;
+    readonly get: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError>;
     readonly getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError>;
     readonly list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError>;
-    readonly listRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
+    readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentRegistry", Interface>;
 export declare class Service extends Service_base {
@@ -24,8 +24,8 @@ export declare class Service extends Service_base {
 export declare const layer: Layer.Layer<Service, never, AgentDefinitionRepository.Service>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError, Service>;
-export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError, Service>;
 export declare const getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError, Service>;
 export declare const list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError, Service>;
-export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
 export {};

package/dist/types/runtime/child/spawn-child-run-tool.d.ts

@@ -189,7 +189,7 @@ export interface DispatchInput {
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly startedAt: number;
     readonly completedAt: number;
-    readonly agentDefinitionId: Ids.AgentDefinitionId;
+    readonly agentId: Ids.AgentId;
     readonly agentDefinitionRevision: Agent.DefinitionRevision;
     readonly agentDefinitionSnapshot: Agent.Definition;
     readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
@@ -197,7 +197,7 @@ export interface DispatchInput {
 }
 export interface Config {
     readonly agent: Agent.Definition;
-    readonly agentDefinitionId: Ids.AgentDefinitionId;
+    readonly agentId: Ids.AgentId;
     readonly agentDefinitionRevision: Agent.DefinitionRevision;
     readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly childRuns: ChildRunService.Interface;

package/dist/types/runtime/cluster/execution-entity.d.ts

@@ -69,8 +69,8 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
@@ -235,8 +235,8 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
@@ -400,8 +400,8 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{

package/dist/types/runtime/execution/execution-service.d.ts

@@ -16,7 +16,7 @@ export interface AcceptInput {
     readonly sessionId?: Ids.SessionId;
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly createdAt: number;
-    readonly agentDefinitionId?: Ids.AgentDefinitionId;
+    readonly agentId?: Ids.AgentId;
     readonly agentDefinitionRevision?: Agent.DefinitionRevision;
     readonly agentDefinitionSnapshot?: Agent.Definition;
     readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;

package/dist/types/runtime/tool/tool-runtime-service.d.ts

@@ -53,12 +53,34 @@ declare const ToolCallInfo_base: Context.ServiceClass<ToolCallInfo, "@relayfx/ru
 export declare class ToolCallInfo extends ToolCallInfo_base {
 }
 export interface RegisteredTool {
+    readonly name: Shared.NonEmptyString;
     readonly definition: Tool.Definition;
-    readonly aiTool?: Ai.Tool.Any;
+    readonly tool: Ai.Tool.Any;
     readonly requiredPermissions?: ReadonlyArray<string>;
-    readonly inputSchema?: Schema.ConstraintDecoder<unknown, never>;
-    readonly handler?: (input: any, context: Ai.Toolkit.HandlerContext<Ai.Tool.Any>) => Effect.Effect<unknown, unknown, any>;
-    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, any>;
+    readonly validateInput?: (input: Shared.JsonValue) => Effect.Effect<void, ToolInputInvalid, any>;
+    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, unknown, any>;
+}
+export interface ToolOptions<Input extends Schema.Constraint, Output extends Schema.Constraint> {
+    readonly description: string;
+    readonly input: Input;
+    readonly output: Output;
+    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
+    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
+    readonly needsApproval?: boolean | undefined;
+    readonly metadata?: Shared.Metadata | undefined;
+    readonly run: (input: Input["Type"], context: ToolExecutionContext) => Effect.Effect<Output["Type"], unknown, any>;
+}
+export interface DynamicToolOptions {
+    readonly description: string;
+    readonly inputSchema: Shared.JsonValue;
+    readonly outputSchema: Shared.JsonValue;
+    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
+    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
+    readonly needsApproval?: boolean | undefined;
+    readonly metadata?: Shared.Metadata | undefined;
+    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, unknown, any>;
 }
 export interface RunInput {
     readonly executionId: Ids.ExecutionId;
@@ -73,18 +95,23 @@ export interface Interface {
     readonly register: (tool: RegisteredTool) => Effect.Effect<void>;
     readonly definitions: Effect.Effect<ReadonlyArray<Tool.Definition>>;
     readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
-    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>;
+    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, any>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ToolRuntime", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const aiToolFromRegistered: (tool: RegisteredTool) => Ai.Tool.Any;
-export declare const definitionFromAiTool: (tool: Ai.Tool.Any, permissions?: ReadonlyArray<Tool.Permission>) => Tool.Definition;
+export declare const toolFromRegistered: (tool: RegisteredTool) => Ai.Tool.Any;
+export declare const tool: <const Name extends string, Input extends Schema.Constraint, Output extends Schema.Constraint>(name: Name, options: ToolOptions<Input, Output>) => RegisteredTool & {
+    readonly name: Name;
+};
+export declare const dynamicTool: <const Name extends string>(name: Name, options: DynamicToolOptions) => RegisteredTool & {
+    readonly name: Name;
+};
 export declare const layer: (initialTools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service, never, ToolCallRepository.Service | EventLog.Service | WaitService.Service>;
 export declare const memoryLayer: (tools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const register: (tool: RegisteredTool) => Effect.Effect<void, never, Service>;
+export declare const register: (registeredTool: RegisteredTool) => Effect.Effect<void, never, Service>;
 export declare const definitions: () => Effect.Effect<readonly Tool.Definition[], never, Service>;
 export declare const registeredTools: () => Effect.Effect<readonly RegisteredTool[], never, Service>;
-export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, Service>;
+export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, any>;
 export {};

package/dist/types/runtime/workflow/execution-workflow.d.ts

@@ -78,8 +78,8 @@ export declare const StartInput: Schema.Struct<{
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
@@ -321,8 +321,8 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{

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

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { AgentDefinitionId, SkillDefinitionId } from "./ids-schema";
+import { AgentId, SkillDefinitionId } from "./ids-schema";
 import { Metadata, NonEmptyString } from "./shared-schema";
 import { Permission } from "./tool-schema";
 export declare const DefinitionRevision: Schema.Int;
@@ -140,7 +140,7 @@ export type ToolRef = {
     readonly name: string;
 } & Readonly<Record<string, unknown>>);
 export interface DefineInput {
-    readonly id: AgentDefinitionId;
+    readonly id: AgentId;
     readonly name: NonEmptyString;
     readonly instructions?: string;
     readonly model: ModelSelection;
@@ -158,8 +158,8 @@ export interface DefineInput {
 }
 export declare const define: (input: DefineInput) => RegisterDefinitionPayload;
 export declare const DefinitionRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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.Struct<{
@@ -224,8 +224,8 @@ export declare const DefinitionRecord: Schema.Struct<{
 export interface DefinitionRecord extends Schema.Schema.Type<typeof DefinitionRecord> {
 }
 export declare const DefinitionRevisionRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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.Struct<{
@@ -289,8 +289,8 @@ export declare const DefinitionRevisionRecord: Schema.Struct<{
 export interface DefinitionRevisionRecord extends Schema.Schema.Type<typeof DefinitionRevisionRecord> {
 }
 export declare const RegisterDefinitionPayload: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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.Struct<{
         readonly name: Schema.String;
@@ -352,8 +352,8 @@ export interface RegisterDefinitionPayload extends Schema.Schema.Type<typeof Reg
 }
 export declare const DefinitionRegistered: Schema.Struct<{
     readonly record: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        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.Struct<{
@@ -420,8 +420,8 @@ export interface DefinitionRegistered extends Schema.Schema.Type<typeof Definiti
 }
 export declare const DefinitionList: Schema.Struct<{
     readonly records: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        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.Struct<{
@@ -488,8 +488,8 @@ 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.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        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.Struct<{

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

@@ -12,8 +12,8 @@ export declare const Execution: Schema.Struct<{
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
     }>;
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
     readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{

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

@@ -12,10 +12,10 @@ export declare const AddressBookEntryId: Schema.brand<Schema.String, "Relay.Addr
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
 };
 export type AddressBookEntryId = typeof AddressBookEntryId.Type;
-export declare const AgentDefinitionId: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+export declare const AgentId: Schema.brand<Schema.String, "Relay.AgentId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
 };
-export type AgentDefinitionId = typeof AgentDefinitionId.Type;
+export type AgentId = typeof AgentId.Type;
 export declare const SkillDefinitionId: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
 };

package/dist/types/store-sql/agent/agent-definition-repository.d.ts

@@ -7,7 +7,7 @@ declare const AgentDefinitionRepositoryError_base: Schema.Class<AgentDefinitionR
 export declare class AgentDefinitionRepositoryError extends AgentDefinitionRepositoryError_base {
 }
 export interface AgentDefinitionRecord {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly currentRevision: Agent.DefinitionRevision;
     readonly definition: Agent.Definition;
     readonly toolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
@@ -15,28 +15,28 @@ export interface AgentDefinitionRecord {
     readonly updatedAt: number;
 }
 export interface AgentDefinitionRevisionRecord {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly revision: Agent.DefinitionRevision;
     readonly definition: Agent.Definition;
     readonly toolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly createdAt: number;
 }
 export interface PutAgentDefinitionInput {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly definition: Agent.Definition;
     readonly toolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly now: number;
 }
 export interface GetAgentDefinitionRevisionInput {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly revision: Agent.DefinitionRevision;
 }
 export interface Interface {
     readonly put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError>;
-    readonly get: (id: Ids.AgentDefinitionId) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError>;
+    readonly get: (id: Ids.AgentId) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError>;
     readonly getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError>;
     readonly list: () => Effect.Effect<ReadonlyArray<AgentDefinitionRecord>, AgentDefinitionRepositoryError>;
-    readonly listRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<ReadonlyArray<AgentDefinitionRevisionRecord>, AgentDefinitionRepositoryError>;
+    readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<ReadonlyArray<AgentDefinitionRevisionRecord>, AgentDefinitionRepositoryError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AgentDefinitionRepository", Interface>;
 export declare class Service extends Service_base {
@@ -60,8 +60,8 @@ export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError, Service>;
-export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError, Service>;
 export declare const getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError, Service>;
 export declare const list: () => Effect.Effect<readonly AgentDefinitionRecord[], AgentDefinitionRepositoryError, Service>;
-export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<readonly AgentDefinitionRevisionRecord[], AgentDefinitionRepositoryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<readonly AgentDefinitionRevisionRecord[], AgentDefinitionRepositoryError, Service>;
 export {};