@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-vjm15z3z.js → command-67nkcjnx.js}

@@ -1,57 +1,58 @@
 import {
-  exports_mime
-} from "./integration-kq3q54gz.js";
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./command-p8qxwesx.js";
 import {
-  exports_filesystem
-} from "./integration-warbtngd.js";
+  Service55,
+  node57
+} from "./command-4y9deqpk.js";
 import {
-  exports_environment1 as exports_environment
-} from "./integration-xckxf18q.js";
+  Content2
+} from "./command-avf2gxwn.js";
 import {
-  NonNegativeInt,
-  PositiveInt,
-  RelativePath
-} from "./integration-j07kk359.js";
+  detect2
+} from "./command-3smtnn6g.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/tool/read-filesystem.ts
 var exports_read_filesystem = {};
 __export(exports_read_filesystem, {
-  BinaryFileError: () => BinaryFileError,
-  FileContent: () => FileContent,
-  ListEntry: () => ListEntry,
-  ListPage: () => ListPage,
-  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES,
-  MAX_READ_BYTES: () => MAX_READ_BYTES,
-  MAX_READ_LINES: () => MAX_READ_LINES,
-  MEDIA_MIMES: () => MEDIA_MIMES,
-  MediaIngestLimitError: () => MediaIngestLimitError,
-  OffsetOutOfRangeError: () => OffsetOutOfRangeError,
-  PageInput: () => PageInput,
-  PathKindError: () => PathKindError,
+  BinaryFileError: () => BinaryFileError2,
+  FileContent: () => FileContent2,
+  ListEntry: () => ListEntry2,
+  ListPage: () => ListPage2,
+  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES2,
+  MAX_READ_BYTES: () => MAX_READ_BYTES2,
+  MAX_READ_LINES: () => MAX_READ_LINES2,
+  MEDIA_MIMES: () => MEDIA_MIMES2,
+  MediaIngestLimitError: () => MediaIngestLimitError2,
+  OffsetOutOfRangeError: () => OffsetOutOfRangeError2,
+  PageInput: () => PageInput2,
+  PathKindError: () => PathKindError2,
   ReadToolFileSystem: () => exports_read_filesystem,
-  Service: () => Service,
-  TextPage: () => TextPage,
-  node: () => node,
-  read: () => read
+  Service: () => Service12,
+  TextPage: () => TextPage2,
+  node: () => node14,
+  read: () => read2
 });
 import path from "path";
 import { pathToFileURL } from "url";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
 import { lookup } from "mime-types";
-var MAX_READ_LINES = 2000;
-var MAX_READ_BYTES = 50 * 1024;
-var MAX_MEDIA_INGEST_BYTES = 20 * 1024 * 1024;
+var MAX_READ_LINES2 = 2000;
+var MAX_READ_BYTES2 = 50 * 1024;
+var MAX_MEDIA_INGEST_BYTES2 = 20 * 1024 * 1024;
 var FIRST_CHUNK = 256 * 1024;
 var MAX_LINE_LENGTH = 2000;
 var TREE_BASE = 6;
 var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
-var MEDIA_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
+var MEDIA_MIMES2 = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
 
-class BinaryFileError extends Schema.TaggedError()("ReadTool.BinaryFileError", {
+class BinaryFileError2 extends Schema.TaggedError()("ReadTool.BinaryFileError", {
   resource: Schema.String
 }) {
   get message() {
@@ -59,7 +60,7 @@ class BinaryFileError extends Schema.TaggedError()("ReadTool.BinaryFileError", {
   }
 }
 
-class MediaIngestLimitError extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
+class MediaIngestLimitError2 extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
   resource: Schema.String,
   maximumBytes: Schema.Number
 }) {
@@ -68,13 +69,13 @@ class MediaIngestLimitError extends Schema.TaggedError()("ReadTool.MediaIngestLi
   }
 }
 
-class OffsetOutOfRangeError extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
+class OffsetOutOfRangeError2 extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
   get message() {
     return `Offset ${this.offset} is out of range`;
   }
 }
 
-class PathKindError extends Schema.TaggedError()("ReadTool.PathKindError", {
+class PathKindError2 extends Schema.TaggedError()("ReadTool.PathKindError", {
   resource: Schema.String,
   expected: Schema.Literals(["a file", "a file or directory"])
 }) {
@@ -82,52 +83,52 @@ class PathKindError extends Schema.TaggedError()("ReadTool.PathKindError", {
     return `Path is not ${this.expected}: ${this.resource}`;
   }
 }
-var PageInput = Schema.Struct({
-  offset: Schema.optionalKey(NonNegativeInt),
-  limit: Schema.optionalKey(NonNegativeInt.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES)))
+var PageInput2 = Schema.Struct({
+  offset: Schema.optionalKey(NonNegativeInt2),
+  limit: Schema.optionalKey(NonNegativeInt2.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES2)))
 });
-var FileContent = Schema.Struct({
+var FileContent2 = Schema.Struct({
   type: Schema.Literal("file"),
-  ...exports_filesystem.Content.fields
+  ...Content2.fields
 }).annotate({ identifier: "ReadTool.FileContent" });
 
-class TextPage extends Schema.Class("ReadTool.TextPage")({
+class TextPage2 extends Schema.Class("ReadTool.TextPage")({
   type: Schema.Literal("text-page"),
   content: Schema.String,
   mime: Schema.String,
-  offset: PositiveInt,
+  offset: PositiveInt2,
   truncated: Schema.Boolean,
-  next: Schema.optionalKey(PositiveInt)
+  next: Schema.optionalKey(PositiveInt2)
 }) {
 }
-var ListEntry = Schema.Struct({
-  path: RelativePath,
+var ListEntry2 = Schema.Struct({
+  path: RelativePath2,
   type: Schema.Literals(["file", "directory", "symlink"])
 }).annotate({ identifier: "ReadTool.ListEntry" });
 
-class ListPage extends Schema.Class("ReadTool.ListPage")({
+class ListPage2 extends Schema.Class("ReadTool.ListPage")({
   type: Schema.Literal("list-page"),
-  entries: Schema.Array(ListEntry),
+  entries: Schema.Array(ListEntry2),
   truncated: Schema.Boolean,
-  next: Schema.optionalKey(PositiveInt)
+  next: Schema.optionalKey(PositiveInt2)
 }) {
 }
 
-class Service extends Context.Service()("@opencode/ReadToolFileSystem") {
+class Service12 extends Context.Service()("@opencode/ReadToolFileSystem") {
 }
 var mimeType = (value) => lookup(value) || "application/octet-stream";
-var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
+var read2 = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
   const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(Effect.catchTag("Environment.WrongKind", (error) => {
     if (error.actual !== "directory")
-      return Effect.fail(new PathKindError({ resource, expected: "a file or directory" }));
-    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file or directory" }))));
+      return Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }));
+    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }))));
   }));
-  if (first instanceof ListPage)
+  if (first instanceof ListPage2)
     return first;
-  const media = exports_mime.detect(first.bytes);
-  if (MEDIA_MIMES.has(media)) {
-    if (first.info.size > MAX_MEDIA_INGEST_BYTES)
-      return yield* new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES });
+  const media = detect2(first.bytes);
+  if (MEDIA_MIMES2.has(media)) {
+    if (first.info.size > MAX_MEDIA_INGEST_BYTES2)
+      return yield* new MediaIngestLimitError2({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES2 });
     const whole = yield* readFile(files, input, resource);
     return {
       type: "file",
@@ -138,10 +139,10 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
       mime: media
     };
   }
-  const paged = first.info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined;
+  const paged = first.info.size > MAX_READ_BYTES2 || page.offset !== undefined || page.limit !== undefined;
   if (!paged) {
     if (first.bytes.includes(0))
-      return yield* new BinaryFileError({ resource });
+      return yield* new BinaryFileError2({ resource });
     return {
       type: "file",
       uri: pathToFileURL(input).href,
@@ -158,7 +159,7 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
     return yield* makeTextPage(input, resource, result, first.bytes.subarray(0, result.consumed).includes(0));
   }
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const leaves = [textLeaf(first.bytes)];
   let bytes = first.bytes.length;
   let lines = leaves[0].summary.lines;
@@ -169,12 +170,12 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
       const tree = textTree(leaves);
       const start = textOffset(tree, offset - 1);
       let position = 0;
-      const selected = Buffer.concat(leaves.flatMap((leaf2) => {
+      const selected = Buffer.concat(leaves.flatMap((leaf) => {
         const leafStart = position;
-        position += leaf2.summary.bytes;
+        position += leaf.summary.bytes;
         if (position <= start)
           return [];
-        return [leaf2.bytes.subarray(Math.max(0, start - leafStart))];
+        return [leaf.bytes.subarray(Math.max(0, start - leafStart))];
       }));
       const result = textPage(selected, eof, { limit });
       if (result !== undefined) {
@@ -185,10 +186,10 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
         };
         const consumed = start + result.consumed;
         let checked = 0;
-        const binary = leaves.some((leaf2) => {
-          const length = Math.min(leaf2.summary.bytes, consumed - checked);
-          checked += leaf2.summary.bytes;
-          return length > 0 && leaf2.bytes.subarray(0, length).includes(0);
+        const binary = leaves.some((leaf) => {
+          const length = Math.min(leaf.summary.bytes, consumed - checked);
+          checked += leaf.summary.bytes;
+          return length > 0 && leaf.bytes.subarray(0, length).includes(0);
         });
         return yield* makeTextPage(input, resource, translated, binary);
       }
@@ -204,13 +205,13 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
     lines += leaf.summary.lines;
   }
 });
-var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file" }))));
+var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file" }))));
 var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary) {
   if (binary)
-    return yield* new BinaryFileError({ resource });
+    return yield* new BinaryFileError2({ resource });
   if (result.entries.length === 0 && result.offset !== 1)
-    return yield* new OffsetOutOfRangeError({ offset: result.offset });
-  return new TextPage({
+    return yield* new OffsetOutOfRangeError2({ offset: result.offset });
+  return new TextPage2({
     type: "text-page",
     content: result.entries.join(`
 `),
@@ -222,16 +223,16 @@ var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary)
 });
 var list = (items, page) => {
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const visible = items.flatMap((item) => item.type === "other" ? [] : [
-    ListEntry.make({
-      path: RelativePath.make(item.name + (item.type === "directory" ? path.sep : "")),
+    ListEntry2.make({
+      path: RelativePath2.make(item.name + (item.type === "directory" ? path.sep : "")),
       type: item.type
     })
   ]).sort((a, b) => a.type === "directory" ? b.type === "directory" ? a.path.localeCompare(b.path) : -1 : b.type === "directory" ? 1 : a.path.localeCompare(b.path));
   const selected = visible.slice(offset - 1, offset - 1 + limit);
   const truncated = offset - 1 + selected.length < visible.length;
-  return new ListPage({
+  return new ListPage2({
     type: "list-page",
     entries: selected,
     truncated,
@@ -240,7 +241,7 @@ var list = (items, page) => {
 };
 var textPage = (bytes, eof, page) => {
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const decoded = new TextDecoder().decode(bytes);
   const split = decoded.split(`
 `);
@@ -251,13 +252,13 @@ var textPage = (bytes, eof, page) => {
   let next;
   for (const [index, value] of available.slice(offset - 1).entries()) {
     const line = offset + index;
-    if (entries.length >= limit || size >= MAX_READ_BYTES) {
+    if (entries.length >= limit || size >= MAX_READ_BYTES2) {
       next = line;
       break;
     }
     const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value;
     const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0);
-    if (size + lineSize > MAX_READ_BYTES) {
+    if (size + lineSize > MAX_READ_BYTES2) {
       next = line;
       break;
     }
@@ -325,13 +326,13 @@ var nthNewline = (bytes, count) => {
       return index + 1;
   }
 };
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const environment = yield* exports_environment.Service;
-  return Service.of({
+var layer = Layer.effect(Service12, Effect.gen(function* () {
+  const environment = yield* Service55;
+  return Service12.of({
     list: environment.files.list,
-    read: (path2, resource, page) => read(environment.files, path2, resource, page)
+    read: (path2, resource, page) => read2(environment.files, path2, resource, page)
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node] });
+var node14 = makeLocationNode({ service: Service12, layer, deps: [node57] });
 
-export { MAX_READ_LINES, MAX_READ_BYTES, MAX_MEDIA_INGEST_BYTES, MEDIA_MIMES, BinaryFileError, MediaIngestLimitError, OffsetOutOfRangeError, PathKindError, PageInput, FileContent, TextPage, ListEntry, ListPage, Service, read, node, exports_read_filesystem };
+export { MAX_READ_LINES2, MAX_READ_BYTES2, MAX_MEDIA_INGEST_BYTES2, MEDIA_MIMES2, BinaryFileError2, MediaIngestLimitError2, OffsetOutOfRangeError2, PathKindError2, PageInput2, FileContent2, TextPage2, ListEntry2, ListPage2, Service12, read2, node14, exports_read_filesystem };

package/dist/chunks/{integration-bd2mvb8t.js → command-6h414ywr.js}

@@ -1,21 +1,21 @@
 import {
-  PositiveInt
-} from "./integration-j07kk359.js";
+  PositiveInt2
+} from "./command-p8qxwesx.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/v1/config/mcp.ts
-var exports_mcp = {};
-__export(exports_mcp, {
-  ConfigMCPV1: () => exports_mcp,
-  Info: () => Info,
-  Local: () => Local,
-  OAuth: () => OAuth,
-  Remote: () => Remote
+var exports_mcp5 = {};
+__export(exports_mcp5, {
+  ConfigMCPV1: () => exports_mcp5,
+  Info: () => Info13,
+  Local: () => Local2,
+  OAuth: () => OAuth2,
+  Remote: () => Remote2
 });
 import { Schema } from "effect";
-var Local = Schema.Struct({
+var Local2 = Schema.Struct({
   type: Schema.Literal("local").annotate({ description: "Type of MCP server connection" }),
   command: Schema.mutable(Schema.Array(Schema.String)).annotate({
     description: "Command and arguments to run the MCP server"
@@ -29,11 +29,11 @@ var Local = Schema.Struct({
   enabled: Schema.optional(Schema.Boolean).annotate({
     description: "Enable or disable the MCP server on startup"
   }),
-  timeout: Schema.optional(PositiveInt).annotate({
+  timeout: Schema.optional(PositiveInt2).annotate({
     description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
   })
 }).annotate({ identifier: "McpLocalConfig" });
-var OAuth = Schema.Struct({
+var OAuth2 = Schema.Struct({
   clientId: Schema.optional(Schema.String).annotate({
     description: "OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted."
   }),
@@ -48,7 +48,7 @@ var OAuth = Schema.Struct({
     description: "OAuth redirect URI (default: http://127.0.0.1:19876/mcp/oauth/callback)."
   })
 }).annotate({ identifier: "McpOAuthConfig" });
-var Remote = Schema.Struct({
+var Remote2 = Schema.Struct({
   type: Schema.Literal("remote").annotate({ description: "Type of MCP server connection" }),
   url: Schema.String.annotate({ description: "URL of the remote MCP server" }),
   enabled: Schema.optional(Schema.Boolean).annotate({
@@ -57,13 +57,13 @@ var Remote = Schema.Struct({
   headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
     description: "Headers to send with the request"
   }),
-  oauth: Schema.optional(Schema.Union([OAuth, Schema.Literal(false)])).annotate({
+  oauth: Schema.optional(Schema.Union([OAuth2, Schema.Literal(false)])).annotate({
     description: "OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection."
   }),
-  timeout: Schema.optional(PositiveInt).annotate({
+  timeout: Schema.optional(PositiveInt2).annotate({
     description: "Timeout in ms for MCP server requests. Defaults to 5000 (5 seconds) if not specified."
   })
 }).annotate({ identifier: "McpRemoteConfig" });
-var Info = Schema.Union([Local, Remote]).annotate({ discriminator: "type" });
+var Info13 = Schema.Union([Local2, Remote2]).annotate({ discriminator: "type" });
 
-export { Local, OAuth, Remote, Info, exports_mcp };
+export { Local2, OAuth2, Remote2, Info13, exports_mcp5 };

package/dist/chunks/{integration-c77ad0vh.js → command-6prwharc.js}

@@ -1,6 +1,6 @@
 // src/tool/plugin/file-diff.ts
 import { createTwoFilesPatch, diffLines } from "diff";
-function fileDiff(file, before, after, status = "modified") {
+function fileDiff2(file, before, after, status = "modified") {
   const counts = diffLines(before, after).reduce((result, item) => ({
     additions: result.additions + (item.added ? item.count ?? 0 : 0),
     deletions: result.deletions + (item.removed ? item.count ?? 0 : 0)
@@ -13,4 +13,4 @@ function fileDiff(file, before, after, status = "modified") {
   };
 }
 
-export { fileDiff };
+export { fileDiff2 };

package/dist/chunks/{integration-svrgfpe2.js → command-6tf8tr4v.js}

@@ -1,17 +1,17 @@
 import {
-  definition,
-  normalizedName
-} from "./integration-xx9qfgev.js";
+  definition2,
+  normalizedName2
+} from "./command-3t738kvx.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/codemode/tool.ts
-var exports_tool = {};
-__export(exports_tool, {
-  CodeModeTool: () => exports_tool,
-  catalog: () => catalog,
-  create: () => create
+var exports_tool2 = {};
+__export(exports_tool2, {
+  CodeModeTool: () => exports_tool2,
+  catalog: () => catalog2,
+  create: () => create2
 });
 import { CodeMode, Namespace, Tool, toolError } from "@opencode-ai/codemode";
 import { Effect, Ref, Schema, Semaphore } from "effect";
@@ -40,7 +40,7 @@ var description = [
   "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`."
 ].join(`
 `);
-var create = (inventory, executeTool) => {
+var create2 = (inventory, executeTool) => {
   return {
     name: "execute",
     description,
@@ -51,17 +51,17 @@ var create = (inventory, executeTool) => {
       const files = yield* Ref.make([]);
       const calls = yield* Ref.make([]);
       const lock = Semaphore.makeUnsafe(1);
-      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls2) => context.progress({ toolCalls: toolCalls2 }))));
+      const updateCalls = (update) => lock.withPermit(Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))));
       const result = yield* runtime(inventory, (name, tool, input) => Effect.gen(function* () {
-        const index = yield* Ref.getAndUpdate(callIndex, (index2) => index2 + 1);
+        const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1);
         const executed = yield* executeTool(name, tool, input, context);
-        const content2 = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
-        const outputFileParts = outputFiles(content2);
+        const content = typeof executed.content === "string" ? [{ type: "text", text: executed.content }] : executed.content ?? [];
+        const outputFileParts = outputFiles(content);
         if (outputFileParts.length > 0)
           yield* Ref.update(files, (items) => [...items, { index, files: outputFileParts }]);
         if (executed.output !== undefined)
           return executed.output;
-        const text = content2.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+        const text = content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
 `);
         return text === "" ? null : text;
       }), {
@@ -115,7 +115,7 @@ var create = (inventory, executeTool) => {
     })
   };
 };
-var catalog = (inventory) => {
+var catalog2 = (inventory) => {
   const pinned = new Set(Array.from(inventory.tools.values()).filter((registration) => registration.options?.pinned === true).map(qualifiedName));
   const root = { children: new Map };
   for (const namespace of inventory.namespaces?.values() ?? [])
@@ -153,7 +153,7 @@ function runtime(inventory, executeTool, hooks) {
   for (const namespace of inventory.namespaces?.values() ?? [])
     getNode(root, namespace.name).namespace = namespace;
   for (const [name, registration] of inventory.tools) {
-    const child = definition(registration);
+    const child = definition2(registration);
     getNode(root, qualifiedName(registration)).tool = Tool.make({
       description: child.description,
       input: child.inputSchema,
@@ -211,7 +211,7 @@ function flattenTools(node, path, tools) {
     flattenTools(child, [...path, name], tools);
 }
 function qualifiedName(registration) {
-  const normalized = normalizedName(registration);
+  const normalized = normalizedName2(registration);
   if (registration.options?.namespace === undefined)
     return normalized;
   return `${registration.options.namespace}.${normalized}`;
@@ -260,4 +260,4 @@ function outputFiles(content) {
   });
 }
 
-export { create, catalog, exports_tool };
+export { create2, catalog2, exports_tool2 };

package/dist/chunks/{integration-etbnsc4s.js → command-6z5bwd8g.js}

@@ -1,22 +1,22 @@
 import {
-  collectBoundedResponseBody
-} from "./integration-jve7t217.js";
+  collectBoundedResponseBody2
+} from "./command-3v8g72cx.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/plugin/websearch/mcp.ts
 var exports_mcp = {};
 __export(exports_mcp, {
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES2,
   WebSearchMcp: () => exports_mcp,
-  call: () => call,
-  parseResponse: () => parseResponse
+  call: () => call2,
+  parseResponse: () => parseResponse2
 });
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-var MAX_RESPONSE_BYTES = 256 * 1024;
-var parseResponse = (body, result) => {
+var MAX_RESPONSE_BYTES2 = 256 * 1024;
+var parseResponse2 = (body, result) => {
   const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })));
   const parse = (payload) => {
     const trimmed = payload.trim();
@@ -39,7 +39,7 @@ var parseResponse = (body, result) => {
     }
   });
 };
-var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
+var call2 = (http, url, tool, schema, value, headers = {}) => Effect.gen(function* () {
   const request = yield* HttpClientRequest.post(url).pipe(HttpClientRequest.accept("application/json, text/event-stream"), HttpClientRequest.setHeaders(headers), HttpClientRequest.schemaBodyJson(Schema.Struct({
     jsonrpc: Schema.Literal("2.0"),
     id: Schema.Literal(1),
@@ -53,12 +53,12 @@ var call = (http, url, tool, schema, value, headers = {}) => Effect.gen(function
   }));
   return yield* Effect.gen(function* () {
     const response = yield* HttpClient.filterStatusOk(http).execute(request);
-    const body = yield* collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`));
-    return yield* parseResponse(body.toString("utf8"), schema.output);
+    const body = yield* collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES2, () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES2} bytes`));
+    return yield* parseResponse2(body.toString("utf8"), schema.output);
   }).pipe(Effect.timeoutOrElse({
     duration: Duration.seconds(25),
     orElse: () => Effect.fail(new Error(`${tool} request timed out`))
   }));
 });
 
-export { MAX_RESPONSE_BYTES, parseResponse, call, exports_mcp };
+export { MAX_RESPONSE_BYTES2, parseResponse2, call2, exports_mcp };

package/dist/chunks/{integration-xdb88cdw.js → command-711hfp6y.js}

@@ -1,19 +1,19 @@
 import {
-  PositiveInt
-} from "./integration-j07kk359.js";
+  PositiveInt2
+} from "./command-p8qxwesx.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/v1/config/server.ts
 var exports_server = {};
 __export(exports_server, {
   ConfigServerV1: () => exports_server,
-  Server: () => Server
+  Server: () => Server2
 });
 import { Schema } from "effect";
-var Server = Schema.Struct({
-  port: Schema.optional(PositiveInt).annotate({
+var Server2 = Schema.Struct({
+  port: Schema.optional(PositiveInt2).annotate({
     description: "Port to listen on"
   }),
   hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
@@ -26,4 +26,4 @@ var Server = Schema.Struct({
   })
 }).annotate({ identifier: "ServerConfig" });
 
-export { Server, exports_server };
+export { Server2, exports_server };