@reactive-agents/reasoning 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,94 @@
+# @reactive-agents/reasoning
+
+Reasoning strategies for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Adds structured thinking to agents via ReAct, Plan-Execute, Tree-of-Thought, and Reflexion strategies.
+
+## Installation
+
+```bash
+bun add @reactive-agents/reasoning effect
+```
+
+## Strategies
+
+| Strategy | Description | LLM Calls | Best For |
+|----------|-------------|-----------|----------|
+| `reactive` | ReAct: Think → Act → Observe loop | 1/iteration | Tool-using agents |
+| `plan-execute-reflect` | Plan all steps, then execute | 2+ | Multi-step tasks |
+| `tree-of-thought` | Explore multiple branches | 3× breadth/depth | Complex reasoning |
+| `reflexion` | Generate → Critique → Improve loop | 3/retry | Quality-critical output |
+
+## Usage
+
+```typescript
+import { ReactiveAgents } from "reactive-agents";
+
+const agent = await ReactiveAgents.create()
+  .withName("researcher")
+  .withProvider("anthropic")
+  .withReasoning()  // defaults to ReAct
+  .build();
+
+const result = await agent.run("Analyze the trade-offs between TCP and UDP");
+```
+
+## ReAct Strategy
+
+The default. A Thought → Action → Observation loop:
+
+```
+Thought: I need to find information about X
+Action: search("X")
+Observation: [search results]
+Thought: Based on the results, I can conclude...
+FINAL ANSWER: [conclusion]
+```
+
+## Reflexion Strategy
+
+A Generate → Self-Critique → Improve loop based on the [Reflexion paper](https://arxiv.org/abs/2303.11366):
+
+```
+[ATTEMPT 1] Initial response...
+[CRITIQUE 1] The response is missing X and Y. The explanation of Z is inaccurate.
+[ATTEMPT 2] Improved response addressing X, Y, and correcting Z...
+[CRITIQUE 2] SATISFIED: The response is now accurate and complete.
+```
+
+Use Reflexion when output quality matters more than latency:
+
+```typescript
+import { executeReflexion } from "@reactive-agents/reasoning";
+import { Effect } from "effect";
+
+const result = await Effect.runPromise(
+  executeReflexion({
+    taskDescription: "Write a concise technical explanation of RAFT consensus.",
+    taskType: "explanation",
+    memoryContext: "",
+    availableTools: [],
+    config: {
+      defaultStrategy: "reflexion",
+      adaptive: { enabled: false, learning: false },
+      strategies: {
+        reactive: { maxIterations: 10, temperature: 0.7 },
+        planExecute: { maxRefinements: 2, reflectionDepth: "deep" },
+        treeOfThought: { breadth: 3, depth: 3, pruningThreshold: 0.5 },
+        reflexion: {
+          maxRetries: 3,             // Max critique-improve cycles
+          selfCritiqueDepth: "deep", // "shallow" | "deep"
+        },
+      },
+    },
+  }).pipe(Effect.provide(llmLayer)),
+);
+
+console.log(result.output);
+console.log(result.metadata.confidence); // 0.6–1.0
+console.log(result.status); // "completed" | "partial"
+```
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts/guides/reasoning/](https://tylerjrbuell.github.io/reactive-agents-ts/guides/reasoning/)

package/dist/index.d.ts

@@ -0,0 +1,275 @@
+import { Schema, Effect, Context, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import * as _reactive_agents_llm_provider from '@reactive-agents/llm-provider';
+import { LLMService } from '@reactive-agents/llm-provider';
+import { ReasoningStrategy } from '@reactive-agents/core';
+export { ReasoningStrategy } from '@reactive-agents/core';
+
+declare const StepId: Schema.brand<typeof Schema.String, "StepId">;
+type StepId = typeof StepId.Type;
+declare const StepType: Schema.Literal<["thought", "action", "observation", "plan", "reflection", "critique"]>;
+type StepType = typeof StepType.Type;
+declare const StepMetadataSchema: Schema.Struct<{
+    confidence: Schema.optional<typeof Schema.Number>;
+    toolUsed: Schema.optional<typeof Schema.String>;
+    cost: Schema.optional<typeof Schema.Number>;
+    duration: Schema.optional<typeof Schema.Number>;
+}>;
+type StepMetadata = typeof StepMetadataSchema.Type;
+declare const ReasoningStepSchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "StepId">;
+    type: Schema.Literal<["thought", "action", "observation", "plan", "reflection", "critique"]>;
+    content: typeof Schema.String;
+    timestamp: typeof Schema.DateFromSelf;
+    metadata: Schema.optional<Schema.Struct<{
+        confidence: Schema.optional<typeof Schema.Number>;
+        toolUsed: Schema.optional<typeof Schema.String>;
+        cost: Schema.optional<typeof Schema.Number>;
+        duration: Schema.optional<typeof Schema.Number>;
+    }>>;
+}>;
+type ReasoningStep = typeof ReasoningStepSchema.Type;
+
+declare const ReasoningStatus: Schema.Literal<["completed", "failed", "partial"]>;
+type ReasoningStatus = typeof ReasoningStatus.Type;
+declare const ReasoningMetadataSchema: Schema.Struct<{
+    duration: typeof Schema.Number;
+    cost: typeof Schema.Number;
+    tokensUsed: typeof Schema.Number;
+    stepsCount: typeof Schema.Number;
+    confidence: typeof Schema.Number;
+    effectiveness: Schema.optional<typeof Schema.Number>;
+    selectedStrategy: Schema.optional<Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>>;
+}>;
+type ReasoningMetadata = typeof ReasoningMetadataSchema.Type;
+declare const ReasoningResultSchema: Schema.Struct<{
+    strategy: Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>;
+    steps: Schema.Array$<Schema.Struct<{
+        id: Schema.brand<typeof Schema.String, "StepId">;
+        type: Schema.Literal<["thought", "action", "observation", "plan", "reflection", "critique"]>;
+        content: typeof Schema.String;
+        timestamp: typeof Schema.DateFromSelf;
+        metadata: Schema.optional<Schema.Struct<{
+            confidence: Schema.optional<typeof Schema.Number>;
+            toolUsed: Schema.optional<typeof Schema.String>;
+            cost: Schema.optional<typeof Schema.Number>;
+            duration: Schema.optional<typeof Schema.Number>;
+        }>>;
+    }>>;
+    output: typeof Schema.Unknown;
+    metadata: Schema.Struct<{
+        duration: typeof Schema.Number;
+        cost: typeof Schema.Number;
+        tokensUsed: typeof Schema.Number;
+        stepsCount: typeof Schema.Number;
+        confidence: typeof Schema.Number;
+        effectiveness: Schema.optional<typeof Schema.Number>;
+        selectedStrategy: Schema.optional<Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>>;
+    }>;
+    status: Schema.Literal<["completed", "failed", "partial"]>;
+}>;
+type ReasoningResult = typeof ReasoningResultSchema.Type;
+declare const SelectionContextSchema: Schema.Struct<{
+    taskDescription: typeof Schema.String;
+    taskType: typeof Schema.String;
+    complexity: typeof Schema.Number;
+    urgency: typeof Schema.Number;
+    costBudget: Schema.optional<typeof Schema.Number>;
+    timeConstraint: Schema.optional<typeof Schema.Number>;
+    preferredStrategy: Schema.optional<Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>>;
+}>;
+type SelectionContext = typeof SelectionContextSchema.Type;
+
+declare const StrategyEffectivenessSchema: Schema.Struct<{
+    strategy: Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>;
+    taskType: typeof Schema.String;
+    successRate: typeof Schema.Number;
+    avgCost: typeof Schema.Number;
+    avgDuration: typeof Schema.Number;
+    avgConfidence: typeof Schema.Number;
+    executions: typeof Schema.Number;
+    lastUsed: typeof Schema.DateFromSelf;
+}>;
+type StrategyEffectiveness = typeof StrategyEffectivenessSchema.Type;
+
+declare const ReactiveConfigSchema: Schema.Struct<{
+    maxIterations: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    temperature: typeof Schema.Number;
+}>;
+type ReactiveConfig = typeof ReactiveConfigSchema.Type;
+declare const PlanExecuteConfigSchema: Schema.Struct<{
+    maxRefinements: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    reflectionDepth: Schema.Literal<["shallow", "deep"]>;
+}>;
+type PlanExecuteConfig = typeof PlanExecuteConfigSchema.Type;
+declare const TreeOfThoughtConfigSchema: Schema.Struct<{
+    breadth: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    depth: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    pruningThreshold: typeof Schema.Number;
+}>;
+type TreeOfThoughtConfig = typeof TreeOfThoughtConfigSchema.Type;
+declare const ReflexionConfigSchema: Schema.Struct<{
+    maxRetries: Schema.filter<Schema.filter<typeof Schema.Number>>;
+    selfCritiqueDepth: Schema.Literal<["shallow", "deep"]>;
+}>;
+type ReflexionConfig = typeof ReflexionConfigSchema.Type;
+declare const ReasoningConfigSchema: Schema.Struct<{
+    defaultStrategy: Schema.Literal<["reactive", "plan-execute-reflect", "tree-of-thought", "reflexion", "adaptive"]>;
+    adaptive: Schema.Struct<{
+        enabled: typeof Schema.Boolean;
+        learning: typeof Schema.Boolean;
+    }>;
+    strategies: Schema.Struct<{
+        reactive: Schema.Struct<{
+            maxIterations: Schema.filter<Schema.filter<typeof Schema.Number>>;
+            temperature: typeof Schema.Number;
+        }>;
+        planExecute: Schema.Struct<{
+            maxRefinements: Schema.filter<Schema.filter<typeof Schema.Number>>;
+            reflectionDepth: Schema.Literal<["shallow", "deep"]>;
+        }>;
+        treeOfThought: Schema.Struct<{
+            breadth: Schema.filter<Schema.filter<typeof Schema.Number>>;
+            depth: Schema.filter<Schema.filter<typeof Schema.Number>>;
+            pruningThreshold: typeof Schema.Number;
+        }>;
+        reflexion: Schema.Struct<{
+            maxRetries: Schema.filter<Schema.filter<typeof Schema.Number>>;
+            selfCritiqueDepth: Schema.Literal<["shallow", "deep"]>;
+        }>;
+    }>;
+}>;
+type ReasoningConfig = typeof ReasoningConfigSchema.Type;
+declare const defaultReasoningConfig: ReasoningConfig;
+
+declare const ReasoningError_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: "ReasoningError";
+} & Readonly<A>;
+declare class ReasoningError extends ReasoningError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const StrategyNotFoundError_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: "StrategyNotFoundError";
+} & Readonly<A>;
+declare class StrategyNotFoundError extends StrategyNotFoundError_base<{
+    readonly strategy: string;
+}> {
+}
+declare const SelectionError_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: "SelectionError";
+} & Readonly<A>;
+declare class SelectionError extends SelectionError_base<{
+    readonly message: string;
+    readonly context?: unknown;
+}> {
+}
+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 strategy: string;
+    readonly message: string;
+    readonly step?: number;
+    readonly cause?: unknown;
+}> {
+}
+declare const IterationLimitError_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: "IterationLimitError";
+} & Readonly<A>;
+declare class IterationLimitError extends IterationLimitError_base<{
+    readonly strategy: string;
+    readonly limit: number;
+    readonly stepsCompleted: number;
+}> {
+}
+type ReasoningErrors = ReasoningError | StrategyNotFoundError | SelectionError | ExecutionError | IterationLimitError;
+
+type StrategyFn = (input: {
+    readonly taskDescription: string;
+    readonly taskType: string;
+    readonly memoryContext: string;
+    readonly availableTools: readonly string[];
+    readonly config: ReasoningConfig;
+}) => Effect.Effect<ReasoningResult, ExecutionError | IterationLimitError, LLMService>;
+declare const StrategyRegistry_base: Context.TagClass<StrategyRegistry, "StrategyRegistry", {
+    readonly get: (name: ReasoningStrategy) => Effect.Effect<StrategyFn, StrategyNotFoundError>;
+    readonly register: (name: ReasoningStrategy, fn: StrategyFn) => Effect.Effect<void>;
+    readonly list: () => Effect.Effect<readonly ReasoningStrategy[]>;
+}>;
+declare class StrategyRegistry extends StrategyRegistry_base {
+}
+declare const StrategyRegistryLive: Layer.Layer<StrategyRegistry, never, never>;
+
+declare const ReasoningService_base: Context.TagClass<ReasoningService, "ReasoningService", {
+    /**
+     * Execute reasoning on a task.
+     * If `strategy` is provided, uses that strategy directly.
+     * Otherwise uses the configured default strategy.
+     */
+    readonly execute: (params: {
+        readonly taskDescription: string;
+        readonly taskType: string;
+        readonly memoryContext: string;
+        readonly availableTools: readonly string[];
+        readonly strategy?: ReasoningStrategy;
+    }) => Effect.Effect<ReasoningResult, ReasoningErrors>;
+    /** Register a custom strategy function. */
+    readonly registerStrategy: (name: ReasoningStrategy, fn: StrategyFn) => Effect.Effect<void>;
+}>;
+declare class ReasoningService extends ReasoningService_base {
+}
+declare const ReasoningServiceLive: (config?: ReasoningConfig) => Layer.Layer<ReasoningService, never, LLMService | StrategyRegistry>;
+
+interface ReactiveInput {
+    readonly taskDescription: string;
+    readonly taskType: string;
+    readonly memoryContext: string;
+    readonly availableTools: readonly string[];
+    readonly config: ReasoningConfig;
+}
+/**
+ * ReAct loop: Thought -> Action -> Observation, iterating until done.
+ * Each iteration calls the LLM once for reasoning.
+ */
+declare const executeReactive: (input: ReactiveInput) => Effect.Effect<ReasoningResult, ExecutionError | IterationLimitError, LLMService>;
+
+/**
+ * Reflexion Strategy — Generate → Reflect → Improve loop.
+ *
+ * Based on the Reflexion paper (Shinn et al., 2023).
+ * The agent:
+ *   1. Generates an initial response (attempt)
+ *   2. Self-critiques the response to identify gaps/errors
+ *   3. Improves the response using the critique as feedback
+ *   4. Repeats until maxRetries reached or the critique is satisfied
+ */
+
+interface ReflexionInput {
+    readonly taskDescription: string;
+    readonly taskType: string;
+    readonly memoryContext: string;
+    readonly availableTools: readonly string[];
+    readonly config: ReasoningConfig;
+}
+/**
+ * Reflexion: Generate → Self-Critique → Improve, repeating until satisfied
+ * or maxRetries is reached.
+ */
+declare const executeReflexion: (input: ReflexionInput) => Effect.Effect<ReasoningResult, ExecutionError | IterationLimitError, LLMService>;
+
+/**
+ * Create the full Reasoning layer (Phase 1: reactive only).
+ *
+ * Provides: ReasoningService, StrategyRegistry
+ * Requires: LLMService (from Layer 1.5)
+ *
+ * Usage:
+ *   const ReasoningLive = createReasoningLayer();
+ *   const program = myEffect.pipe(Effect.provide(ReasoningLive));
+ */
+declare const createReasoningLayer: (config?: ReasoningConfig) => Layer.Layer<StrategyRegistry | ReasoningService, never, _reactive_agents_llm_provider.LLMService>;
+
+export { ExecutionError, IterationLimitError, type PlanExecuteConfig, PlanExecuteConfigSchema, type ReactiveConfig, ReactiveConfigSchema, type ReasoningConfig, ReasoningConfigSchema, ReasoningError, type ReasoningErrors, type ReasoningMetadata, ReasoningMetadataSchema, type ReasoningResult, ReasoningResultSchema, ReasoningService, ReasoningServiceLive, ReasoningStatus, type ReasoningStep, ReasoningStepSchema, type ReflexionConfig, ReflexionConfigSchema, type SelectionContext, SelectionContextSchema, SelectionError, StepId, type StepMetadata, StepMetadataSchema, StepType, type StrategyEffectiveness, StrategyEffectivenessSchema, type StrategyFn, StrategyNotFoundError, StrategyRegistry, StrategyRegistryLive, type TreeOfThoughtConfig, TreeOfThoughtConfigSchema, createReasoningLayer, defaultReasoningConfig, executeReactive, executeReflexion };

package/dist/index.js

@@ -0,0 +1,566 @@
+// src/types/step.ts
+import { Schema } from "effect";
+var StepId = Schema.String.pipe(Schema.brand("StepId"));
+var StepType = Schema.Literal(
+  "thought",
+  // Thinking/reasoning
+  "action",
+  // Tool call
+  "observation",
+  // Tool result
+  "plan",
+  // Planning step
+  "reflection",
+  // Self-reflection
+  "critique"
+  // Self-critique
+);
+var StepMetadataSchema = Schema.Struct({
+  confidence: Schema.optional(Schema.Number),
+  toolUsed: Schema.optional(Schema.String),
+  cost: Schema.optional(Schema.Number),
+  duration: Schema.optional(Schema.Number)
+});
+var ReasoningStepSchema = Schema.Struct({
+  id: StepId,
+  type: StepType,
+  content: Schema.String,
+  timestamp: Schema.DateFromSelf,
+  metadata: Schema.optional(StepMetadataSchema)
+});
+
+// src/types/reasoning.ts
+import { Schema as Schema2 } from "effect";
+import { ReasoningStrategy } from "@reactive-agents/core";
+var ReasoningStatus = Schema2.Literal("completed", "failed", "partial");
+var ReasoningMetadataSchema = Schema2.Struct({
+  duration: Schema2.Number,
+  // ms
+  cost: Schema2.Number,
+  // USD
+  tokensUsed: Schema2.Number,
+  stepsCount: Schema2.Number,
+  confidence: Schema2.Number,
+  // 0-1
+  effectiveness: Schema2.optional(Schema2.Number),
+  // 0-1 (learned)
+  selectedStrategy: Schema2.optional(ReasoningStrategy)
+  // for adaptive
+});
+var ReasoningResultSchema = Schema2.Struct({
+  strategy: ReasoningStrategy,
+  steps: Schema2.Array(ReasoningStepSchema),
+  output: Schema2.Unknown,
+  metadata: ReasoningMetadataSchema,
+  status: ReasoningStatus
+});
+var SelectionContextSchema = Schema2.Struct({
+  taskDescription: Schema2.String,
+  taskType: Schema2.String,
+  complexity: Schema2.Number,
+  // 0-1
+  urgency: Schema2.Number,
+  // 0-1
+  costBudget: Schema2.optional(Schema2.Number),
+  timeConstraint: Schema2.optional(Schema2.Number),
+  // ms
+  preferredStrategy: Schema2.optional(ReasoningStrategy)
+});
+
+// src/types/effectiveness.ts
+import { Schema as Schema3 } from "effect";
+var StrategyEffectivenessSchema = Schema3.Struct({
+  strategy: ReasoningStrategy,
+  taskType: Schema3.String,
+  successRate: Schema3.Number,
+  // 0-1
+  avgCost: Schema3.Number,
+  avgDuration: Schema3.Number,
+  avgConfidence: Schema3.Number,
+  executions: Schema3.Number,
+  lastUsed: Schema3.DateFromSelf
+});
+
+// src/types/config.ts
+import { Schema as Schema4 } from "effect";
+var ReactiveConfigSchema = Schema4.Struct({
+  maxIterations: Schema4.Number.pipe(Schema4.int(), Schema4.positive()),
+  temperature: Schema4.Number
+});
+var PlanExecuteConfigSchema = Schema4.Struct({
+  maxRefinements: Schema4.Number.pipe(Schema4.int(), Schema4.positive()),
+  reflectionDepth: Schema4.Literal("shallow", "deep")
+});
+var TreeOfThoughtConfigSchema = Schema4.Struct({
+  breadth: Schema4.Number.pipe(Schema4.int(), Schema4.positive()),
+  depth: Schema4.Number.pipe(Schema4.int(), Schema4.positive()),
+  pruningThreshold: Schema4.Number
+});
+var ReflexionConfigSchema = Schema4.Struct({
+  maxRetries: Schema4.Number.pipe(Schema4.int(), Schema4.positive()),
+  selfCritiqueDepth: Schema4.Literal("shallow", "deep")
+});
+var ReasoningConfigSchema = Schema4.Struct({
+  defaultStrategy: ReasoningStrategy,
+  adaptive: Schema4.Struct({
+    enabled: Schema4.Boolean,
+    learning: Schema4.Boolean
+  }),
+  strategies: Schema4.Struct({
+    reactive: ReactiveConfigSchema,
+    planExecute: PlanExecuteConfigSchema,
+    treeOfThought: TreeOfThoughtConfigSchema,
+    reflexion: ReflexionConfigSchema
+  })
+});
+var defaultReasoningConfig = {
+  defaultStrategy: "reactive",
+  adaptive: { enabled: false, learning: false },
+  strategies: {
+    reactive: { maxIterations: 10, temperature: 0.7 },
+    planExecute: { maxRefinements: 2, reflectionDepth: "deep" },
+    treeOfThought: { breadth: 3, depth: 3, pruningThreshold: 0.5 },
+    reflexion: { maxRetries: 3, selfCritiqueDepth: "deep" }
+  }
+};
+
+// src/errors/errors.ts
+import { Data } from "effect";
+var ReasoningError = class extends Data.TaggedError("ReasoningError") {
+};
+var StrategyNotFoundError = class extends Data.TaggedError(
+  "StrategyNotFoundError"
+) {
+};
+var SelectionError = class extends Data.TaggedError("SelectionError") {
+};
+var ExecutionError = class extends Data.TaggedError("ExecutionError") {
+};
+var IterationLimitError = class extends Data.TaggedError(
+  "IterationLimitError"
+) {
+};
+
+// src/services/reasoning-service.ts
+import { Context as Context2, Effect as Effect4, Layer as Layer2 } from "effect";
+
+// src/services/strategy-registry.ts
+import { Context, Effect as Effect3, Layer, Ref } from "effect";
+
+// src/strategies/reactive.ts
+import { Effect } from "effect";
+import { ulid } from "ulid";
+import { LLMService } from "@reactive-agents/llm-provider";
+var executeReactive = (input) => Effect.gen(function* () {
+  const llm = yield* LLMService;
+  const maxIter = input.config.strategies.reactive.maxIterations;
+  const temp = input.config.strategies.reactive.temperature;
+  const steps = [];
+  const start = Date.now();
+  let context = buildInitialContext(input);
+  let iteration = 0;
+  let totalTokens = 0;
+  let totalCost = 0;
+  while (iteration < maxIter) {
+    const thoughtResponse = yield* llm.complete({
+      messages: [
+        { role: "user", content: buildThoughtPrompt(context, steps) }
+      ],
+      systemPrompt: `You are a reasoning agent. Task: ${input.taskDescription}`,
+      maxTokens: 300,
+      temperature: temp
+    }).pipe(
+      Effect.mapError(
+        (err) => new ExecutionError({
+          strategy: "reactive",
+          message: `LLM thought failed at iteration ${iteration}`,
+          step: iteration,
+          cause: err
+        })
+      )
+    );
+    const thought = thoughtResponse.content;
+    totalTokens += thoughtResponse.usage.totalTokens;
+    totalCost += thoughtResponse.usage.estimatedCost;
+    steps.push({
+      id: ulid(),
+      type: "thought",
+      content: thought,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (hasFinalAnswer(thought)) {
+      return buildResult(
+        steps,
+        thought,
+        "completed",
+        start,
+        totalTokens,
+        totalCost
+      );
+    }
+    const toolRequest = parseToolRequest(thought);
+    if (toolRequest) {
+      steps.push({
+        id: ulid(),
+        type: "action",
+        content: JSON.stringify(toolRequest),
+        timestamp: /* @__PURE__ */ new Date(),
+        metadata: { toolUsed: toolRequest.tool }
+      });
+      steps.push({
+        id: ulid(),
+        type: "observation",
+        content: `[Tool call requested: ${toolRequest.tool}(${JSON.stringify(toolRequest.input)})]`,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      context = appendToContext(context, thought);
+    }
+    iteration++;
+  }
+  return buildResult(steps, null, "partial", start, totalTokens, totalCost);
+});
+function buildInitialContext(input) {
+  return [
+    `Task: ${input.taskDescription}`,
+    `Task Type: ${input.taskType}`,
+    `Relevant Memory:
+${input.memoryContext}`,
+    `Available Tools: ${input.availableTools.join(", ")}`
+  ].join("\n\n");
+}
+function buildThoughtPrompt(context, history) {
+  const historyStr = history.map((s) => `[${s.type}] ${s.content}`).join("\n");
+  return `${context}
+
+Previous steps:
+${historyStr}
+
+Think step-by-step. If you need a tool, respond with "ACTION: tool_name(input)". If you have a final answer, respond with "FINAL ANSWER: ...".`;
+}
+function hasFinalAnswer(thought) {
+  return /final answer:/i.test(thought);
+}
+function parseToolRequest(thought) {
+  const match = thought.match(/ACTION:\s*(\w+)\((.+?)\)/i);
+  return match ? { tool: match[1], input: match[2] } : null;
+}
+function appendToContext(context, addition) {
+  return `${context}
+
+${addition}`;
+}
+function buildResult(steps, output, status, startMs, tokensUsed, cost) {
+  return {
+    strategy: "reactive",
+    steps: [...steps],
+    output,
+    metadata: {
+      duration: Date.now() - startMs,
+      cost,
+      tokensUsed,
+      stepsCount: steps.length,
+      confidence: status === "completed" ? 0.8 : 0.4
+    },
+    status
+  };
+}
+
+// src/strategies/reflexion.ts
+import { Effect as Effect2 } from "effect";
+import { ulid as ulid2 } from "ulid";
+import { LLMService as LLMService2 } from "@reactive-agents/llm-provider";
+var executeReflexion = (input) => Effect2.gen(function* () {
+  const llm = yield* LLMService2;
+  const { maxRetries, selfCritiqueDepth } = input.config.strategies.reflexion;
+  const steps = [];
+  const start = Date.now();
+  let totalTokens = 0;
+  let totalCost = 0;
+  let attempt = 0;
+  let previousCritiques = [];
+  const initialResponse = yield* llm.complete({
+    messages: [
+      {
+        role: "user",
+        content: buildGenerationPrompt(input, null)
+      }
+    ],
+    systemPrompt: buildSystemPrompt(input.taskDescription),
+    maxTokens: selfCritiqueDepth === "deep" ? 800 : 500,
+    temperature: 0.7
+  }).pipe(
+    Effect2.mapError(
+      (err) => new ExecutionError({
+        strategy: "reflexion",
+        message: "Initial generation failed",
+        step: 0,
+        cause: err
+      })
+    )
+  );
+  let currentResponse = initialResponse.content;
+  totalTokens += initialResponse.usage.totalTokens;
+  totalCost += initialResponse.usage.estimatedCost;
+  steps.push({
+    id: ulid2(),
+    type: "thought",
+    content: `[ATTEMPT 1] ${currentResponse}`,
+    timestamp: /* @__PURE__ */ new Date()
+  });
+  while (attempt < maxRetries) {
+    attempt++;
+    const critiqueResponse = yield* llm.complete({
+      messages: [
+        {
+          role: "user",
+          content: buildCritiquePrompt(
+            input.taskDescription,
+            currentResponse,
+            selfCritiqueDepth,
+            previousCritiques
+          )
+        }
+      ],
+      systemPrompt: "You are a critical evaluator. Analyze responses for accuracy, completeness, and quality.",
+      maxTokens: selfCritiqueDepth === "deep" ? 600 : 300,
+      temperature: 0.3
+      // low temp for objective critique
+    }).pipe(
+      Effect2.mapError(
+        (err) => new ExecutionError({
+          strategy: "reflexion",
+          message: `Self-critique failed at attempt ${attempt}`,
+          step: attempt,
+          cause: err
+        })
+      )
+    );
+    const critique = critiqueResponse.content;
+    totalTokens += critiqueResponse.usage.totalTokens;
+    totalCost += critiqueResponse.usage.estimatedCost;
+    steps.push({
+      id: ulid2(),
+      type: "observation",
+      content: `[CRITIQUE ${attempt}] ${critique}`,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    if (isSatisfied(critique)) {
+      return buildResult2(
+        steps,
+        currentResponse,
+        "completed",
+        start,
+        totalTokens,
+        totalCost,
+        attempt
+      );
+    }
+    previousCritiques.push(critique);
+    const improvedResponse = yield* llm.complete({
+      messages: [
+        {
+          role: "user",
+          content: buildGenerationPrompt(input, previousCritiques)
+        }
+      ],
+      systemPrompt: buildSystemPrompt(input.taskDescription),
+      maxTokens: selfCritiqueDepth === "deep" ? 800 : 500,
+      temperature: 0.6
+    }).pipe(
+      Effect2.mapError(
+        (err) => new ExecutionError({
+          strategy: "reflexion",
+          message: `Improvement generation failed at attempt ${attempt}`,
+          step: attempt,
+          cause: err
+        })
+      )
+    );
+    currentResponse = improvedResponse.content;
+    totalTokens += improvedResponse.usage.totalTokens;
+    totalCost += improvedResponse.usage.estimatedCost;
+    steps.push({
+      id: ulid2(),
+      type: "thought",
+      content: `[ATTEMPT ${attempt + 1}] ${currentResponse}`,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+  }
+  return buildResult2(
+    steps,
+    currentResponse,
+    "partial",
+    start,
+    totalTokens,
+    totalCost,
+    attempt
+  );
+});
+function buildSystemPrompt(taskDescription) {
+  return `You are a thoughtful reasoning agent. Your task is: ${taskDescription}
+Provide clear, accurate, and complete responses.`;
+}
+function buildGenerationPrompt(input, previousCritiques) {
+  const parts = [
+    `Task: ${input.taskDescription}`,
+    `Task Type: ${input.taskType}`
+  ];
+  if (input.memoryContext) {
+    parts.push(`Relevant Context:
+${input.memoryContext}`);
+  }
+  if (previousCritiques && previousCritiques.length > 0) {
+    parts.push(
+      `Previous attempts had these issues:
+${previousCritiques.map((c, i) => `${i + 1}. ${c}`).join("\n")}
+
+Please address all of these issues in your improved response.`
+    );
+  }
+  parts.push(
+    "Provide a thorough and accurate response to the task above."
+  );
+  return parts.join("\n\n");
+}
+function buildCritiquePrompt(taskDescription, response, depth, previousCritiques) {
+  const deepInstructions = depth === "deep" ? "\n- Check for logical consistency and coherence\n- Identify any unsupported claims or assumptions\n- Assess whether all aspects of the task are addressed" : "";
+  const prevCritiqueNote = previousCritiques.length > 0 ? `
+
+Previous critiques identified these issues:
+${previousCritiques.map((c, i) => `${i + 1}. ${c}`).join("\n")}
+
+Focus on whether the new response adequately addresses these.` : "";
+  return `Task: ${taskDescription}
+
+Response to evaluate:
+${response}
+
+Critically evaluate this response. Identify:
+- Factual errors or inaccuracies
+- Missing information or incomplete answers
+- Unclear or ambiguous statements${deepInstructions}${prevCritiqueNote}
+
+If the response is accurate and complete, start your critique with "SATISFIED:".
+Otherwise, clearly list the specific issues that need to be fixed.`;
+}
+function isSatisfied(critique) {
+  return /^SATISFIED:/i.test(critique.trim());
+}
+function buildResult2(steps, output, status, startMs, tokensUsed, cost, iterations) {
+  const maxNormal = 3;
+  const confidence = status === "completed" ? Math.max(0.6, 1 - iterations / maxNormal * 0.3) : 0.4;
+  return {
+    strategy: "reflexion",
+    steps: [...steps],
+    output,
+    metadata: {
+      duration: Date.now() - startMs,
+      cost,
+      tokensUsed,
+      stepsCount: steps.length,
+      confidence
+    },
+    status
+  };
+}
+
+// src/services/strategy-registry.ts
+var StrategyRegistry = class extends Context.Tag("StrategyRegistry")() {
+};
+var StrategyRegistryLive = Layer.effect(
+  StrategyRegistry,
+  Effect3.gen(function* () {
+    const registryRef = yield* Ref.make(
+      /* @__PURE__ */ new Map([
+        ["reactive", executeReactive],
+        ["reflexion", executeReflexion]
+      ])
+    );
+    return {
+      get: (name) => Effect3.gen(function* () {
+        const registry = yield* Ref.get(registryRef);
+        const fn = registry.get(name);
+        if (!fn) {
+          return yield* Effect3.fail(
+            new StrategyNotFoundError({ strategy: name })
+          );
+        }
+        return fn;
+      }),
+      register: (name, fn) => Ref.update(registryRef, (m) => {
+        const next = new Map(m);
+        next.set(name, fn);
+        return next;
+      }),
+      list: () => Ref.get(registryRef).pipe(
+        Effect3.map((m) => Array.from(m.keys()))
+      )
+    };
+  })
+);
+
+// src/services/reasoning-service.ts
+import { LLMService as LLMService3 } from "@reactive-agents/llm-provider";
+var ReasoningService = class extends Context2.Tag("ReasoningService")() {
+};
+var ReasoningServiceLive = (config = defaultReasoningConfig) => Layer2.effect(
+  ReasoningService,
+  Effect4.gen(function* () {
+    const registry = yield* StrategyRegistry;
+    const llmService = yield* LLMService3;
+    const llmLayer = Layer2.succeed(LLMService3, llmService);
+    return {
+      execute: (params) => Effect4.gen(function* () {
+        const strategyName = params.strategy ?? config.defaultStrategy;
+        const strategyFn = yield* registry.get(strategyName);
+        const result = yield* strategyFn({
+          ...params,
+          config
+        }).pipe(Effect4.provide(llmLayer));
+        return result;
+      }),
+      registerStrategy: (name, fn) => registry.register(name, fn)
+    };
+  })
+);
+
+// src/runtime.ts
+import { Layer as Layer3 } from "effect";
+var createReasoningLayer = (config = defaultReasoningConfig) => {
+  const RegistryLayer = StrategyRegistryLive;
+  const ServiceLayer = ReasoningServiceLive(config).pipe(
+    Layer3.provide(RegistryLayer)
+  );
+  return Layer3.mergeAll(ServiceLayer, RegistryLayer);
+};
+export {
+  ExecutionError,
+  IterationLimitError,
+  PlanExecuteConfigSchema,
+  ReactiveConfigSchema,
+  ReasoningConfigSchema,
+  ReasoningError,
+  ReasoningMetadataSchema,
+  ReasoningResultSchema,
+  ReasoningService,
+  ReasoningServiceLive,
+  ReasoningStatus,
+  ReasoningStepSchema,
+  ReasoningStrategy,
+  ReflexionConfigSchema,
+  SelectionContextSchema,
+  SelectionError,
+  StepId,
+  StepMetadataSchema,
+  StepType,
+  StrategyEffectivenessSchema,
+  StrategyNotFoundError,
+  StrategyRegistry,
+  StrategyRegistryLive,
+  TreeOfThoughtConfigSchema,
+  createReasoningLayer,
+  defaultReasoningConfig,
+  executeReactive,
+  executeReflexion
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/step.ts","../src/types/reasoning.ts","../src/types/effectiveness.ts","../src/types/config.ts","../src/errors/errors.ts","../src/services/reasoning-service.ts","../src/services/strategy-registry.ts","../src/strategies/reactive.ts","../src/strategies/reflexion.ts","../src/runtime.ts"],"sourcesContent":["// File: src/types/step.ts\nimport { Schema } from \"effect\";\n\n// ─── Step ID (branded string) ───\n\nexport const StepId = Schema.String.pipe(Schema.brand(\"StepId\"));\nexport type StepId = typeof StepId.Type;\n\n// ─── Step Type ───\n\nexport const StepType = Schema.Literal(\n  \"thought\", // Thinking/reasoning\n  \"action\", // Tool call\n  \"observation\", // Tool result\n  \"plan\", // Planning step\n  \"reflection\", // Self-reflection\n  \"critique\", // Self-critique\n);\nexport type StepType = typeof StepType.Type;\n\n// ─── Step Metadata ───\n\nexport const StepMetadataSchema = Schema.Struct({\n  confidence: Schema.optional(Schema.Number),\n  toolUsed: Schema.optional(Schema.String),\n  cost: Schema.optional(Schema.Number),\n  duration: Schema.optional(Schema.Number),\n});\nexport type StepMetadata = typeof StepMetadataSchema.Type;\n\n// ─── Reasoning Step ───\n\nexport const ReasoningStepSchema = Schema.Struct({\n  id: StepId,\n  type: StepType,\n  content: Schema.String,\n  timestamp: Schema.DateFromSelf,\n  metadata: Schema.optional(StepMetadataSchema),\n});\nexport type ReasoningStep = typeof ReasoningStepSchema.Type;\n","// File: src/types/reasoning.ts\nimport { Schema } from \"effect\";\nimport { ReasoningStepSchema } from \"./step.js\";\n\n// ─── Reasoning Strategy ───\n// Canonical definition lives in @reactive-agents/core.\n// Re-export here so downstream reasoning code can import from either package.\nimport { ReasoningStrategy } from \"@reactive-agents/core\";\nexport { ReasoningStrategy };\n\n// ─── Result Status ───\n\nexport const ReasoningStatus = Schema.Literal(\"completed\", \"failed\", \"partial\");\nexport type ReasoningStatus = typeof ReasoningStatus.Type;\n\n// ─── Reasoning Metadata ───\n\nexport const ReasoningMetadataSchema = Schema.Struct({\n  duration: Schema.Number, // ms\n  cost: Schema.Number, // USD\n  tokensUsed: Schema.Number,\n  stepsCount: Schema.Number,\n  confidence: Schema.Number, // 0-1\n  effectiveness: Schema.optional(Schema.Number), // 0-1 (learned)\n  selectedStrategy: Schema.optional(ReasoningStrategy), // for adaptive\n});\nexport type ReasoningMetadata = typeof ReasoningMetadataSchema.Type;\n\n// ─── Reasoning Result ───\n\nexport const ReasoningResultSchema = Schema.Struct({\n  strategy: ReasoningStrategy,\n  steps: Schema.Array(ReasoningStepSchema),\n  output: Schema.Unknown,\n  metadata: ReasoningMetadataSchema,\n  status: ReasoningStatus,\n});\nexport type ReasoningResult = typeof ReasoningResultSchema.Type;\n\n// ─── Selection Context ───\n\nexport const SelectionContextSchema = Schema.Struct({\n  taskDescription: Schema.String,\n  taskType: Schema.String,\n  complexity: Schema.Number, // 0-1\n  urgency: Schema.Number, // 0-1\n  costBudget: Schema.optional(Schema.Number),\n  timeConstraint: Schema.optional(Schema.Number), // ms\n  preferredStrategy: Schema.optional(ReasoningStrategy),\n});\nexport type SelectionContext = typeof SelectionContextSchema.Type;\n","// File: src/types/effectiveness.ts\nimport { Schema } from \"effect\";\nimport { ReasoningStrategy } from \"./reasoning.js\";\n\n// ─── Strategy Effectiveness Record ───\n\nexport const StrategyEffectivenessSchema = Schema.Struct({\n  strategy: ReasoningStrategy,\n  taskType: Schema.String,\n  successRate: Schema.Number, // 0-1\n  avgCost: Schema.Number,\n  avgDuration: Schema.Number,\n  avgConfidence: Schema.Number,\n  executions: Schema.Number,\n  lastUsed: Schema.DateFromSelf,\n});\nexport type StrategyEffectiveness = typeof StrategyEffectivenessSchema.Type;\n","// File: src/types/config.ts\nimport { Schema } from \"effect\";\nimport { ReasoningStrategy } from \"./reasoning.js\";\n\n// ─── Per-Strategy Configuration ───\n\nexport const ReactiveConfigSchema = Schema.Struct({\n  maxIterations: Schema.Number.pipe(Schema.int(), Schema.positive()),\n  temperature: Schema.Number,\n});\nexport type ReactiveConfig = typeof ReactiveConfigSchema.Type;\n\nexport const PlanExecuteConfigSchema = Schema.Struct({\n  maxRefinements: Schema.Number.pipe(Schema.int(), Schema.positive()),\n  reflectionDepth: Schema.Literal(\"shallow\", \"deep\"),\n});\nexport type PlanExecuteConfig = typeof PlanExecuteConfigSchema.Type;\n\nexport const TreeOfThoughtConfigSchema = Schema.Struct({\n  breadth: Schema.Number.pipe(Schema.int(), Schema.positive()),\n  depth: Schema.Number.pipe(Schema.int(), Schema.positive()),\n  pruningThreshold: Schema.Number,\n});\nexport type TreeOfThoughtConfig = typeof TreeOfThoughtConfigSchema.Type;\n\nexport const ReflexionConfigSchema = Schema.Struct({\n  maxRetries: Schema.Number.pipe(Schema.int(), Schema.positive()),\n  selfCritiqueDepth: Schema.Literal(\"shallow\", \"deep\"),\n});\nexport type ReflexionConfig = typeof ReflexionConfigSchema.Type;\n\n// ─── Full Reasoning Config ───\n\nexport const ReasoningConfigSchema = Schema.Struct({\n  defaultStrategy: ReasoningStrategy,\n  adaptive: Schema.Struct({\n    enabled: Schema.Boolean,\n    learning: Schema.Boolean,\n  }),\n  strategies: Schema.Struct({\n    reactive: ReactiveConfigSchema,\n    planExecute: PlanExecuteConfigSchema,\n    treeOfThought: TreeOfThoughtConfigSchema,\n    reflexion: ReflexionConfigSchema,\n  }),\n});\nexport type ReasoningConfig = typeof ReasoningConfigSchema.Type;\n\n// ─── Default Config ───\n\nexport const defaultReasoningConfig: ReasoningConfig = {\n  defaultStrategy: \"reactive\",\n  adaptive: { enabled: false, learning: false },\n  strategies: {\n    reactive: { maxIterations: 10, temperature: 0.7 },\n    planExecute: { maxRefinements: 2, reflectionDepth: \"deep\" },\n    treeOfThought: { breadth: 3, depth: 3, pruningThreshold: 0.5 },\n    reflexion: { maxRetries: 3, selfCritiqueDepth: \"deep\" },\n  },\n};\n","// File: src/errors/errors.ts\nimport { Data } from \"effect\";\n\n// ─── Base reasoning error ───\nexport class ReasoningError extends Data.TaggedError(\"ReasoningError\")<{\n  readonly message: string;\n  readonly cause?: unknown;\n}> {}\n\n// ─── Strategy not found in registry ───\nexport class StrategyNotFoundError extends Data.TaggedError(\n  \"StrategyNotFoundError\",\n)<{\n  readonly strategy: string;\n}> {}\n\n// ─── Strategy selection failed ───\nexport class SelectionError extends Data.TaggedError(\"SelectionError\")<{\n  readonly message: string;\n  readonly context?: unknown;\n}> {}\n\n// ─── Strategy execution failed ───\nexport class ExecutionError extends Data.TaggedError(\"ExecutionError\")<{\n  readonly strategy: string;\n  readonly message: string;\n  readonly step?: number;\n  readonly cause?: unknown;\n}> {}\n\n// ─── Max iterations / depth exceeded ───\nexport class IterationLimitError extends Data.TaggedError(\n  \"IterationLimitError\",\n)<{\n  readonly strategy: string;\n  readonly limit: number;\n  readonly stepsCompleted: number;\n}> {}\n\n// ─── Union type for service signatures ───\nexport type ReasoningErrors =\n  | ReasoningError\n  | StrategyNotFoundError\n  | SelectionError\n  | ExecutionError\n  | IterationLimitError;\n","// File: src/services/reasoning-service.ts\nimport { Context, Effect, Layer } from \"effect\";\nimport type {\n  ReasoningResult,\n  ReasoningStrategy,\n} from \"../types/index.js\";\nimport type { ReasoningConfig } from \"../types/config.js\";\nimport { defaultReasoningConfig } from \"../types/config.js\";\nimport { StrategyRegistry, type StrategyFn } from \"./strategy-registry.js\";\nimport type { ReasoningErrors } from \"../errors/errors.js\";\nimport { LLMService } from \"@reactive-agents/llm-provider\";\n\n// ─── Service Tag ───\n\nexport class ReasoningService extends Context.Tag(\"ReasoningService\")<\n  ReasoningService,\n  {\n    /**\n     * Execute reasoning on a task.\n     * If `strategy` is provided, uses that strategy directly.\n     * Otherwise uses the configured default strategy.\n     */\n    readonly execute: (params: {\n      readonly taskDescription: string;\n      readonly taskType: string;\n      readonly memoryContext: string;\n      readonly availableTools: readonly string[];\n      readonly strategy?: ReasoningStrategy;\n    }) => Effect.Effect<ReasoningResult, ReasoningErrors>;\n\n    /** Register a custom strategy function. */\n    readonly registerStrategy: (\n      name: ReasoningStrategy,\n      fn: StrategyFn,\n    ) => Effect.Effect<void>;\n  }\n>() {}\n\n// ─── Live Layer ───\n// Requires: StrategyRegistry, LLMService\n\nexport const ReasoningServiceLive = (\n  config: ReasoningConfig = defaultReasoningConfig,\n) =>\n  Layer.effect(\n    ReasoningService,\n    Effect.gen(function* () {\n      const registry = yield* StrategyRegistry;\n      // Capture LLMService at layer construction time so we can provide\n      // it to strategy functions when executing them.\n      const llmService = yield* LLMService;\n      const llmLayer = Layer.succeed(LLMService, llmService);\n\n      return {\n        execute: (params) =>\n          Effect.gen(function* () {\n            // ── Determine which strategy to use ──\n            const strategyName: ReasoningStrategy =\n              params.strategy ?? config.defaultStrategy;\n\n            // ── Get strategy function from registry ──\n            const strategyFn = yield* registry.get(strategyName);\n\n            // ── Execute strategy, providing LLMService ──\n            const result = yield* strategyFn({\n              ...params,\n              config,\n            }).pipe(Effect.provide(llmLayer));\n\n            return result;\n          }),\n\n        registerStrategy: (name, fn) => registry.register(name, fn),\n      };\n    }),\n  );\n","// File: src/services/strategy-registry.ts\nimport { Context, Effect, Layer, Ref } from \"effect\";\nimport type { ReasoningResult, ReasoningStrategy } from \"../types/index.js\";\nimport type { ReasoningConfig } from \"../types/config.js\";\nimport {\n  StrategyNotFoundError,\n  type ExecutionError,\n  type IterationLimitError,\n} from \"../errors/errors.js\";\nimport type { LLMService } from \"@reactive-agents/llm-provider\";\nimport { executeReactive } from \"../strategies/reactive.js\";\nimport { executeReflexion } from \"../strategies/reflexion.js\";\n\n// ─── Strategy function type ───\n\nexport type StrategyFn = (input: {\n  readonly taskDescription: string;\n  readonly taskType: string;\n  readonly memoryContext: string;\n  readonly availableTools: readonly string[];\n  readonly config: ReasoningConfig;\n}) => Effect.Effect<\n  ReasoningResult,\n  ExecutionError | IterationLimitError,\n  LLMService\n>;\n\n// ─── Service Tag ───\n\nexport class StrategyRegistry extends Context.Tag(\"StrategyRegistry\")<\n  StrategyRegistry,\n  {\n    readonly get: (\n      name: ReasoningStrategy,\n    ) => Effect.Effect<StrategyFn, StrategyNotFoundError>;\n\n    readonly register: (\n      name: ReasoningStrategy,\n      fn: StrategyFn,\n    ) => Effect.Effect<void>;\n\n    readonly list: () => Effect.Effect<readonly ReasoningStrategy[]>;\n  }\n>() {}\n\n// ─── Live Layer (Phase 1: reactive only) ───\n\nexport const StrategyRegistryLive = Layer.effect(\n  StrategyRegistry,\n  Effect.gen(function* () {\n    // Ref-based mutable map of strategies\n    const registryRef = yield* Ref.make<Map<string, StrategyFn>>(\n      new Map<string, StrategyFn>([\n        [\"reactive\", executeReactive],\n        [\"reflexion\", executeReflexion],\n      ]),\n    );\n\n    return {\n      get: (name) =>\n        Effect.gen(function* () {\n          const registry = yield* Ref.get(registryRef);\n          const fn = registry.get(name);\n          if (!fn) {\n            return yield* Effect.fail(\n              new StrategyNotFoundError({ strategy: name }),\n            );\n          }\n          return fn;\n        }),\n\n      register: (name, fn) =>\n        Ref.update(registryRef, (m) => {\n          const next = new Map(m);\n          next.set(name, fn);\n          return next;\n        }),\n\n      list: () =>\n        Ref.get(registryRef).pipe(\n          Effect.map((m) => Array.from(m.keys()) as ReasoningStrategy[]),\n        ),\n    };\n  }),\n);\n","// File: src/strategies/reactive.ts\nimport { Effect } from \"effect\";\nimport { ulid } from \"ulid\";\nimport type { ReasoningResult, ReasoningStep } from \"../types/index.js\";\nimport type { StepId } from \"../types/step.js\";\nimport { ExecutionError, IterationLimitError } from \"../errors/errors.js\";\nimport type { ReasoningConfig } from \"../types/config.js\";\nimport { LLMService } from \"@reactive-agents/llm-provider\";\n\ninterface ReactiveInput {\n  readonly taskDescription: string;\n  readonly taskType: string;\n  readonly memoryContext: string;\n  readonly availableTools: readonly string[];\n  readonly config: ReasoningConfig;\n}\n\n/**\n * ReAct loop: Thought -> Action -> Observation, iterating until done.\n * Each iteration calls the LLM once for reasoning.\n */\nexport const executeReactive = (\n  input: ReactiveInput,\n): Effect.Effect<\n  ReasoningResult,\n  ExecutionError | IterationLimitError,\n  LLMService\n> =>\n  Effect.gen(function* () {\n    const llm = yield* LLMService;\n    const maxIter = input.config.strategies.reactive.maxIterations;\n    const temp = input.config.strategies.reactive.temperature;\n    const steps: ReasoningStep[] = [];\n    const start = Date.now();\n\n    let context = buildInitialContext(input);\n    let iteration = 0;\n    let totalTokens = 0;\n    let totalCost = 0;\n\n    while (iteration < maxIter) {\n      // ── THOUGHT ──\n      const thoughtResponse = yield* llm\n        .complete({\n          messages: [\n            { role: \"user\", content: buildThoughtPrompt(context, steps) },\n          ],\n          systemPrompt: `You are a reasoning agent. Task: ${input.taskDescription}`,\n          maxTokens: 300,\n          temperature: temp,\n        })\n        .pipe(\n          Effect.mapError(\n            (err) =>\n              new ExecutionError({\n                strategy: \"reactive\",\n                message: `LLM thought failed at iteration ${iteration}`,\n                step: iteration,\n                cause: err,\n              }),\n          ),\n        );\n\n      const thought = thoughtResponse.content;\n      totalTokens += thoughtResponse.usage.totalTokens;\n      totalCost += thoughtResponse.usage.estimatedCost;\n\n      steps.push({\n        id: ulid() as StepId,\n        type: \"thought\",\n        content: thought,\n        timestamp: new Date(),\n      });\n\n      // ── CHECK: does the thought indicate a final answer? ──\n      if (hasFinalAnswer(thought)) {\n        return buildResult(\n          steps,\n          thought,\n          \"completed\",\n          start,\n          totalTokens,\n          totalCost,\n        );\n      }\n\n      // ── ACTION: does the thought request a tool call? ──\n      const toolRequest = parseToolRequest(thought);\n      if (toolRequest) {\n        steps.push({\n          id: ulid() as StepId,\n          type: \"action\",\n          content: JSON.stringify(toolRequest),\n          timestamp: new Date(),\n          metadata: { toolUsed: toolRequest.tool },\n        });\n\n        // Tool execution is deferred to the caller (ReasoningService) via a\n        // placeholder observation. The service orchestrates tool calls through\n        // the ToolService from Layer 8. Here, we note the request and continue.\n        steps.push({\n          id: ulid() as StepId,\n          type: \"observation\",\n          content: `[Tool call requested: ${toolRequest.tool}(${JSON.stringify(toolRequest.input)})]`,\n          timestamp: new Date(),\n        });\n\n        // Update context with tool request for next iteration\n        context = appendToContext(context, thought);\n      }\n\n      iteration++;\n    }\n\n    // Max iterations reached — return partial result\n    return buildResult(steps, null, \"partial\", start, totalTokens, totalCost);\n  });\n\n// ─── Helpers (private to module) ───\n\nfunction buildInitialContext(input: ReactiveInput): string {\n  return [\n    `Task: ${input.taskDescription}`,\n    `Task Type: ${input.taskType}`,\n    `Relevant Memory:\\n${input.memoryContext}`,\n    `Available Tools: ${input.availableTools.join(\", \")}`,\n  ].join(\"\\n\\n\");\n}\n\nfunction buildThoughtPrompt(\n  context: string,\n  history: readonly ReasoningStep[],\n): string {\n  const historyStr = history.map((s) => `[${s.type}] ${s.content}`).join(\"\\n\");\n  return `${context}\\n\\nPrevious steps:\\n${historyStr}\\n\\nThink step-by-step. If you need a tool, respond with \"ACTION: tool_name(input)\". If you have a final answer, respond with \"FINAL ANSWER: ...\".`;\n}\n\nfunction hasFinalAnswer(thought: string): boolean {\n  return /final answer:/i.test(thought);\n}\n\nfunction parseToolRequest(\n  thought: string,\n): { tool: string; input: string } | null {\n  const match = thought.match(/ACTION:\\s*(\\w+)\\((.+?)\\)/i);\n  return match ? { tool: match[1], input: match[2] } : null;\n}\n\nfunction appendToContext(context: string, addition: string): string {\n  return `${context}\\n\\n${addition}`;\n}\n\nfunction buildResult(\n  steps: readonly ReasoningStep[],\n  output: unknown,\n  status: \"completed\" | \"partial\",\n  startMs: number,\n  tokensUsed: number,\n  cost: number,\n): ReasoningResult {\n  return {\n    strategy: \"reactive\",\n    steps: [...steps],\n    output,\n    metadata: {\n      duration: Date.now() - startMs,\n      cost,\n      tokensUsed,\n      stepsCount: steps.length,\n      confidence: status === \"completed\" ? 0.8 : 0.4,\n    },\n    status,\n  };\n}\n","// File: src/strategies/reflexion.ts\n/**\n * Reflexion Strategy — Generate → Reflect → Improve loop.\n *\n * Based on the Reflexion paper (Shinn et al., 2023).\n * The agent:\n *   1. Generates an initial response (attempt)\n *   2. Self-critiques the response to identify gaps/errors\n *   3. Improves the response using the critique as feedback\n *   4. Repeats until maxRetries reached or the critique is satisfied\n */\nimport { Effect } from \"effect\";\nimport { ulid } from \"ulid\";\nimport type { ReasoningResult, ReasoningStep } from \"../types/index.js\";\nimport type { StepId } from \"../types/step.js\";\nimport { ExecutionError, IterationLimitError } from \"../errors/errors.js\";\nimport type { ReasoningConfig } from \"../types/config.js\";\nimport { LLMService } from \"@reactive-agents/llm-provider\";\n\ninterface ReflexionInput {\n  readonly taskDescription: string;\n  readonly taskType: string;\n  readonly memoryContext: string;\n  readonly availableTools: readonly string[];\n  readonly config: ReasoningConfig;\n}\n\n/**\n * Reflexion: Generate → Self-Critique → Improve, repeating until satisfied\n * or maxRetries is reached.\n */\nexport const executeReflexion = (\n  input: ReflexionInput,\n): Effect.Effect<\n  ReasoningResult,\n  ExecutionError | IterationLimitError,\n  LLMService\n> =>\n  Effect.gen(function* () {\n    const llm = yield* LLMService;\n    const { maxRetries, selfCritiqueDepth } = input.config.strategies.reflexion;\n    const steps: ReasoningStep[] = [];\n    const start = Date.now();\n    let totalTokens = 0;\n    let totalCost = 0;\n    let attempt = 0;\n    let previousCritiques: string[] = [];\n\n    // ── STEP 1: Initial generation ──\n    const initialResponse = yield* llm\n      .complete({\n        messages: [\n          {\n            role: \"user\",\n            content: buildGenerationPrompt(input, null),\n          },\n        ],\n        systemPrompt: buildSystemPrompt(input.taskDescription),\n        maxTokens: selfCritiqueDepth === \"deep\" ? 800 : 500,\n        temperature: 0.7,\n      })\n      .pipe(\n        Effect.mapError(\n          (err) =>\n            new ExecutionError({\n              strategy: \"reflexion\",\n              message: \"Initial generation failed\",\n              step: 0,\n              cause: err,\n            }),\n        ),\n      );\n\n    let currentResponse = initialResponse.content;\n    totalTokens += initialResponse.usage.totalTokens;\n    totalCost += initialResponse.usage.estimatedCost;\n\n    steps.push({\n      id: ulid() as StepId,\n      type: \"thought\",\n      content: `[ATTEMPT 1] ${currentResponse}`,\n      timestamp: new Date(),\n    });\n\n    // ── LOOP: Reflect → Improve ──\n    while (attempt < maxRetries) {\n      attempt++;\n\n      // ── Reflect: self-critique the current response ──\n      const critiqueResponse = yield* llm\n        .complete({\n          messages: [\n            {\n              role: \"user\",\n              content: buildCritiquePrompt(\n                input.taskDescription,\n                currentResponse,\n                selfCritiqueDepth,\n                previousCritiques,\n              ),\n            },\n          ],\n          systemPrompt:\n            \"You are a critical evaluator. Analyze responses for accuracy, completeness, and quality.\",\n          maxTokens: selfCritiqueDepth === \"deep\" ? 600 : 300,\n          temperature: 0.3, // low temp for objective critique\n        })\n        .pipe(\n          Effect.mapError(\n            (err) =>\n              new ExecutionError({\n                strategy: \"reflexion\",\n                message: `Self-critique failed at attempt ${attempt}`,\n                step: attempt,\n                cause: err,\n              }),\n          ),\n        );\n\n      const critique = critiqueResponse.content;\n      totalTokens += critiqueResponse.usage.totalTokens;\n      totalCost += critiqueResponse.usage.estimatedCost;\n\n      steps.push({\n        id: ulid() as StepId,\n        type: \"observation\",\n        content: `[CRITIQUE ${attempt}] ${critique}`,\n        timestamp: new Date(),\n        });\n\n      // ── Check if satisfied ──\n      if (isSatisfied(critique)) {\n        return buildResult(\n          steps,\n          currentResponse,\n          \"completed\",\n          start,\n          totalTokens,\n          totalCost,\n          attempt,\n        );\n      }\n\n      previousCritiques.push(critique);\n\n      // ── Improve: generate a refined response ──\n      const improvedResponse = yield* llm\n        .complete({\n          messages: [\n            {\n              role: \"user\",\n              content: buildGenerationPrompt(input, previousCritiques),\n            },\n          ],\n          systemPrompt: buildSystemPrompt(input.taskDescription),\n          maxTokens: selfCritiqueDepth === \"deep\" ? 800 : 500,\n          temperature: 0.6,\n        })\n        .pipe(\n          Effect.mapError(\n            (err) =>\n              new ExecutionError({\n                strategy: \"reflexion\",\n                message: `Improvement generation failed at attempt ${attempt}`,\n                step: attempt,\n                cause: err,\n              }),\n          ),\n        );\n\n      currentResponse = improvedResponse.content;\n      totalTokens += improvedResponse.usage.totalTokens;\n      totalCost += improvedResponse.usage.estimatedCost;\n\n      steps.push({\n        id: ulid() as StepId,\n        type: \"thought\",\n        content: `[ATTEMPT ${attempt + 1}] ${currentResponse}`,\n        timestamp: new Date(),\n        });\n    }\n\n    // Max retries reached — return the best response so far\n    return buildResult(\n      steps,\n      currentResponse,\n      \"partial\",\n      start,\n      totalTokens,\n      totalCost,\n      attempt,\n    );\n  });\n\n// ─── Private Helpers ───\n\nfunction buildSystemPrompt(taskDescription: string): string {\n  return `You are a thoughtful reasoning agent. Your task is: ${taskDescription}\\nProvide clear, accurate, and complete responses.`;\n}\n\nfunction buildGenerationPrompt(\n  input: ReflexionInput,\n  previousCritiques: string[] | null,\n): string {\n  const parts: string[] = [\n    `Task: ${input.taskDescription}`,\n    `Task Type: ${input.taskType}`,\n  ];\n\n  if (input.memoryContext) {\n    parts.push(`Relevant Context:\\n${input.memoryContext}`);\n  }\n\n  if (previousCritiques && previousCritiques.length > 0) {\n    parts.push(\n      `Previous attempts had these issues:\\n${previousCritiques.map((c, i) => `${i + 1}. ${c}`).join(\"\\n\")}\\n\\nPlease address all of these issues in your improved response.`,\n    );\n  }\n\n  parts.push(\n    \"Provide a thorough and accurate response to the task above.\",\n  );\n\n  return parts.join(\"\\n\\n\");\n}\n\nfunction buildCritiquePrompt(\n  taskDescription: string,\n  response: string,\n  depth: \"shallow\" | \"deep\",\n  previousCritiques: string[],\n): string {\n  const deepInstructions =\n    depth === \"deep\"\n      ? \"\\n- Check for logical consistency and coherence\\n- Identify any unsupported claims or assumptions\\n- Assess whether all aspects of the task are addressed\"\n      : \"\";\n\n  const prevCritiqueNote =\n    previousCritiques.length > 0\n      ? `\\n\\nPrevious critiques identified these issues:\\n${previousCritiques.map((c, i) => `${i + 1}. ${c}`).join(\"\\n\")}\\n\\nFocus on whether the new response adequately addresses these.`\n      : \"\";\n\n  return `Task: ${taskDescription}\n\nResponse to evaluate:\n${response}\n\nCritically evaluate this response. Identify:\n- Factual errors or inaccuracies\n- Missing information or incomplete answers\n- Unclear or ambiguous statements${deepInstructions}${prevCritiqueNote}\n\nIf the response is accurate and complete, start your critique with \"SATISFIED:\".\nOtherwise, clearly list the specific issues that need to be fixed.`;\n}\n\nfunction isSatisfied(critique: string): boolean {\n  return /^SATISFIED:/i.test(critique.trim());\n}\n\nfunction buildResult(\n  steps: readonly ReasoningStep[],\n  output: string,\n  status: \"completed\" | \"partial\",\n  startMs: number,\n  tokensUsed: number,\n  cost: number,\n  iterations: number,\n): ReasoningResult {\n  // Confidence is higher when fewer iterations were needed\n  const maxNormal = 3;\n  const confidence =\n    status === \"completed\"\n      ? Math.max(0.6, 1 - (iterations / maxNormal) * 0.3)\n      : 0.4;\n\n  return {\n    strategy: \"reflexion\",\n    steps: [...steps],\n    output,\n    metadata: {\n      duration: Date.now() - startMs,\n      cost,\n      tokensUsed,\n      stepsCount: steps.length,\n      confidence,\n    },\n    status,\n  };\n}\n","// File: src/runtime.ts\nimport { Layer } from \"effect\";\nimport type { ReasoningConfig } from \"./types/config.js\";\nimport { defaultReasoningConfig } from \"./types/config.js\";\nimport { StrategyRegistryLive } from \"./services/strategy-registry.js\";\nimport { ReasoningServiceLive } from \"./services/reasoning-service.js\";\n\n/**\n * Create the full Reasoning layer (Phase 1: reactive only).\n *\n * Provides: ReasoningService, StrategyRegistry\n * Requires: LLMService (from Layer 1.5)\n *\n * Usage:\n *   const ReasoningLive = createReasoningLayer();\n *   const program = myEffect.pipe(Effect.provide(ReasoningLive));\n */\nexport const createReasoningLayer = (\n  config: ReasoningConfig = defaultReasoningConfig,\n) => {\n  // StrategyRegistry has no deps (strategies are registered at construction)\n  const RegistryLayer = StrategyRegistryLive;\n\n  // ReasoningService needs StrategyRegistry\n  const ServiceLayer = ReasoningServiceLive(config).pipe(\n    Layer.provide(RegistryLayer),\n  );\n\n  // Merge all services into one layer\n  return Layer.mergeAll(ServiceLayer, RegistryLayer);\n};\n"],"mappings":"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","names":["Schema","Schema","Schema","Schema","Schema","Schema","Context","Effect","Layer","Effect","Effect","ulid","LLMService","Effect","ulid","buildResult","Effect","LLMService","Context","Layer","Effect","Layer","Layer"]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@reactive-agents/reasoning",
+  "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",
+    "ulid": "^2.3.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/reasoning"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Reasoning strategies for Reactive Agents — ReAct, Plan-Execute, and Tree-of-Thought",
+  "homepage": "https://tylerjrbuell.github.io/reactive-agents-ts/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}