@reactive-agents/runtime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,93 @@
+# @reactive-agents/runtime
+
+The execution runtime for [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/).
+
+Contains the 10-phase `ExecutionEngine`, the `ReactiveAgentBuilder` fluent API, and `createRuntime()` — the function that wires all optional layers together.
+
+## Installation
+
+```bash
+bun add @reactive-agents/runtime effect
+```
+
+Or install everything at once (recommended for new projects):
+
+```bash
+bun add reactive-agents effect
+```
+
+## Usage
+
+### Builder API (recommended)
+
+```typescript
+import { ReactiveAgents } from "@reactive-agents/runtime";
+
+const agent = await ReactiveAgents.create()
+  .withName("my-agent")
+  .withProvider("anthropic")
+  .withModel("claude-sonnet-4-20250514")
+  .withMemory("1")
+  .withReasoning()
+  .withGuardrails()
+  .withCostTracking()
+  .build();
+
+const result = await agent.run("Explain the CAP theorem");
+console.log(result.output);
+console.log(result.metadata); // { duration, cost, tokensUsed, stepsCount }
+```
+
+### Effect API
+
+```typescript
+import { Effect } from "effect";
+import { ReactiveAgents } from "@reactive-agents/runtime";
+
+const program = Effect.gen(function* () {
+  const agent = yield* ReactiveAgents.create()
+    .withName("my-agent")
+    .withProvider("anthropic")
+    .buildEffect();
+
+  return yield* agent.runEffect("What is the meaning of life?");
+});
+
+const result = await Effect.runPromise(program);
+```
+
+### Low-level `createRuntime()`
+
+```typescript
+import { createRuntime } from "@reactive-agents/runtime";
+import { Effect } from "effect";
+
+const runtime = createRuntime({
+  agentId: "my-agent",
+  provider: "anthropic",
+  enableReasoning: true,
+  enableGuardrails: true,
+  enableCostTracking: true,
+});
+```
+
+## The 10-Phase Execution Engine
+
+Every task flows through:
+
+1. **Bootstrap** — load memory context
+2. **Guardrail** — safety checks on input
+3. **Cost Route** — select optimal model
+4. **Strategy Select** — choose reasoning strategy
+5. **Think** — LLM completion
+6. **Act** — tool execution
+7. **Observe** — append results
+8. **Verify** — fact-check output
+9. **Memory Flush** — persist session
+10. **Complete** — return result
+
+Each phase supports `before`, `after`, and `on-error` lifecycle hooks.
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts](https://tylerjrbuell.github.io/reactive-agents-ts/)

package/dist/index.d.ts

@@ -0,0 +1,241 @@
+import * as effect from 'effect';
+import { Schema, Context, Effect, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import * as _reactive_agents_core from '@reactive-agents/core';
+import { Task, TaskResult, TaskError } from '@reactive-agents/core';
+import * as _reactive_agents_memory from '@reactive-agents/memory';
+import * as _reactive_agents_llm_provider from '@reactive-agents/llm-provider';
+
+declare const ExecutionError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ExecutionError";
+} & Readonly<A>;
+declare class ExecutionError extends ExecutionError_base<{
+    readonly message: string;
+    readonly taskId: string;
+    readonly phase: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const HookError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "HookError";
+} & Readonly<A>;
+declare class HookError extends HookError_base<{
+    readonly message: string;
+    readonly phase: string;
+    readonly timing: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const MaxIterationsError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "MaxIterationsError";
+} & Readonly<A>;
+declare class MaxIterationsError extends MaxIterationsError_base<{
+    readonly message: string;
+    readonly taskId: string;
+    readonly iterations: number;
+    readonly maxIterations: number;
+}> {
+}
+declare const GuardrailViolationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "GuardrailViolationError";
+} & Readonly<A>;
+declare class GuardrailViolationError extends GuardrailViolationError_base<{
+    readonly message: string;
+    readonly taskId: string;
+    readonly violation: string;
+}> {
+}
+type RuntimeErrors = ExecutionError | HookError | MaxIterationsError | GuardrailViolationError;
+
+declare const LifecyclePhase: Schema.Literal<["bootstrap", "guardrail", "cost-route", "strategy-select", "think", "act", "observe", "verify", "memory-flush", "cost-track", "audit", "complete"]>;
+type LifecyclePhase = typeof LifecyclePhase.Type;
+declare const HookTiming: Schema.Literal<["before", "after", "on-error"]>;
+type HookTiming = typeof HookTiming.Type;
+declare const AgentState: Schema.Literal<["idle", "bootstrapping", "running", "paused", "verifying", "flushing", "completed", "failed"]>;
+type AgentState = typeof AgentState.Type;
+declare const ExecutionContextSchema: Schema.Struct<{
+    taskId: typeof Schema.String;
+    agentId: typeof Schema.String;
+    sessionId: typeof Schema.String;
+    phase: Schema.Literal<["bootstrap", "guardrail", "cost-route", "strategy-select", "think", "act", "observe", "verify", "memory-flush", "cost-track", "audit", "complete"]>;
+    agentState: Schema.Literal<["idle", "bootstrapping", "running", "paused", "verifying", "flushing", "completed", "failed"]>;
+    iteration: typeof Schema.Number;
+    maxIterations: typeof Schema.Number;
+    messages: Schema.Array$<typeof Schema.Unknown>;
+    memoryContext: Schema.optional<typeof Schema.Unknown>;
+    selectedStrategy: Schema.optional<typeof Schema.String>;
+    selectedModel: Schema.optional<typeof Schema.Unknown>;
+    toolResults: Schema.Array$<typeof Schema.Unknown>;
+    cost: typeof Schema.Number;
+    startedAt: typeof Schema.DateFromSelf;
+    metadata: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type ExecutionContext = typeof ExecutionContextSchema.Type;
+declare const ToolResultSchema: Schema.Struct<{
+    toolCallId: typeof Schema.String;
+    toolName: typeof Schema.String;
+    result: typeof Schema.Unknown;
+    error: Schema.optional<typeof Schema.String>;
+    durationMs: typeof Schema.Number;
+}>;
+type ToolResult = typeof ToolResultSchema.Type;
+interface LifecycleHook {
+    readonly phase: LifecyclePhase;
+    readonly timing: HookTiming;
+    readonly handler: (ctx: ExecutionContext) => effect.Effect.Effect<ExecutionContext, ExecutionError>;
+}
+declare const ReactiveAgentsConfigSchema: Schema.Struct<{
+    maxIterations: typeof Schema.Number;
+    defaultModel: Schema.optional<typeof Schema.Unknown>;
+    memoryTier: Schema.Literal<["1", "2"]>;
+    enableGuardrails: typeof Schema.Boolean;
+    enableVerification: typeof Schema.Boolean;
+    enableCostTracking: typeof Schema.Boolean;
+    enableAudit: typeof Schema.Boolean;
+    agentId: typeof Schema.String;
+}>;
+type ReactiveAgentsConfig = typeof ReactiveAgentsConfigSchema.Type;
+declare const defaultReactiveAgentsConfig: (agentId: string) => ReactiveAgentsConfig;
+
+declare const LifecycleHookRegistry_base: Context.TagClass<LifecycleHookRegistry, "LifecycleHookRegistry", {
+    /** Register a lifecycle hook. Returns unregister function. */
+    readonly register: (hook: LifecycleHook) => Effect.Effect<() => void, never>;
+    /** Run all hooks for a phase/timing. Returns updated context. */
+    readonly run: (phase: LifecyclePhase, timing: HookTiming, ctx: ExecutionContext) => Effect.Effect<ExecutionContext, HookError>;
+    /** Get all registered hooks. */
+    readonly list: () => Effect.Effect<readonly LifecycleHook[], never>;
+}>;
+declare class LifecycleHookRegistry extends LifecycleHookRegistry_base {
+}
+declare const LifecycleHookRegistryLive: Layer.Layer<LifecycleHookRegistry, never, never>;
+
+declare const ExecutionEngine_base: Context.TagClass<ExecutionEngine, "ExecutionEngine", {
+    readonly execute: (task: Task) => Effect.Effect<TaskResult, RuntimeErrors | TaskError>;
+    readonly registerHook: (hook: LifecycleHook) => Effect.Effect<void, never>;
+    readonly getContext: (taskId: string) => Effect.Effect<ExecutionContext | null, never>;
+    readonly cancel: (taskId: string) => Effect.Effect<void, ExecutionError>;
+}>;
+declare class ExecutionEngine extends ExecutionEngine_base {
+}
+declare const ExecutionEngineLive: (config: ReactiveAgentsConfig) => Layer.Layer<ExecutionEngine, never, LifecycleHookRegistry>;
+
+interface RuntimeOptions {
+    agentId: string;
+    provider?: "anthropic" | "openai" | "ollama" | "gemini" | "test";
+    memoryTier?: "1" | "2";
+    maxIterations?: number;
+    testResponses?: Record<string, string>;
+    extraLayers?: Layer.Layer<any, any>;
+    enableGuardrails?: boolean;
+    enableVerification?: boolean;
+    enableCostTracking?: boolean;
+    enableReasoning?: boolean;
+    enableTools?: boolean;
+    enableIdentity?: boolean;
+    enableObservability?: boolean;
+    enableInteraction?: boolean;
+    enablePrompts?: boolean;
+    enableOrchestration?: boolean;
+    enableAudit?: boolean;
+}
+/**
+ * Create the full reactive-agents runtime layer.
+ *
+ * Composes Core + LLM + Memory + ExecutionEngine as the base,
+ * then merges optional layers based on the enabled flags.
+ *
+ * Usage:
+ *   const Runtime = createRuntime({
+ *     agentId: "my-agent",
+ *     provider: "anthropic",
+ *     enableReasoning: true,
+ *     enableGuardrails: true,
+ *   });
+ */
+declare const createRuntime: (options: RuntimeOptions) => Layer.Layer<LifecycleHookRegistry | ExecutionEngine | _reactive_agents_core.AgentService | _reactive_agents_core.TaskService | _reactive_agents_core.ContextWindowManager | _reactive_agents_core.EventBus | _reactive_agents_llm_provider.LLMService | _reactive_agents_llm_provider.PromptManager | _reactive_agents_memory.MemoryDatabase | _reactive_agents_memory.MemorySearchService | _reactive_agents_memory.WorkingMemoryService | _reactive_agents_memory.SemanticMemoryService | _reactive_agents_memory.EpisodicMemoryService | _reactive_agents_memory.ProceduralMemoryService | _reactive_agents_memory.MemoryFileSystem | _reactive_agents_memory.ZettelkastenService | _reactive_agents_memory.MemoryService, _reactive_agents_memory.DatabaseError, never>;
+
+interface AgentResultMetadata {
+    readonly duration: number;
+    readonly cost: number;
+    readonly tokensUsed: number;
+    readonly strategyUsed?: string;
+    readonly stepsCount: number;
+}
+interface AgentResult {
+    readonly output: string;
+    readonly success: boolean;
+    readonly taskId: string;
+    readonly agentId: string;
+    readonly metadata: AgentResultMetadata;
+}
+declare const ReactiveAgents: {
+    /** Create a new builder. All configuration is optional except `.withModel()`. */
+    create: () => ReactiveAgentBuilder;
+};
+declare class ReactiveAgentBuilder {
+    private _name;
+    private _provider;
+    private _model?;
+    private _memoryTier;
+    private _hooks;
+    private _maxIterations;
+    private _enableGuardrails;
+    private _enableVerification;
+    private _enableCostTracking;
+    private _enableAudit;
+    private _enableReasoning;
+    private _enableTools;
+    private _enableIdentity;
+    private _enableObservability;
+    private _enableInteraction;
+    private _enablePrompts;
+    private _enableOrchestration;
+    private _testResponses?;
+    private _extraLayers?;
+    withName(name: string): this;
+    withModel(model: string): this;
+    withProvider(provider: "anthropic" | "openai" | "ollama" | "gemini" | "test"): this;
+    withMemory(tier: "1" | "2"): this;
+    withMaxIterations(n: number): this;
+    withHook(hook: LifecycleHook): this;
+    withGuardrails(): this;
+    withVerification(): this;
+    withCostTracking(): this;
+    withAudit(): this;
+    withReasoning(): this;
+    withTools(): this;
+    withIdentity(): this;
+    withObservability(): this;
+    withInteraction(): this;
+    withPrompts(): this;
+    withOrchestration(): this;
+    withTestResponses(responses: Record<string, string>): this;
+    withLayers(layers: Layer.Layer<any, any>): this;
+    build(): Promise<ReactiveAgent>;
+    buildEffect(): Effect.Effect<ReactiveAgent, Error>;
+}
+declare class ReactiveAgent {
+    private readonly engine;
+    readonly agentId: string;
+    private readonly runtime;
+    constructor(engine: {
+        execute: (task: any) => Effect.Effect<any, any>;
+        cancel: (taskId: string) => Effect.Effect<void, any>;
+        getContext: (taskId: string) => Effect.Effect<any, never>;
+    }, agentId: string, runtime: Layer.Layer<any, any>);
+    /**
+     * Run a task and return the result (Simple API).
+     */
+    run(input: string): Promise<AgentResult>;
+    /**
+     * Run a task and return the result (Advanced API — Effect).
+     */
+    runEffect(input: string): Effect.Effect<AgentResult, Error>;
+    /** Cancel a running task by ID. */
+    cancel(taskId: string): Promise<void>;
+    /** Inspect context of a running task (null if not running). */
+    getContext(taskId: string): Promise<unknown>;
+}
+
+export { type AgentResult, type AgentResultMetadata, AgentState, AgentState as AgentStateSchema, type ExecutionContext, ExecutionContextSchema, ExecutionEngine, ExecutionEngineLive, ExecutionError, GuardrailViolationError, HookError, HookTiming, HookTiming as HookTimingSchema, type LifecycleHook, LifecycleHookRegistry, LifecycleHookRegistryLive, LifecyclePhase, LifecyclePhase as LifecyclePhaseSchema, MaxIterationsError, ReactiveAgent, ReactiveAgentBuilder, ReactiveAgents, type ReactiveAgentsConfig, ReactiveAgentsConfigSchema, type RuntimeErrors, type ToolResult, ToolResultSchema, createRuntime, defaultReactiveAgentsConfig };

package/dist/index.js

@@ -0,0 +1,757 @@
+// src/types.ts
+import { Schema } from "effect";
+var LifecyclePhase = Schema.Literal(
+  "bootstrap",
+  "guardrail",
+  "cost-route",
+  "strategy-select",
+  "think",
+  "act",
+  "observe",
+  "verify",
+  "memory-flush",
+  "cost-track",
+  "audit",
+  "complete"
+);
+var HookTiming = Schema.Literal("before", "after", "on-error");
+var AgentState = Schema.Literal(
+  "idle",
+  "bootstrapping",
+  "running",
+  "paused",
+  "verifying",
+  "flushing",
+  "completed",
+  "failed"
+);
+var ExecutionContextSchema = Schema.Struct({
+  taskId: Schema.String,
+  agentId: Schema.String,
+  sessionId: Schema.String,
+  phase: LifecyclePhase,
+  agentState: AgentState,
+  iteration: Schema.Number,
+  maxIterations: Schema.Number,
+  messages: Schema.Array(Schema.Unknown),
+  memoryContext: Schema.optional(Schema.Unknown),
+  selectedStrategy: Schema.optional(Schema.String),
+  selectedModel: Schema.optional(Schema.Unknown),
+  toolResults: Schema.Array(Schema.Unknown),
+  cost: Schema.Number,
+  startedAt: Schema.DateFromSelf,
+  metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown })
+});
+var ToolResultSchema = Schema.Struct({
+  toolCallId: Schema.String,
+  toolName: Schema.String,
+  result: Schema.Unknown,
+  error: Schema.optional(Schema.String),
+  durationMs: Schema.Number
+});
+var ReactiveAgentsConfigSchema = Schema.Struct({
+  maxIterations: Schema.Number,
+  defaultModel: Schema.optional(Schema.Unknown),
+  memoryTier: Schema.Literal("1", "2"),
+  enableGuardrails: Schema.Boolean,
+  enableVerification: Schema.Boolean,
+  enableCostTracking: Schema.Boolean,
+  enableAudit: Schema.Boolean,
+  agentId: Schema.String
+});
+var defaultReactiveAgentsConfig = (agentId) => ({
+  maxIterations: 10,
+  memoryTier: "1",
+  enableGuardrails: false,
+  enableVerification: false,
+  enableCostTracking: false,
+  enableAudit: false,
+  agentId
+});
+
+// src/errors.ts
+import { Data } from "effect";
+var ExecutionError = class extends Data.TaggedError("ExecutionError") {
+};
+var HookError = class extends Data.TaggedError("HookError") {
+};
+var MaxIterationsError = class extends Data.TaggedError("MaxIterationsError") {
+};
+var GuardrailViolationError = class extends Data.TaggedError(
+  "GuardrailViolationError"
+) {
+};
+
+// src/hooks.ts
+import { Effect, Context, Layer, Ref } from "effect";
+var LifecycleHookRegistry = class extends Context.Tag("LifecycleHookRegistry")() {
+};
+var LifecycleHookRegistryLive = Layer.effect(
+  LifecycleHookRegistry,
+  Effect.gen(function* () {
+    const hooks = yield* Ref.make([]);
+    return {
+      register: (hook) => Effect.gen(function* () {
+        yield* Ref.update(hooks, (hs) => [...hs, hook]);
+        return () => {
+          Effect.runSync(
+            Ref.update(hooks, (hs) => hs.filter((h) => h !== hook))
+          );
+        };
+      }),
+      run: (phase, timing, ctx) => Effect.gen(function* () {
+        const allHooks = yield* Ref.get(hooks);
+        const matching = allHooks.filter(
+          (h) => h.phase === phase && h.timing === timing
+        );
+        let current = ctx;
+        for (const hook of matching) {
+          current = yield* hook.handler(current).pipe(
+            Effect.mapError(
+              (cause) => new HookError({
+                message: `Hook failed for ${phase}/${timing}: ${cause}`,
+                phase,
+                timing,
+                cause
+              })
+            )
+          );
+        }
+        return current;
+      }),
+      list: () => Ref.get(hooks)
+    };
+  })
+);
+
+// src/execution-engine.ts
+import { Effect as Effect2, Context as Context2, Layer as Layer2, Ref as Ref2 } from "effect";
+var ExecutionEngine = class extends Context2.Tag("ExecutionEngine")() {
+};
+var ExecutionEngineLive = (config) => Layer2.effect(
+  ExecutionEngine,
+  Effect2.gen(function* () {
+    const hookRegistry = yield* LifecycleHookRegistry;
+    const runningContexts = yield* Ref2.make(
+      /* @__PURE__ */ new Map()
+    );
+    const cancelledTasks = yield* Ref2.make(/* @__PURE__ */ new Set());
+    const runPhase = (ctx, phase, body) => Effect2.gen(function* () {
+      const ctxBefore = { ...ctx, phase };
+      const ctxAfterBefore = yield* hookRegistry.run(phase, "before", ctxBefore).pipe(Effect2.catchAll(() => Effect2.succeed(ctxBefore)));
+      const cancelled = yield* Ref2.get(cancelledTasks);
+      if (cancelled.has(ctx.taskId)) {
+        return yield* Effect2.fail(
+          new ExecutionError({
+            message: `Task ${ctx.taskId} was cancelled`,
+            taskId: ctx.taskId,
+            phase
+          })
+        );
+      }
+      const ctxAfterBody = yield* body(ctxAfterBefore).pipe(
+        Effect2.tapError(
+          (e) => hookRegistry.run(phase, "on-error", {
+            ...ctxAfterBefore,
+            metadata: { ...ctxAfterBefore.metadata, error: e }
+          }).pipe(Effect2.catchAll(() => Effect2.void))
+        )
+      );
+      const ctxFinal = yield* hookRegistry.run(phase, "after", ctxAfterBody).pipe(Effect2.catchAll(() => Effect2.succeed(ctxAfterBody)));
+      return ctxFinal;
+    });
+    const execute = (task) => Effect2.gen(function* () {
+      const now = /* @__PURE__ */ new Date();
+      const sessionId = `session-${Date.now()}`;
+      let ctx = {
+        taskId: task.id,
+        agentId: task.agentId,
+        sessionId,
+        phase: "bootstrap",
+        agentState: "bootstrapping",
+        iteration: 0,
+        maxIterations: config.maxIterations,
+        messages: [],
+        toolResults: [],
+        cost: 0,
+        startedAt: now,
+        metadata: {}
+      };
+      yield* Ref2.update(
+        runningContexts,
+        (m) => new Map(m).set(task.id, ctx)
+      );
+      ctx = yield* runPhase(
+        ctx,
+        "bootstrap",
+        (c) => Effect2.gen(function* () {
+          const memoryContext = yield* Effect2.serviceOption(
+            Context2.GenericTag("MemoryService")
+          ).pipe(
+            Effect2.flatMap(
+              (opt) => opt._tag === "Some" ? opt.value.bootstrap(c.agentId).pipe(Effect2.map((mc) => mc)) : Effect2.succeed(void 0)
+            ),
+            Effect2.catchAll(() => Effect2.succeed(void 0))
+          );
+          return {
+            ...c,
+            agentState: "running",
+            memoryContext
+          };
+        })
+      );
+      if (config.enableGuardrails) {
+        ctx = yield* runPhase(
+          ctx,
+          "guardrail",
+          (c) => Effect2.succeed(c)
+        );
+      }
+      if (config.enableCostTracking) {
+        ctx = yield* runPhase(
+          ctx,
+          "cost-route",
+          (c) => Effect2.succeed({ ...c, selectedModel: config.defaultModel })
+        );
+      }
+      ctx = yield* runPhase(
+        ctx,
+        "strategy-select",
+        (c) => Effect2.gen(function* () {
+          const selectorOpt = yield* Effect2.serviceOption(
+            Context2.GenericTag("StrategySelector")
+          );
+          const strategy = selectorOpt._tag === "Some" ? yield* selectorOpt.value.select(
+            {
+              taskDescription: JSON.stringify(task.input),
+              taskType: task.type,
+              complexity: 0.5,
+              urgency: 0.5
+            },
+            c.memoryContext
+          ).pipe(Effect2.catchAll(() => Effect2.succeed("reactive"))) : "reactive";
+          return { ...c, selectedStrategy: strategy };
+        })
+      );
+      const reasoningOpt = yield* Effect2.serviceOption(
+        Context2.GenericTag("ReasoningService")
+      );
+      if (reasoningOpt._tag === "Some") {
+        ctx = yield* runPhase(
+          ctx,
+          "think",
+          (c) => Effect2.gen(function* () {
+            const result2 = yield* reasoningOpt.value.execute({
+              taskDescription: JSON.stringify(task.input),
+              taskType: task.type,
+              memoryContext: String(
+                c.memoryContext?.semanticContext ?? ""
+              ),
+              availableTools: [],
+              strategy: c.selectedStrategy ?? "reactive"
+            });
+            return {
+              ...c,
+              cost: c.cost + (result2.metadata.cost ?? 0),
+              metadata: {
+                ...c.metadata,
+                lastResponse: String(result2.output ?? ""),
+                isComplete: result2.status === "completed",
+                reasoningResult: result2,
+                stepsCount: result2.metadata.stepsCount
+              }
+            };
+          })
+        );
+      } else {
+        let isComplete = false;
+        while (!isComplete && ctx.iteration < ctx.maxIterations) {
+          ctx = yield* runPhase(
+            ctx,
+            "think",
+            (c) => Effect2.gen(function* () {
+              const llm = yield* Context2.GenericTag("LLMService");
+              const systemPrompt = c.memoryContext ? `${String(c.memoryContext.semanticContext ?? "")}
+
+Complete the task: ${JSON.stringify(task.input)}` : `Complete the task: ${JSON.stringify(task.input)}`;
+              const response = yield* llm.complete({
+                messages: c.messages,
+                systemPrompt,
+                model: c.selectedModel
+              });
+              const updatedMessages = [
+                ...c.messages,
+                { role: "assistant", content: response.content }
+              ];
+              const done = response.stopReason === "end_turn" && !response.toolCalls?.length;
+              return {
+                ...c,
+                messages: updatedMessages,
+                metadata: {
+                  ...c.metadata,
+                  lastResponse: response.content,
+                  pendingToolCalls: response.toolCalls ?? [],
+                  isComplete: done
+                }
+              };
+            })
+          );
+          const pendingCalls = ctx.metadata.pendingToolCalls ?? [];
+          if (pendingCalls.length > 0) {
+            ctx = yield* runPhase(
+              ctx,
+              "act",
+              (c) => Effect2.gen(function* () {
+                const toolResults = pendingCalls.map(
+                  (call) => ({
+                    toolCallId: call.id ?? "unknown",
+                    toolName: call.name ?? "unknown",
+                    result: `[Tool ${call.name} executed]`,
+                    durationMs: 0
+                  })
+                );
+                return {
+                  ...c,
+                  toolResults: [...c.toolResults, ...toolResults]
+                };
+              })
+            );
+            ctx = yield* runPhase(
+              ctx,
+              "observe",
+              (c) => Effect2.succeed({
+                ...c,
+                messages: [
+                  ...c.messages,
+                  {
+                    role: "user",
+                    content: c.toolResults.slice(-pendingCalls.length).map(
+                      (r) => `Tool result: ${JSON.stringify(r.result)}`
+                    ).join("\n")
+                  }
+                ],
+                iteration: c.iteration + 1
+              })
+            );
+          } else {
+            isComplete = Boolean(ctx.metadata.isComplete);
+            ctx = { ...ctx, iteration: ctx.iteration + 1 };
+          }
+        }
+        if (!isComplete && ctx.iteration >= ctx.maxIterations) {
+          return yield* Effect2.fail(
+            new MaxIterationsError({
+              message: `Task ${task.id} exceeded max iterations (${ctx.maxIterations})`,
+              taskId: task.id,
+              iterations: ctx.iteration,
+              maxIterations: ctx.maxIterations
+            })
+          );
+        }
+      }
+      if (config.enableVerification) {
+        ctx = yield* runPhase(ctx, "verify", (c) => Effect2.succeed(c));
+      }
+      ctx = yield* runPhase(
+        ctx,
+        "memory-flush",
+        (c) => Effect2.gen(function* () {
+          yield* Effect2.serviceOption(
+            Context2.GenericTag("MemoryService")
+          ).pipe(
+            Effect2.flatMap(
+              (opt) => opt._tag === "Some" ? opt.value.snapshot({
+                id: c.sessionId,
+                agentId: c.agentId,
+                messages: c.messages,
+                summary: String(c.metadata.lastResponse ?? ""),
+                keyDecisions: [],
+                taskIds: [c.taskId],
+                startedAt: c.startedAt,
+                endedAt: /* @__PURE__ */ new Date(),
+                totalCost: c.cost,
+                totalTokens: 0
+              }) : Effect2.void
+            ),
+            Effect2.catchAll(() => Effect2.void)
+          );
+          return { ...c, agentState: "flushing" };
+        })
+      );
+      if (config.enableCostTracking) {
+        ctx = yield* runPhase(
+          ctx,
+          "cost-track",
+          (c) => Effect2.succeed(c)
+        );
+      }
+      if (config.enableAudit) {
+        ctx = yield* runPhase(ctx, "audit", (c) => Effect2.succeed(c));
+      }
+      ctx = yield* runPhase(
+        ctx,
+        "complete",
+        (c) => Effect2.succeed({ ...c, agentState: "completed" })
+      );
+      const result = {
+        taskId: task.id,
+        agentId: task.agentId,
+        output: ctx.metadata.lastResponse ?? null,
+        success: true,
+        metadata: {
+          duration: Date.now() - ctx.startedAt.getTime(),
+          cost: ctx.cost,
+          tokensUsed: 0,
+          strategyUsed: ctx.selectedStrategy,
+          stepsCount: ctx.iteration
+        },
+        completedAt: /* @__PURE__ */ new Date()
+      };
+      return result;
+    }).pipe(
+      // Always clean up running context
+      Effect2.ensuring(
+        Ref2.update(runningContexts, (m) => {
+          const next = new Map(m);
+          next.delete(task.id);
+          return next;
+        })
+      )
+    );
+    return {
+      execute,
+      registerHook: (hook) => hookRegistry.register(hook).pipe(Effect2.asVoid),
+      getContext: (taskId) => Ref2.get(runningContexts).pipe(
+        Effect2.map((m) => m.get(taskId) ?? null)
+      ),
+      cancel: (taskId) => Effect2.gen(function* () {
+        const running = yield* Ref2.get(runningContexts);
+        if (!running.has(taskId)) {
+          return yield* Effect2.fail(
+            new ExecutionError({
+              message: `Task ${taskId} is not running`,
+              taskId,
+              phase: "complete"
+            })
+          );
+        }
+        yield* Ref2.update(cancelledTasks, (s) => new Set(s).add(taskId));
+      })
+    };
+  })
+);
+
+// src/runtime.ts
+import { Layer as Layer3 } from "effect";
+import { CoreServicesLive, EventBusLive } from "@reactive-agents/core";
+import { createLLMProviderLayer } from "@reactive-agents/llm-provider";
+import { createMemoryLayer } from "@reactive-agents/memory";
+import { createGuardrailsLayer } from "@reactive-agents/guardrails";
+import { createVerificationLayer } from "@reactive-agents/verification";
+import { createCostLayer } from "@reactive-agents/cost";
+import { createReasoningLayer } from "@reactive-agents/reasoning";
+import { createToolsLayer } from "@reactive-agents/tools";
+import { createIdentityLayer } from "@reactive-agents/identity";
+import { createObservabilityLayer } from "@reactive-agents/observability";
+import { createInteractionLayer } from "@reactive-agents/interaction";
+import { createPromptLayer } from "@reactive-agents/prompts";
+import { createOrchestrationLayer } from "@reactive-agents/orchestration";
+var createRuntime = (options) => {
+  const config = {
+    ...defaultReactiveAgentsConfig(options.agentId),
+    memoryTier: options.memoryTier ?? "1",
+    maxIterations: options.maxIterations ?? 10,
+    enableGuardrails: options.enableGuardrails ?? false,
+    enableVerification: options.enableVerification ?? false,
+    enableCostTracking: options.enableCostTracking ?? false,
+    enableAudit: options.enableAudit ?? false
+  };
+  const eventBusLayer = EventBusLive;
+  const coreLayer = CoreServicesLive;
+  const llmLayer = createLLMProviderLayer(
+    options.provider ?? "test",
+    options.testResponses
+  );
+  const memoryLayer = createMemoryLayer(config.memoryTier, {
+    agentId: options.agentId
+  });
+  const hookLayer = LifecycleHookRegistryLive;
+  const engineLayer = ExecutionEngineLive(config).pipe(Layer3.provide(hookLayer));
+  let runtime = Layer3.mergeAll(
+    coreLayer,
+    eventBusLayer,
+    llmLayer,
+    memoryLayer,
+    hookLayer,
+    engineLayer
+  );
+  if (options.enableGuardrails) {
+    runtime = Layer3.merge(runtime, createGuardrailsLayer());
+  }
+  if (options.enableVerification) {
+    runtime = Layer3.merge(runtime, createVerificationLayer());
+  }
+  if (options.enableCostTracking) {
+    runtime = Layer3.merge(runtime, createCostLayer());
+  }
+  if (options.enableReasoning) {
+    const reasoningLayer = createReasoningLayer().pipe(Layer3.provide(llmLayer));
+    runtime = Layer3.merge(runtime, reasoningLayer);
+  }
+  if (options.enableTools) {
+    const toolsLayer = createToolsLayer().pipe(Layer3.provide(eventBusLayer));
+    runtime = Layer3.merge(runtime, toolsLayer);
+  }
+  if (options.enableIdentity) {
+    runtime = Layer3.merge(runtime, createIdentityLayer());
+  }
+  if (options.enableObservability) {
+    runtime = Layer3.merge(runtime, createObservabilityLayer());
+  }
+  if (options.enableInteraction) {
+    const interactionLayer = createInteractionLayer().pipe(
+      Layer3.provide(eventBusLayer)
+    );
+    runtime = Layer3.merge(runtime, interactionLayer);
+  }
+  if (options.enablePrompts) {
+    runtime = Layer3.merge(runtime, createPromptLayer());
+  }
+  if (options.enableOrchestration) {
+    runtime = Layer3.merge(runtime, createOrchestrationLayer());
+  }
+  if (options.extraLayers) {
+    runtime = Layer3.merge(runtime, options.extraLayers);
+  }
+  return runtime;
+};
+
+// src/builder.ts
+import { Effect as Effect3 } from "effect";
+var ReactiveAgents = {
+  /** Create a new builder. All configuration is optional except `.withModel()`. */
+  create: () => new ReactiveAgentBuilder()
+};
+var ReactiveAgentBuilder = class {
+  _name = "agent";
+  _provider = "test";
+  _model;
+  _memoryTier = "1";
+  _hooks = [];
+  _maxIterations = 10;
+  _enableGuardrails = false;
+  _enableVerification = false;
+  _enableCostTracking = false;
+  _enableAudit = false;
+  _enableReasoning = false;
+  _enableTools = false;
+  _enableIdentity = false;
+  _enableObservability = false;
+  _enableInteraction = false;
+  _enablePrompts = false;
+  _enableOrchestration = false;
+  _testResponses;
+  _extraLayers;
+  // ─── Identity ───
+  withName(name) {
+    this._name = name;
+    return this;
+  }
+  // ─── Model & Provider ───
+  withModel(model) {
+    this._model = model;
+    return this;
+  }
+  withProvider(provider) {
+    this._provider = provider;
+    return this;
+  }
+  // ─── Memory ───
+  withMemory(tier) {
+    this._memoryTier = tier;
+    return this;
+  }
+  // ─── Execution ───
+  withMaxIterations(n) {
+    this._maxIterations = n;
+    return this;
+  }
+  // ─── Lifecycle Hooks ───
+  withHook(hook) {
+    this._hooks.push(hook);
+    return this;
+  }
+  // ─── Optional Features ───
+  withGuardrails() {
+    this._enableGuardrails = true;
+    return this;
+  }
+  withVerification() {
+    this._enableVerification = true;
+    return this;
+  }
+  withCostTracking() {
+    this._enableCostTracking = true;
+    return this;
+  }
+  withAudit() {
+    this._enableAudit = true;
+    return this;
+  }
+  withReasoning() {
+    this._enableReasoning = true;
+    return this;
+  }
+  withTools() {
+    this._enableTools = true;
+    return this;
+  }
+  withIdentity() {
+    this._enableIdentity = true;
+    return this;
+  }
+  withObservability() {
+    this._enableObservability = true;
+    return this;
+  }
+  withInteraction() {
+    this._enableInteraction = true;
+    return this;
+  }
+  withPrompts() {
+    this._enablePrompts = true;
+    return this;
+  }
+  withOrchestration() {
+    this._enableOrchestration = true;
+    return this;
+  }
+  // ─── Testing ───
+  withTestResponses(responses) {
+    this._testResponses = responses;
+    return this;
+  }
+  // ─── Extra Layers ───
+  withLayers(layers) {
+    this._extraLayers = layers;
+    return this;
+  }
+  // ─── Build ───
+  async build() {
+    return Effect3.runPromise(this.buildEffect());
+  }
+  buildEffect() {
+    const agentId = `${this._name}-${Date.now()}`;
+    const runtime = createRuntime({
+      agentId,
+      provider: this._provider,
+      memoryTier: this._memoryTier,
+      maxIterations: this._maxIterations,
+      enableGuardrails: this._enableGuardrails,
+      enableVerification: this._enableVerification,
+      enableCostTracking: this._enableCostTracking,
+      enableAudit: this._enableAudit,
+      enableReasoning: this._enableReasoning,
+      enableTools: this._enableTools,
+      enableIdentity: this._enableIdentity,
+      enableObservability: this._enableObservability,
+      enableInteraction: this._enableInteraction,
+      enablePrompts: this._enablePrompts,
+      enableOrchestration: this._enableOrchestration,
+      testResponses: this._testResponses,
+      extraLayers: this._extraLayers
+    });
+    const hooks = [...this._hooks];
+    return Effect3.gen(function* () {
+      const engine = yield* ExecutionEngine.pipe(Effect3.provide(runtime));
+      for (const hook of hooks) {
+        yield* engine.registerHook(hook);
+      }
+      return new ReactiveAgent(engine, agentId, runtime);
+    });
+  }
+};
+var ReactiveAgent = class {
+  constructor(engine, agentId, runtime) {
+    this.engine = engine;
+    this.agentId = agentId;
+    this.runtime = runtime;
+  }
+  /**
+   * Run a task and return the result (Simple API).
+   */
+  async run(input) {
+    return Effect3.runPromise(this.runEffect(input));
+  }
+  /**
+   * Run a task and return the result (Advanced API — Effect).
+   */
+  runEffect(input) {
+    const taskId = `task-${Date.now()}`;
+    const agentId = this.agentId;
+    const engine = this.engine;
+    const runtime = this.runtime;
+    const task = {
+      id: taskId,
+      agentId,
+      type: "query",
+      input: { question: input },
+      priority: "medium",
+      status: "pending",
+      metadata: { tags: [] },
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    return engine.execute(task).pipe(
+      Effect3.map((result) => ({
+        output: String(result.output ?? ""),
+        success: Boolean(result.success),
+        taskId: String(result.taskId),
+        agentId: String(result.agentId),
+        metadata: result.metadata
+      })),
+      Effect3.mapError(
+        (e) => new Error(e.message ?? String(e))
+      ),
+      Effect3.provide(runtime)
+    );
+  }
+  /** Cancel a running task by ID. */
+  async cancel(taskId) {
+    return Effect3.runPromise(
+      this.engine.cancel(taskId).pipe(
+        Effect3.mapError((e) => new Error(e.message ?? String(e))),
+        Effect3.provide(this.runtime)
+      )
+    );
+  }
+  /** Inspect context of a running task (null if not running). */
+  async getContext(taskId) {
+    return Effect3.runPromise(
+      this.engine.getContext(taskId).pipe(
+        Effect3.provide(this.runtime)
+      )
+    );
+  }
+};
+export {
+  AgentState as AgentStateSchema,
+  ExecutionContextSchema,
+  ExecutionEngine,
+  ExecutionEngineLive,
+  ExecutionError,
+  GuardrailViolationError,
+  HookError,
+  HookTiming as HookTimingSchema,
+  LifecycleHookRegistry,
+  LifecycleHookRegistryLive,
+  LifecyclePhase as LifecyclePhaseSchema,
+  MaxIterationsError,
+  ReactiveAgent,
+  ReactiveAgentBuilder,
+  ReactiveAgents,
+  ReactiveAgentsConfigSchema,
+  ToolResultSchema,
+  createRuntime,
+  defaultReactiveAgentsConfig
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/errors.ts","../src/hooks.ts","../src/execution-engine.ts","../src/runtime.ts","../src/builder.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n// ─── Lifecycle Phase ───\n\nexport const LifecyclePhase = Schema.Literal(\n  \"bootstrap\",\n  \"guardrail\",\n  \"cost-route\",\n  \"strategy-select\",\n  \"think\",\n  \"act\",\n  \"observe\",\n  \"verify\",\n  \"memory-flush\",\n  \"cost-track\",\n  \"audit\",\n  \"complete\",\n);\nexport type LifecyclePhase = typeof LifecyclePhase.Type;\n\n// ─── Hook Timing ───\n\nexport const HookTiming = Schema.Literal(\"before\", \"after\", \"on-error\");\nexport type HookTiming = typeof HookTiming.Type;\n\n// ─── Agent State Machine ───\n\nexport const AgentState = Schema.Literal(\n  \"idle\",\n  \"bootstrapping\",\n  \"running\",\n  \"paused\",\n  \"verifying\",\n  \"flushing\",\n  \"completed\",\n  \"failed\",\n);\nexport type AgentState = typeof AgentState.Type;\n\n// ─── Execution Context (passed between phases) ───\n\nexport const ExecutionContextSchema = Schema.Struct({\n  taskId: Schema.String,\n  agentId: Schema.String,\n  sessionId: Schema.String,\n  phase: LifecyclePhase,\n  agentState: AgentState,\n  iteration: Schema.Number,\n  maxIterations: Schema.Number,\n  messages: Schema.Array(Schema.Unknown),\n  memoryContext: Schema.optional(Schema.Unknown),\n  selectedStrategy: Schema.optional(Schema.String),\n  selectedModel: Schema.optional(Schema.Unknown),\n  toolResults: Schema.Array(Schema.Unknown),\n  cost: Schema.Number,\n  startedAt: Schema.DateFromSelf,\n  metadata: Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n});\nexport type ExecutionContext = typeof ExecutionContextSchema.Type;\n\n// ─── Tool Result ───\n\nexport const ToolResultSchema = Schema.Struct({\n  toolCallId: Schema.String,\n  toolName: Schema.String,\n  result: Schema.Unknown,\n  error: Schema.optional(Schema.String),\n  durationMs: Schema.Number,\n});\nexport type ToolResult = typeof ToolResultSchema.Type;\n\n// ─── Lifecycle Hook ───\n\nexport interface LifecycleHook {\n  readonly phase: LifecyclePhase;\n  readonly timing: HookTiming;\n  readonly handler: (\n    ctx: ExecutionContext,\n  ) => import(\"effect\").Effect.Effect<\n    ExecutionContext,\n    import(\"./errors.js\").ExecutionError\n  >;\n}\n\n// ─── Reactive Agents Config ───\n\nexport const ReactiveAgentsConfigSchema = Schema.Struct({\n  maxIterations: Schema.Number,\n  defaultModel: Schema.optional(Schema.Unknown),\n  memoryTier: Schema.Literal(\"1\", \"2\"),\n  enableGuardrails: Schema.Boolean,\n  enableVerification: Schema.Boolean,\n  enableCostTracking: Schema.Boolean,\n  enableAudit: Schema.Boolean,\n  agentId: Schema.String,\n});\nexport type ReactiveAgentsConfig = typeof ReactiveAgentsConfigSchema.Type;\n\nexport const defaultReactiveAgentsConfig = (\n  agentId: string,\n): ReactiveAgentsConfig => ({\n  maxIterations: 10,\n  memoryTier: \"1\",\n  enableGuardrails: false,\n  enableVerification: false,\n  enableCostTracking: false,\n  enableAudit: false,\n  agentId,\n});\n","import { Data } from \"effect\";\n\nexport class ExecutionError extends Data.TaggedError(\"ExecutionError\")<{\n  readonly message: string;\n  readonly taskId: string;\n  readonly phase: string;\n  readonly cause?: unknown;\n}> {}\n\nexport class HookError extends Data.TaggedError(\"HookError\")<{\n  readonly message: string;\n  readonly phase: string;\n  readonly timing: string;\n  readonly cause?: unknown;\n}> {}\n\nexport class MaxIterationsError extends Data.TaggedError(\"MaxIterationsError\")<{\n  readonly message: string;\n  readonly taskId: string;\n  readonly iterations: number;\n  readonly maxIterations: number;\n}> {}\n\nexport class GuardrailViolationError extends Data.TaggedError(\n  \"GuardrailViolationError\",\n)<{\n  readonly message: string;\n  readonly taskId: string;\n  readonly violation: string;\n}> {}\n\nexport type RuntimeErrors =\n  | ExecutionError\n  | HookError\n  | MaxIterationsError\n  | GuardrailViolationError;\n","import { Effect, Context, Layer, Ref } from \"effect\";\nimport type {\n  LifecycleHook,\n  LifecyclePhase,\n  HookTiming,\n  ExecutionContext,\n} from \"./types.js\";\nimport { HookError } from \"./errors.js\";\n\n// ─── Service Tag ───\n\nexport class LifecycleHookRegistry extends Context.Tag(\"LifecycleHookRegistry\")<\n  LifecycleHookRegistry,\n  {\n    /** Register a lifecycle hook. Returns unregister function. */\n    readonly register: (\n      hook: LifecycleHook,\n    ) => Effect.Effect<() => void, never>;\n\n    /** Run all hooks for a phase/timing. Returns updated context. */\n    readonly run: (\n      phase: LifecyclePhase,\n      timing: HookTiming,\n      ctx: ExecutionContext,\n    ) => Effect.Effect<ExecutionContext, HookError>;\n\n    /** Get all registered hooks. */\n    readonly list: () => Effect.Effect<readonly LifecycleHook[], never>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const LifecycleHookRegistryLive = Layer.effect(\n  LifecycleHookRegistry,\n  Effect.gen(function* () {\n    const hooks = yield* Ref.make<LifecycleHook[]>([]);\n\n    return {\n      register: (hook) =>\n        Effect.gen(function* () {\n          yield* Ref.update(hooks, (hs) => [...hs, hook]);\n          return () => {\n            Effect.runSync(\n              Ref.update(hooks, (hs) => hs.filter((h) => h !== hook)),\n            );\n          };\n        }),\n\n      run: (phase, timing, ctx) =>\n        Effect.gen(function* () {\n          const allHooks = yield* Ref.get(hooks);\n          const matching = allHooks.filter(\n            (h) => h.phase === phase && h.timing === timing,\n          );\n\n          let current = ctx;\n          for (const hook of matching) {\n            current = yield* hook.handler(current).pipe(\n              Effect.mapError(\n                (cause) =>\n                  new HookError({\n                    message: `Hook failed for ${phase}/${timing}: ${cause}`,\n                    phase,\n                    timing,\n                    cause,\n                  }),\n              ),\n            );\n          }\n          return current;\n        }),\n\n      list: () => Ref.get(hooks),\n    };\n  }),\n);\n","import { Effect, Context, Layer, Ref } from \"effect\";\nimport type { ExecutionContext, ReactiveAgentsConfig } from \"./types.js\";\nimport {\n  ExecutionError,\n  MaxIterationsError,\n  type RuntimeErrors,\n} from \"./errors.js\";\nimport { LifecycleHookRegistry } from \"./hooks.js\";\nimport type { LifecycleHook } from \"./types.js\";\n\n// Import from other packages (type-only to avoid circular deps at runtime)\nimport type { Task, TaskResult } from \"@reactive-agents/core\";\nimport type { TaskError } from \"@reactive-agents/core\";\n\n// ─── Service Tag ───\n\nexport class ExecutionEngine extends Context.Tag(\"ExecutionEngine\")<\n  ExecutionEngine,\n  {\n    readonly execute: (\n      task: Task,\n    ) => Effect.Effect<TaskResult, RuntimeErrors | TaskError>;\n\n    readonly registerHook: (hook: LifecycleHook) => Effect.Effect<void, never>;\n\n    readonly getContext: (\n      taskId: string,\n    ) => Effect.Effect<ExecutionContext | null, never>;\n\n    readonly cancel: (taskId: string) => Effect.Effect<void, ExecutionError>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const ExecutionEngineLive = (config: ReactiveAgentsConfig) =>\n  Layer.effect(\n    ExecutionEngine,\n    Effect.gen(function* () {\n      const hookRegistry = yield* LifecycleHookRegistry;\n\n      // Track running contexts (taskId -> ExecutionContext)\n      const runningContexts = yield* Ref.make<Map<string, ExecutionContext>>(\n        new Map(),\n      );\n\n      // Track cancelled task IDs\n      const cancelledTasks = yield* Ref.make<Set<string>>(new Set());\n\n      /**\n       * Run a phase: fire before hooks, execute phase body, fire after hooks.\n       * On error: fire on-error hooks, then propagate.\n       */\n      const runPhase = <E>(\n        ctx: ExecutionContext,\n        phase: ExecutionContext[\"phase\"],\n        body: (ctx: ExecutionContext) => Effect.Effect<ExecutionContext, E>,\n      ): Effect.Effect<ExecutionContext, E | RuntimeErrors> =>\n        Effect.gen(function* () {\n          const ctxBefore = { ...ctx, phase };\n\n          // Before hooks\n          const ctxAfterBefore = yield* hookRegistry\n            .run(phase, \"before\", ctxBefore)\n            .pipe(Effect.catchAll(() => Effect.succeed(ctxBefore)));\n\n          // Check cancellation\n          const cancelled = yield* Ref.get(cancelledTasks);\n          if (cancelled.has(ctx.taskId)) {\n            return yield* Effect.fail(\n              new ExecutionError({\n                message: `Task ${ctx.taskId} was cancelled`,\n                taskId: ctx.taskId,\n                phase,\n              }),\n            );\n          }\n\n          // Phase body\n          const ctxAfterBody = yield* body(ctxAfterBefore).pipe(\n            Effect.tapError((e) =>\n              hookRegistry\n                .run(phase, \"on-error\", {\n                  ...ctxAfterBefore,\n                  metadata: { ...ctxAfterBefore.metadata, error: e },\n                })\n                .pipe(Effect.catchAll(() => Effect.void)),\n            ),\n          );\n\n          // After hooks\n          const ctxFinal = yield* hookRegistry\n            .run(phase, \"after\", ctxAfterBody)\n            .pipe(Effect.catchAll(() => Effect.succeed(ctxAfterBody)));\n\n          return ctxFinal;\n        });\n\n      const execute = (task: Task): Effect.Effect<TaskResult, RuntimeErrors> =>\n        (Effect.gen(function* () {\n          const now = new Date();\n          const sessionId = `session-${Date.now()}`;\n\n          // Initialize context\n          let ctx: ExecutionContext = {\n            taskId: task.id,\n            agentId: task.agentId,\n            sessionId,\n            phase: \"bootstrap\",\n            agentState: \"bootstrapping\",\n            iteration: 0,\n            maxIterations: config.maxIterations,\n            messages: [],\n            toolResults: [],\n            cost: 0,\n            startedAt: now,\n            metadata: {},\n          };\n\n          // Register context as running\n          yield* Ref.update(runningContexts, (m) =>\n            new Map(m).set(task.id, ctx),\n          );\n\n          // ── Phase 1: BOOTSTRAP ──\n          ctx = yield* runPhase(ctx, \"bootstrap\", (c) =>\n            Effect.gen(function* () {\n              // MemoryService is optional — skip if not provided\n              const memoryContext = yield* Effect.serviceOption(\n                Context.GenericTag<{\n                  bootstrap: (id: string) => Effect.Effect<unknown>;\n                }>(\"MemoryService\"),\n              ).pipe(\n                Effect.flatMap((opt) =>\n                  opt._tag === \"Some\"\n                    ? opt.value\n                        .bootstrap(c.agentId)\n                        .pipe(Effect.map((mc) => mc))\n                    : Effect.succeed(undefined),\n                ),\n                Effect.catchAll(() => Effect.succeed(undefined)),\n              );\n\n              return {\n                ...c,\n                agentState: \"running\" as const,\n                memoryContext,\n              };\n            }),\n          );\n\n          // ── Phase 2: GUARDRAIL (optional) ──\n          if (config.enableGuardrails) {\n            ctx = yield* runPhase(ctx, \"guardrail\", (c) =>\n              Effect.succeed(c),\n            );\n          }\n\n          // ── Phase 3: COST_ROUTE (optional) ──\n          if (config.enableCostTracking) {\n            ctx = yield* runPhase(ctx, \"cost-route\", (c) =>\n              Effect.succeed({ ...c, selectedModel: config.defaultModel }),\n            );\n          }\n\n          // ── Phase 4: STRATEGY_SELECT ──\n          ctx = yield* runPhase(ctx, \"strategy-select\", (c) =>\n            Effect.gen(function* () {\n              const selectorOpt = yield* Effect.serviceOption(\n                Context.GenericTag<{\n                  select: (\n                    selCtx: unknown,\n                    memCtx: unknown,\n                  ) => Effect.Effect<string>;\n                }>(\"StrategySelector\"),\n              );\n              const strategy =\n                selectorOpt._tag === \"Some\"\n                  ? yield* selectorOpt.value\n                      .select(\n                        {\n                          taskDescription: JSON.stringify(task.input),\n                          taskType: task.type,\n                          complexity: 0.5,\n                          urgency: 0.5,\n                        },\n                        c.memoryContext,\n                      )\n                      .pipe(Effect.catchAll(() => Effect.succeed(\"reactive\")))\n                  : \"reactive\";\n              return { ...c, selectedStrategy: strategy };\n            }),\n          );\n\n          // ── Phase 5: AGENT_LOOP ──\n          const reasoningOpt = yield* Effect.serviceOption(\n            Context.GenericTag<{\n              execute: (params: {\n                taskDescription: string;\n                taskType: string;\n                memoryContext: string;\n                availableTools: readonly string[];\n                strategy?: string;\n              }) => Effect.Effect<{\n                output: unknown;\n                status: string;\n                metadata: {\n                  cost: number;\n                  tokensUsed: number;\n                  stepsCount: number;\n                };\n              }>;\n            }>(\"ReasoningService\"),\n          );\n\n          if (reasoningOpt._tag === \"Some\") {\n            // ── Full reasoning path ──\n            ctx = yield* runPhase(ctx, \"think\", (c) =>\n              Effect.gen(function* () {\n                const result = yield* reasoningOpt.value.execute({\n                  taskDescription: JSON.stringify(task.input),\n                  taskType: task.type,\n                  memoryContext: String(\n                    (c.memoryContext as any)?.semanticContext ?? \"\",\n                  ),\n                  availableTools: [],\n                  strategy: c.selectedStrategy ?? \"reactive\",\n                });\n                return {\n                  ...c,\n                  cost: c.cost + (result.metadata.cost ?? 0),\n                  metadata: {\n                    ...c.metadata,\n                    lastResponse: String(result.output ?? \"\"),\n                    isComplete: result.status === \"completed\",\n                    reasoningResult: result,\n                    stepsCount: result.metadata.stepsCount,\n                  },\n                };\n              }),\n            );\n          } else {\n            // ── Minimal direct-LLM loop ──\n            let isComplete = false;\n\n            while (!isComplete && ctx.iteration < ctx.maxIterations) {\n              // 5a. THINK\n              ctx = yield* runPhase(ctx, \"think\", (c) =>\n                (Effect.gen(function* () {\n                  const llm = yield* Context.GenericTag<{\n                    complete: (\n                      req: unknown,\n                    ) => Effect.Effect<{\n                      content: string;\n                      toolCalls?: unknown[];\n                      stopReason: string;\n                    }>;\n                  }>(\"LLMService\");\n\n                  const systemPrompt = c.memoryContext\n                    ? `${String((c.memoryContext as any).semanticContext ?? \"\")}\\n\\nComplete the task: ${JSON.stringify(task.input)}`\n                    : `Complete the task: ${JSON.stringify(task.input)}`;\n\n                  const response = yield* llm.complete({\n                    messages: c.messages,\n                    systemPrompt,\n                    model: c.selectedModel,\n                  });\n\n                  const updatedMessages = [\n                    ...c.messages,\n                    { role: \"assistant\", content: response.content },\n                  ];\n\n                  const done =\n                    response.stopReason === \"end_turn\" &&\n                    !response.toolCalls?.length;\n\n                  return {\n                    ...c,\n                    messages: updatedMessages,\n                    metadata: {\n                      ...c.metadata,\n                      lastResponse: response.content,\n                      pendingToolCalls: response.toolCalls ?? [],\n                      isComplete: done,\n                    },\n                  };\n                }) as unknown as Effect.Effect<ExecutionContext, never>),\n              );\n\n              // 5b. ACT (if tool calls present)\n              const pendingCalls =\n                (ctx.metadata.pendingToolCalls as unknown[]) ?? [];\n              if (pendingCalls.length > 0) {\n                ctx = yield* runPhase(ctx, \"act\", (c) =>\n                  Effect.gen(function* () {\n                    const toolResults: unknown[] = pendingCalls.map(\n                      (call: any) => ({\n                        toolCallId: call.id ?? \"unknown\",\n                        toolName: call.name ?? \"unknown\",\n                        result: `[Tool ${call.name} executed]`,\n                        durationMs: 0,\n                      }),\n                    );\n\n                    return {\n                      ...c,\n                      toolResults: [...c.toolResults, ...toolResults],\n                    };\n                  }),\n                );\n\n                // 5c. OBSERVE\n                ctx = yield* runPhase(ctx, \"observe\", (c) =>\n                  Effect.succeed({\n                    ...c,\n                    messages: [\n                      ...c.messages,\n                      {\n                        role: \"user\",\n                        content: c.toolResults\n                          .slice(-pendingCalls.length)\n                          .map(\n                            (r: any) =>\n                              `Tool result: ${JSON.stringify(r.result)}`,\n                          )\n                          .join(\"\\n\"),\n                      },\n                    ],\n                    iteration: c.iteration + 1,\n                  }),\n                );\n              } else {\n                // 5d. LOOP_CHECK\n                isComplete = Boolean(ctx.metadata.isComplete);\n                ctx = { ...ctx, iteration: ctx.iteration + 1 };\n              }\n            }\n\n            // Max iterations reached without completion\n            if (!isComplete && ctx.iteration >= ctx.maxIterations) {\n              return yield* Effect.fail(\n                new MaxIterationsError({\n                  message: `Task ${task.id} exceeded max iterations (${ctx.maxIterations})`,\n                  taskId: task.id,\n                  iterations: ctx.iteration,\n                  maxIterations: ctx.maxIterations,\n                }),\n              );\n            }\n          }\n\n          // ── Phase 6: VERIFY (optional) ──\n          if (config.enableVerification) {\n            ctx = yield* runPhase(ctx, \"verify\", (c) => Effect.succeed(c));\n          }\n\n          // ── Phase 7: MEMORY_FLUSH ──\n          ctx = yield* runPhase(ctx, \"memory-flush\", (c) =>\n            Effect.gen(function* () {\n              yield* Effect.serviceOption(\n                Context.GenericTag<{\n                  snapshot: (s: unknown) => Effect.Effect<void>;\n                }>(\"MemoryService\"),\n              ).pipe(\n                Effect.flatMap((opt) =>\n                  opt._tag === \"Some\"\n                    ? opt.value.snapshot({\n                        id: c.sessionId,\n                        agentId: c.agentId,\n                        messages: c.messages,\n                        summary: String(c.metadata.lastResponse ?? \"\"),\n                        keyDecisions: [],\n                        taskIds: [c.taskId],\n                        startedAt: c.startedAt,\n                        endedAt: new Date(),\n                        totalCost: c.cost,\n                        totalTokens: 0,\n                      })\n                    : Effect.void,\n                ),\n                Effect.catchAll(() => Effect.void),\n              );\n\n              return { ...c, agentState: \"flushing\" as const };\n            }),\n          );\n\n          // ── Phase 8: COST_TRACK (optional) ──\n          if (config.enableCostTracking) {\n            ctx = yield* runPhase(ctx, \"cost-track\", (c) =>\n              Effect.succeed(c),\n            );\n          }\n\n          // ── Phase 9: AUDIT (optional) ──\n          if (config.enableAudit) {\n            ctx = yield* runPhase(ctx, \"audit\", (c) => Effect.succeed(c));\n          }\n\n          // ── Phase 10: COMPLETE ──\n          ctx = yield* runPhase(ctx, \"complete\", (c) =>\n            Effect.succeed({ ...c, agentState: \"completed\" as const }),\n          );\n\n          // Build TaskResult\n          const result: TaskResult = {\n            taskId: task.id as any,\n            agentId: task.agentId,\n            output: ctx.metadata.lastResponse ?? null,\n            success: true,\n            metadata: {\n              duration: Date.now() - ctx.startedAt.getTime(),\n              cost: ctx.cost,\n              tokensUsed: 0,\n              strategyUsed: ctx.selectedStrategy,\n              stepsCount: ctx.iteration,\n            },\n            completedAt: new Date(),\n          };\n\n          return result;\n        }) as Effect.Effect<TaskResult, RuntimeErrors, any>).pipe(\n          // Always clean up running context\n          Effect.ensuring(\n            Ref.update(runningContexts, (m) => {\n              const next = new Map(m);\n              next.delete(task.id);\n              return next;\n            }),\n          ),\n        ) as Effect.Effect<TaskResult, RuntimeErrors>;\n\n      return {\n        execute,\n\n        registerHook: (hook) => hookRegistry.register(hook).pipe(Effect.asVoid),\n\n        getContext: (taskId) =>\n          Ref.get(runningContexts).pipe(\n            Effect.map((m) => m.get(taskId) ?? null),\n          ),\n\n        cancel: (taskId) =>\n          Effect.gen(function* () {\n            const running = yield* Ref.get(runningContexts);\n            if (!running.has(taskId)) {\n              return yield* Effect.fail(\n                new ExecutionError({\n                  message: `Task ${taskId} is not running`,\n                  taskId,\n                  phase: \"complete\",\n                }),\n              );\n            }\n            yield* Ref.update(cancelledTasks, (s) => new Set(s).add(taskId));\n          }),\n      };\n    }),\n  );\n","import { Layer } from \"effect\";\nimport { LifecycleHookRegistryLive } from \"./hooks.js\";\nimport { ExecutionEngineLive } from \"./execution-engine.js\";\nimport type { ReactiveAgentsConfig } from \"./types.js\";\nimport { defaultReactiveAgentsConfig } from \"./types.js\";\nimport { CoreServicesLive, EventBusLive } from \"@reactive-agents/core\";\nimport { createLLMProviderLayer } from \"@reactive-agents/llm-provider\";\nimport { createMemoryLayer } from \"@reactive-agents/memory\";\n\n// Optional package imports\nimport { createGuardrailsLayer } from \"@reactive-agents/guardrails\";\nimport { createVerificationLayer } from \"@reactive-agents/verification\";\nimport { createCostLayer } from \"@reactive-agents/cost\";\nimport { createReasoningLayer } from \"@reactive-agents/reasoning\";\nimport { createToolsLayer } from \"@reactive-agents/tools\";\nimport { createIdentityLayer } from \"@reactive-agents/identity\";\nimport { createObservabilityLayer } from \"@reactive-agents/observability\";\nimport { createInteractionLayer } from \"@reactive-agents/interaction\";\nimport { createPromptLayer } from \"@reactive-agents/prompts\";\nimport { createOrchestrationLayer } from \"@reactive-agents/orchestration\";\n\n// ─── Runtime Options ───\n\nexport interface RuntimeOptions {\n  agentId: string;\n  provider?: \"anthropic\" | \"openai\" | \"ollama\" | \"gemini\" | \"test\";\n  memoryTier?: \"1\" | \"2\";\n  maxIterations?: number;\n  testResponses?: Record<string, string>;\n  extraLayers?: Layer.Layer<any, any>;\n\n  // Optional features\n  enableGuardrails?: boolean;\n  enableVerification?: boolean;\n  enableCostTracking?: boolean;\n  enableReasoning?: boolean;\n  enableTools?: boolean;\n  enableIdentity?: boolean;\n  enableObservability?: boolean;\n  enableInteraction?: boolean;\n  enablePrompts?: boolean;\n  enableOrchestration?: boolean;\n  enableAudit?: boolean;\n}\n\n/**\n * Create the full reactive-agents runtime layer.\n *\n * Composes Core + LLM + Memory + ExecutionEngine as the base,\n * then merges optional layers based on the enabled flags.\n *\n * Usage:\n *   const Runtime = createRuntime({\n *     agentId: \"my-agent\",\n *     provider: \"anthropic\",\n *     enableReasoning: true,\n *     enableGuardrails: true,\n *   });\n */\nexport const createRuntime = (options: RuntimeOptions) => {\n  const config: ReactiveAgentsConfig = {\n    ...defaultReactiveAgentsConfig(options.agentId),\n    memoryTier: options.memoryTier ?? \"1\",\n    maxIterations: options.maxIterations ?? 10,\n    enableGuardrails: options.enableGuardrails ?? false,\n    enableVerification: options.enableVerification ?? false,\n    enableCostTracking: options.enableCostTracking ?? false,\n    enableAudit: options.enableAudit ?? false,\n  };\n\n  // ── Required layers ──\n  // EventBusLive is exposed separately so optional layers that need it can be provided\n  const eventBusLayer = EventBusLive;\n  const coreLayer = CoreServicesLive;\n  const llmLayer = createLLMProviderLayer(\n    options.provider ?? \"test\",\n    options.testResponses,\n  );\n  const memoryLayer = createMemoryLayer(config.memoryTier, {\n    agentId: options.agentId,\n  });\n  const hookLayer = LifecycleHookRegistryLive;\n  const engineLayer = ExecutionEngineLive(config).pipe(Layer.provide(hookLayer));\n\n  let runtime = Layer.mergeAll(\n    coreLayer,\n    eventBusLayer,\n    llmLayer,\n    memoryLayer,\n    hookLayer,\n    engineLayer,\n  );\n\n  // ── Optional layers ──\n\n  if (options.enableGuardrails) {\n    runtime = Layer.merge(runtime, createGuardrailsLayer()) as any;\n  }\n\n  if (options.enableVerification) {\n    runtime = Layer.merge(runtime, createVerificationLayer()) as any;\n  }\n\n  if (options.enableCostTracking) {\n    runtime = Layer.merge(runtime, createCostLayer()) as any;\n  }\n\n  if (options.enableReasoning) {\n    // ReasoningService requires LLMService\n    const reasoningLayer = createReasoningLayer().pipe(Layer.provide(llmLayer));\n    runtime = Layer.merge(runtime, reasoningLayer) as any;\n  }\n\n  if (options.enableTools) {\n    // ToolService requires EventBus\n    const toolsLayer = createToolsLayer().pipe(Layer.provide(eventBusLayer));\n    runtime = Layer.merge(runtime, toolsLayer) as any;\n  }\n\n  if (options.enableIdentity) {\n    runtime = Layer.merge(runtime, createIdentityLayer()) as any;\n  }\n\n  if (options.enableObservability) {\n    runtime = Layer.merge(runtime, createObservabilityLayer()) as any;\n  }\n\n  if (options.enableInteraction) {\n    // InteractionManager requires EventBus\n    const interactionLayer = createInteractionLayer().pipe(\n      Layer.provide(eventBusLayer),\n    );\n    runtime = Layer.merge(runtime, interactionLayer) as any;\n  }\n\n  if (options.enablePrompts) {\n    runtime = Layer.merge(runtime, createPromptLayer()) as any;\n  }\n\n  if (options.enableOrchestration) {\n    runtime = Layer.merge(runtime, createOrchestrationLayer()) as any;\n  }\n\n  if (options.extraLayers) {\n    runtime = Layer.merge(runtime, options.extraLayers) as any;\n  }\n\n  return runtime;\n};\n","import { Effect, Layer } from \"effect\";\nimport { createRuntime } from \"./runtime.js\";\nimport { ExecutionEngine } from \"./execution-engine.js\";\nimport type { LifecycleHook } from \"./types.js\";\n\n// ─── Result Types ────────────────────────────────────────────────────────────\n\nexport interface AgentResultMetadata {\n  readonly duration: number;\n  readonly cost: number;\n  readonly tokensUsed: number;\n  readonly strategyUsed?: string;\n  readonly stepsCount: number;\n}\n\nexport interface AgentResult {\n  readonly output: string;\n  readonly success: boolean;\n  readonly taskId: string;\n  readonly agentId: string;\n  readonly metadata: AgentResultMetadata;\n}\n\n// ─── ReactiveAgents Namespace ────────────────────────────────────────────────\n\nexport const ReactiveAgents = {\n  /** Create a new builder. All configuration is optional except `.withModel()`. */\n  create: (): ReactiveAgentBuilder => new ReactiveAgentBuilder(),\n};\n\n// ─── ReactiveAgentBuilder ────────────────────────────────────────────────────\n\nexport class ReactiveAgentBuilder {\n  private _name: string = \"agent\";\n  private _provider: \"anthropic\" | \"openai\" | \"ollama\" | \"gemini\" | \"test\" = \"test\";\n  private _model?: string;\n  private _memoryTier: \"1\" | \"2\" = \"1\";\n  private _hooks: LifecycleHook[] = [];\n  private _maxIterations: number = 10;\n  private _enableGuardrails: boolean = false;\n  private _enableVerification: boolean = false;\n  private _enableCostTracking: boolean = false;\n  private _enableAudit: boolean = false;\n  private _enableReasoning: boolean = false;\n  private _enableTools: boolean = false;\n  private _enableIdentity: boolean = false;\n  private _enableObservability: boolean = false;\n  private _enableInteraction: boolean = false;\n  private _enablePrompts: boolean = false;\n  private _enableOrchestration: boolean = false;\n  private _testResponses?: Record<string, string>;\n  private _extraLayers?: Layer.Layer<any, any>;\n\n  // ─── Identity ───\n\n  withName(name: string): this {\n    this._name = name;\n    return this;\n  }\n\n  // ─── Model & Provider ───\n\n  withModel(model: string): this {\n    this._model = model;\n    return this;\n  }\n\n  withProvider(\n    provider: \"anthropic\" | \"openai\" | \"ollama\" | \"gemini\" | \"test\",\n  ): this {\n    this._provider = provider;\n    return this;\n  }\n\n  // ─── Memory ───\n\n  withMemory(tier: \"1\" | \"2\"): this {\n    this._memoryTier = tier;\n    return this;\n  }\n\n  // ─── Execution ───\n\n  withMaxIterations(n: number): this {\n    this._maxIterations = n;\n    return this;\n  }\n\n  // ─── Lifecycle Hooks ───\n\n  withHook(hook: LifecycleHook): this {\n    this._hooks.push(hook);\n    return this;\n  }\n\n  // ─── Optional Features ───\n\n  withGuardrails(): this {\n    this._enableGuardrails = true;\n    return this;\n  }\n\n  withVerification(): this {\n    this._enableVerification = true;\n    return this;\n  }\n\n  withCostTracking(): this {\n    this._enableCostTracking = true;\n    return this;\n  }\n\n  withAudit(): this {\n    this._enableAudit = true;\n    return this;\n  }\n\n  withReasoning(): this {\n    this._enableReasoning = true;\n    return this;\n  }\n\n  withTools(): this {\n    this._enableTools = true;\n    return this;\n  }\n\n  withIdentity(): this {\n    this._enableIdentity = true;\n    return this;\n  }\n\n  withObservability(): this {\n    this._enableObservability = true;\n    return this;\n  }\n\n  withInteraction(): this {\n    this._enableInteraction = true;\n    return this;\n  }\n\n  withPrompts(): this {\n    this._enablePrompts = true;\n    return this;\n  }\n\n  withOrchestration(): this {\n    this._enableOrchestration = true;\n    return this;\n  }\n\n  // ─── Testing ───\n\n  withTestResponses(responses: Record<string, string>): this {\n    this._testResponses = responses;\n    return this;\n  }\n\n  // ─── Extra Layers ───\n\n  withLayers(layers: Layer.Layer<any, any>): this {\n    this._extraLayers = layers;\n    return this;\n  }\n\n  // ─── Build ───\n\n  async build(): Promise<ReactiveAgent> {\n    return Effect.runPromise(this.buildEffect());\n  }\n\n  buildEffect(): Effect.Effect<ReactiveAgent, Error> {\n    const agentId = `${this._name}-${Date.now()}`;\n\n    const runtime = createRuntime({\n      agentId,\n      provider: this._provider,\n      memoryTier: this._memoryTier,\n      maxIterations: this._maxIterations,\n      enableGuardrails: this._enableGuardrails,\n      enableVerification: this._enableVerification,\n      enableCostTracking: this._enableCostTracking,\n      enableAudit: this._enableAudit,\n      enableReasoning: this._enableReasoning,\n      enableTools: this._enableTools,\n      enableIdentity: this._enableIdentity,\n      enableObservability: this._enableObservability,\n      enableInteraction: this._enableInteraction,\n      enablePrompts: this._enablePrompts,\n      enableOrchestration: this._enableOrchestration,\n      testResponses: this._testResponses,\n      extraLayers: this._extraLayers,\n    });\n\n    const hooks = [...this._hooks];\n\n    return Effect.gen(function* () {\n      const engine = yield* ExecutionEngine.pipe(Effect.provide(runtime));\n\n      for (const hook of hooks) {\n        yield* engine.registerHook(hook);\n      }\n\n      return new ReactiveAgent(engine, agentId, runtime);\n    });\n  }\n}\n\n// ─── ReactiveAgent Facade ────────────────────────────────────────────────────\n\nexport class ReactiveAgent {\n  constructor(\n    private readonly engine: {\n      execute: (task: any) => Effect.Effect<any, any>;\n      cancel: (taskId: string) => Effect.Effect<void, any>;\n      getContext: (taskId: string) => Effect.Effect<any, never>;\n    },\n    readonly agentId: string,\n    private readonly runtime: Layer.Layer<any, any>,\n  ) {}\n\n  /**\n   * Run a task and return the result (Simple API).\n   */\n  async run(input: string): Promise<AgentResult> {\n    return Effect.runPromise(this.runEffect(input));\n  }\n\n  /**\n   * Run a task and return the result (Advanced API — Effect).\n   */\n  runEffect(input: string): Effect.Effect<AgentResult, Error> {\n    const taskId = `task-${Date.now()}`;\n    const agentId = this.agentId;\n    const engine = this.engine;\n    const runtime = this.runtime;\n\n    const task = {\n      id: taskId,\n      agentId,\n      type: \"query\" as const,\n      input: { question: input },\n      priority: \"medium\" as const,\n      status: \"pending\" as const,\n      metadata: { tags: [] },\n      createdAt: new Date(),\n    };\n\n    return engine.execute(task).pipe(\n      Effect.map((result: any) => ({\n        output: String(result.output ?? \"\"),\n        success: Boolean(result.success),\n        taskId: String(result.taskId),\n        agentId: String(result.agentId),\n        metadata: result.metadata as AgentResultMetadata,\n      })),\n      Effect.mapError(\n        (e: any) => new Error(e.message ?? String(e)),\n      ),\n      Effect.provide(runtime as unknown as Layer.Layer<never>),\n    ) as Effect.Effect<AgentResult, Error>;\n  }\n\n  /** Cancel a running task by ID. */\n  async cancel(taskId: string): Promise<void> {\n    return Effect.runPromise(\n      this.engine.cancel(taskId).pipe(\n        Effect.mapError((e: any) => new Error(e.message ?? String(e))),\n        Effect.provide(this.runtime as unknown as Layer.Layer<never>),\n      ) as Effect.Effect<void>,\n    );\n  }\n\n  /** Inspect context of a running task (null if not running). */\n  async getContext(taskId: string): Promise<unknown> {\n    return Effect.runPromise(\n      this.engine.getContext(taskId).pipe(\n        Effect.provide(this.runtime as unknown as Layer.Layer<never>),\n      ) as Effect.Effect<unknown>,\n    );\n  }\n}\n"],"mappings":"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","names":["Effect","Context","Layer","Ref","Context","Layer","Effect","Ref","result","Layer","Layer","Effect","Effect"]}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@reactive-agents/runtime",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsup --config ../../tsup.config.base.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "dependencies": {
+    "effect": "^3.10.0",
+    "@reactive-agents/core": "0.1.0",
+    "@reactive-agents/llm-provider": "0.1.0",
+    "@reactive-agents/memory": "0.1.0",
+    "@reactive-agents/guardrails": "0.1.0",
+    "@reactive-agents/verification": "0.1.0",
+    "@reactive-agents/cost": "0.1.0",
+    "@reactive-agents/reasoning": "0.1.0",
+    "@reactive-agents/tools": "0.1.0",
+    "@reactive-agents/identity": "0.1.0",
+    "@reactive-agents/observability": "0.1.0",
+    "@reactive-agents/interaction": "0.1.0",
+    "@reactive-agents/prompts": "0.1.0",
+    "@reactive-agents/orchestration": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "bun-types": "latest"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts.git",
+    "directory": "packages/runtime"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Runtime for Reactive Agents — ExecutionEngine, ReactiveAgentBuilder, and createRuntime",
+  "homepage": "https://tylerjrbuell.github.io/reactive-agents-ts/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}