@relayfx/sdk 0.0.48 → 0.0.50

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

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import { Definition } from "./agent-schema";
 export declare const ExecutionStatus: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
 export type ExecutionStatus = typeof ExecutionStatus.Type;
 export declare const Execution: Schema.Struct<{
@@ -16,61 +17,76 @@ export declare const Execution: Schema.Struct<{
         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.Struct<{
-        readonly name: Schema.String;
-        readonly instructions: Schema.optionalKey<Schema.String>;
-        readonly model: Schema.Struct<{
-            readonly provider: Schema.String;
-            readonly model: Schema.String;
-            readonly registration_key: Schema.optionalKey<Schema.String>;
-            readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        readonly tool_names: Schema.$Array<Schema.String>;
-        readonly permissions: Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>>;
-        readonly skill_definition_ids: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
-        }>>;
-        readonly permission_rules: Schema.optionalKey<Schema.Struct<{
-            readonly rules: Schema.$Array<Schema.Struct<{
-                readonly pattern: Schema.String;
-                readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-                readonly reason: Schema.optionalKey<Schema.String>;
-            }>>;
-            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
-        }>>;
-        readonly max_tool_turns: Schema.optionalKey<Schema.Int>;
-        readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
-        readonly token_budget: Schema.optionalKey<Schema.Int>;
-        readonly child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
-            readonly instructions: Schema.optionalKey<Schema.String>;
-            readonly model: Schema.optionalKey<Schema.Struct<{
-                readonly provider: Schema.String;
-                readonly model: Schema.String;
-                readonly registration_key: Schema.optionalKey<Schema.String>;
-                readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-            }>>;
-            readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
-            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
-            readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
-                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
-                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
-            }>>;
-            readonly output_schema_ref: Schema.optionalKey<Schema.String>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>>>;
-        readonly handoff_targets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly agent_snapshot: Schema.optionalKey<Schema.Codec<Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: import("./agent-schema").TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
             readonly name: Schema.String;
             readonly preset_name: Schema.String;
-        }>>>;
-        readonly output_schema_ref: Schema.optionalKey<Schema.String>;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>>;
+        }, "Encoded">[];
+    }, never, never>>;
     readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly created_at: Schema.Int;

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

@@ -68,6 +68,10 @@ export declare const ToolCallId: Schema.brand<Schema.String, "Relay.ToolCallId">
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
 };
 export type ToolCallId = typeof ToolCallId.Type;
+export declare const ToolAttemptId: Schema.brand<Schema.String, "Relay.ToolAttemptId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+};
+export type ToolAttemptId = typeof ToolAttemptId.Type;
 export declare const WaitId: Schema.brand<Schema.String, "Relay.WaitId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
 };

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

@@ -13,6 +13,34 @@ export declare const RuntimeRequirement: Schema.Union<readonly [Schema.Struct<{
 }>]>;
 export interface RuntimeRequirement extends Schema.Schema.Type<typeof RuntimeRequirement> {
 }
+export declare const PlacementKey: Schema.String;
+export type PlacementKey = typeof PlacementKey.Type;
+export declare const WorkerId: Schema.String;
+export type WorkerId = typeof WorkerId.Type;
+export declare const Placement: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"local">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"client">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"remote">;
+    readonly queue: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"mcp">;
+    readonly server_id: Schema.String;
+}>]>;
+export type Placement = typeof Placement.Type;
+export declare const ExternalOutcome: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"success">;
+    readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"failure">;
+    readonly message: Schema.String;
+}>]>;
+export type ExternalOutcome = typeof ExternalOutcome.Type;
+export declare const CallState: Schema.Literals<readonly ["requested", "waiting", "running", "submitted", "completed", "failed"]>;
+export type CallState = typeof CallState.Type;
+export declare const AttemptState: Schema.Literals<readonly ["running", "completed", "failed", "released", "expired", "abandoned"]>;
+export type AttemptState = typeof AttemptState.Type;
 export declare const Definition: Schema.Struct<{
     readonly name: Schema.String;
     readonly description: Schema.String;
@@ -53,3 +81,4 @@ export declare const Result: Schema.Struct<{
 export interface Result extends Schema.Schema.Type<typeof Result> {
 }
 export declare const parametersSchema: (inputSchema: JsonValue) => Schema.Top;
+export declare const resultSchema: (outputSchema: JsonValue) => Schema.Codec<unknown>;

package/dist/types/store-sql/envelope/envelope-repository.d.ts

@@ -117,6 +117,10 @@ export interface ListWaitsInput {
     readonly executionId?: Ids.ExecutionId;
     readonly limit?: number;
 }
+export interface ListAllWaitsInput {
+    readonly state?: WaitState;
+    readonly executionId?: Ids.ExecutionId;
+}
 export interface CompleteWaitInput {
     readonly waitId: Ids.WaitId;
     readonly state: Exclude<WaitState, "open">;
@@ -133,6 +137,7 @@ export interface Interface {
     readonly getWait: (id: Ids.WaitId) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError>;
     readonly createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError>;
     readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;
+    readonly listAllWaits: (input: ListAllWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;
     readonly claimReady: (input: ClaimReadyInput) => Effect.Effect<EnvelopeReadyRecord | undefined, EnvelopeRepositoryError>;
     readonly releaseReady: (input: ReleaseReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch | EnvelopeRepositoryError>;
     readonly ackReady: (input: AckReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch | EnvelopeRepositoryError>;
@@ -190,6 +195,7 @@ export declare const getEnvelope: (id: string & import("effect/Brand").Brand<"Re
 export declare const getWait: (id: string & import("effect/Brand").Brand<"Relay.WaitId">) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError, Service>;
 export declare const createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError, Service>;
 export declare const listWaits: (input: ListWaitsInput) => Effect.Effect<readonly WaitRecord[], EnvelopeRepositoryError, Service>;
+export declare const listAllWaits: (input: ListAllWaitsInput) => Effect.Effect<readonly WaitRecord[], EnvelopeRepositoryError, Service>;
 export declare const claimReady: (input: ClaimReadyInput) => Effect.Effect<EnvelopeReadyRecord | undefined, EnvelopeRepositoryError, Service>;
 export declare const releaseReady: (input: ReleaseReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeRepositoryError | EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch, Service>;
 export declare const ackReady: (input: AckReadyInput) => Effect.Effect<EnvelopeReadyRecord, EnvelopeRepositoryError | EnvelopeReadyNotFound | EnvelopeReadyClaimMismatch, Service>;

package/dist/types/store-sql/execution/execution-event-repository.d.ts

@@ -48,6 +48,10 @@ export interface FindByCursorInput {
     readonly executionId: Ids.ExecutionId;
     readonly cursor: string;
 }
+export interface FindBySequenceInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sequence: Execution.ExecutionEventSequence;
+}
 export interface FindFirstByTypeAfterSequenceInput {
     readonly executionId: Ids.ExecutionId;
     readonly type: Execution.ExecutionEventType;
@@ -63,6 +67,7 @@ export interface Interface {
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, ExecutionEventCursorNotFound | ExecutionEventRepositoryError>;
     readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
     readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
+    readonly findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
     readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;
     readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, ExecutionEventRepositoryError>;
     readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, ExecutionEventRepositoryError>;
@@ -92,6 +97,7 @@ export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<
 export declare const list: (input: ListInput) => Effect.Effect<readonly Execution.ExecutionEvent[], ExecutionEventCursorNotFound | ExecutionEventRepositoryError, Service>;
 export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;
 export declare const findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;
+export declare const findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;
 export declare const findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError, Service>;
 export declare const maxSequence: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number | undefined, ExecutionEventRepositoryError, Service>;
 export declare const sumUsage: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number, ExecutionEventRepositoryError, Service>;