@relayfx/sdk 0.0.7 → 0.0.8

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

@@ -3,7 +3,7 @@ export * as Client from "./client";
 export * as Database from "./database";
 export * as Operation from "./operation";
 export { Address, Agent, Content, Envelope, Execution, Ids, Schedule, Shared, Skill, Tool } from "../schema/index";
-export { AddressBook, AddressResolution, AgentLoop, AgentRegistry, ArtifactStore, BlobStore, ChildRunService, EnvelopeService, EventLog, ExecutionEntity, ExecutionService, ExecutionWorkflow, LanguageModelService, ModelCallPolicy, PromptAssembler, SchedulerService, SchemaRegistry, SkillRegistry, ToolRuntime, WaitService, } from "../runtime/index";
+export { AddressBook, AddressResolution, AgentLoop, AgentRegistry, ActivityVersionRegistry, ArtifactStore, BlobStore, ChildRunService, EnvelopeService, EventLog, ExecutionEntity, ExecutionService, ExecutionWorkflow, LanguageModelService, ModelCallPolicy, PromptAssembler, SchedulerService, SchemaRegistry, SkillRegistry, ToolRuntime, WaitService, } from "../runtime/index";
 export { RunnerRuntime } from "../runtime/index";
 export { LanguageModelRegistration } from "../ai/index";
 export { RelaySchema, SkillDefinitionRepository } from "../store-sql/index";

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

@@ -1076,7 +1076,7 @@ export declare const ReplayExecutionResult: Schema.Struct<{
         readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
         }>;
-        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+        readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
         readonly sequence: Schema.Int;
         readonly cursor: Schema.String;
         readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

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

@@ -37,11 +37,6 @@ declare const AgentLoopBudgetExceeded_base: Schema.Class<AgentLoopBudgetExceeded
     readonly token_budget: Schema.Int;
     readonly next_event_sequence: Schema.Int;
 }>, import("effect/Cause").YieldableError>;
-/**
- * Raised when an agent's per-execution `token_budget` is reached. Checked
- * between turns at durable boundaries (never mid-stream); the execution fails
- * terminally, exactly like `AgentLoopError` (docs/spec/07 + ADR-0021).
- */
 export declare class AgentLoopBudgetExceeded extends AgentLoopBudgetExceeded_base {
 }
 export interface RunInput {

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

@@ -32,4 +32,5 @@ export * as WorkspacePlanner from "./workspace/workspace-planner-service";
 export * as WorkspaceProvider from "./workspace/workspace-provider-service";
 export * as WorkspaceRuntime from "./workspace/workspace-runtime-service";
 export * as ExecutionWorkflow from "./workflow/execution-workflow";
+export * as ActivityVersionRegistry from "./workflow/activity-version-registry";
 export declare const runtimePackage = "./index";

package/dist/types/runtime/workflow/activity-version-registry.d.ts

@@ -0,0 +1,89 @@
+import { Crypto, Effect, Schema } from "effect";
+export declare const ActivityManifestEntry: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly signature_hash: Schema.String;
+}>;
+export interface ActivityManifestEntry extends Schema.Schema.Type<typeof ActivityManifestEntry> {
+}
+export declare const ActivityManifest: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly generated_from: Schema.String;
+    readonly hash_algorithm: Schema.Literal<"sha256-json-schema-v1">;
+    readonly activities: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly signature_hash: Schema.String;
+    }>>;
+}>;
+export interface ActivityManifest extends Schema.Schema.Type<typeof ActivityManifest> {
+}
+export declare const ActivityManifestChange: Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
+    readonly name: Schema.String;
+    readonly baseline_hash: Schema.optionalKey<Schema.String>;
+    readonly current_hash: Schema.optionalKey<Schema.String>;
+}>;
+export interface ActivityManifestChange extends Schema.Schema.Type<typeof ActivityManifestChange> {
+}
+export declare const ActivityManifestGuardResult: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["pass", "fail"]>;
+    readonly waiting_executions: Schema.Int;
+    readonly breaking_changes: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
+        readonly name: Schema.String;
+        readonly baseline_hash: Schema.optionalKey<Schema.String>;
+        readonly current_hash: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly additive_changes: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
+        readonly name: Schema.String;
+        readonly baseline_hash: Schema.optionalKey<Schema.String>;
+        readonly current_hash: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export interface ActivityManifestGuardResult extends Schema.Schema.Type<typeof ActivityManifestGuardResult> {
+}
+declare const ActivityManifestGuardFailed_base: Schema.Class<ActivityManifestGuardFailed, Schema.TaggedStruct<"ActivityManifestGuardFailed", {
+    readonly message: Schema.String;
+    readonly result: Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["pass", "fail"]>;
+        readonly waiting_executions: Schema.Int;
+        readonly breaking_changes: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
+            readonly name: Schema.String;
+            readonly baseline_hash: Schema.optionalKey<Schema.String>;
+            readonly current_hash: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly additive_changes: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
+            readonly name: Schema.String;
+            readonly baseline_hash: Schema.optionalKey<Schema.String>;
+            readonly current_hash: Schema.optionalKey<Schema.String>;
+        }>>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ActivityManifestGuardFailed extends ActivityManifestGuardFailed_base {
+}
+export declare const currentManifest: () => Effect.Effect<{
+    version: 1;
+    generated_from: string;
+    hash_algorithm: "sha256-json-schema-v1";
+    activities: {
+        name: string;
+        signature_hash: string;
+    }[];
+}, import("effect/PlatformError").PlatformError, Crypto.Crypto>;
+export declare const diffManifests: (baseline: ActivityManifest, current: ActivityManifest) => {
+    breaking: ActivityManifestChange[];
+    additive: ActivityManifestChange[];
+};
+export declare const evaluateGuard: (input: {
+    readonly baseline: ActivityManifest;
+    readonly current: ActivityManifest;
+    readonly waitingExecutions: number;
+}) => ActivityManifestGuardResult;
+export declare const guard: (input: {
+    readonly baseline: ActivityManifest;
+    readonly current: ActivityManifest;
+    readonly waitingExecutions: number;
+}) => Effect.Effect<ActivityManifestGuardResult, ActivityManifestGuardFailed, never>;
+export {};

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

@@ -4,6 +4,7 @@ import { Workflow } from "effect/unstable/workflow";
 import { Effect, Layer, Option, Schema } from "effect";
 import * as AddressResolution from "../address/address-resolution-service";
 import * as AgentLoop from "../agent/agent-loop-service";
+import * as ParentNotifier from "../child/parent-notifier-service";
 import * as SkillRegistry from "../skill/skill-registry-service";
 import * as EventLog from "../execution/event-log-service";
 import * as ExecutionService from "../execution/execution-service";
@@ -222,6 +223,41 @@ export declare const StartResult: Schema.Struct<{
 }>;
 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: ParentNotifier.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">;

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

@@ -259,7 +259,7 @@ export declare const ChildRunAccepted: Schema.Struct<{
 }>;
 export interface ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
 }
-export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
 export type ExecutionEventType = typeof ExecutionEventType.Type;
 export declare const ExecutionEvent: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
@@ -271,7 +271,7 @@ export declare const ExecutionEvent: Schema.Struct<{
     readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
     }>;
-    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
     readonly sequence: Schema.Int;
     readonly cursor: Schema.String;
     readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

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

@@ -3,6 +3,11 @@ export declare const AddressId: Schema.brand<Schema.String, "Relay.AddressId"> &
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
 };
 export type AddressId = typeof AddressId.Type;
+export declare const TenantId: Schema.brand<Schema.String, "Relay.TenantId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.TenantId">;
+};
+export type TenantId = typeof TenantId.Type;
+export declare const SystemTenantId: string & import("effect/Brand").Brand<"Relay.TenantId">;
 export declare const AddressBookEntryId: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
 };

package/dist/types/store-sql/index.d.ts

@@ -18,5 +18,6 @@ export * as SessionRepository from "./session/session-repository";
 export * as SkillDefinitionRepository from "./skill/skill-definition-repository";
 export * as SteeringRepository from "./steering/steering-repository";
 export * as ToolCallRepository from "./tool/tool-call-repository";
+export * as TenantId from "./tenant/tenant-id";
 export * as WorkspaceLeaseRepository from "./workspace/workspace-lease-repository";
 export declare const storeSqlPackage = "./index";