@relayfx/test 0.3.1 → 0.3.3

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

@@ -1,84 +0,0 @@
-import { Schema } from "effect";
-import { JsonValue } from "./shared-schema";
-export declare const Permission: 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>>>;
-}>;
-export interface Permission extends Schema.Schema.Type<typeof Permission> {
-}
-export declare const RuntimeRequirement: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"workspace">;
-    readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
-}>]>;
-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;
-    readonly input_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-    readonly output_schema: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-    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 requirements: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"workspace">;
-        readonly mode: Schema.Literals<readonly ["read", "write", "exec"]>;
-    }>]>>>;
-    readonly needs_approval: Schema.optionalKey<Schema.Boolean>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>;
-export interface Definition extends Schema.Schema.Type<typeof Definition> {
-}
-export declare const 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>>>;
-}>;
-export interface Call extends Schema.Schema.Type<typeof Call> {
-}
-export declare const 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>>>;
-}>;
-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/schema/wait-schema.d.ts

@@ -1,98 +0,0 @@
-import { Schema } from "effect";
-import { WaitMode } from "./envelope-schema";
-import { EnvelopeId, WaitId } from "./ids-schema";
-export declare const WaitKind: Schema.Literals<readonly ["permission", "tool_approval", "tool_placement", "child_join", "inbox", "reply", "timer", "external"]>;
-export type WaitKind = typeof WaitKind.Type;
-export declare const PermissionWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"permission">;
-    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 tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-    };
-}>;
-export declare const ToolApprovalWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"tool_approval">;
-    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 tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-    };
-}>;
-export declare const ToolPlacementWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"tool_placement">;
-    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 tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-    };
-}>;
-export declare const ChildJoinWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"child_join">;
-    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 child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
-    };
-}>;
-export declare const InboxWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"inbox">;
-    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 tool_call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-    };
-}>;
-export declare const ReplyWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"reply">;
-    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 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">;
-    }>;
-}>;
-export declare const TimerWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"timer">;
-    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-}>;
-export declare const ExternalWait: Schema.Struct<{
-    readonly kind: Schema.Literal<"external">;
-    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 mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
-}>;
-export type Classification = typeof PermissionWait.Type | typeof ToolApprovalWait.Type | typeof ToolPlacementWait.Type | typeof ChildJoinWait.Type | typeof InboxWait.Type | typeof ReplyWait.Type | typeof TimerWait.Type | typeof ExternalWait.Type;
-export declare const Classification: Schema.Schema<Classification>;
-export interface ClassifyInput {
-    readonly wait_id: WaitId;
-    readonly mode: WaitMode;
-    readonly envelope_id?: EnvelopeId;
-    readonly correlation_key?: string;
-}
-/**
- * Derives a wait's public kind from its persisted fields.
- *
- * Relay mints every runtime-owned wait id inside a reserved namespace, so the
- * namespace is the classification authority; envelope anchoring and mode only
- * classify what no namespace claims. Reconnecting clients and replay consumers
- * get the same answer Relay does without interpreting internal metadata.
- */
-export declare const classify: (input: ClassifyInput) => Classification;
-export declare const Resolver: Schema.Literals<readonly ["resolve_permission", "resolve_tool_approval", "wake"]>;
-export type Resolver = typeof Resolver.Type;
-/**
- * Names the one public resolver a classification admits. Runtime-owned kinds
- * (child joins, inbox parks, tool placement) return undefined: deliveries,
- * child completion, and tool completion resolve them — callers never do.
- */
-export declare const resolverFor: (classification: Classification) => Resolver | undefined;
-export declare const externallyResolvable: (classification: Classification) => boolean;