@relayfx/test 0.3.1 → 0.3.2

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

@@ -1,534 +0,0 @@
-import { Agent, Ids } from "../../schema/index";
-import { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "@relayfx/store-sql/portable";
-import { Workflow, WorkflowEngine } from "effect/unstable/workflow";
-import { Effect, Layer, Option, Schema } from "effect";
-import { Service as AgentLoopService } from "../agent/agent-loop-service";
-import { ChildTerminalStatus } from "../child/parent-notifier-service";
-import { Service as EventLogService } from "../execution/event-log-service";
-import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
-import { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
-declare const ExecutionWorkflowFailed_base: Schema.Class<ExecutionWorkflowFailed, Schema.TaggedStruct<"ExecutionWorkflowFailed", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ExecutionWorkflowFailed extends ExecutionWorkflowFailed_base {
-}
-export declare const StartInput: 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">;
-    };
-    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">;
-        readonly call: 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 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">;
-        readonly result: Schema.Struct<{
-            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            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;
-    readonly started_at: Schema.Int;
-    readonly completed_at: Schema.Int;
-    readonly agent_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_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Agent.Definition, {
-        readonly name: string;
-        readonly instructions?: string;
-        readonly model: {
-            readonly provider: string;
-            readonly model: string;
-            readonly registration_key?: string;
-            readonly request_options?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        };
-        readonly tool_names: readonly string[];
-        readonly permissions: readonly {
-            readonly name: string;
-            readonly value: Schema.Json;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
-        readonly skill_definition_ids?: readonly string[];
-        readonly permission_rules?: {
-            readonly rules: readonly {
-                readonly pattern: string;
-                readonly level: "allow" | "ask" | "deny";
-                readonly reason?: string;
-            }[];
-            readonly fallback?: "allow" | "ask" | "deny";
-        };
-        readonly turn_policy?: Agent.TurnPolicySnapshot;
-        readonly compaction_policy?: {
-            readonly context_window: number;
-            readonly reserve_tokens: number;
-            readonly keep_recent_tokens: number;
-            readonly summary_model?: {
-                readonly provider: string;
-                readonly model: string;
-                readonly registration_key?: string;
-                readonly request_options?: {
-                    readonly [x: string]: Schema.Json;
-                };
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-        };
-        readonly max_tool_turns?: number;
-        readonly max_wait_turns?: number;
-        readonly token_budget?: number;
-        readonly child_run_presets?: {
-            readonly [x: string]: {
-                readonly instructions?: string;
-                readonly model?: {
-                    readonly provider: string;
-                    readonly model: string;
-                    readonly registration_key?: string;
-                    readonly request_options?: {
-                        readonly [x: string]: Schema.Json;
-                    };
-                    readonly metadata?: {
-                        readonly [x: string]: Schema.Json;
-                    };
-                };
-                readonly compaction_policy?: {
-                    readonly context_window: number;
-                    readonly reserve_tokens: number;
-                    readonly keep_recent_tokens: number;
-                    readonly summary_model?: {
-                        readonly provider: string;
-                        readonly model: string;
-                        readonly registration_key?: string;
-                        readonly request_options?: {
-                            readonly [x: string]: Schema.Json;
-                        };
-                        readonly metadata?: {
-                            readonly [x: string]: Schema.Json;
-                        };
-                    };
-                };
-                readonly tool_names?: readonly string[];
-                readonly permissions?: readonly string[];
-                readonly workspace_policy?: {
-                    readonly mode: "fork" | "share";
-                    readonly fallback?: "fail" | "fresh";
-                };
-                readonly output_schema_ref?: string;
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-        };
-        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
-            readonly name: Schema.String;
-            readonly preset_name: Schema.String;
-        }, "Encoded">[];
-        readonly output_schema_ref?: string;
-        readonly metadata?: {
-            readonly [x: string]: Schema.Json;
-        };
-    }, never, never>>;
-    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-    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>>>;
-}>;
-export interface StartInput extends Schema.Schema.Type<typeof StartInput> {
-}
-export declare const WaitSignalState: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
-export type WaitSignalState = typeof WaitSignalState.Type;
-export declare const WaitSignal: Schema.Struct<{
-    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-    readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
-    readonly signaled_at: Schema.Int;
-}>;
-export interface WaitSignal extends Schema.Schema.Type<typeof WaitSignal> {
-}
-export declare const SignalWaitInput: Schema.Struct<{
-    readonly workflow_execution_id: Schema.String;
-    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-    readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
-    readonly signaled_at: Schema.Int;
-}>;
-export interface SignalWaitInput extends Schema.Schema.Type<typeof SignalWaitInput> {
-}
-export declare const CancelExecutionInput: 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">;
-    };
-    readonly cancelled_at: Schema.Int;
-    readonly reason: Schema.optionalKey<Schema.String>;
-}>;
-export interface CancelExecutionInput extends Schema.Schema.Type<typeof CancelExecutionInput> {
-}
-export declare const CancelExecutionResult: 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>;
-export interface CancelExecutionResult extends Schema.Schema.Type<typeof CancelExecutionResult> {
-}
-export declare const WaitSnapshot: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-    readonly envelope_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
-    }>;
-    readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
-    readonly correlation_key: Schema.optionalKey<Schema.String>;
-    readonly state: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
-    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly created_at: Schema.Int;
-    readonly resolved_at: Schema.optionalKey<Schema.Int>;
-}>;
-export interface WaitSnapshot extends Schema.Schema.Type<typeof WaitSnapshot> {
-}
-export declare const StartResult: 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">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    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 wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>;
-export interface StartResult extends Schema.Schema.Type<typeof StartResult> {
-}
-export declare const StartExecutionWorkflowName = "Relay/Execution/Start";
-export declare const ActivityNames: {
-    readonly resolveLocalAgent: "Relay/Execution/Start/ResolveLocalAgent";
-    readonly accept: "Relay/Execution/Start/Accept";
-    readonly cancel: (turn: number) => string;
-    readonly checkCancel: (turn: number) => string;
-    readonly loadWaitBeforeSleep: (waitId: Ids.WaitId) => string;
-    readonly loadWaitAfterWake: (waitId: Ids.WaitId) => string;
-    readonly markWaiting: (waitId: Ids.WaitId) => string;
-    readonly ensureWorkspace: "Relay/Execution/Start/EnsureWorkspace";
-    readonly suspendWorkspace: (key: string) => string;
-    readonly resumeWorkspace: (key: string) => string;
-    readonly releaseWorkspace: "Relay/Execution/Start/ReleaseWorkspace";
-    readonly complete: (turn: number) => string;
-    readonly checkQueuedChildCancellation: "Relay/Execution/Start/CheckQueuedChildCancellation";
-    readonly notifyParent: (status: ChildTerminalStatus) => string;
-    readonly continueAsNew: (turn: number) => string;
-};
-export declare const ActivityNameTemplates: {
-    readonly resolveLocalAgent: "Relay/Execution/Start/ResolveLocalAgent";
-    readonly accept: "Relay/Execution/Start/Accept";
-    readonly cancel: "Relay/Execution/Start/Cancel/:turn";
-    readonly checkCancel: "Relay/Execution/Start/CheckCancel/:turn";
-    readonly loadWaitBeforeSleep: "Relay/Execution/Start/LoadWaitBeforeSleep/:wait_id";
-    readonly loadWaitAfterWake: "Relay/Execution/Start/LoadWaitAfterWake/:wait_id";
-    readonly markWaiting: "Relay/Execution/Start/MarkWaiting/:wait_id";
-    readonly ensureWorkspace: "Relay/Execution/Start/EnsureWorkspace";
-    readonly suspendWorkspace: "Relay/Execution/Start/SuspendWorkspace/:key";
-    readonly resumeWorkspace: "Relay/Execution/Start/ResumeWorkspace/:key";
-    readonly releaseWorkspace: "Relay/Execution/Start/ReleaseWorkspace";
-    readonly complete: "Relay/Execution/Start/Complete/:turn";
-    readonly checkQueuedChildCancellation: "Relay/Execution/Start/CheckQueuedChildCancellation";
-    readonly notifyParent: "Relay/Execution/Start/NotifyParent/:status";
-    readonly continueAsNew: "Relay/Execution/Start/ContinueAsNew/:turn";
-};
-export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/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">;
-    };
-    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">;
-        readonly call: 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 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">;
-        readonly result: Schema.Struct<{
-            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            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;
-    readonly started_at: Schema.Int;
-    readonly completed_at: Schema.Int;
-    readonly agent_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_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Agent.Definition, {
-        readonly name: string;
-        readonly instructions?: string;
-        readonly model: {
-            readonly provider: string;
-            readonly model: string;
-            readonly registration_key?: string;
-            readonly request_options?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        };
-        readonly tool_names: readonly string[];
-        readonly permissions: readonly {
-            readonly name: string;
-            readonly value: Schema.Json;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
-        readonly skill_definition_ids?: readonly string[];
-        readonly permission_rules?: {
-            readonly rules: readonly {
-                readonly pattern: string;
-                readonly level: "allow" | "ask" | "deny";
-                readonly reason?: string;
-            }[];
-            readonly fallback?: "allow" | "ask" | "deny";
-        };
-        readonly turn_policy?: Agent.TurnPolicySnapshot;
-        readonly compaction_policy?: {
-            readonly context_window: number;
-            readonly reserve_tokens: number;
-            readonly keep_recent_tokens: number;
-            readonly summary_model?: {
-                readonly provider: string;
-                readonly model: string;
-                readonly registration_key?: string;
-                readonly request_options?: {
-                    readonly [x: string]: Schema.Json;
-                };
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-        };
-        readonly max_tool_turns?: number;
-        readonly max_wait_turns?: number;
-        readonly token_budget?: number;
-        readonly child_run_presets?: {
-            readonly [x: string]: {
-                readonly instructions?: string;
-                readonly model?: {
-                    readonly provider: string;
-                    readonly model: string;
-                    readonly registration_key?: string;
-                    readonly request_options?: {
-                        readonly [x: string]: Schema.Json;
-                    };
-                    readonly metadata?: {
-                        readonly [x: string]: Schema.Json;
-                    };
-                };
-                readonly compaction_policy?: {
-                    readonly context_window: number;
-                    readonly reserve_tokens: number;
-                    readonly keep_recent_tokens: number;
-                    readonly summary_model?: {
-                        readonly provider: string;
-                        readonly model: string;
-                        readonly registration_key?: string;
-                        readonly request_options?: {
-                            readonly [x: string]: Schema.Json;
-                        };
-                        readonly metadata?: {
-                            readonly [x: string]: Schema.Json;
-                        };
-                    };
-                };
-                readonly tool_names?: readonly string[];
-                readonly permissions?: readonly string[];
-                readonly workspace_policy?: {
-                    readonly mode: "fork" | "share";
-                    readonly fallback?: "fail" | "fresh";
-                };
-                readonly output_schema_ref?: string;
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-        };
-        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
-            readonly name: Schema.String;
-            readonly preset_name: Schema.String;
-        }, "Encoded">[];
-        readonly output_schema_ref?: string;
-        readonly metadata?: {
-            readonly [x: string]: Schema.Json;
-        };
-    }, never, never>>;
-    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
-    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"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    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 wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflowFailed>;
-export declare const sessionEntryScope: {
-    (input: StartInput, turn: number): string;
-    (turn: number): (input: StartInput) => string;
-};
-export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | ToolRuntimeService | import("../address/address-resolution-service").Service | import("../skill/skill-registry-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | import("../workspace/workspace-planner-service").Service | AgentLoopService | WorkflowEngine.WorkflowEngine>;
-interface StartOptions<Discard extends boolean> {
-    readonly discard?: Discard;
-}
-export declare const start: {
-    <const Discard extends boolean = false>(input: StartInput, options?: StartOptions<Discard>): Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
-    <const Discard extends boolean = false>(options?: StartOptions<Discard>): (input: StartInput) => Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
-};
-export declare const startRequest: (input: StartInput) => Effect.Effect<StartResult, ExecutionWorkflowFailed, ExecutionRepository.Service | import("../wait/wait-service").Service | WorkflowEngine.WorkflowEngine>;
-export declare const dispatchRequest: (input: StartInput) => Effect.Effect<void, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
-export declare const cancelRequest: (input: CancelExecutionInput) => Effect.Effect<{
-    execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
-}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine>;
-export declare const poll: (executionId: string) => Effect.Effect<Option.Option<Workflow.Result<{
-    readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    readonly status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
-    readonly wait_id?: string & import("effect/Brand").Brand<"Relay.WaitId">;
-    readonly wait_state?: "cancelled" | "resolved" | "timed_out";
-    readonly metadata?: {
-        readonly [x: string]: Schema.Json;
-    };
-}, ExecutionWorkflowFailed>>, never, WorkflowEngine.WorkflowEngine>;
-export declare const resume: (executionId: string) => Effect.Effect<void, never, WorkflowEngine.WorkflowEngine>;
-export declare const workflowExecutionId: (input: StartInput) => Effect.Effect<string, never, never>;
-export declare const workflowExecutionIdForExecution: {
-    (executionId: Ids.ExecutionId): Effect.Effect<string>;
-    (executionId: Ids.ExecutionId, workflowGeneration: number): Effect.Effect<string>;
-    (workflowGeneration: number): (executionId: Ids.ExecutionId) => Effect.Effect<string>;
-};
-export declare const activeWorkflowExecutionIdForExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<string, ExecutionWorkflowFailed, ExecutionRepository.Service>;
-export declare const signalWait: (input: SignalWaitInput) => Effect.Effect<void, never, WorkflowEngine.WorkflowEngine>;
-export {};

package/dist/types/runtime/workspace/workspace-planner-service.d.ts

@@ -1,64 +0,0 @@
-import { Agent, Ids, Shared, Tool, Workspace } from "../../schema/index";
-import { WorkspaceLeaseRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
-import { WorkspaceCapabilityUnsupported } from "./workspace-provider-service";
-import type { WorkspaceNotFound, WorkspaceProviderError, WorkspaceUnavailable } from "./workspace-provider-service";
-import { Service as WorkspaceRuntimeService } from "./workspace-runtime-service";
-declare const WorkspaceRuntimeMissing_base: Schema.Class<WorkspaceRuntimeMissing, Schema.TaggedStruct<"WorkspaceRuntimeMissing", {
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceRuntimeMissing extends WorkspaceRuntimeMissing_base {
-}
-declare const WorkspaceLeaseMissingRef_base: Schema.Class<WorkspaceLeaseMissingRef, Schema.TaggedStruct<"WorkspaceLeaseMissingRef", {
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspaceLeaseMissingRef extends WorkspaceLeaseMissingRef_base {
-}
-declare const WorkspacePlannerError_base: Schema.Class<WorkspacePlannerError, Schema.TaggedStruct<"WorkspacePlannerError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WorkspacePlannerError extends WorkspacePlannerError_base {
-}
-export interface EnsureInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly agent: Agent.Definition;
-    readonly toolDefinitions: ReadonlyArray<Tool.Definition>;
-    readonly request?: Workspace.WorkspaceRequest;
-    readonly now: number;
-}
-export interface WorkspacePlan {
-    readonly lease: Workspace.WorkspaceLeaseRecord;
-    readonly runtimeLayer: Layer.Layer<WorkspaceRuntimeService>;
-}
-export interface LifecycleInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly now: number;
-}
-export interface FailureInput extends LifecycleInput {
-    readonly metadata?: Shared.Metadata;
-}
-export interface Interface {
-    readonly ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
-    readonly suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
-    readonly resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
-    readonly attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
-    readonly release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProviderError>;
-    readonly fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workspace/workspace-planner-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, WorkspaceLeaseRepository.Service | EventLogService>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceUnavailable, Service>;
-export declare const suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceCapabilityUnsupported | WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing, Service>;
-export declare const resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceUnavailable, Service>;
-export declare const attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceLeaseMissingRef | WorkspaceNotFound | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceUnavailable, Service>;
-export declare const release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProviderError | WorkspaceRuntimeMissing, Service>;
-export declare const fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError, Service>;
-export {};