@reactive-agents/tools 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,53 @@
+# @reactive-agents/tools
+
+Tool system for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Provides a type-safe tool registry, sandboxed execution, and an MCP (Model Context Protocol) client.
+
+## Installation
+
+```bash
+bun add @reactive-agents/tools effect
+```
+
+## Features
+
+- **Tool registry** — register typed tools with Effect-TS schemas
+- **Sandboxed execution** — tools run in isolation with timeout and resource limits
+- **MCP client** — connect to any MCP-compatible tool server
+
+## Usage
+
+```typescript
+import { ReactiveAgents } from "reactive-agents";
+import { defineTool } from "@reactive-agents/tools";
+import { Schema } from "effect";
+
+const searchTool = defineTool({
+  name: "web_search",
+  description: "Search the web for information",
+  input: Schema.Struct({ query: Schema.String }),
+  handler: ({ query }) => Effect.succeed(`Results for: ${query}`),
+});
+
+const agent = await ReactiveAgents.create()
+  .withName("research-agent")
+  .withProvider("anthropic")
+  .withReasoning()
+  .withTools([searchTool])
+  .build();
+
+const result = await agent.run("What are the latest AI developments?");
+```
+
+## MCP Client
+
+```typescript
+const agent = await ReactiveAgents.create()
+  .withTools({ mcp: { url: "http://localhost:3000" } })
+  .build();
+```
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts/guides/tools/](https://tylerjrbuell.github.io/reactive-agents-ts/guides/tools/)

package/dist/index.d.ts

@@ -0,0 +1,242 @@
+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 { EventBus } from '@reactive-agents/core';
+
+declare const ToolParameterSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    type: Schema.Literal<["string", "number", "boolean", "object", "array"]>;
+    description: typeof Schema.String;
+    required: typeof Schema.Boolean;
+    default: Schema.optional<typeof Schema.Unknown>;
+    enum: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+type ToolParameter = typeof ToolParameterSchema.Type;
+declare const ToolDefinitionSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    description: typeof Schema.String;
+    parameters: Schema.Array$<Schema.Struct<{
+        name: typeof Schema.String;
+        type: Schema.Literal<["string", "number", "boolean", "object", "array"]>;
+        description: typeof Schema.String;
+        required: typeof Schema.Boolean;
+        default: Schema.optional<typeof Schema.Unknown>;
+        enum: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    }>>;
+    returnType: Schema.optional<typeof Schema.String>;
+    category: Schema.optional<Schema.Literal<["search", "file", "code", "http", "data", "custom"]>>;
+    riskLevel: Schema.Literal<["low", "medium", "high", "critical"]>;
+    timeoutMs: typeof Schema.Number;
+    requiresApproval: typeof Schema.Boolean;
+    source: Schema.Literal<["builtin", "mcp", "function", "plugin"]>;
+}>;
+type ToolDefinition = typeof ToolDefinitionSchema.Type;
+declare const ToolInputSchema: Schema.Struct<{
+    toolName: typeof Schema.String;
+    arguments: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+    agentId: typeof Schema.String;
+    sessionId: typeof Schema.String;
+    correlationId: Schema.optional<typeof Schema.String>;
+}>;
+type ToolInput = typeof ToolInputSchema.Type;
+declare const ToolOutputSchema: Schema.Struct<{
+    toolName: typeof Schema.String;
+    success: typeof Schema.Boolean;
+    result: typeof Schema.Unknown;
+    error: Schema.optional<typeof Schema.String>;
+    executionTimeMs: typeof Schema.Number;
+    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+type ToolOutput = typeof ToolOutputSchema.Type;
+declare const MCPServerSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    version: typeof Schema.String;
+    transport: Schema.Literal<["stdio", "sse", "websocket"]>;
+    endpoint: Schema.optional<typeof Schema.String>;
+    command: Schema.optional<typeof Schema.String>;
+    args: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    tools: Schema.Array$<typeof Schema.String>;
+    status: Schema.Literal<["connected", "disconnected", "error"]>;
+}>;
+type MCPServer = typeof MCPServerSchema.Type;
+declare const MCPRequestSchema: Schema.Struct<{
+    jsonrpc: Schema.Literal<["2.0"]>;
+    id: Schema.Union<[typeof Schema.String, typeof Schema.Number]>;
+    method: typeof Schema.String;
+    params: Schema.optional<typeof Schema.Unknown>;
+}>;
+type MCPRequest = typeof MCPRequestSchema.Type;
+declare const MCPResponseSchema: Schema.Struct<{
+    jsonrpc: Schema.Literal<["2.0"]>;
+    id: Schema.Union<[typeof Schema.String, typeof Schema.Number]>;
+    result: Schema.optional<typeof Schema.Unknown>;
+    error: Schema.optional<Schema.Struct<{
+        code: typeof Schema.Number;
+        message: typeof Schema.String;
+        data: Schema.optional<typeof Schema.Unknown>;
+    }>>;
+}>;
+type MCPResponse = typeof MCPResponseSchema.Type;
+declare const FunctionCallingToolSchema: Schema.Struct<{
+    name: typeof Schema.String;
+    description: typeof Schema.String;
+    input_schema: Schema.Record$<typeof Schema.String, typeof Schema.Unknown>;
+}>;
+type FunctionCallingTool = typeof FunctionCallingToolSchema.Type;
+
+declare const ToolNotFoundError_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: "ToolNotFoundError";
+} & Readonly<A>;
+declare class ToolNotFoundError extends ToolNotFoundError_base<{
+    readonly message: string;
+    readonly toolName: string;
+    readonly availableTools?: readonly string[];
+}> {
+}
+declare const ToolExecutionError_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: "ToolExecutionError";
+} & Readonly<A>;
+declare class ToolExecutionError extends ToolExecutionError_base<{
+    readonly message: string;
+    readonly toolName: string;
+    readonly input?: unknown;
+    readonly cause?: unknown;
+}> {
+}
+declare const ToolTimeoutError_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: "ToolTimeoutError";
+} & Readonly<A>;
+declare class ToolTimeoutError extends ToolTimeoutError_base<{
+    readonly message: string;
+    readonly toolName: string;
+    readonly timeoutMs: number;
+}> {
+}
+declare const ToolValidationError_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: "ToolValidationError";
+} & Readonly<A>;
+declare class ToolValidationError extends ToolValidationError_base<{
+    readonly message: string;
+    readonly toolName: string;
+    readonly parameter: string;
+    readonly expected: string;
+    readonly received: string;
+}> {
+}
+declare const MCPConnectionError_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: "MCPConnectionError";
+} & Readonly<A>;
+declare class MCPConnectionError extends MCPConnectionError_base<{
+    readonly message: string;
+    readonly serverName: string;
+    readonly transport: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ToolAuthorizationError_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: "ToolAuthorizationError";
+} & Readonly<A>;
+declare class ToolAuthorizationError extends ToolAuthorizationError_base<{
+    readonly message: string;
+    readonly toolName: string;
+    readonly agentId: string;
+}> {
+}
+
+declare const ToolService_base: Context.TagClass<ToolService, "ToolService", {
+    readonly execute: (input: ToolInput) => Effect.Effect<ToolOutput, ToolNotFoundError | ToolExecutionError | ToolTimeoutError | ToolValidationError | ToolAuthorizationError>;
+    readonly register: (definition: ToolDefinition, handler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>) => Effect.Effect<void, never>;
+    readonly connectMCPServer: (config: Pick<MCPServer, "name" | "transport" | "endpoint" | "command" | "args">) => Effect.Effect<MCPServer, MCPConnectionError>;
+    readonly disconnectMCPServer: (serverName: string) => Effect.Effect<void, MCPConnectionError>;
+    readonly listTools: (filter?: {
+        category?: string;
+        source?: string;
+        riskLevel?: string;
+    }) => Effect.Effect<readonly ToolDefinition[], never>;
+    readonly getTool: (name: string) => Effect.Effect<ToolDefinition, ToolNotFoundError>;
+    readonly toFunctionCallingFormat: () => Effect.Effect<readonly FunctionCallingTool[], never>;
+    readonly listMCPServers: () => Effect.Effect<readonly MCPServer[], never>;
+}>;
+declare class ToolService extends ToolService_base {
+}
+declare const ToolServiceLive: Layer.Layer<ToolService, never, EventBus>;
+
+interface RegisteredTool {
+    readonly definition: ToolDefinition;
+    readonly handler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+}
+declare const makeToolRegistry: Effect.Effect<{
+    register: (definition: ToolDefinition, handler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>) => Effect.Effect<void, never>;
+    get: (name: string) => Effect.Effect<RegisteredTool, ToolNotFoundError>;
+    list: (filter?: {
+        category?: string;
+        source?: string;
+        riskLevel?: string;
+    }) => Effect.Effect<readonly ToolDefinition[], never>;
+    toFunctionCallingFormat: () => Effect.Effect<readonly FunctionCallingTool[], never>;
+}, never, never>;
+
+declare const makeMCPClient: Effect.Effect<{
+    connect: (config: Pick<MCPServer, "name" | "transport" | "endpoint" | "command" | "args">) => Effect.Effect<MCPServer, MCPConnectionError>;
+    callTool: (serverName: string, toolName: string, args: Record<string, unknown>) => Effect.Effect<unknown, MCPConnectionError | ToolExecutionError>;
+    disconnect: (serverName: string) => Effect.Effect<void, MCPConnectionError>;
+    listServers: () => Effect.Effect<readonly MCPServer[], never>;
+}, never, never>;
+
+/**
+ * Adapt a native function into a ToolDefinition + handler pair
+ * suitable for registration in the ToolRegistry.
+ */
+declare const adaptFunction: (opts: {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: ToolDefinition["parameters"];
+    readonly category?: ToolDefinition["category"];
+    readonly riskLevel?: ToolDefinition["riskLevel"];
+    readonly timeoutMs?: number;
+    readonly fn: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+}) => {
+    definition: ToolDefinition;
+    handler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+};
+/**
+ * Convert a ToolDefinition to the Anthropic/OpenAI function calling format.
+ */
+declare const toFunctionCallingTool: (definition: ToolDefinition) => FunctionCallingTool;
+
+declare const makeSandbox: () => {
+    execute: <A>(fn: () => Effect.Effect<A, ToolExecutionError>, options: {
+        timeoutMs: number;
+        toolName?: string;
+    }) => Effect.Effect<A, ToolExecutionError | ToolTimeoutError>;
+};
+
+declare const validateToolInput: (definition: ToolDefinition, args: Record<string, unknown>) => Effect.Effect<Record<string, unknown>, ToolValidationError>;
+
+declare const webSearchTool: ToolDefinition;
+declare const webSearchHandler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+
+declare const fileReadTool: ToolDefinition;
+declare const fileReadHandler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+declare const fileWriteTool: ToolDefinition;
+declare const fileWriteHandler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+
+declare const httpGetTool: ToolDefinition;
+declare const httpGetHandler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+
+declare const codeExecuteTool: ToolDefinition;
+declare const codeExecuteHandler: (args: Record<string, unknown>) => Effect.Effect<unknown, ToolExecutionError>;
+
+/**
+ * Creates the full Tools layer with all dependencies wired.
+ * Requires EventBus to be provided (or uses EventBusLive by default).
+ */
+declare const createToolsLayer: () => Layer.Layer<ToolService, never, never>;
+/**
+ * ToolServiceLive layer that requires EventBus to be provided externally.
+ * Use this when composing with a shared EventBus from the runtime.
+ */
+declare const ToolsLayer: Layer.Layer<ToolService, never, _reactive_agents_core.EventBus>;
+
+export { type FunctionCallingTool, FunctionCallingToolSchema, MCPConnectionError, type MCPRequest, MCPRequestSchema, type MCPResponse, MCPResponseSchema, type MCPServer, MCPServerSchema, type RegisteredTool, ToolAuthorizationError, type ToolDefinition, ToolDefinitionSchema, ToolExecutionError, type ToolInput, ToolInputSchema, ToolNotFoundError, type ToolOutput, ToolOutputSchema, type ToolParameter, ToolParameterSchema, ToolService, ToolServiceLive, ToolTimeoutError, ToolValidationError, ToolsLayer, adaptFunction, codeExecuteHandler, codeExecuteTool, createToolsLayer, fileReadHandler, fileReadTool, fileWriteHandler, fileWriteTool, httpGetHandler, httpGetTool, makeMCPClient, makeSandbox, makeToolRegistry, toFunctionCallingTool, validateToolInput, webSearchHandler, webSearchTool };

package/dist/index.js

@@ -0,0 +1,762 @@
+// src/types.ts
+import { Schema } from "effect";
+var ToolParameterSchema = Schema.Struct({
+  name: Schema.String,
+  type: Schema.Literal("string", "number", "boolean", "object", "array"),
+  description: Schema.String,
+  required: Schema.Boolean,
+  default: Schema.optional(Schema.Unknown),
+  enum: Schema.optional(Schema.Array(Schema.String))
+});
+var ToolDefinitionSchema = Schema.Struct({
+  name: Schema.String,
+  description: Schema.String,
+  parameters: Schema.Array(ToolParameterSchema),
+  returnType: Schema.optional(Schema.String),
+  category: Schema.optional(
+    Schema.Literal("search", "file", "code", "http", "data", "custom")
+  ),
+  riskLevel: Schema.Literal("low", "medium", "high", "critical"),
+  timeoutMs: Schema.Number,
+  requiresApproval: Schema.Boolean,
+  source: Schema.Literal("builtin", "mcp", "function", "plugin")
+});
+var ToolInputSchema = Schema.Struct({
+  toolName: Schema.String,
+  arguments: Schema.Record({ key: Schema.String, value: Schema.Unknown }),
+  agentId: Schema.String,
+  sessionId: Schema.String,
+  correlationId: Schema.optional(Schema.String)
+});
+var ToolOutputSchema = Schema.Struct({
+  toolName: Schema.String,
+  success: Schema.Boolean,
+  result: Schema.Unknown,
+  error: Schema.optional(Schema.String),
+  executionTimeMs: Schema.Number,
+  metadata: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.Unknown })
+  )
+});
+var MCPServerSchema = Schema.Struct({
+  name: Schema.String,
+  version: Schema.String,
+  transport: Schema.Literal("stdio", "sse", "websocket"),
+  endpoint: Schema.optional(Schema.String),
+  command: Schema.optional(Schema.String),
+  args: Schema.optional(Schema.Array(Schema.String)),
+  tools: Schema.Array(Schema.String),
+  status: Schema.Literal("connected", "disconnected", "error")
+});
+var MCPRequestSchema = Schema.Struct({
+  jsonrpc: Schema.Literal("2.0"),
+  id: Schema.Union(Schema.String, Schema.Number),
+  method: Schema.String,
+  params: Schema.optional(Schema.Unknown)
+});
+var MCPResponseSchema = Schema.Struct({
+  jsonrpc: Schema.Literal("2.0"),
+  id: Schema.Union(Schema.String, Schema.Number),
+  result: Schema.optional(Schema.Unknown),
+  error: Schema.optional(
+    Schema.Struct({
+      code: Schema.Number,
+      message: Schema.String,
+      data: Schema.optional(Schema.Unknown)
+    })
+  )
+});
+var FunctionCallingToolSchema = Schema.Struct({
+  name: Schema.String,
+  description: Schema.String,
+  input_schema: Schema.Record({ key: Schema.String, value: Schema.Unknown })
+});
+
+// src/errors.ts
+import { Data } from "effect";
+var ToolNotFoundError = class extends Data.TaggedError("ToolNotFoundError") {
+};
+var ToolExecutionError = class extends Data.TaggedError(
+  "ToolExecutionError"
+) {
+};
+var ToolTimeoutError = class extends Data.TaggedError("ToolTimeoutError") {
+};
+var ToolValidationError = class extends Data.TaggedError(
+  "ToolValidationError"
+) {
+};
+var MCPConnectionError = class extends Data.TaggedError(
+  "MCPConnectionError"
+) {
+};
+var ToolAuthorizationError = class extends Data.TaggedError(
+  "ToolAuthorizationError"
+) {
+};
+
+// src/tool-service.ts
+import { Effect as Effect5, Context, Layer } from "effect";
+
+// src/registry/tool-registry.ts
+import { Effect, Ref } from "effect";
+var makeToolRegistry = Effect.gen(function* () {
+  const toolsRef = yield* Ref.make(/* @__PURE__ */ new Map());
+  const register = (definition, handler) => Ref.update(toolsRef, (tools) => {
+    const newTools = new Map(tools);
+    newTools.set(definition.name, { definition, handler });
+    return newTools;
+  });
+  const get = (name) => Effect.gen(function* () {
+    const tools = yield* Ref.get(toolsRef);
+    const tool = tools.get(name);
+    if (!tool) {
+      const available = [...tools.keys()];
+      return yield* Effect.fail(
+        new ToolNotFoundError({
+          message: `Tool "${name}" not found`,
+          toolName: name,
+          availableTools: available
+        })
+      );
+    }
+    return tool;
+  });
+  const list = (filter) => Effect.gen(function* () {
+    const tools = yield* Ref.get(toolsRef);
+    let definitions = [...tools.values()].map((t) => t.definition);
+    if (filter?.category)
+      definitions = definitions.filter((d) => d.category === filter.category);
+    if (filter?.source)
+      definitions = definitions.filter((d) => d.source === filter.source);
+    if (filter?.riskLevel)
+      definitions = definitions.filter(
+        (d) => d.riskLevel === filter.riskLevel
+      );
+    return definitions;
+  });
+  const toFunctionCallingFormat = () => Effect.gen(function* () {
+    const tools = yield* Ref.get(toolsRef);
+    return [...tools.values()].map((t) => ({
+      name: t.definition.name,
+      description: t.definition.description,
+      input_schema: {
+        type: "object",
+        properties: Object.fromEntries(
+          t.definition.parameters.map((p) => [
+            p.name,
+            {
+              type: p.type,
+              description: p.description,
+              ...p.enum ? { enum: p.enum } : {}
+            }
+          ])
+        ),
+        required: t.definition.parameters.filter((p) => p.required).map((p) => p.name)
+      }
+    }));
+  });
+  return { register, get, list, toFunctionCallingFormat };
+});
+
+// src/mcp/mcp-client.ts
+import { Effect as Effect2, Ref as Ref2 } from "effect";
+var createTransport = (_config) => Effect2.void;
+var sendRequest = (_config, request) => Effect2.succeed({
+  jsonrpc: "2.0",
+  id: request.id,
+  result: {}
+});
+var makeMCPClient = Effect2.gen(function* () {
+  const serversRef = yield* Ref2.make(/* @__PURE__ */ new Map());
+  const requestIdRef = yield* Ref2.make(0);
+  const nextRequestId = Ref2.updateAndGet(requestIdRef, (id) => id + 1);
+  const connect = (config) => Effect2.gen(function* () {
+    yield* createTransport(config).pipe(
+      Effect2.mapError(
+        (e) => new MCPConnectionError({
+          message: `Failed to connect to MCP server "${config.name}"`,
+          serverName: config.name,
+          transport: config.transport,
+          cause: e
+        })
+      )
+    );
+    const reqId1 = yield* nextRequestId;
+    const initResponse = yield* sendRequest(config, {
+      jsonrpc: "2.0",
+      id: reqId1,
+      method: "initialize",
+      params: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        clientInfo: { name: "reactive-agents", version: "1.0.0" }
+      }
+    });
+    const reqId2 = yield* nextRequestId;
+    const toolsResponse = yield* sendRequest(config, {
+      jsonrpc: "2.0",
+      id: reqId2,
+      method: "tools/list"
+    });
+    const toolNames = Array.isArray(toolsResponse.result) ? toolsResponse.result.map(
+      (t) => t.name
+    ) : [];
+    const server = {
+      name: config.name,
+      version: initResponse.result?.serverInfo != null ? String(
+        initResponse.result.serverInfo?.version
+      ) : "unknown",
+      transport: config.transport,
+      endpoint: config.endpoint,
+      command: config.command,
+      args: config.args,
+      tools: toolNames,
+      status: "connected"
+    };
+    yield* Ref2.update(serversRef, (servers) => {
+      const newServers = new Map(servers);
+      newServers.set(server.name, server);
+      return newServers;
+    });
+    return server;
+  });
+  const callTool = (serverName, toolName, args) => Effect2.gen(function* () {
+    const servers = yield* Ref2.get(serversRef);
+    const server = servers.get(serverName);
+    if (!server || server.status !== "connected") {
+      return yield* Effect2.fail(
+        new MCPConnectionError({
+          message: `MCP server "${serverName}" not connected`,
+          serverName,
+          transport: server?.transport ?? "unknown"
+        })
+      );
+    }
+    const reqId = yield* nextRequestId;
+    const response = yield* sendRequest(
+      {
+        name: serverName,
+        transport: server.transport,
+        endpoint: server.endpoint,
+        command: server.command
+      },
+      {
+        jsonrpc: "2.0",
+        id: reqId,
+        method: "tools/call",
+        params: { name: toolName, arguments: args }
+      }
+    );
+    if (response.error) {
+      return yield* Effect2.fail(
+        new ToolExecutionError({
+          message: `MCP tool "${toolName}" failed: ${response.error.message}`,
+          toolName,
+          input: args
+        })
+      );
+    }
+    return response.result;
+  });
+  const disconnect = (serverName) => Ref2.update(serversRef, (servers) => {
+    const newServers = new Map(servers);
+    const server = newServers.get(serverName);
+    if (server) {
+      newServers.set(serverName, { ...server, status: "disconnected" });
+    }
+    return newServers;
+  });
+  const listServers = () => Effect2.gen(function* () {
+    const servers = yield* Ref2.get(serversRef);
+    return [...servers.values()];
+  });
+  return { connect, callTool, disconnect, listServers };
+});
+
+// src/execution/sandbox.ts
+import { Duration, Effect as Effect3 } from "effect";
+var makeSandbox = () => {
+  const execute = (fn, options) => fn().pipe(
+    // Enforce timeout
+    Effect3.timeoutFail({
+      duration: Duration.millis(options.timeoutMs),
+      onTimeout: () => new ToolTimeoutError({
+        message: `Tool execution timed out after ${options.timeoutMs}ms`,
+        toolName: options.toolName ?? "unknown",
+        timeoutMs: options.timeoutMs
+      })
+    }),
+    // Catch unexpected errors
+    Effect3.catchAllDefect(
+      (defect) => Effect3.fail(
+        new ToolExecutionError({
+          message: `Tool crashed: ${String(defect)}`,
+          toolName: options.toolName ?? "unknown",
+          cause: defect
+        })
+      )
+    )
+  );
+  return { execute };
+};
+
+// src/validation/input-validator.ts
+import { Effect as Effect4 } from "effect";
+var validateToolInput = (definition, args) => Effect4.gen(function* () {
+  const validated = {};
+  for (const param of definition.parameters) {
+    const value = args[param.name];
+    if (param.required && (value === void 0 || value === null)) {
+      return yield* Effect4.fail(
+        new ToolValidationError({
+          message: `Missing required parameter "${param.name}"`,
+          toolName: definition.name,
+          parameter: param.name,
+          expected: param.type,
+          received: "undefined"
+        })
+      );
+    }
+    if (value === void 0) {
+      if (param.default !== void 0) {
+        validated[param.name] = param.default;
+      }
+      continue;
+    }
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    if (actualType !== param.type && !(param.type === "object" && actualType === "object")) {
+      return yield* Effect4.fail(
+        new ToolValidationError({
+          message: `Parameter "${param.name}" expected ${param.type}, got ${actualType}`,
+          toolName: definition.name,
+          parameter: param.name,
+          expected: param.type,
+          received: actualType
+        })
+      );
+    }
+    if (param.enum && typeof value === "string" && !param.enum.includes(value)) {
+      return yield* Effect4.fail(
+        new ToolValidationError({
+          message: `Parameter "${param.name}" must be one of: ${param.enum.join(", ")}`,
+          toolName: definition.name,
+          parameter: param.name,
+          expected: param.enum.join(" | "),
+          received: String(value)
+        })
+      );
+    }
+    validated[param.name] = value;
+  }
+  return validated;
+});
+
+// src/tool-service.ts
+import { EventBus } from "@reactive-agents/core";
+var ToolService = class extends Context.Tag("ToolService")() {
+};
+var ToolServiceLive = Layer.effect(
+  ToolService,
+  Effect5.gen(function* () {
+    const eventBus = yield* EventBus;
+    const registry = yield* makeToolRegistry;
+    const mcpClient = yield* makeMCPClient;
+    const sandbox = makeSandbox();
+    const execute = (input) => Effect5.gen(function* () {
+      const startTime = Date.now();
+      const tool = yield* registry.get(input.toolName);
+      const validatedArgs = yield* validateToolInput(
+        tool.definition,
+        input.arguments
+      );
+      const result = yield* sandbox.execute(
+        () => tool.handler(validatedArgs),
+        {
+          timeoutMs: tool.definition.timeoutMs,
+          toolName: input.toolName
+        }
+      );
+      const executionTimeMs = Date.now() - startTime;
+      yield* eventBus.publish({
+        _tag: "Custom",
+        type: "tools.executed",
+        payload: {
+          toolName: input.toolName,
+          success: true,
+          executionTimeMs
+        }
+      });
+      return {
+        toolName: input.toolName,
+        success: true,
+        result,
+        executionTimeMs
+      };
+    });
+    const register = (definition, handler) => registry.register(definition, handler);
+    const connectMCPServer = (config) => Effect5.gen(function* () {
+      const server = yield* mcpClient.connect(config);
+      for (const toolName of server.tools) {
+        yield* registry.register(
+          {
+            name: `${server.name}/${toolName}`,
+            description: `MCP tool from ${server.name}`,
+            parameters: [],
+            riskLevel: "medium",
+            timeoutMs: 3e4,
+            requiresApproval: false,
+            source: "mcp"
+          },
+          (args) => mcpClient.callTool(server.name, toolName, args).pipe(
+            Effect5.mapError(
+              (e) => new ToolExecutionError({
+                message: `MCP tool ${toolName} failed`,
+                toolName,
+                cause: e
+              })
+            )
+          )
+        );
+      }
+      yield* eventBus.publish({
+        _tag: "Custom",
+        type: "tools.mcp-connected",
+        payload: { serverName: server.name, tools: server.tools }
+      });
+      return server;
+    });
+    const disconnectMCPServer = (serverName) => Effect5.gen(function* () {
+      yield* mcpClient.disconnect(serverName);
+      yield* eventBus.publish({
+        _tag: "Custom",
+        type: "tools.mcp-disconnected",
+        payload: { serverName }
+      });
+    });
+    const listTools = (filter) => registry.list(filter);
+    const getTool = (name) => registry.get(name).pipe(Effect5.map((t) => t.definition));
+    const toFunctionCallingFormat = () => registry.toFunctionCallingFormat();
+    const listMCPServers = () => mcpClient.listServers();
+    return {
+      execute,
+      register,
+      connectMCPServer,
+      disconnectMCPServer,
+      listTools,
+      getTool,
+      toFunctionCallingFormat,
+      listMCPServers
+    };
+  })
+);
+
+// src/function-calling/function-adapter.ts
+import "effect";
+var adaptFunction = (opts) => ({
+  definition: {
+    name: opts.name,
+    description: opts.description,
+    parameters: opts.parameters,
+    category: opts.category,
+    riskLevel: opts.riskLevel ?? "low",
+    timeoutMs: opts.timeoutMs ?? 3e4,
+    requiresApproval: false,
+    source: "function"
+  },
+  handler: opts.fn
+});
+var toFunctionCallingTool = (definition) => ({
+  name: definition.name,
+  description: definition.description,
+  input_schema: {
+    type: "object",
+    properties: Object.fromEntries(
+      definition.parameters.map((p) => [
+        p.name,
+        {
+          type: p.type,
+          description: p.description,
+          ...p.enum ? { enum: p.enum } : {}
+        }
+      ])
+    ),
+    required: definition.parameters.filter((p) => p.required).map((p) => p.name)
+  }
+});
+
+// src/skills/web-search.ts
+import { Effect as Effect7 } from "effect";
+var webSearchTool = {
+  name: "web-search",
+  description: "Search the web for information using a query string",
+  parameters: [
+    {
+      name: "query",
+      type: "string",
+      description: "Search query",
+      required: true
+    },
+    {
+      name: "maxResults",
+      type: "number",
+      description: "Max results to return",
+      required: false,
+      default: 5
+    }
+  ],
+  category: "search",
+  riskLevel: "low",
+  timeoutMs: 1e4,
+  requiresApproval: false,
+  source: "builtin"
+};
+var webSearchHandler = (args) => Effect7.tryPromise({
+  try: async () => {
+    const query = args.query;
+    const maxResults = args.maxResults ?? 5;
+    return {
+      query,
+      maxResults,
+      results: [],
+      message: "Web search stub - configure TAVILY_API_KEY for real results"
+    };
+  },
+  catch: (e) => new ToolExecutionError({
+    message: `Web search failed: ${e}`,
+    toolName: "web-search",
+    cause: e
+  })
+});
+
+// src/skills/file-operations.ts
+import { Effect as Effect8 } from "effect";
+import * as fs from "fs/promises";
+import * as path from "path";
+var fileReadTool = {
+  name: "file-read",
+  description: "Read the contents of a file",
+  parameters: [
+    {
+      name: "path",
+      type: "string",
+      description: "File path to read",
+      required: true
+    },
+    {
+      name: "encoding",
+      type: "string",
+      description: "File encoding",
+      required: false,
+      default: "utf-8"
+    }
+  ],
+  category: "file",
+  riskLevel: "medium",
+  timeoutMs: 5e3,
+  requiresApproval: false,
+  source: "builtin"
+};
+var fileReadHandler = (args) => Effect8.tryPromise({
+  try: async () => {
+    const filePath = args.path;
+    const encoding = args.encoding ?? "utf-8";
+    const resolved = path.resolve(filePath);
+    const allowedBase = process.cwd();
+    if (!resolved.startsWith(allowedBase)) {
+      throw new Error(`Path traversal detected: ${filePath}`);
+    }
+    return await fs.readFile(resolved, { encoding });
+  },
+  catch: (e) => new ToolExecutionError({
+    message: `File read failed: ${e}`,
+    toolName: "file-read",
+    cause: e
+  })
+});
+var fileWriteTool = {
+  name: "file-write",
+  description: "Write contents to a file",
+  parameters: [
+    {
+      name: "path",
+      type: "string",
+      description: "File path to write",
+      required: true
+    },
+    {
+      name: "content",
+      type: "string",
+      description: "Content to write",
+      required: true
+    },
+    {
+      name: "encoding",
+      type: "string",
+      description: "File encoding",
+      required: false,
+      default: "utf-8"
+    }
+  ],
+  category: "file",
+  riskLevel: "high",
+  timeoutMs: 5e3,
+  requiresApproval: true,
+  source: "builtin"
+};
+var fileWriteHandler = (args) => Effect8.tryPromise({
+  try: async () => {
+    const filePath = args.path;
+    const content = args.content;
+    const encoding = args.encoding ?? "utf-8";
+    const resolved = path.resolve(filePath);
+    const allowedBase = process.cwd();
+    if (!resolved.startsWith(allowedBase)) {
+      throw new Error(`Path traversal detected: ${filePath}`);
+    }
+    await fs.writeFile(resolved, content, { encoding });
+    return { written: true, path: resolved };
+  },
+  catch: (e) => new ToolExecutionError({
+    message: `File write failed: ${e}`,
+    toolName: "file-write",
+    cause: e
+  })
+});
+
+// src/skills/http-client.ts
+import { Effect as Effect9 } from "effect";
+var httpGetTool = {
+  name: "http-get",
+  description: "Make an HTTP GET request to a URL",
+  parameters: [
+    {
+      name: "url",
+      type: "string",
+      description: "URL to fetch",
+      required: true
+    },
+    {
+      name: "headers",
+      type: "object",
+      description: "Optional request headers",
+      required: false
+    }
+  ],
+  category: "http",
+  riskLevel: "medium",
+  timeoutMs: 15e3,
+  requiresApproval: false,
+  source: "builtin"
+};
+var httpGetHandler = (args) => Effect9.tryPromise({
+  try: async () => {
+    const url = args.url;
+    const headers = args.headers ?? {};
+    const response = await fetch(url, { method: "GET", headers });
+    const contentType = response.headers.get("content-type") ?? "";
+    let body;
+    if (contentType.includes("application/json")) {
+      body = await response.json();
+    } else {
+      body = await response.text();
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body
+    };
+  },
+  catch: (e) => new ToolExecutionError({
+    message: `HTTP GET failed: ${e}`,
+    toolName: "http-get",
+    cause: e
+  })
+});
+
+// src/skills/code-execution.ts
+import { Effect as Effect10 } from "effect";
+var codeExecuteTool = {
+  name: "code-execute",
+  description: "Execute a JavaScript/TypeScript code snippet in a sandboxed environment",
+  parameters: [
+    {
+      name: "code",
+      type: "string",
+      description: "Code to execute",
+      required: true
+    },
+    {
+      name: "language",
+      type: "string",
+      description: "Programming language",
+      required: false,
+      default: "javascript",
+      enum: ["javascript", "typescript"]
+    }
+  ],
+  category: "code",
+  riskLevel: "critical",
+  timeoutMs: 3e4,
+  requiresApproval: true,
+  source: "builtin"
+};
+var codeExecuteHandler = (args) => Effect10.try({
+  try: () => {
+    const code = args.code;
+    return {
+      code,
+      executed: false,
+      message: "Code execution stub - production implementation requires sandboxed runtime"
+    };
+  },
+  catch: (e) => new ToolExecutionError({
+    message: `Code execution failed: ${e}`,
+    toolName: "code-execute",
+    cause: e
+  })
+});
+
+// src/runtime.ts
+import { Layer as Layer2 } from "effect";
+import { EventBusLive } from "@reactive-agents/core";
+var createToolsLayer = () => ToolServiceLive.pipe(Layer2.provide(EventBusLive));
+var ToolsLayer = ToolServiceLive;
+export {
+  FunctionCallingToolSchema,
+  MCPConnectionError,
+  MCPRequestSchema,
+  MCPResponseSchema,
+  MCPServerSchema,
+  ToolAuthorizationError,
+  ToolDefinitionSchema,
+  ToolExecutionError,
+  ToolInputSchema,
+  ToolNotFoundError,
+  ToolOutputSchema,
+  ToolParameterSchema,
+  ToolService,
+  ToolServiceLive,
+  ToolTimeoutError,
+  ToolValidationError,
+  ToolsLayer,
+  adaptFunction,
+  codeExecuteHandler,
+  codeExecuteTool,
+  createToolsLayer,
+  fileReadHandler,
+  fileReadTool,
+  fileWriteHandler,
+  fileWriteTool,
+  httpGetHandler,
+  httpGetTool,
+  makeMCPClient,
+  makeSandbox,
+  makeToolRegistry,
+  toFunctionCallingTool,
+  validateToolInput,
+  webSearchHandler,
+  webSearchTool
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/errors.ts","../src/tool-service.ts","../src/registry/tool-registry.ts","../src/mcp/mcp-client.ts","../src/execution/sandbox.ts","../src/validation/input-validator.ts","../src/function-calling/function-adapter.ts","../src/skills/web-search.ts","../src/skills/file-operations.ts","../src/skills/http-client.ts","../src/skills/code-execution.ts","../src/runtime.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\n// ─── Tool Definition ───\n\nexport const ToolParameterSchema = Schema.Struct({\n  name: Schema.String,\n  type: Schema.Literal(\"string\", \"number\", \"boolean\", \"object\", \"array\"),\n  description: Schema.String,\n  required: Schema.Boolean,\n  default: Schema.optional(Schema.Unknown),\n  enum: Schema.optional(Schema.Array(Schema.String)),\n});\nexport type ToolParameter = typeof ToolParameterSchema.Type;\n\nexport const ToolDefinitionSchema = Schema.Struct({\n  name: Schema.String,\n  description: Schema.String,\n  parameters: Schema.Array(ToolParameterSchema),\n  returnType: Schema.optional(Schema.String),\n  category: Schema.optional(\n    Schema.Literal(\"search\", \"file\", \"code\", \"http\", \"data\", \"custom\"),\n  ),\n  riskLevel: Schema.Literal(\"low\", \"medium\", \"high\", \"critical\"),\n  timeoutMs: Schema.Number,\n  requiresApproval: Schema.Boolean,\n  source: Schema.Literal(\"builtin\", \"mcp\", \"function\", \"plugin\"),\n});\nexport type ToolDefinition = typeof ToolDefinitionSchema.Type;\n\n// ─── Tool Execution ───\n\nexport const ToolInputSchema = Schema.Struct({\n  toolName: Schema.String,\n  arguments: Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n  agentId: Schema.String,\n  sessionId: Schema.String,\n  correlationId: Schema.optional(Schema.String),\n});\nexport type ToolInput = typeof ToolInputSchema.Type;\n\nexport const ToolOutputSchema = Schema.Struct({\n  toolName: Schema.String,\n  success: Schema.Boolean,\n  result: Schema.Unknown,\n  error: Schema.optional(Schema.String),\n  executionTimeMs: Schema.Number,\n  metadata: Schema.optional(\n    Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n  ),\n});\nexport type ToolOutput = typeof ToolOutputSchema.Type;\n\n// ─── MCP Types ───\n\nexport const MCPServerSchema = Schema.Struct({\n  name: Schema.String,\n  version: Schema.String,\n  transport: Schema.Literal(\"stdio\", \"sse\", \"websocket\"),\n  endpoint: Schema.optional(Schema.String),\n  command: Schema.optional(Schema.String),\n  args: Schema.optional(Schema.Array(Schema.String)),\n  tools: Schema.Array(Schema.String),\n  status: Schema.Literal(\"connected\", \"disconnected\", \"error\"),\n});\nexport type MCPServer = typeof MCPServerSchema.Type;\n\nexport const MCPRequestSchema = Schema.Struct({\n  jsonrpc: Schema.Literal(\"2.0\"),\n  id: Schema.Union(Schema.String, Schema.Number),\n  method: Schema.String,\n  params: Schema.optional(Schema.Unknown),\n});\nexport type MCPRequest = typeof MCPRequestSchema.Type;\n\nexport const MCPResponseSchema = Schema.Struct({\n  jsonrpc: Schema.Literal(\"2.0\"),\n  id: Schema.Union(Schema.String, Schema.Number),\n  result: Schema.optional(Schema.Unknown),\n  error: Schema.optional(\n    Schema.Struct({\n      code: Schema.Number,\n      message: Schema.String,\n      data: Schema.optional(Schema.Unknown),\n    }),\n  ),\n});\nexport type MCPResponse = typeof MCPResponseSchema.Type;\n\n// ─── Function Calling (Anthropic/OpenAI format) ───\n\nexport const FunctionCallingToolSchema = Schema.Struct({\n  name: Schema.String,\n  description: Schema.String,\n  input_schema: Schema.Record({ key: Schema.String, value: Schema.Unknown }),\n});\nexport type FunctionCallingTool = typeof FunctionCallingToolSchema.Type;\n","import { Data } from \"effect\";\n\nexport class ToolNotFoundError extends Data.TaggedError(\"ToolNotFoundError\")<{\n  readonly message: string;\n  readonly toolName: string;\n  readonly availableTools?: readonly string[];\n}> {}\n\nexport class ToolExecutionError extends Data.TaggedError(\n  \"ToolExecutionError\",\n)<{\n  readonly message: string;\n  readonly toolName: string;\n  readonly input?: unknown;\n  readonly cause?: unknown;\n}> {}\n\nexport class ToolTimeoutError extends Data.TaggedError(\"ToolTimeoutError\")<{\n  readonly message: string;\n  readonly toolName: string;\n  readonly timeoutMs: number;\n}> {}\n\nexport class ToolValidationError extends Data.TaggedError(\n  \"ToolValidationError\",\n)<{\n  readonly message: string;\n  readonly toolName: string;\n  readonly parameter: string;\n  readonly expected: string;\n  readonly received: string;\n}> {}\n\nexport class MCPConnectionError extends Data.TaggedError(\n  \"MCPConnectionError\",\n)<{\n  readonly message: string;\n  readonly serverName: string;\n  readonly transport: string;\n  readonly cause?: unknown;\n}> {}\n\nexport class ToolAuthorizationError extends Data.TaggedError(\n  \"ToolAuthorizationError\",\n)<{\n  readonly message: string;\n  readonly toolName: string;\n  readonly agentId: string;\n}> {}\n","import { Effect, Context, Layer } from \"effect\";\n\nimport type {\n  ToolInput,\n  ToolOutput,\n  ToolDefinition,\n  MCPServer,\n  FunctionCallingTool,\n} from \"./types.js\";\nimport {\n  ToolNotFoundError,\n  ToolExecutionError,\n  ToolTimeoutError,\n  ToolValidationError,\n  ToolAuthorizationError,\n  MCPConnectionError,\n} from \"./errors.js\";\nimport { makeToolRegistry } from \"./registry/tool-registry.js\";\nimport { makeMCPClient } from \"./mcp/mcp-client.js\";\nimport { makeSandbox } from \"./execution/sandbox.js\";\nimport { validateToolInput } from \"./validation/input-validator.js\";\nimport { EventBus } from \"@reactive-agents/core\";\n\n// ─── Service Tag ───\n\nexport class ToolService extends Context.Tag(\"ToolService\")<\n  ToolService,\n  {\n    readonly execute: (\n      input: ToolInput,\n    ) => Effect.Effect<\n      ToolOutput,\n      | ToolNotFoundError\n      | ToolExecutionError\n      | ToolTimeoutError\n      | ToolValidationError\n      | ToolAuthorizationError\n    >;\n\n    readonly register: (\n      definition: ToolDefinition,\n      handler: (\n        args: Record<string, unknown>,\n      ) => Effect.Effect<unknown, ToolExecutionError>,\n    ) => Effect.Effect<void, never>;\n\n    readonly connectMCPServer: (\n      config: Pick<\n        MCPServer,\n        \"name\" | \"transport\" | \"endpoint\" | \"command\" | \"args\"\n      >,\n    ) => Effect.Effect<MCPServer, MCPConnectionError>;\n\n    readonly disconnectMCPServer: (\n      serverName: string,\n    ) => Effect.Effect<void, MCPConnectionError>;\n\n    readonly listTools: (filter?: {\n      category?: string;\n      source?: string;\n      riskLevel?: string;\n    }) => Effect.Effect<readonly ToolDefinition[], never>;\n\n    readonly getTool: (\n      name: string,\n    ) => Effect.Effect<ToolDefinition, ToolNotFoundError>;\n\n    readonly toFunctionCallingFormat: () => Effect.Effect<\n      readonly FunctionCallingTool[],\n      never\n    >;\n\n    readonly listMCPServers: () => Effect.Effect<readonly MCPServer[], never>;\n  }\n>() {}\n\n// ─── Live Implementation ───\n\nexport const ToolServiceLive = Layer.effect(\n  ToolService,\n  Effect.gen(function* () {\n    const eventBus = yield* EventBus;\n    const registry = yield* makeToolRegistry;\n    const mcpClient = yield* makeMCPClient;\n    const sandbox = makeSandbox();\n\n    const execute = (\n      input: ToolInput,\n    ): Effect.Effect<\n      ToolOutput,\n      | ToolNotFoundError\n      | ToolExecutionError\n      | ToolTimeoutError\n      | ToolValidationError\n      | ToolAuthorizationError\n    > =>\n      Effect.gen(function* () {\n        const startTime = Date.now();\n\n        // Step 1: Look up tool\n        const tool = yield* registry.get(input.toolName);\n\n        // Step 2: Validate input\n        const validatedArgs = yield* validateToolInput(\n          tool.definition,\n          input.arguments,\n        );\n\n        // Step 3: Execute in sandbox with timeout\n        const result = yield* sandbox.execute(\n          () => tool.handler(validatedArgs),\n          {\n            timeoutMs: tool.definition.timeoutMs,\n            toolName: input.toolName,\n          },\n        );\n\n        const executionTimeMs = Date.now() - startTime;\n\n        // Step 4: Emit event\n        yield* eventBus.publish({\n          _tag: \"Custom\",\n          type: \"tools.executed\",\n          payload: {\n            toolName: input.toolName,\n            success: true,\n            executionTimeMs,\n          },\n        });\n\n        return {\n          toolName: input.toolName,\n          success: true as const,\n          result,\n          executionTimeMs,\n        } satisfies ToolOutput;\n      });\n\n    const register = (\n      definition: ToolDefinition,\n      handler: (\n        args: Record<string, unknown>,\n      ) => Effect.Effect<unknown, ToolExecutionError>,\n    ): Effect.Effect<void, never> => registry.register(definition, handler);\n\n    const connectMCPServer = (\n      config: Pick<\n        MCPServer,\n        \"name\" | \"transport\" | \"endpoint\" | \"command\" | \"args\"\n      >,\n    ): Effect.Effect<MCPServer, MCPConnectionError> =>\n      Effect.gen(function* () {\n        const server = yield* mcpClient.connect(config);\n\n        // Register each MCP tool in the registry\n        for (const toolName of server.tools) {\n          yield* registry.register(\n            {\n              name: `${server.name}/${toolName}`,\n              description: `MCP tool from ${server.name}`,\n              parameters: [],\n              riskLevel: \"medium\",\n              timeoutMs: 30_000,\n              requiresApproval: false,\n              source: \"mcp\",\n            },\n            (args) =>\n              mcpClient.callTool(server.name, toolName, args).pipe(\n                Effect.mapError(\n                  (e) =>\n                    new ToolExecutionError({\n                      message: `MCP tool ${toolName} failed`,\n                      toolName,\n                      cause: e,\n                    }),\n                ),\n              ),\n          );\n        }\n\n        yield* eventBus.publish({\n          _tag: \"Custom\",\n          type: \"tools.mcp-connected\",\n          payload: { serverName: server.name, tools: server.tools },\n        });\n\n        return server;\n      });\n\n    const disconnectMCPServer = (\n      serverName: string,\n    ): Effect.Effect<void, MCPConnectionError> =>\n      Effect.gen(function* () {\n        yield* mcpClient.disconnect(serverName);\n        yield* eventBus.publish({\n          _tag: \"Custom\",\n          type: \"tools.mcp-disconnected\",\n          payload: { serverName },\n        });\n      });\n\n    const listTools = (filter?: {\n      category?: string;\n      source?: string;\n      riskLevel?: string;\n    }): Effect.Effect<readonly ToolDefinition[], never> =>\n      registry.list(filter);\n\n    const getTool = (\n      name: string,\n    ): Effect.Effect<ToolDefinition, ToolNotFoundError> =>\n      registry.get(name).pipe(Effect.map((t) => t.definition));\n\n    const toFunctionCallingFormat = (): Effect.Effect<\n      readonly FunctionCallingTool[],\n      never\n    > => registry.toFunctionCallingFormat();\n\n    const listMCPServers = (): Effect.Effect<readonly MCPServer[], never> =>\n      mcpClient.listServers();\n\n    return {\n      execute,\n      register,\n      connectMCPServer,\n      disconnectMCPServer,\n      listTools,\n      getTool,\n      toFunctionCallingFormat,\n      listMCPServers,\n    };\n  }),\n);\n","import { Effect, Ref } from \"effect\";\n\nimport type { ToolDefinition, FunctionCallingTool } from \"../types.js\";\nimport { ToolNotFoundError, ToolExecutionError } from \"../errors.js\";\n\nexport interface RegisteredTool {\n  readonly definition: ToolDefinition;\n  readonly handler: (\n    args: Record<string, unknown>,\n  ) => Effect.Effect<unknown, ToolExecutionError>;\n}\n\nexport const makeToolRegistry = Effect.gen(function* () {\n  const toolsRef = yield* Ref.make<Map<string, RegisteredTool>>(new Map());\n\n  const register = (\n    definition: ToolDefinition,\n    handler: (\n      args: Record<string, unknown>,\n    ) => Effect.Effect<unknown, ToolExecutionError>,\n  ): Effect.Effect<void, never> =>\n    Ref.update(toolsRef, (tools) => {\n      const newTools = new Map(tools);\n      newTools.set(definition.name, { definition, handler });\n      return newTools;\n    });\n\n  const get = (\n    name: string,\n  ): Effect.Effect<RegisteredTool, ToolNotFoundError> =>\n    Effect.gen(function* () {\n      const tools = yield* Ref.get(toolsRef);\n      const tool = tools.get(name);\n      if (!tool) {\n        const available = [...tools.keys()];\n        return yield* Effect.fail(\n          new ToolNotFoundError({\n            message: `Tool \"${name}\" not found`,\n            toolName: name,\n            availableTools: available,\n          }),\n        );\n      }\n      return tool;\n    });\n\n  const list = (filter?: {\n    category?: string;\n    source?: string;\n    riskLevel?: string;\n  }): Effect.Effect<readonly ToolDefinition[], never> =>\n    Effect.gen(function* () {\n      const tools = yield* Ref.get(toolsRef);\n      let definitions = [...tools.values()].map((t) => t.definition);\n\n      if (filter?.category)\n        definitions = definitions.filter((d) => d.category === filter.category);\n      if (filter?.source)\n        definitions = definitions.filter((d) => d.source === filter.source);\n      if (filter?.riskLevel)\n        definitions = definitions.filter(\n          (d) => d.riskLevel === filter.riskLevel,\n        );\n\n      return definitions;\n    });\n\n  const toFunctionCallingFormat = (): Effect.Effect<\n    readonly FunctionCallingTool[],\n    never\n  > =>\n    Effect.gen(function* () {\n      const tools = yield* Ref.get(toolsRef);\n      return [...tools.values()].map((t) => ({\n        name: t.definition.name,\n        description: t.definition.description,\n        input_schema: {\n          type: \"object\" as unknown,\n          properties: Object.fromEntries(\n            t.definition.parameters.map((p) => [\n              p.name,\n              {\n                type: p.type,\n                description: p.description,\n                ...(p.enum ? { enum: p.enum } : {}),\n              },\n            ]),\n          ) as Record<string, unknown>,\n          required: t.definition.parameters\n            .filter((p) => p.required)\n            .map((p) => p.name),\n        } as Record<string, unknown>,\n      }));\n    });\n\n  return { register, get, list, toFunctionCallingFormat };\n});\n","import { Effect, Ref } from \"effect\";\n\nimport type { MCPServer, MCPRequest, MCPResponse } from \"../types.js\";\nimport { MCPConnectionError, ToolExecutionError } from \"../errors.js\";\n\n// ─── Transport Creation (stub - real implementation varies by transport) ───\n\nconst createTransport = (\n  _config: Pick<\n    MCPServer,\n    \"name\" | \"transport\" | \"endpoint\" | \"command\" | \"args\"\n  >,\n): Effect.Effect<void, unknown> => Effect.void;\n\n// ─── JSON-RPC request sender (stub) ───\n\nconst sendRequest = (\n  _config: Pick<MCPServer, \"name\" | \"transport\" | \"endpoint\" | \"command\">,\n  request: MCPRequest,\n): Effect.Effect<MCPResponse, MCPConnectionError> =>\n  Effect.succeed({\n    jsonrpc: \"2.0\" as const,\n    id: request.id,\n    result: {},\n  });\n\nexport const makeMCPClient = Effect.gen(function* () {\n  const serversRef = yield* Ref.make<Map<string, MCPServer>>(new Map());\n  const requestIdRef = yield* Ref.make(0);\n\n  const nextRequestId = Ref.updateAndGet(requestIdRef, (id) => id + 1);\n\n  const connect = (\n    config: Pick<\n      MCPServer,\n      \"name\" | \"transport\" | \"endpoint\" | \"command\" | \"args\"\n    >,\n  ): Effect.Effect<MCPServer, MCPConnectionError> =>\n    Effect.gen(function* () {\n      // Step 1: Establish connection based on transport\n      yield* createTransport(config).pipe(\n        Effect.mapError(\n          (e) =>\n            new MCPConnectionError({\n              message: `Failed to connect to MCP server \"${config.name}\"`,\n              serverName: config.name,\n              transport: config.transport,\n              cause: e,\n            }),\n        ),\n      );\n\n      // Step 2: Initialize protocol (send initialize request)\n      const reqId1 = yield* nextRequestId;\n      const initResponse = yield* sendRequest(config, {\n        jsonrpc: \"2.0\",\n        id: reqId1,\n        method: \"initialize\",\n        params: {\n          protocolVersion: \"2024-11-05\",\n          capabilities: { tools: {} },\n          clientInfo: { name: \"reactive-agents\", version: \"1.0.0\" },\n        },\n      });\n\n      // Step 3: Discover available tools\n      const reqId2 = yield* nextRequestId;\n      const toolsResponse = yield* sendRequest(config, {\n        jsonrpc: \"2.0\",\n        id: reqId2,\n        method: \"tools/list\",\n      });\n\n      const toolNames = Array.isArray(toolsResponse.result)\n        ? toolsResponse.result.map(\n            (t: Record<string, unknown>) => t.name as string,\n          )\n        : [];\n\n      const server: MCPServer = {\n        name: config.name,\n        version:\n          (initResponse.result as Record<string, unknown>)?.serverInfo !=\n          null\n            ? String(\n                (\n                  (initResponse.result as Record<string, unknown>)\n                    .serverInfo as Record<string, unknown>\n                )?.version,\n              )\n            : \"unknown\",\n        transport: config.transport,\n        endpoint: config.endpoint,\n        command: config.command,\n        args: config.args,\n        tools: toolNames,\n        status: \"connected\",\n      };\n\n      yield* Ref.update(serversRef, (servers) => {\n        const newServers = new Map(servers);\n        newServers.set(server.name, server);\n        return newServers;\n      });\n\n      return server;\n    });\n\n  const callTool = (\n    serverName: string,\n    toolName: string,\n    args: Record<string, unknown>,\n  ): Effect.Effect<unknown, MCPConnectionError | ToolExecutionError> =>\n    Effect.gen(function* () {\n      const servers = yield* Ref.get(serversRef);\n      const server = servers.get(serverName);\n\n      if (!server || server.status !== \"connected\") {\n        return yield* Effect.fail(\n          new MCPConnectionError({\n            message: `MCP server \"${serverName}\" not connected`,\n            serverName,\n            transport: server?.transport ?? \"unknown\",\n          }),\n        );\n      }\n\n      const reqId = yield* nextRequestId;\n      const response = yield* sendRequest(\n        {\n          name: serverName,\n          transport: server.transport,\n          endpoint: server.endpoint,\n          command: server.command,\n        },\n        {\n          jsonrpc: \"2.0\",\n          id: reqId,\n          method: \"tools/call\",\n          params: { name: toolName, arguments: args },\n        },\n      );\n\n      if (response.error) {\n        return yield* Effect.fail(\n          new ToolExecutionError({\n            message: `MCP tool \"${toolName}\" failed: ${response.error.message}`,\n            toolName,\n            input: args,\n          }),\n        );\n      }\n\n      return response.result;\n    });\n\n  const disconnect = (\n    serverName: string,\n  ): Effect.Effect<void, MCPConnectionError> =>\n    Ref.update(serversRef, (servers) => {\n      const newServers = new Map(servers);\n      const server = newServers.get(serverName);\n      if (server) {\n        newServers.set(serverName, { ...server, status: \"disconnected\" });\n      }\n      return newServers;\n    });\n\n  const listServers = (): Effect.Effect<readonly MCPServer[], never> =>\n    Effect.gen(function* () {\n      const servers = yield* Ref.get(serversRef);\n      return [...servers.values()];\n    });\n\n  return { connect, callTool, disconnect, listServers };\n});\n","import { Duration, Effect } from \"effect\";\n\nimport { ToolExecutionError, ToolTimeoutError } from \"../errors.js\";\n\nexport const makeSandbox = () => {\n  const execute = <A>(\n    fn: () => Effect.Effect<A, ToolExecutionError>,\n    options: { timeoutMs: number; toolName?: string },\n  ): Effect.Effect<A, ToolExecutionError | ToolTimeoutError> =>\n    fn().pipe(\n      // Enforce timeout\n      Effect.timeoutFail({\n        duration: Duration.millis(options.timeoutMs),\n        onTimeout: () =>\n          new ToolTimeoutError({\n            message: `Tool execution timed out after ${options.timeoutMs}ms`,\n            toolName: options.toolName ?? \"unknown\",\n            timeoutMs: options.timeoutMs,\n          }),\n      }),\n      // Catch unexpected errors\n      Effect.catchAllDefect((defect) =>\n        Effect.fail(\n          new ToolExecutionError({\n            message: `Tool crashed: ${String(defect)}`,\n            toolName: options.toolName ?? \"unknown\",\n            cause: defect,\n          }),\n        ),\n      ),\n    );\n\n  return { execute };\n};\n","import { Effect } from \"effect\";\n\nimport type { ToolDefinition } from \"../types.js\";\nimport { ToolValidationError } from \"../errors.js\";\n\nexport const validateToolInput = (\n  definition: ToolDefinition,\n  args: Record<string, unknown>,\n): Effect.Effect<Record<string, unknown>, ToolValidationError> =>\n  Effect.gen(function* () {\n    const validated: Record<string, unknown> = {};\n\n    for (const param of definition.parameters) {\n      const value = args[param.name];\n\n      // Check required\n      if (param.required && (value === undefined || value === null)) {\n        return yield* Effect.fail(\n          new ToolValidationError({\n            message: `Missing required parameter \"${param.name}\"`,\n            toolName: definition.name,\n            parameter: param.name,\n            expected: param.type,\n            received: \"undefined\",\n          }),\n        );\n      }\n\n      if (value === undefined) {\n        if (param.default !== undefined) {\n          validated[param.name] = param.default;\n        }\n        continue;\n      }\n\n      // Type check\n      const actualType = Array.isArray(value) ? \"array\" : typeof value;\n      if (\n        actualType !== param.type &&\n        !(param.type === \"object\" && actualType === \"object\")\n      ) {\n        return yield* Effect.fail(\n          new ToolValidationError({\n            message: `Parameter \"${param.name}\" expected ${param.type}, got ${actualType}`,\n            toolName: definition.name,\n            parameter: param.name,\n            expected: param.type,\n            received: actualType,\n          }),\n        );\n      }\n\n      // Enum check\n      if (\n        param.enum &&\n        typeof value === \"string\" &&\n        !param.enum.includes(value)\n      ) {\n        return yield* Effect.fail(\n          new ToolValidationError({\n            message: `Parameter \"${param.name}\" must be one of: ${param.enum.join(\", \")}`,\n            toolName: definition.name,\n            parameter: param.name,\n            expected: param.enum.join(\" | \"),\n            received: String(value),\n          }),\n        );\n      }\n\n      validated[param.name] = value;\n    }\n\n    return validated;\n  });\n","import { Effect } from \"effect\";\n\nimport type { ToolDefinition, FunctionCallingTool } from \"../types.js\";\nimport { ToolExecutionError } from \"../errors.js\";\n\n/**\n * Adapt a native function into a ToolDefinition + handler pair\n * suitable for registration in the ToolRegistry.\n */\nexport const adaptFunction = (opts: {\n  readonly name: string;\n  readonly description: string;\n  readonly parameters: ToolDefinition[\"parameters\"];\n  readonly category?: ToolDefinition[\"category\"];\n  readonly riskLevel?: ToolDefinition[\"riskLevel\"];\n  readonly timeoutMs?: number;\n  readonly fn: (\n    args: Record<string, unknown>,\n  ) => Effect.Effect<unknown, ToolExecutionError>;\n}): {\n  definition: ToolDefinition;\n  handler: (\n    args: Record<string, unknown>,\n  ) => Effect.Effect<unknown, ToolExecutionError>;\n} => ({\n  definition: {\n    name: opts.name,\n    description: opts.description,\n    parameters: opts.parameters,\n    category: opts.category,\n    riskLevel: opts.riskLevel ?? \"low\",\n    timeoutMs: opts.timeoutMs ?? 30_000,\n    requiresApproval: false,\n    source: \"function\" as const,\n  },\n  handler: opts.fn,\n});\n\n/**\n * Convert a ToolDefinition to the Anthropic/OpenAI function calling format.\n */\nexport const toFunctionCallingTool = (\n  definition: ToolDefinition,\n): FunctionCallingTool => ({\n  name: definition.name,\n  description: definition.description,\n  input_schema: {\n    type: \"object\" as unknown,\n    properties: Object.fromEntries(\n      definition.parameters.map((p) => [\n        p.name,\n        {\n          type: p.type,\n          description: p.description,\n          ...(p.enum ? { enum: p.enum } : {}),\n        },\n      ]),\n    ) as Record<string, unknown>,\n    required: definition.parameters\n      .filter((p) => p.required)\n      .map((p) => p.name),\n  } as Record<string, unknown>,\n});\n","import { Effect } from \"effect\";\n\nimport type { ToolDefinition } from \"../types.js\";\nimport { ToolExecutionError } from \"../errors.js\";\n\nexport const webSearchTool: ToolDefinition = {\n  name: \"web-search\",\n  description: \"Search the web for information using a query string\",\n  parameters: [\n    {\n      name: \"query\",\n      type: \"string\",\n      description: \"Search query\",\n      required: true,\n    },\n    {\n      name: \"maxResults\",\n      type: \"number\",\n      description: \"Max results to return\",\n      required: false,\n      default: 5,\n    },\n  ],\n  category: \"search\",\n  riskLevel: \"low\",\n  timeoutMs: 10_000,\n  requiresApproval: false,\n  source: \"builtin\",\n};\n\nexport const webSearchHandler = (\n  args: Record<string, unknown>,\n): Effect.Effect<unknown, ToolExecutionError> =>\n  Effect.tryPromise({\n    try: async () => {\n      const query = args.query as string;\n      const maxResults = (args.maxResults as number) ?? 5;\n\n      // In production: call search API (Tavily, SerpAPI, etc.)\n      // Stub implementation for Phase 1\n      return {\n        query,\n        maxResults,\n        results: [],\n        message: \"Web search stub - configure TAVILY_API_KEY for real results\",\n      };\n    },\n    catch: (e) =>\n      new ToolExecutionError({\n        message: `Web search failed: ${e}`,\n        toolName: \"web-search\",\n        cause: e,\n      }),\n  });\n","import { Effect } from \"effect\";\nimport * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\n\nimport type { ToolDefinition } from \"../types.js\";\nimport { ToolExecutionError } from \"../errors.js\";\n\nexport const fileReadTool: ToolDefinition = {\n  name: \"file-read\",\n  description: \"Read the contents of a file\",\n  parameters: [\n    {\n      name: \"path\",\n      type: \"string\",\n      description: \"File path to read\",\n      required: true,\n    },\n    {\n      name: \"encoding\",\n      type: \"string\",\n      description: \"File encoding\",\n      required: false,\n      default: \"utf-8\",\n    },\n  ],\n  category: \"file\",\n  riskLevel: \"medium\",\n  timeoutMs: 5_000,\n  requiresApproval: false,\n  source: \"builtin\",\n};\n\nexport const fileReadHandler = (\n  args: Record<string, unknown>,\n): Effect.Effect<unknown, ToolExecutionError> =>\n  Effect.tryPromise({\n    try: async () => {\n      const filePath = args.path as string;\n      const encoding = (args.encoding as BufferEncoding) ?? \"utf-8\";\n\n      // Security: resolve path and check it's within allowed directory\n      const resolved = path.resolve(filePath);\n      const allowedBase = process.cwd();\n      if (!resolved.startsWith(allowedBase)) {\n        throw new Error(`Path traversal detected: ${filePath}`);\n      }\n\n      return await fs.readFile(resolved, { encoding });\n    },\n    catch: (e) =>\n      new ToolExecutionError({\n        message: `File read failed: ${e}`,\n        toolName: \"file-read\",\n        cause: e,\n      }),\n  });\n\nexport const fileWriteTool: ToolDefinition = {\n  name: \"file-write\",\n  description: \"Write contents to a file\",\n  parameters: [\n    {\n      name: \"path\",\n      type: \"string\",\n      description: \"File path to write\",\n      required: true,\n    },\n    {\n      name: \"content\",\n      type: \"string\",\n      description: \"Content to write\",\n      required: true,\n    },\n    {\n      name: \"encoding\",\n      type: \"string\",\n      description: \"File encoding\",\n      required: false,\n      default: \"utf-8\",\n    },\n  ],\n  category: \"file\",\n  riskLevel: \"high\",\n  timeoutMs: 5_000,\n  requiresApproval: true,\n  source: \"builtin\",\n};\n\nexport const fileWriteHandler = (\n  args: Record<string, unknown>,\n): Effect.Effect<unknown, ToolExecutionError> =>\n  Effect.tryPromise({\n    try: async () => {\n      const filePath = args.path as string;\n      const content = args.content as string;\n      const encoding = (args.encoding as BufferEncoding) ?? \"utf-8\";\n\n      const resolved = path.resolve(filePath);\n      const allowedBase = process.cwd();\n      if (!resolved.startsWith(allowedBase)) {\n        throw new Error(`Path traversal detected: ${filePath}`);\n      }\n\n      await fs.writeFile(resolved, content, { encoding });\n      return { written: true, path: resolved };\n    },\n    catch: (e) =>\n      new ToolExecutionError({\n        message: `File write failed: ${e}`,\n        toolName: \"file-write\",\n        cause: e,\n      }),\n  });\n","import { Effect } from \"effect\";\n\nimport type { ToolDefinition } from \"../types.js\";\nimport { ToolExecutionError } from \"../errors.js\";\n\nexport const httpGetTool: ToolDefinition = {\n  name: \"http-get\",\n  description: \"Make an HTTP GET request to a URL\",\n  parameters: [\n    {\n      name: \"url\",\n      type: \"string\",\n      description: \"URL to fetch\",\n      required: true,\n    },\n    {\n      name: \"headers\",\n      type: \"object\",\n      description: \"Optional request headers\",\n      required: false,\n    },\n  ],\n  category: \"http\",\n  riskLevel: \"medium\",\n  timeoutMs: 15_000,\n  requiresApproval: false,\n  source: \"builtin\",\n};\n\nexport const httpGetHandler = (\n  args: Record<string, unknown>,\n): Effect.Effect<unknown, ToolExecutionError> =>\n  Effect.tryPromise({\n    try: async () => {\n      const url = args.url as string;\n      const headers = (args.headers as Record<string, string>) ?? {};\n\n      const response = await fetch(url, { method: \"GET\", headers });\n      const contentType = response.headers.get(\"content-type\") ?? \"\";\n\n      let body: unknown;\n      if (contentType.includes(\"application/json\")) {\n        body = await response.json();\n      } else {\n        body = await response.text();\n      }\n\n      return {\n        status: response.status,\n        statusText: response.statusText,\n        headers: Object.fromEntries(response.headers.entries()),\n        body,\n      };\n    },\n    catch: (e) =>\n      new ToolExecutionError({\n        message: `HTTP GET failed: ${e}`,\n        toolName: \"http-get\",\n        cause: e,\n      }),\n  });\n","import { Effect } from \"effect\";\n\nimport type { ToolDefinition } from \"../types.js\";\nimport { ToolExecutionError } from \"../errors.js\";\n\nexport const codeExecuteTool: ToolDefinition = {\n  name: \"code-execute\",\n  description: \"Execute a JavaScript/TypeScript code snippet in a sandboxed environment\",\n  parameters: [\n    {\n      name: \"code\",\n      type: \"string\",\n      description: \"Code to execute\",\n      required: true,\n    },\n    {\n      name: \"language\",\n      type: \"string\",\n      description: \"Programming language\",\n      required: false,\n      default: \"javascript\",\n      enum: [\"javascript\", \"typescript\"],\n    },\n  ],\n  category: \"code\",\n  riskLevel: \"critical\",\n  timeoutMs: 30_000,\n  requiresApproval: true,\n  source: \"builtin\",\n};\n\nexport const codeExecuteHandler = (\n  args: Record<string, unknown>,\n): Effect.Effect<unknown, ToolExecutionError> =>\n  Effect.try({\n    try: () => {\n      const code = args.code as string;\n      // Phase 1: Simple eval-based execution (stub)\n      // In production: use isolated-vm or Worker threads\n      // For safety, we only return a stub response\n      return {\n        code,\n        executed: false,\n        message:\n          \"Code execution stub - production implementation requires sandboxed runtime\",\n      };\n    },\n    catch: (e) =>\n      new ToolExecutionError({\n        message: `Code execution failed: ${e}`,\n        toolName: \"code-execute\",\n        cause: e,\n      }),\n  });\n","import { Layer } from \"effect\";\n\nimport { EventBusLive } from \"@reactive-agents/core\";\nimport { ToolServiceLive } from \"./tool-service.js\";\n\n/**\n * Creates the full Tools layer with all dependencies wired.\n * Requires EventBus to be provided (or uses EventBusLive by default).\n */\nexport const createToolsLayer = () =>\n  ToolServiceLive.pipe(Layer.provide(EventBusLive));\n\n/**\n * ToolServiceLive layer that requires EventBus to be provided externally.\n * Use this when composing with a shared EventBus from the runtime.\n */\nexport const ToolsLayer = ToolServiceLive;\n"],"mappings":";AAAA,SAAS,cAAc;AAIhB,IAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C,MAAM,OAAO;AAAA,EACb,MAAM,OAAO,QAAQ,UAAU,UAAU,WAAW,UAAU,OAAO;AAAA,EACrE,aAAa,OAAO;AAAA,EACpB,UAAU,OAAO;AAAA,EACjB,SAAS,OAAO,SAAS,OAAO,OAAO;AAAA,EACvC,MAAM,OAAO,SAAS,OAAO,MAAM,OAAO,MAAM,CAAC;AACnD,CAAC;AAGM,IAAM,uBAAuB,OAAO,OAAO;AAAA,EAChD,MAAM,OAAO;AAAA,EACb,aAAa,OAAO;AAAA,EACpB,YAAY,OAAO,MAAM,mBAAmB;AAAA,EAC5C,YAAY,OAAO,SAAS,OAAO,MAAM;AAAA,EACzC,UAAU,OAAO;AAAA,IACf,OAAO,QAAQ,UAAU,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ;AAAA,EACnE;AAAA,EACA,WAAW,OAAO,QAAQ,OAAO,UAAU,QAAQ,UAAU;AAAA,EAC7D,WAAW,OAAO;AAAA,EAClB,kBAAkB,OAAO;AAAA,EACzB,QAAQ,OAAO,QAAQ,WAAW,OAAO,YAAY,QAAQ;AAC/D,CAAC;AAKM,IAAM,kBAAkB,OAAO,OAAO;AAAA,EAC3C,UAAU,OAAO;AAAA,EACjB,WAAW,OAAO,OAAO,EAAE,KAAK,OAAO,QAAQ,OAAO,OAAO,QAAQ,CAAC;AAAA,EACtE,SAAS,OAAO;AAAA,EAChB,WAAW,OAAO;AAAA,EAClB,eAAe,OAAO,SAAS,OAAO,MAAM;AAC9C,CAAC;AAGM,IAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,UAAU,OAAO;AAAA,EACjB,SAAS,OAAO;AAAA,EAChB,QAAQ,OAAO;AAAA,EACf,OAAO,OAAO,SAAS,OAAO,MAAM;AAAA,EACpC,iBAAiB,OAAO;AAAA,EACxB,UAAU,OAAO;AAAA,IACf,OAAO,OAAO,EAAE,KAAK,OAAO,QAAQ,OAAO,OAAO,QAAQ,CAAC;AAAA,EAC7D;AACF,CAAC;AAKM,IAAM,kBAAkB,OAAO,OAAO;AAAA,EAC3C,MAAM,OAAO;AAAA,EACb,SAAS,OAAO;AAAA,EAChB,WAAW,OAAO,QAAQ,SAAS,OAAO,WAAW;AAAA,EACrD,UAAU,OAAO,SAAS,OAAO,MAAM;AAAA,EACvC,SAAS,OAAO,SAAS,OAAO,MAAM;AAAA,EACtC,MAAM,OAAO,SAAS,OAAO,MAAM,OAAO,MAAM,CAAC;AAAA,EACjD,OAAO,OAAO,MAAM,OAAO,MAAM;AAAA,EACjC,QAAQ,OAAO,QAAQ,aAAa,gBAAgB,OAAO;AAC7D,CAAC;AAGM,IAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,SAAS,OAAO,QAAQ,KAAK;AAAA,EAC7B,IAAI,OAAO,MAAM,OAAO,QAAQ,OAAO,MAAM;AAAA,EAC7C,QAAQ,OAAO;AAAA,EACf,QAAQ,OAAO,SAAS,OAAO,OAAO;AACxC,CAAC;AAGM,IAAM,oBAAoB,OAAO,OAAO;AAAA,EAC7C,SAAS,OAAO,QAAQ,KAAK;AAAA,EAC7B,IAAI,OAAO,MAAM,OAAO,QAAQ,OAAO,MAAM;AAAA,EAC7C,QAAQ,OAAO,SAAS,OAAO,OAAO;AAAA,EACtC,OAAO,OAAO;AAAA,IACZ,OAAO,OAAO;AAAA,MACZ,MAAM,OAAO;AAAA,MACb,SAAS,OAAO;AAAA,MAChB,MAAM,OAAO,SAAS,OAAO,OAAO;AAAA,IACtC,CAAC;AAAA,EACH;AACF,CAAC;AAKM,IAAM,4BAA4B,OAAO,OAAO;AAAA,EACrD,MAAM,OAAO;AAAA,EACb,aAAa,OAAO;AAAA,EACpB,cAAc,OAAO,OAAO,EAAE,KAAK,OAAO,QAAQ,OAAO,OAAO,QAAQ,CAAC;AAC3E,CAAC;;;AC9FD,SAAS,YAAY;AAEd,IAAM,oBAAN,cAAgC,KAAK,YAAY,mBAAmB,EAIxE;AAAC;AAEG,IAAM,qBAAN,cAAiC,KAAK;AAAA,EAC3C;AACF,EAKG;AAAC;AAEG,IAAM,mBAAN,cAA+B,KAAK,YAAY,kBAAkB,EAItE;AAAC;AAEG,IAAM,sBAAN,cAAkC,KAAK;AAAA,EAC5C;AACF,EAMG;AAAC;AAEG,IAAM,qBAAN,cAAiC,KAAK;AAAA,EAC3C;AACF,EAKG;AAAC;AAEG,IAAM,yBAAN,cAAqC,KAAK;AAAA,EAC/C;AACF,EAIG;AAAC;;;AChDJ,SAAS,UAAAA,SAAQ,SAAS,aAAa;;;ACAvC,SAAS,QAAQ,WAAW;AAYrB,IAAM,mBAAmB,OAAO,IAAI,aAAa;AACtD,QAAM,WAAW,OAAO,IAAI,KAAkC,oBAAI,IAAI,CAAC;AAEvE,QAAM,WAAW,CACf,YACA,YAIA,IAAI,OAAO,UAAU,CAAC,UAAU;AAC9B,UAAM,WAAW,IAAI,IAAI,KAAK;AAC9B,aAAS,IAAI,WAAW,MAAM,EAAE,YAAY,QAAQ,CAAC;AACrD,WAAO;AAAA,EACT,CAAC;AAEH,QAAM,MAAM,CACV,SAEA,OAAO,IAAI,aAAa;AACtB,UAAM,QAAQ,OAAO,IAAI,IAAI,QAAQ;AACrC,UAAM,OAAO,MAAM,IAAI,IAAI;AAC3B,QAAI,CAAC,MAAM;AACT,YAAM,YAAY,CAAC,GAAG,MAAM,KAAK,CAAC;AAClC,aAAO,OAAO,OAAO;AAAA,QACnB,IAAI,kBAAkB;AAAA,UACpB,SAAS,SAAS,IAAI;AAAA,UACtB,UAAU;AAAA,UACV,gBAAgB;AAAA,QAClB,CAAC;AAAA,MACH;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AAEH,QAAM,OAAO,CAAC,WAKZ,OAAO,IAAI,aAAa;AACtB,UAAM,QAAQ,OAAO,IAAI,IAAI,QAAQ;AACrC,QAAI,cAAc,CAAC,GAAG,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,UAAU;AAE7D,QAAI,QAAQ;AACV,oBAAc,YAAY,OAAO,CAAC,MAAM,EAAE,aAAa,OAAO,QAAQ;AACxE,QAAI,QAAQ;AACV,oBAAc,YAAY,OAAO,CAAC,MAAM,EAAE,WAAW,OAAO,MAAM;AACpE,QAAI,QAAQ;AACV,oBAAc,YAAY;AAAA,QACxB,CAAC,MAAM,EAAE,cAAc,OAAO;AAAA,MAChC;AAEF,WAAO;AAAA,EACT,CAAC;AAEH,QAAM,0BAA0B,MAI9B,OAAO,IAAI,aAAa;AACtB,UAAM,QAAQ,OAAO,IAAI,IAAI,QAAQ;AACrC,WAAO,CAAC,GAAG,MAAM,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO;AAAA,MACrC,MAAM,EAAE,WAAW;AAAA,MACnB,aAAa,EAAE,WAAW;AAAA,MAC1B,cAAc;AAAA,QACZ,MAAM;AAAA,QACN,YAAY,OAAO;AAAA,UACjB,EAAE,WAAW,WAAW,IAAI,CAAC,MAAM;AAAA,YACjC,EAAE;AAAA,YACF;AAAA,cACE,MAAM,EAAE;AAAA,cACR,aAAa,EAAE;AAAA,cACf,GAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,YACnC;AAAA,UACF,CAAC;AAAA,QACH;AAAA,QACA,UAAU,EAAE,WAAW,WACpB,OAAO,CAAC,MAAM,EAAE,QAAQ,EACxB,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,MACtB;AAAA,IACF,EAAE;AAAA,EACJ,CAAC;AAEH,SAAO,EAAE,UAAU,KAAK,MAAM,wBAAwB;AACxD,CAAC;;;AChGD,SAAS,UAAAC,SAAQ,OAAAC,YAAW;AAO5B,IAAM,kBAAkB,CACtB,YAIiCC,QAAO;AAI1C,IAAM,cAAc,CAClB,SACA,YAEAA,QAAO,QAAQ;AAAA,EACb,SAAS;AAAA,EACT,IAAI,QAAQ;AAAA,EACZ,QAAQ,CAAC;AACX,CAAC;AAEI,IAAM,gBAAgBA,QAAO,IAAI,aAAa;AACnD,QAAM,aAAa,OAAOC,KAAI,KAA6B,oBAAI,IAAI,CAAC;AACpE,QAAM,eAAe,OAAOA,KAAI,KAAK,CAAC;AAEtC,QAAM,gBAAgBA,KAAI,aAAa,cAAc,CAAC,OAAO,KAAK,CAAC;AAEnE,QAAM,UAAU,CACd,WAKAD,QAAO,IAAI,aAAa;AAEtB,WAAO,gBAAgB,MAAM,EAAE;AAAA,MAC7BA,QAAO;AAAA,QACL,CAAC,MACC,IAAI,mBAAmB;AAAA,UACrB,SAAS,oCAAoC,OAAO,IAAI;AAAA,UACxD,YAAY,OAAO;AAAA,UACnB,WAAW,OAAO;AAAA,UAClB,OAAO;AAAA,QACT,CAAC;AAAA,MACL;AAAA,IACF;AAGA,UAAM,SAAS,OAAO;AACtB,UAAM,eAAe,OAAO,YAAY,QAAQ;AAAA,MAC9C,SAAS;AAAA,MACT,IAAI;AAAA,MACJ,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,iBAAiB;AAAA,QACjB,cAAc,EAAE,OAAO,CAAC,EAAE;AAAA,QAC1B,YAAY,EAAE,MAAM,mBAAmB,SAAS,QAAQ;AAAA,MAC1D;AAAA,IACF,CAAC;AAGD,UAAM,SAAS,OAAO;AACtB,UAAM,gBAAgB,OAAO,YAAY,QAAQ;AAAA,MAC/C,SAAS;AAAA,MACT,IAAI;AAAA,MACJ,QAAQ;AAAA,IACV,CAAC;AAED,UAAM,YAAY,MAAM,QAAQ,cAAc,MAAM,IAChD,cAAc,OAAO;AAAA,MACnB,CAAC,MAA+B,EAAE;AAAA,IACpC,IACA,CAAC;AAEL,UAAM,SAAoB;AAAA,MACxB,MAAM,OAAO;AAAA,MACb,SACG,aAAa,QAAoC,cAClD,OACI;AAAA,QAEK,aAAa,OACX,YACF;AAAA,MACL,IACA;AAAA,MACN,WAAW,OAAO;AAAA,MAClB,UAAU,OAAO;AAAA,MACjB,SAAS,OAAO;AAAA,MAChB,MAAM,OAAO;AAAA,MACb,OAAO;AAAA,MACP,QAAQ;AAAA,IACV;AAEA,WAAOC,KAAI,OAAO,YAAY,CAAC,YAAY;AACzC,YAAM,aAAa,IAAI,IAAI,OAAO;AAClC,iBAAW,IAAI,OAAO,MAAM,MAAM;AAClC,aAAO;AAAA,IACT,CAAC;AAED,WAAO;AAAA,EACT,CAAC;AAEH,QAAM,WAAW,CACf,YACA,UACA,SAEAD,QAAO,IAAI,aAAa;AACtB,UAAM,UAAU,OAAOC,KAAI,IAAI,UAAU;AACzC,UAAM,SAAS,QAAQ,IAAI,UAAU;AAErC,QAAI,CAAC,UAAU,OAAO,WAAW,aAAa;AAC5C,aAAO,OAAOD,QAAO;AAAA,QACnB,IAAI,mBAAmB;AAAA,UACrB,SAAS,eAAe,UAAU;AAAA,UAClC;AAAA,UACA,WAAW,QAAQ,aAAa;AAAA,QAClC,CAAC;AAAA,MACH;AAAA,IACF;AAEA,UAAM,QAAQ,OAAO;AACrB,UAAM,WAAW,OAAO;AAAA,MACtB;AAAA,QACE,MAAM;AAAA,QACN,WAAW,OAAO;AAAA,QAClB,UAAU,OAAO;AAAA,QACjB,SAAS,OAAO;AAAA,MAClB;AAAA,MACA;AAAA,QACE,SAAS;AAAA,QACT,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,QAAQ,EAAE,MAAM,UAAU,WAAW,KAAK;AAAA,MAC5C;AAAA,IACF;AAEA,QAAI,SAAS,OAAO;AAClB,aAAO,OAAOA,QAAO;AAAA,QACnB,IAAI,mBAAmB;AAAA,UACrB,SAAS,aAAa,QAAQ,aAAa,SAAS,MAAM,OAAO;AAAA,UACjE;AAAA,UACA,OAAO;AAAA,QACT,CAAC;AAAA,MACH;AAAA,IACF;AAEA,WAAO,SAAS;AAAA,EAClB,CAAC;AAEH,QAAM,aAAa,CACjB,eAEAC,KAAI,OAAO,YAAY,CAAC,YAAY;AAClC,UAAM,aAAa,IAAI,IAAI,OAAO;AAClC,UAAM,SAAS,WAAW,IAAI,UAAU;AACxC,QAAI,QAAQ;AACV,iBAAW,IAAI,YAAY,EAAE,GAAG,QAAQ,QAAQ,eAAe,CAAC;AAAA,IAClE;AACA,WAAO;AAAA,EACT,CAAC;AAEH,QAAM,cAAc,MAClBD,QAAO,IAAI,aAAa;AACtB,UAAM,UAAU,OAAOC,KAAI,IAAI,UAAU;AACzC,WAAO,CAAC,GAAG,QAAQ,OAAO,CAAC;AAAA,EAC7B,CAAC;AAEH,SAAO,EAAE,SAAS,UAAU,YAAY,YAAY;AACtD,CAAC;;;AC/KD,SAAS,UAAU,UAAAC,eAAc;AAI1B,IAAM,cAAc,MAAM;AAC/B,QAAM,UAAU,CACd,IACA,YAEA,GAAG,EAAE;AAAA;AAAA,IAEHC,QAAO,YAAY;AAAA,MACjB,UAAU,SAAS,OAAO,QAAQ,SAAS;AAAA,MAC3C,WAAW,MACT,IAAI,iBAAiB;AAAA,QACnB,SAAS,kCAAkC,QAAQ,SAAS;AAAA,QAC5D,UAAU,QAAQ,YAAY;AAAA,QAC9B,WAAW,QAAQ;AAAA,MACrB,CAAC;AAAA,IACL,CAAC;AAAA;AAAA,IAEDA,QAAO;AAAA,MAAe,CAAC,WACrBA,QAAO;AAAA,QACL,IAAI,mBAAmB;AAAA,UACrB,SAAS,iBAAiB,OAAO,MAAM,CAAC;AAAA,UACxC,UAAU,QAAQ,YAAY;AAAA,UAC9B,OAAO;AAAA,QACT,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEF,SAAO,EAAE,QAAQ;AACnB;;;ACjCA,SAAS,UAAAC,eAAc;AAKhB,IAAM,oBAAoB,CAC/B,YACA,SAEAC,QAAO,IAAI,aAAa;AACtB,QAAM,YAAqC,CAAC;AAE5C,aAAW,SAAS,WAAW,YAAY;AACzC,UAAM,QAAQ,KAAK,MAAM,IAAI;AAG7B,QAAI,MAAM,aAAa,UAAU,UAAa,UAAU,OAAO;AAC7D,aAAO,OAAOA,QAAO;AAAA,QACnB,IAAI,oBAAoB;AAAA,UACtB,SAAS,+BAA+B,MAAM,IAAI;AAAA,UAClD,UAAU,WAAW;AAAA,UACrB,WAAW,MAAM;AAAA,UACjB,UAAU,MAAM;AAAA,UAChB,UAAU;AAAA,QACZ,CAAC;AAAA,MACH;AAAA,IACF;AAEA,QAAI,UAAU,QAAW;AACvB,UAAI,MAAM,YAAY,QAAW;AAC/B,kBAAU,MAAM,IAAI,IAAI,MAAM;AAAA,MAChC;AACA;AAAA,IACF;AAGA,UAAM,aAAa,MAAM,QAAQ,KAAK,IAAI,UAAU,OAAO;AAC3D,QACE,eAAe,MAAM,QACrB,EAAE,MAAM,SAAS,YAAY,eAAe,WAC5C;AACA,aAAO,OAAOA,QAAO;AAAA,QACnB,IAAI,oBAAoB;AAAA,UACtB,SAAS,cAAc,MAAM,IAAI,cAAc,MAAM,IAAI,SAAS,UAAU;AAAA,UAC5E,UAAU,WAAW;AAAA,UACrB,WAAW,MAAM;AAAA,UACjB,UAAU,MAAM;AAAA,UAChB,UAAU;AAAA,QACZ,CAAC;AAAA,MACH;AAAA,IACF;AAGA,QACE,MAAM,QACN,OAAO,UAAU,YACjB,CAAC,MAAM,KAAK,SAAS,KAAK,GAC1B;AACA,aAAO,OAAOA,QAAO;AAAA,QACnB,IAAI,oBAAoB;AAAA,UACtB,SAAS,cAAc,MAAM,IAAI,qBAAqB,MAAM,KAAK,KAAK,IAAI,CAAC;AAAA,UAC3E,UAAU,WAAW;AAAA,UACrB,WAAW,MAAM;AAAA,UACjB,UAAU,MAAM,KAAK,KAAK,KAAK;AAAA,UAC/B,UAAU,OAAO,KAAK;AAAA,QACxB,CAAC;AAAA,MACH;AAAA,IACF;AAEA,cAAU,MAAM,IAAI,IAAI;AAAA,EAC1B;AAEA,SAAO;AACT,CAAC;;;AJpDH,SAAS,gBAAgB;AAIlB,IAAM,cAAN,cAA0B,QAAQ,IAAI,aAAa,EAiDxD,EAAE;AAAC;AAIE,IAAM,kBAAkB,MAAM;AAAA,EACnC;AAAA,EACAC,QAAO,IAAI,aAAa;AACtB,UAAM,WAAW,OAAO;AACxB,UAAM,WAAW,OAAO;AACxB,UAAM,YAAY,OAAO;AACzB,UAAM,UAAU,YAAY;AAE5B,UAAM,UAAU,CACd,UASAA,QAAO,IAAI,aAAa;AACtB,YAAM,YAAY,KAAK,IAAI;AAG3B,YAAM,OAAO,OAAO,SAAS,IAAI,MAAM,QAAQ;AAG/C,YAAM,gBAAgB,OAAO;AAAA,QAC3B,KAAK;AAAA,QACL,MAAM;AAAA,MACR;AAGA,YAAM,SAAS,OAAO,QAAQ;AAAA,QAC5B,MAAM,KAAK,QAAQ,aAAa;AAAA,QAChC;AAAA,UACE,WAAW,KAAK,WAAW;AAAA,UAC3B,UAAU,MAAM;AAAA,QAClB;AAAA,MACF;AAEA,YAAM,kBAAkB,KAAK,IAAI,IAAI;AAGrC,aAAO,SAAS,QAAQ;AAAA,QACtB,MAAM;AAAA,QACN,MAAM;AAAA,QACN,SAAS;AAAA,UACP,UAAU,MAAM;AAAA,UAChB,SAAS;AAAA,UACT;AAAA,QACF;AAAA,MACF,CAAC;AAED,aAAO;AAAA,QACL,UAAU,MAAM;AAAA,QAChB,SAAS;AAAA,QACT;AAAA,QACA;AAAA,MACF;AAAA,IACF,CAAC;AAEH,UAAM,WAAW,CACf,YACA,YAG+B,SAAS,SAAS,YAAY,OAAO;AAEtE,UAAM,mBAAmB,CACvB,WAKAA,QAAO,IAAI,aAAa;AACtB,YAAM,SAAS,OAAO,UAAU,QAAQ,MAAM;AAG9C,iBAAW,YAAY,OAAO,OAAO;AACnC,eAAO,SAAS;AAAA,UACd;AAAA,YACE,MAAM,GAAG,OAAO,IAAI,IAAI,QAAQ;AAAA,YAChC,aAAa,iBAAiB,OAAO,IAAI;AAAA,YACzC,YAAY,CAAC;AAAA,YACb,WAAW;AAAA,YACX,WAAW;AAAA,YACX,kBAAkB;AAAA,YAClB,QAAQ;AAAA,UACV;AAAA,UACA,CAAC,SACC,UAAU,SAAS,OAAO,MAAM,UAAU,IAAI,EAAE;AAAA,YAC9CA,QAAO;AAAA,cACL,CAAC,MACC,IAAI,mBAAmB;AAAA,gBACrB,SAAS,YAAY,QAAQ;AAAA,gBAC7B;AAAA,gBACA,OAAO;AAAA,cACT,CAAC;AAAA,YACL;AAAA,UACF;AAAA,QACJ;AAAA,MACF;AAEA,aAAO,SAAS,QAAQ;AAAA,QACtB,MAAM;AAAA,QACN,MAAM;AAAA,QACN,SAAS,EAAE,YAAY,OAAO,MAAM,OAAO,OAAO,MAAM;AAAA,MAC1D,CAAC;AAED,aAAO;AAAA,IACT,CAAC;AAEH,UAAM,sBAAsB,CAC1B,eAEAA,QAAO,IAAI,aAAa;AACtB,aAAO,UAAU,WAAW,UAAU;AACtC,aAAO,SAAS,QAAQ;AAAA,QACtB,MAAM;AAAA,QACN,MAAM;AAAA,QACN,SAAS,EAAE,WAAW;AAAA,MACxB,CAAC;AAAA,IACH,CAAC;AAEH,UAAM,YAAY,CAAC,WAKjB,SAAS,KAAK,MAAM;AAEtB,UAAM,UAAU,CACd,SAEA,SAAS,IAAI,IAAI,EAAE,KAAKA,QAAO,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC;AAEzD,UAAM,0BAA0B,MAG3B,SAAS,wBAAwB;AAEtC,UAAM,iBAAiB,MACrB,UAAU,YAAY;AAExB,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;AKxOA,OAAuB;AAShB,IAAM,gBAAgB,CAAC,UAexB;AAAA,EACJ,YAAY;AAAA,IACV,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,YAAY,KAAK;AAAA,IACjB,UAAU,KAAK;AAAA,IACf,WAAW,KAAK,aAAa;AAAA,IAC7B,WAAW,KAAK,aAAa;AAAA,IAC7B,kBAAkB;AAAA,IAClB,QAAQ;AAAA,EACV;AAAA,EACA,SAAS,KAAK;AAChB;AAKO,IAAM,wBAAwB,CACnC,gBACyB;AAAA,EACzB,MAAM,WAAW;AAAA,EACjB,aAAa,WAAW;AAAA,EACxB,cAAc;AAAA,IACZ,MAAM;AAAA,IACN,YAAY,OAAO;AAAA,MACjB,WAAW,WAAW,IAAI,CAAC,MAAM;AAAA,QAC/B,EAAE;AAAA,QACF;AAAA,UACE,MAAM,EAAE;AAAA,UACR,aAAa,EAAE;AAAA,UACf,GAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,QACnC;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA,UAAU,WAAW,WAClB,OAAO,CAAC,MAAM,EAAE,QAAQ,EACxB,IAAI,CAAC,MAAM,EAAE,IAAI;AAAA,EACtB;AACF;;;AC9DA,SAAS,UAAAC,eAAc;AAKhB,IAAM,gBAAgC;AAAA,EAC3C,MAAM;AAAA,EACN,aAAa;AAAA,EACb,YAAY;AAAA,IACV;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,MACV,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EACA,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,QAAQ;AACV;AAEO,IAAM,mBAAmB,CAC9B,SAEAC,QAAO,WAAW;AAAA,EAChB,KAAK,YAAY;AACf,UAAM,QAAQ,KAAK;AACnB,UAAM,aAAc,KAAK,cAAyB;AAIlD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,CAAC;AAAA,MACV,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EACA,OAAO,CAAC,MACN,IAAI,mBAAmB;AAAA,IACrB,SAAS,sBAAsB,CAAC;AAAA,IAChC,UAAU;AAAA,IACV,OAAO;AAAA,EACT,CAAC;AACL,CAAC;;;ACrDH,SAAS,UAAAC,eAAc;AACvB,YAAY,QAAQ;AACpB,YAAY,UAAU;AAKf,IAAM,eAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,aAAa;AAAA,EACb,YAAY;AAAA,IACV;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,MACV,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EACA,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,QAAQ;AACV;AAEO,IAAM,kBAAkB,CAC7B,SAEAC,QAAO,WAAW;AAAA,EAChB,KAAK,YAAY;AACf,UAAM,WAAW,KAAK;AACtB,UAAM,WAAY,KAAK,YAA+B;AAGtD,UAAM,WAAgB,aAAQ,QAAQ;AACtC,UAAM,cAAc,QAAQ,IAAI;AAChC,QAAI,CAAC,SAAS,WAAW,WAAW,GAAG;AACrC,YAAM,IAAI,MAAM,4BAA4B,QAAQ,EAAE;AAAA,IACxD;AAEA,WAAO,MAAS,YAAS,UAAU,EAAE,SAAS,CAAC;AAAA,EACjD;AAAA,EACA,OAAO,CAAC,MACN,IAAI,mBAAmB;AAAA,IACrB,SAAS,qBAAqB,CAAC;AAAA,IAC/B,UAAU;AAAA,IACV,OAAO;AAAA,EACT,CAAC;AACL,CAAC;AAEI,IAAM,gBAAgC;AAAA,EAC3C,MAAM;AAAA,EACN,aAAa;AAAA,EACb,YAAY;AAAA,IACV;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,MACV,SAAS;AAAA,IACX;AAAA,EACF;AAAA,EACA,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,QAAQ;AACV;AAEO,IAAM,mBAAmB,CAC9B,SAEAA,QAAO,WAAW;AAAA,EAChB,KAAK,YAAY;AACf,UAAM,WAAW,KAAK;AACtB,UAAM,UAAU,KAAK;AACrB,UAAM,WAAY,KAAK,YAA+B;AAEtD,UAAM,WAAgB,aAAQ,QAAQ;AACtC,UAAM,cAAc,QAAQ,IAAI;AAChC,QAAI,CAAC,SAAS,WAAW,WAAW,GAAG;AACrC,YAAM,IAAI,MAAM,4BAA4B,QAAQ,EAAE;AAAA,IACxD;AAEA,UAAS,aAAU,UAAU,SAAS,EAAE,SAAS,CAAC;AAClD,WAAO,EAAE,SAAS,MAAM,MAAM,SAAS;AAAA,EACzC;AAAA,EACA,OAAO,CAAC,MACN,IAAI,mBAAmB;AAAA,IACrB,SAAS,sBAAsB,CAAC;AAAA,IAChC,UAAU;AAAA,IACV,OAAO;AAAA,EACT,CAAC;AACL,CAAC;;;AChHH,SAAS,UAAAC,eAAc;AAKhB,IAAM,cAA8B;AAAA,EACzC,MAAM;AAAA,EACN,aAAa;AAAA,EACb,YAAY;AAAA,IACV;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,EACF;AAAA,EACA,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,QAAQ;AACV;AAEO,IAAM,iBAAiB,CAC5B,SAEAC,QAAO,WAAW;AAAA,EAChB,KAAK,YAAY;AACf,UAAM,MAAM,KAAK;AACjB,UAAM,UAAW,KAAK,WAAsC,CAAC;AAE7D,UAAM,WAAW,MAAM,MAAM,KAAK,EAAE,QAAQ,OAAO,QAAQ,CAAC;AAC5D,UAAM,cAAc,SAAS,QAAQ,IAAI,cAAc,KAAK;AAE5D,QAAI;AACJ,QAAI,YAAY,SAAS,kBAAkB,GAAG;AAC5C,aAAO,MAAM,SAAS,KAAK;AAAA,IAC7B,OAAO;AACL,aAAO,MAAM,SAAS,KAAK;AAAA,IAC7B;AAEA,WAAO;AAAA,MACL,QAAQ,SAAS;AAAA,MACjB,YAAY,SAAS;AAAA,MACrB,SAAS,OAAO,YAAY,SAAS,QAAQ,QAAQ,CAAC;AAAA,MACtD;AAAA,IACF;AAAA,EACF;AAAA,EACA,OAAO,CAAC,MACN,IAAI,mBAAmB;AAAA,IACrB,SAAS,oBAAoB,CAAC;AAAA,IAC9B,UAAU;AAAA,IACV,OAAO;AAAA,EACT,CAAC;AACL,CAAC;;;AC5DH,SAAS,UAAAC,gBAAc;AAKhB,IAAM,kBAAkC;AAAA,EAC7C,MAAM;AAAA,EACN,aAAa;AAAA,EACb,YAAY;AAAA,IACV;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,IACZ;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,aAAa;AAAA,MACb,UAAU;AAAA,MACV,SAAS;AAAA,MACT,MAAM,CAAC,cAAc,YAAY;AAAA,IACnC;AAAA,EACF;AAAA,EACA,UAAU;AAAA,EACV,WAAW;AAAA,EACX,WAAW;AAAA,EACX,kBAAkB;AAAA,EAClB,QAAQ;AACV;AAEO,IAAM,qBAAqB,CAChC,SAEAC,SAAO,IAAI;AAAA,EACT,KAAK,MAAM;AACT,UAAM,OAAO,KAAK;AAIlB,WAAO;AAAA,MACL;AAAA,MACA,UAAU;AAAA,MACV,SACE;AAAA,IACJ;AAAA,EACF;AAAA,EACA,OAAO,CAAC,MACN,IAAI,mBAAmB;AAAA,IACrB,SAAS,0BAA0B,CAAC;AAAA,IACpC,UAAU;AAAA,IACV,OAAO;AAAA,EACT,CAAC;AACL,CAAC;;;ACrDH,SAAS,SAAAC,cAAa;AAEtB,SAAS,oBAAoB;AAOtB,IAAM,mBAAmB,MAC9B,gBAAgB,KAAKC,OAAM,QAAQ,YAAY,CAAC;AAM3C,IAAM,aAAa;","names":["Effect","Effect","Ref","Effect","Ref","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Effect","Layer","Layer"]}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@reactive-agents/tools",
+  "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"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "bun-types": "latest"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts.git",
+    "directory": "packages/tools"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "description": "Tool system for Reactive Agents — registry, sandboxed execution, and MCP client",
+  "homepage": "https://tylerjrbuell.github.io/reactive-agents-ts/",
+  "bugs": {
+    "url": "https://github.com/tylerjrbuell/reactive-agents-ts/issues"
+  }
+}