@relayfx/sdk 0.0.6 → 0.0.7

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

@@ -1,4 +1,4 @@
-import type { ExecutionRepository } from "../../store-sql/index";
+import type { ChildExecutionRepository, ExecutionRepository } from "../../store-sql/index";
 import { Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
 import type { WorkflowEngine } from "effect/unstable/workflow";
@@ -14,25 +14,32 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
     readonly root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
+    readonly session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    }>;
     readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"structured">;
         readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"blob-reference">;
         readonly uri: Schema.String;
         readonly media_type: Schema.String;
         readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"artifact-reference">;
         readonly artifact_id: Schema.String;
         readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"tool-call">;
@@ -44,6 +51,7 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
             readonly input: 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 provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"tool-result">;
@@ -55,6 +63,7 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
             readonly error: Schema.optionalKey<Schema.String>;
             readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         }>;
+        readonly provider_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 event_sequence: Schema.Int;
@@ -80,6 +89,17 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
             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 max_tool_turns: Schema.optionalKey<Schema.Int>;
         readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
         readonly token_budget: Schema.optionalKey<Schema.Int>;
@@ -101,12 +121,25 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
             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>>>;
     }>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
+    readonly resume_tool_call: Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        };
+        readonly name: Schema.String;
+        readonly input: 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 workflow_generation: Schema.optionalKey<Schema.Int>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -146,25 +179,32 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
     readonly root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
+    readonly session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    }>;
     readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"structured">;
         readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"blob-reference">;
         readonly uri: Schema.String;
         readonly media_type: Schema.String;
         readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"artifact-reference">;
         readonly artifact_id: Schema.String;
         readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"tool-call">;
@@ -176,6 +216,7 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
             readonly input: 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 provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"tool-result">;
@@ -187,6 +228,7 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
             readonly error: Schema.optionalKey<Schema.String>;
             readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         }>;
+        readonly provider_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 event_sequence: Schema.Int;
@@ -212,6 +254,17 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
             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 max_tool_turns: Schema.optionalKey<Schema.Int>;
         readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
         readonly token_budget: Schema.optionalKey<Schema.Int>;
@@ -233,12 +286,25 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
             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>>>;
     }>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
+    readonly resume_tool_call: Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        };
+        readonly name: Schema.String;
+        readonly input: 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 workflow_generation: Schema.optionalKey<Schema.Int>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -269,7 +335,7 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
     };
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
 }>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>>;
-export declare const layer: import("effect/Layer").Layer<never, never, ExecutionRepository.Service | EventLog.Service | WaitService.Service | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLog.Service | WaitService.Service | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
 export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<Rpc.Rpc<"start", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -277,25 +343,32 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
     readonly root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
+    readonly session_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    }>;
     readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
         readonly text: Schema.String;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"structured">;
         readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
         readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"blob-reference">;
         readonly uri: Schema.String;
         readonly media_type: Schema.String;
         readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"artifact-reference">;
         readonly artifact_id: Schema.String;
         readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"tool-call">;
@@ -307,6 +380,7 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
             readonly input: 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 provider_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>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"tool-result">;
@@ -318,6 +392,7 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
             readonly error: Schema.optionalKey<Schema.String>;
             readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         }>;
+        readonly provider_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 event_sequence: Schema.Int;
@@ -343,6 +418,17 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
             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 max_tool_turns: Schema.optionalKey<Schema.Int>;
         readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
         readonly token_budget: Schema.optionalKey<Schema.Int>;
@@ -364,12 +450,25 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
             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>>>;
     }>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
+    readonly resume_tool_call: Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        };
+        readonly name: Schema.String;
+        readonly input: 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 workflow_generation: Schema.optionalKey<Schema.Int>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {

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

@@ -24,6 +24,10 @@ export interface FindBySequenceOrCursorInput {
     readonly sequence: Execution.ExecutionEventSequence;
     readonly cursor: string;
 }
+export interface FindByCursorInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly cursor: string;
+}
 export interface FindFirstByTypeAfterSequenceInput {
     readonly executionId: Ids.ExecutionId;
     readonly type: Execution.ExecutionEventType;
@@ -34,6 +38,7 @@ export interface Interface {
     readonly replay: (input: ReplayInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, EventLogCursorNotFound | EventLogError>;
     readonly stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | EventLogError>;
     readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
+    readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, EventLogError>;
     /**
@@ -54,6 +59,7 @@ export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<
 export declare const appendIdempotent: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
 export declare const replay: (input: ReplayInput) => Effect.Effect<readonly Execution.ExecutionEvent[], EventLogCursorNotFound | EventLogError, Service>;
 export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
+export declare const findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
 export declare const findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
 export declare const maxSequence: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number | undefined, EventLogError, Service>;
 export declare const sumUsage: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number, EventLogError, Service>;

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

@@ -13,6 +13,7 @@ export declare class ExecutionServiceError extends ExecutionServiceError_base {
 export interface AcceptInput {
     readonly executionId: Ids.ExecutionId;
     readonly rootAddressId: Ids.AddressId;
+    readonly sessionId?: Ids.SessionId;
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly createdAt: number;
     readonly agentDefinitionId?: Ids.AgentDefinitionId;

package/dist/types/runtime/index.d.ts

@@ -5,17 +5,26 @@ export * as AgentRegistry from "./agent/agent-registry-service";
 export * as ArtifactStore from "./content/artifact-store-service";
 export * as BlobStore from "./content/blob-store-service";
 export * as ChildRunService from "./child/child-run-service";
+export * as SpawnChildRunTool from "./child/spawn-child-run-tool";
 export * as ExecutionEntity from "./cluster/execution-entity";
 export * as EnvelopeService from "./envelope/envelope-service";
 export * as EventLog from "./execution/event-log-service";
 export * as ExecutionService from "./execution/execution-service";
+export * as EmbeddingModelService from "./model/embedding-model-service";
 export * as LanguageModelService from "./model/language-model-service";
+export * as MemoryService from "./memory/memory-service";
 export * as ModelCallPolicy from "./model/model-call-policy";
 export * as ParentNotifier from "./child/parent-notifier-service";
 export * as PromptAssembler from "./agent/prompt-assembler-service";
+export * as RelayCompaction from "./agent/relay-compaction";
+export * as RelayPermissions from "./agent/relay-permissions";
+export * as RelaySteering from "./agent/relay-steering";
+export * as RelayToolOutput from "./agent/relay-tool-output";
 export * as RunnerRuntime from "./runner/runner-runtime-service";
 export * as SchedulerService from "./schedule/scheduler-service";
 export * as SchemaRegistry from "./schema-registry/schema-registry-service";
+export * as RelaySessionStore from "./session/session-store-service";
+export * as SkillRegistry from "./skill/skill-registry-service";
 export * as ToolRuntime from "./tool/tool-runtime-service";
 export * as WaitService from "./wait/wait-service";
 export * as WaitSignal from "./wait/wait-signal";

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

@@ -0,0 +1,20 @@
+import { Memory } from "@batonfx/core";
+import { MemoryRepository } from "../../store-sql/index";
+import { Context, Effect, Layer } from "effect";
+import * as EmbeddingModelService from "../model/embedding-model-service";
+export interface Options {
+    readonly topK?: number | undefined;
+    readonly minScore?: number | undefined;
+    readonly embeddingSelection?: EmbeddingModelService.ModelSelection | undefined;
+}
+export interface Interface extends Memory.Interface {
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/MemoryService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: Options) => Layer.Layer<Service | Memory.Memory, never, MemoryRepository.Service | EmbeddingModelService.Service>;
+export declare const memoryLayer: (options?: Options) => Layer.Layer<Service | Memory.Memory, never, MemoryRepository.Service | EmbeddingModelService.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service | Memory.Memory>;
+export declare const recall: (input: Memory.RecallInput) => Effect.Effect<readonly Memory.Item[], Memory.MemoryError, Service>;
+export declare const remember: (input: Memory.RememberInput) => Effect.Effect<void, Memory.MemoryError, Service>;
+export {};

package/dist/types/runtime/model/embedding-model-service.d.ts

@@ -0,0 +1,68 @@
+import { Agent, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Ai from "effect/unstable/ai";
+declare const EmbeddingModelNotRegistered_base: Schema.Class<EmbeddingModelNotRegistered, Schema.TaggedStruct<"EmbeddingModelNotRegistered", {
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly registration_key: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class EmbeddingModelNotRegistered extends EmbeddingModelNotRegistered_base {
+}
+export interface ModelSelection {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+}
+export type ModelEnvironment = Ai.EmbeddingModel.EmbeddingModel | Ai.EmbeddingModel.Dimensions | Ai.Model.ProviderName | Ai.Model.ModelName;
+export interface Registration {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+    readonly layer: Layer.Layer<ModelEnvironment>;
+    readonly metadata?: Shared.Metadata | undefined;
+}
+export interface RegisterInput {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+    readonly layer: Layer.Layer<ModelEnvironment>;
+    readonly metadata?: Shared.Metadata | undefined;
+}
+export interface LayerOptions {
+    readonly defaultSelection?: ModelSelection | undefined;
+}
+export interface DeterministicOptions {
+    readonly provider?: string | undefined;
+    readonly model?: string | undefined;
+    readonly dimensions?: number | undefined;
+}
+export interface Interface {
+    readonly register: (input: RegisterInput) => Effect.Effect<void>;
+    readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
+    readonly provide: <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Exclude<R, ModelEnvironment>>;
+    readonly provideDefault: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Exclude<R, ModelEnvironment>>;
+    readonly provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Exclude<R, ModelEnvironment>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EmbeddingModelService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const registrationFromLayer: <Provides extends ModelEnvironment, R>(input: {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+    readonly layer: Layer.Layer<Provides, never, R>;
+    readonly metadata?: Shared.Metadata | undefined;
+}) => Effect.Effect<Registration, never, R>;
+export declare const layer: (initialRegistrations?: ReadonlyArray<Registration>, options?: LayerOptions) => Layer.Layer<Service, never, never>;
+export declare const layerFromRegistrationEffects: <E, R>(registrations: ReadonlyArray<Effect.Effect<Registration, E, R>>, options?: LayerOptions) => Layer.Layer<Service, E, Exclude<R, import("effect/Scope").Scope>>;
+export declare const memoryLayer: (initialRegistrations?: ReadonlyArray<Registration>, options?: LayerOptions) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const deterministicLayer: (options?: DeterministicOptions) => Layer.Layer<Ai.EmbeddingModel.EmbeddingModel | Ai.EmbeddingModel.Dimensions, never, never>;
+export declare const deterministicRegistration: (options?: DeterministicOptions) => Effect.Effect<Registration, never, never>;
+export declare const deterministicTestLayer: (options?: DeterministicOptions) => Layer.Layer<Service, never, never>;
+export declare const register: (input: RegisterInput) => Effect.Effect<void, never, Service>;
+export declare const registrations: () => Effect.Effect<readonly Registration[], never, Service>;
+export declare const provide: <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, EmbeddingModelNotRegistered | E, Service | Exclude<R, ModelEnvironment>>;
+export declare const provideDefault: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, EmbeddingModelNotRegistered | E, Service | Exclude<R, ModelEnvironment>>;
+export declare const provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, EmbeddingModelNotRegistered | E, Service | Exclude<R, ModelEnvironment>>;
+export {};

package/dist/types/runtime/model/model-call-policy.d.ts

@@ -1,33 +1,52 @@
+import { ModelResilience } from "@batonfx/core";
 import { Context, Layer, Schedule } from "effect";
 /**
- * Classification of a model-call failure.
+ * Shim over `@batonfx/core`'s `ModelResilience` seam. Baton's `Agent.stream`
+ * resolves `ModelResilience.ModelResilience` via `Effect.serviceOption` and
+ * applies `ModelResilience.apply` to the model internally, so Relay no longer
+ * hand-wraps the model with its own retry logic (see `agent-loop-service.ts`,
+ * which resolves this policy and re-provides it under Baton's own tag —
+ * `Baton.ModelResilience.ModelResilience` — for the duration of a run).
+ *
+ * This module keeps its own local service tag (rather than re-exporting
+ * Baton's tag directly) because `@batonfx/core` ships its `exports` field
+ * pointed at TS source under `node_modules`; a re-exported tag's nominal type
+ * resolves to that nested source path, which `tsc --declaration` cannot name
+ * portably from deeply composed call sites (TS2742) such as
+ * `runner-runtime-service.ts`'s layer-composition helpers. Keeping a local,
+ * package-owned tag avoids that while still sharing Baton's `Interface`
+ * shape, `Classification` type, and `defaultClassify` implementation
+ * one-for-one — and `agent-loop-service.ts` explicitly re-provides the
+ * resolved policy under Baton's tag at the one call site that needs it, so
+ * the two tags never need to be identical for Baton to see the seam.
+ *
+ * Preserves every historical export name and Relay's historical default
+ * schedule (jittered exponential from 1s, up to 4 retries) — Baton's own
+ * `ModelResilience.make()` defaults to `Schedule.recurs(0)` (no retry), so
+ * Relay must keep supplying its own default or retries silently vanish.
  *
  * @experimental
  */
-export type Classification = "transient" | "terminal";
+export type Classification = ModelResilience.Classification;
 /**
- * Runtime-level policy for retrying transient model-call failures.
- *
  * @experimental
  */
-export interface Interface {
-    readonly classify: (error: unknown) => Classification;
-    readonly retrySchedule: Schedule.Schedule<unknown>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ModelCallPolicy", Interface>;
+export type Interface = ModelResilience.Interface;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ModelCallPolicy", ModelResilience.Interface>;
 /**
  * @experimental
  */
 export declare class Service extends Service_base {
 }
 /**
- * Default classification: retryable AiErrors are transient, everything else terminal.
+ * Default classification: malformed model output is terminal, other failures follow Baton.
  *
  * @experimental
  */
 export declare const defaultClassify: (error: unknown) => Classification;
 /**
- * Default schedule: jittered exponential from 1s, at most 4 retries.
+ * Default schedule: jittered exponential from 1s, at most 4 retries. Relay's
+ * historical default — Baton's own default is `Schedule.recurs(0)` (no retry).
  *
  * @experimental
  */