@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/{instance-b3ba60js.js → kv-jnv71sbj.js}

@@ -1,100 +1,101 @@
 import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
+  Service79,
+  node83
+} from "./kv-9j3fyze8.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/form.ts
 var exports_form = {};
 __export(exports_form, {
-  AlreadyExistsError: () => AlreadyExistsError,
-  AlreadySettledError: () => AlreadySettledError,
-  Answer: () => Answer,
-  Event: () => Event,
-  Field: () => Field,
-  Fields: () => Fields,
+  AlreadyExistsError: () => AlreadyExistsError2,
+  AlreadySettledError: () => AlreadySettledError2,
+  Answer: () => Answer2,
+  Event: () => Event20,
+  Field: () => Field2,
+  Fields: () => Fields2,
   Form: () => exports_form,
-  ID: () => ID,
-  Info: () => Info,
-  InvalidAnswerError: () => InvalidAnswerError,
-  InvalidFormError: () => InvalidFormError,
-  NotFoundError: () => NotFoundError,
-  Reply: () => Reply,
-  Service: () => Service,
-  State: () => State,
-  When: () => When,
-  layer: () => layer,
-  node: () => node,
-  validateAnswer: () => validateAnswer,
-  validateFields: () => validateFields
+  ID: () => ID18,
+  Info: () => Info32,
+  InvalidAnswerError: () => InvalidAnswerError2,
+  InvalidFormError: () => InvalidFormError2,
+  NotFoundError: () => NotFoundError10,
+  Reply: () => Reply3,
+  Service: () => Service78,
+  State: () => State3,
+  When: () => When2,
+  layer: () => layer25,
+  node: () => node82,
+  validateAnswer: () => validateAnswer2,
+  validateFields: () => validateFields2
 });
 import { Form } from "@opencode-ai/schema/form";
 import { Cache, Context, Deferred, Duration, Effect, Exit, Layer, Option, Schema } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-import { Event } from "@opencode-ai/schema/form";
+import { Event as Event20 } from "@opencode-ai/schema/form";
 var RETENTION = Duration.minutes(10);
-var ID = Form.ID;
-var Info = Form.Info;
-var Field = Form.Field;
-var Fields = Form.Fields;
-var When = Form.When;
-var State = Form.State;
-var Answer = Form.Answer;
-var Reply = Form.Reply;
+var ID18 = Form.ID;
+var Info32 = Form.Info;
+var Field2 = Form.Field;
+var Fields2 = Form.Fields;
+var When2 = Form.When;
+var State3 = Form.State;
+var Answer2 = Form.Answer;
+var Reply3 = Form.Reply;
 
-class NotFoundError extends Schema.TaggedError()("Form.NotFoundError", {
-  id: ID
+class NotFoundError10 extends Schema.TaggedError()("Form.NotFoundError", {
+  id: ID18
 }) {
   get message() {
     return `Form not found: ${this.id}`;
   }
 }
 
-class AlreadySettledError extends Schema.TaggedError()("Form.AlreadySettledError", {
-  id: ID
+class AlreadySettledError2 extends Schema.TaggedError()("Form.AlreadySettledError", {
+  id: ID18
 }) {
   get message() {
     return `Form already settled: ${this.id}`;
   }
 }
 
-class AlreadyExistsError extends Schema.TaggedError()("Form.AlreadyExistsError", {
-  id: ID
+class AlreadyExistsError2 extends Schema.TaggedError()("Form.AlreadyExistsError", {
+  id: ID18
 }) {
   get message() {
     return `Form already exists: ${this.id}`;
   }
 }
 
-class InvalidAnswerError extends Schema.TaggedError()("Form.InvalidAnswerError", {
-  id: ID,
+class InvalidAnswerError2 extends Schema.TaggedError()("Form.InvalidAnswerError", {
+  id: ID18,
   message: Schema.String
 }) {
 }
 
-class InvalidFormError extends Schema.TaggedError()("Form.InvalidFormError", {
+class InvalidFormError2 extends Schema.TaggedError()("Form.InvalidFormError", {
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Form") {
+class Service78 extends Context.Service()("@opencode/Form") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const bus = yield* exports_bus.Service;
+var layer25 = Layer.effect(Service78, Effect.gen(function* () {
+  const bus = yield* Service79;
   const forms = yield* Cache.makeWith(() => Effect.die(new Error("Form cache must be used via set/getSuccess, never get")), {
     capacity: Number.MAX_SAFE_INTEGER,
     timeToLive: (exit) => Exit.isSuccess(exit) && exit.value.state.status === "pending" ? Duration.infinity : RETENTION
   });
-  const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError({ id })))));
+  const requireEntry = Effect.fn("Form.requireEntry")((id) => Cache.getSuccess(forms, id).pipe(Effect.flatMap((entry) => Effect.fromOption(entry, () => new NotFoundError10({ id })))));
   const create = Effect.fn("Form.create")((input) => Effect.uninterruptible(Effect.gen(function* () {
-    const id = input.id ?? ID.create();
+    const id = input.id ?? ID18.create();
     const existing = yield* Cache.getSuccess(forms, id);
     if (Option.isSome(existing))
-      return yield* new AlreadyExistsError({ id });
-    const invalid = validateFields(input.fields);
+      return yield* new AlreadyExistsError2({ id });
+    const invalid = validateFields2(input.fields);
     if (invalid)
-      return yield* new InvalidFormError({ message: invalid });
+      return yield* new InvalidFormError2({ message: invalid });
     const form = {
       id,
       sessionID: input.sessionID,
@@ -129,10 +130,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const reply = Effect.fn("Form.reply")((input) => Effect.uninterruptible(Effect.gen(function* () {
     const entry = yield* requireEntry(input.id);
     if (entry.state.status !== "pending")
-      return yield* new AlreadySettledError({ id: input.id });
-    const invalid = validateAnswer(entry.form.fields, input.answer);
+      return yield* new AlreadySettledError2({ id: input.id });
+    const invalid = validateAnswer2(entry.form.fields, input.answer);
     if (invalid)
-      return yield* new InvalidAnswerError({ id: input.id, message: invalid });
+      return yield* new InvalidAnswerError2({ id: input.id, message: invalid });
     const next = { status: "answered", answer: input.answer };
     yield* bus.publish(Form.Event.Replied, {
       id: input.id,
@@ -145,17 +146,17 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   const cancel = Effect.fn("Form.cancel")((id) => Effect.uninterruptible(Effect.gen(function* () {
     const entry = yield* requireEntry(id);
     if (entry.state.status !== "pending")
-      return yield* new AlreadySettledError({ id });
+      return yield* new AlreadySettledError2({ id });
     const next = { status: "cancelled" };
     yield* bus.publish(Form.Event.Cancelled, { id, sessionID: entry.form.sessionID });
     yield* Cache.set(forms, id, { ...entry, state: next });
     yield* Deferred.succeed(entry.deferred, next);
   })));
   yield* Effect.addFinalizer(() => Cache.values(forms).pipe(Effect.flatMap((entries) => Effect.forEach(Array.from(entries).filter((entry) => entry.state.status === "pending"), (entry) => cancel(entry.form.id).pipe(Effect.ignore), { discard: true }))));
-  return Service.of({ create, ask, get, list, state, reply, cancel });
+  return Service78.of({ create, ask, get, list, state, reply, cancel });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_bus.node] });
-function validateAnswer(form, answer) {
+var node82 = makeLocationNode({ service: Service78, layer: layer25, deps: [node83] });
+function validateAnswer2(form, answer) {
   const fields = new Map(form.map((field) => [field.key, field]));
   for (const key of Object.keys(answer)) {
     if (!fields.has(key))
@@ -192,7 +193,7 @@ function matches(when, value) {
   const hit = Array.isArray(value) ? value.some((item) => item === when.value) : value === when.value;
   return when.op === "eq" ? hit : !hit;
 }
-function validateFields(fields) {
+function validateFields2(fields) {
   if (fields.length === 0)
     return "Form must have at least one field";
   const earlier = new Map;
@@ -306,4 +307,4 @@ function isDateTime(value) {
   return !Number.isNaN(new Date(value).getTime());
 }
 
-export { ID, Info, Field, Fields, When, State, Answer, Reply, NotFoundError, AlreadySettledError, AlreadyExistsError, InvalidAnswerError, InvalidFormError, Service, layer, node, validateAnswer, validateFields, exports_form, Event };
+export { ID18, Info32, Field2, Fields2, When2, State3, Answer2, Reply3, NotFoundError10, AlreadySettledError2, AlreadyExistsError2, InvalidAnswerError2, InvalidFormError2, Service78, layer25, node82, validateAnswer2, validateFields2, exports_form, Event20 };

package/dist/chunks/kv-jqh9b0xq.js

@@ -0,0 +1,18 @@
+import {
+  __export
+} from "./kv-9rqn6x4v.js";
+
+// src/plugin/service.ts
+var exports_service = {};
+__export(exports_service, {
+  Plugin: () => exports_service,
+  Service: () => Service36,
+  awaitActivation: () => awaitActivation2
+});
+import { Context } from "effect";
+
+class Service36 extends Context.Service()("@opencode/Plugin") {
+}
+var awaitActivation2 = Service36.use((plugins) => plugins.awaitActivation);
+
+export { Service36, awaitActivation2, exports_service };

package/dist/chunks/{instance-2tm6xfe0.js → kv-jtgs360h.js}

@@ -1,15 +1,15 @@
 import {
-  prepareResponsesTools
-} from "./instance-8ez3qcv1.js";
+  openaiFailedResponseHandler2
+} from "./kv-550bvhaj.js";
 import {
-  openaiFailedResponseHandler
-} from "./instance-r8f4w671.js";
+  convertToOpenAIResponsesInput2
+} from "./kv-j5zkgpj8.js";
 import {
-  mapOpenAIResponseFinishReason
-} from "./instance-m8cbvarh.js";
+  mapOpenAIResponseFinishReason2
+} from "./kv-3asan66x.js";
 import {
-  convertToOpenAIResponsesInput
-} from "./instance-vac9eqd2.js";
+  prepareResponsesTools2
+} from "./kv-ykczf8eq.js";
 
 // src/github-copilot/responses/openai-responses-language-model.ts
 import {
@@ -81,7 +81,7 @@ var LOGPROBS_SCHEMA = z.array(z.object({
   }))
 }));
 
-class OpenAIResponsesLanguageModel {
+class OpenAIResponsesLanguageModel2 {
   specificationVersion = "v3";
   modelId;
   config;
@@ -140,7 +140,7 @@ class OpenAIResponsesLanguageModel {
       schema: openaiResponsesProviderOptionsSchema
     });
     const store = openaiOptions?.store ?? false;
-    const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
+    const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput2({
       prompt,
       systemMessageMode: modelConfig.systemMessageMode,
       fileIdPrefixes: this.config.fileIdPrefixes,
@@ -168,7 +168,7 @@ class OpenAIResponsesLanguageModel {
       hostedTools,
       selectedHostedTool,
       toolWarnings
-    } = prepareResponsesTools({
+    } = prepareResponsesTools2({
       tools,
       toolChoice,
       strictJsonSchema
@@ -305,7 +305,7 @@ class OpenAIResponsesLanguageModel {
       url,
       headers: combineHeaders(this.config.headers(), options.headers),
       body,
-      failedResponseHandler: openaiFailedResponseHandler,
+      failedResponseHandler: openaiFailedResponseHandler2,
       successfulResponseHandler: createJsonResponseHandler(z.object({
         id: z.string(),
         created_at: z.number(),
@@ -578,7 +578,7 @@ class OpenAIResponsesLanguageModel {
     return {
       content,
       finishReason: {
-        unified: mapOpenAIResponseFinishReason({
+        unified: mapOpenAIResponseFinishReason2({
           finishReason: response.incomplete_details?.reason,
           hasFunctionCall
         }),
@@ -622,7 +622,7 @@ class OpenAIResponsesLanguageModel {
         ...body,
         stream: true
       },
-      failedResponseHandler: openaiFailedResponseHandler,
+      failedResponseHandler: openaiFailedResponseHandler2,
       successfulResponseHandler: createEventSourceResponseHandler(openaiResponsesChunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
@@ -1022,7 +1022,7 @@ class OpenAIResponsesLanguageModel {
             }
           } else if (isResponseFinishedChunk(value)) {
             finishReason = {
-              unified: mapOpenAIResponseFinishReason({
+              unified: mapOpenAIResponseFinishReason2({
                 finishReason: value.response.incomplete_details?.reason,
                 hasFunctionCall
               }),
@@ -1416,4 +1416,4 @@ var openaiResponsesProviderOptionsSchema = z.object({
   user: z.string().nullish()
 });
 
-export { OpenAIResponsesLanguageModel };
+export { OpenAIResponsesLanguageModel2 };

package/dist/chunks/{instance-66mds5ht.js → kv-jwcy2c2z.js}

@@ -1,16 +1,16 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/effect/keyed-mutex.ts
 var exports_keyed_mutex = {};
 __export(exports_keyed_mutex, {
   KeyedMutex: () => exports_keyed_mutex,
-  make: () => make,
-  makeUnsafe: () => makeUnsafe
+  make: () => make21,
+  makeUnsafe: () => makeUnsafe2
 });
 import { Effect, Semaphore } from "effect";
-var makeUnsafe = () => {
+var makeUnsafe2 = () => {
   const locks = new Map;
   const withLock = (key) => (effect) => Effect.suspend(() => {
     const current = locks.get(key);
@@ -26,6 +26,6 @@ var makeUnsafe = () => {
   });
   return { size: Effect.sync(() => locks.size), withLock };
 };
-var make = () => Effect.sync(makeUnsafe);
+var make21 = () => Effect.sync(makeUnsafe2);
 
-export { makeUnsafe, make, exports_keyed_mutex };
+export { makeUnsafe2, make21, exports_keyed_mutex };

package/dist/chunks/{instance-x4az4y7r.js → kv-k4bwy1x5.js}

@@ -1,15 +1,15 @@
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/id/id.ts
 var exports_id = {};
 __export(exports_id, {
   Identifier: () => exports_id,
-  ascending: () => ascending,
+  ascending: () => ascending2,
   create: () => createID,
-  descending: () => descending,
-  timestamp: () => timestamp
+  descending: () => descending2,
+  timestamp: () => timestamp2
 });
 import { create } from "@opencode-ai/schema/identifier";
 var prefixes = {
@@ -24,10 +24,10 @@ var prefixes = {
   tool: "tool",
   workspace: "wrk"
 };
-function ascending(prefix, given) {
+function ascending2(prefix, given) {
   return generateID(prefix, "ascending", given);
 }
-function descending(prefix, given) {
+function descending2(prefix, given) {
   return generateID(prefix, "descending", given);
 }
 function generateID(prefix, direction, given) {
@@ -42,10 +42,10 @@ function generateID(prefix, direction, given) {
 function createID(prefix, direction, timestamp) {
   return prefix + "_" + create(direction === "descending", timestamp);
 }
-function timestamp(id) {
+function timestamp2(id) {
   const prefix = id.split("_")[0];
   const hex = id.slice(prefix.length + 1, prefix.length + 13);
   return Number(BigInt(`0x${hex}`) / 0x1000n);
 }
 
-export { ascending, descending, createID, timestamp, exports_id };
+export { ascending2, descending2, createID, timestamp2, exports_id };

package/dist/chunks/{instance-d5rbqqhr.js → kv-k9jet765.js}

@@ -1,58 +1,61 @@
 import {
-  exports_tool
-} from "./instance-svrgfpe2.js";
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./kv-3t738kvx.js";
 import {
-  definition,
-  effectiveName,
-  execute,
-  normalizeContent,
-  normalizedName
-} from "./instance-xx9qfgev.js";
+  create2,
+  catalog2
+} from "./kv-6tf8tr4v.js";
 import {
-  exports_image
-} from "./instance-kqbaffed.js";
+  create3
+} from "./kv-kg06axw8.js";
 import {
-  exports_wildcard
-} from "./instance-edxnhgvj.js";
+  Service47,
+  node50
+} from "./kv-5kceqzn1.js";
 import {
-  exports_hooks
-} from "./instance-xws7arpm.js";
+  Service57,
+  node60
+} from "./kv-327n2tt7.js";
 import {
-  exports_state
-} from "./instance-j6s3yjyb.js";
+  match2
+} from "./kv-y1fvbwt7.js";
 import {
   __export
-} from "./instance-vpjkya7h.js";
+} from "./kv-9rqn6x4v.js";
 
 // src/tool.ts
-var exports_tool2 = {};
-__export(exports_tool2, {
-  CallID: () => CallID,
-  Content: () => Content,
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content2,
   Error: () => Error2,
-  FileContent: () => FileContent,
-  RegistrationError: () => RegistrationError,
-  Service: () => Service,
-  TextContent: () => TextContent,
-  Tool: () => exports_tool2,
-  node: () => node
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service43,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node46
 });
-import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { CallID as CallID2, Content as Content2, Error as Error2, FileContent as FileContent3, TextContent as TextContent2 } from "@opencode-ai/schema/tool";
 import { ToolDefinition } from "@opencode-ai/ai";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Context, Effect, Layer, Result, Schema, SchemaIssue } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-class RegistrationError extends Schema.TaggedError()("Tool.RegistrationError", {
+class RegistrationError2 extends Schema.TaggedError()("Tool.RegistrationError", {
   name: Schema.String,
   message: Schema.String
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Tool") {
+class Service43 extends Context.Service()("@opencode/Tool") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const hooks = yield* exports_hooks.Service;
-  const image = yield* exports_image.Service;
+var layer = Layer.effect(Service43, Effect.gen(function* () {
+  const hooks = yield* Service57;
+  const image = yield* Service47;
   const normalizeImages = Effect.fnUntraced(function* (content) {
     const normalized = yield* Effect.forEach(content, (item) => {
       if (item.type !== "file" || !item.mime.startsWith("image/"))
@@ -88,7 +91,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     input
   });
   const executeTool = Effect.fn("Tool.execute")(function* (tool, name, input, context) {
-    const execution = yield* execute(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
+    const execution = yield* execute3(tool, input, context).pipe(Effect.map((value) => ({ value })), Effect.catchTag("Tool.Error", (failure) => Effect.succeed({ failure })));
     const base = {
       tool: name,
       sessionID: context.sessionID,
@@ -98,13 +101,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       input
     };
     if ("failure" in execution) {
-      const afterEvent2 = {
+      const afterEvent = {
         ...base,
         status: "error",
         error: execution.failure
       };
-      yield* hooks.trigger("tool", "execute.after", afterEvent2);
-      return yield* afterEvent2.error;
+      yield* hooks.trigger("tool", "execute.after", afterEvent);
+      return yield* afterEvent.error;
     }
     const afterEvent = {
       ...base,
@@ -116,14 +119,14 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       }
     };
     yield* hooks.trigger("tool", "execute.after", afterEvent);
-    const afterContent = yield* normalizeImages(normalizeContent(afterEvent.result.content, afterEvent.result.output));
+    const afterContent = yield* normalizeImages(normalizeContent2(afterEvent.result.content, afterEvent.result.output));
     return {
       ...afterEvent.result.output === undefined ? {} : { output: afterEvent.result.output },
       content: afterContent,
       ...afterEvent.result.metadata === undefined ? {} : { metadata: afterEvent.result.metadata }
     };
   });
-  const state = exports_state.create({
+  const state = create3({
     name: "tool",
     initial: () => ({
       tools: new Map,
@@ -147,7 +150,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           editor.errors.push({ kind: "tool", name: tool.name, namespace: tool.options?.namespace, error });
           return;
         }
-        const id = effectiveName(tool);
+        const id = effectiveName2(tool);
         editor.tools.set(id, { ...tool, id, options: tool.options && { ...tool.options } });
       },
       update: (id, update) => {
@@ -177,7 +180,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       error: error.message
     }), { discard: true })
   });
-  return Service.of({
+  return Service43.of({
     transform: state.transform,
     reload: state.reload,
     snapshot: Effect.fn("Tool.snapshot")((permissions) => Effect.sync(() => {
@@ -193,13 +196,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       const namespaces = state.get().namespaces;
       const codeModeInventory = { tools: codeModeTools, namespaces };
       const codeModeEnabled = !whollyDisabled("execute", rules);
-      const codeModeTool = codeModeEnabled ? exports_tool.create(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
-      const codeModeCatalog = codeModeEnabled ? exports_tool.catalog(codeModeInventory) : undefined;
+      const codeModeTool = codeModeEnabled ? create2(codeModeInventory, (name, tool, input, context) => beforeExecute(name, input, context).pipe(Effect.flatMap((event) => executeTool(tool, name, event.input, context)))) : undefined;
+      const codeModeCatalog = codeModeEnabled ? catalog2(codeModeInventory) : undefined;
       return {
         ...codeModeCatalog === undefined ? {} : { codeModeCatalog },
         definitions: [
-          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition(tool)),
-          ...codeModeTool ? [definition(codeModeTool)] : []
+          ...Array.from(direct).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([, tool]) => definition2(tool)),
+          ...codeModeTool ? [definition2(codeModeTool)] : []
         ],
         execute: Effect.fnUntraced(function* (input) {
           const context = {
@@ -226,7 +229,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
 }));
 var whollyDisabled = (action, rules) => {
-  const rule = rules.findLast((rule2) => exports_wildcard.match(action, rule2.action));
+  const rule = rules.findLast((rule) => match2(action, rule.action));
   return rule?.resource === "*" && rule.effect === "deny";
 };
 var formatSchemaIssue = SchemaIssue.makeFormatterDefault();
@@ -242,27 +245,27 @@ function registrationError(tool) {
     if (error)
       return error;
   }
-  const name = normalizedName(tool);
+  const name = normalizedName2(tool);
   if (!/^[A-Za-z0-9_-]{1,64}$/.test(name))
-    return new RegistrationError({ name, message: `Invalid tool name: ${name}` });
-  const id = effectiveName(tool);
+    return new RegistrationError2({ name, message: `Invalid tool name: ${name}` });
+  const id = effectiveName2(tool);
   if (tool.options?.codemode === false && id === "execute")
-    return new RegistrationError({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
+    return new RegistrationError2({ name: id, message: 'Tool name "execute" is reserved for CodeMode' });
   const result = Result.try({
-    try: () => ToolDefinition.make(definition(tool)),
-    catch: (error) => new RegistrationError({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
+    try: () => ToolDefinition.make(definition2(tool)),
+    catch: (error) => new RegistrationError2({ name: id, message: `Invalid tool definition ${id}: ${schemaMakeError(error)}` })
   });
   return Result.isFailure(result) ? result.failure : undefined;
 }
 function namespaceError(name) {
   if (name.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment)))
     return;
-  return new RegistrationError({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
+  return new RegistrationError2({ name, message: `Invalid tool namespace: ${JSON.stringify(name)}` });
 }
-var node = makeLocationNode({
-  service: Service,
+var node46 = makeLocationNode({
+  service: Service43,
   layer,
-  deps: [exports_hooks.node, exports_image.node]
+  deps: [node60, node50]
 });
 
-export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error2 as Error, FileContent, TextContent };
+export { RegistrationError2, Service43, node46, exports_tool, CallID2, Content2, Error2, FileContent3, TextContent2 };