@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19129

package/dist/chunks/{schema-k3e42drn.js → pty-qaymkmh1.js}

@@ -1,7 +1,7 @@
 // src/util/which.ts
 import whichPkg from "which";
 import path from "path";
-function which(cmd, env, bin) {
+function which2(cmd, env, bin) {
   const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
   const full = base && bin ? base + path.delimiter + bin : base || bin;
   return whichPkg.sync(cmd, {
@@ -11,4 +11,4 @@ function which(cmd, env, bin) {
   });
 }
 
-export { which };
+export { which2 };

package/dist/chunks/{schema-264e1nfp.js → pty-qepd2pkj.js}

@@ -1,10 +1,10 @@
 import {
-  SessionSchema
-} from "./schema-bjwj8hwv.js";
+  AbsolutePath2,
+  RelativePath2
+} from "./pty-p8qxwesx.js";
 import {
-  AbsolutePath,
-  RelativePath
-} from "./schema-j07kk359.js";
+  SessionSchema2
+} from "./pty-jysfrgga.js";
 
 // src/session/info.ts
 import { DateTime, Schema } from "effect";
@@ -17,14 +17,14 @@ import { Workspace } from "@opencode-ai/schema/workspace";
 import { PersistedRevert } from "@opencode-ai/schema/session-revert";
 import { Money } from "@opencode-ai/schema/money";
 var decodeRevert = Schema.decodeUnknownSync(PersistedRevert);
-function fromRow(row) {
-  return SessionSchema.Info.make({
-    id: SessionSchema.ID.make(row.id),
+function fromRow2(row) {
+  return SessionSchema2.Info.make({
+    id: SessionSchema2.ID.make(row.id),
     projectID: Project.ID.make(row.project_id),
     title: row.title ?? undefined,
-    parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
+    parentID: row.parent_id ? SessionSchema2.ID.make(row.parent_id) : undefined,
     fork: row.fork_session_id && row.fork_boundary ? {
-      sessionID: SessionSchema.ID.make(row.fork_session_id),
+      sessionID: SessionSchema2.ID.make(row.fork_session_id),
       boundary: row.fork_boundary
     } : undefined,
     agent: row.agent ? Agent.ID.make(row.agent) : undefined,
@@ -44,10 +44,10 @@ function fromRow(row) {
       }
     },
     location: Location.Ref.make({
-      directory: AbsolutePath.make(row.directory),
+      directory: AbsolutePath2.make(row.directory),
       workspaceID: row.workspace_id ? Workspace.ID.make(row.workspace_id) : undefined
     }),
-    subpath: row.path ? RelativePath.make(row.path) : undefined,
+    subpath: row.path ? RelativePath2.make(row.path) : undefined,
     metadata: row.metadata ?? undefined,
     revert: row.revert ? decodeRevert(row.revert) : undefined,
     outcome: row.idle_outcome ?? undefined,
@@ -61,4 +61,4 @@ function fromRow(row) {
   });
 }
 
-export { fromRow };
+export { fromRow2 };

package/dist/chunks/{schema-sem2g21k.js → pty-qfa1cgps.js}

@@ -1,8 +1,8 @@
 // src/database/schema.sql.ts
 import { integer } from "drizzle-orm/sqlite-core";
-var Timestamps = {
+var Timestamps2 = {
   time_created: integer().notNull().$default(() => Date.now()),
   time_updated: integer().notNull().$onUpdate(() => Date.now())
 };
 
-export { Timestamps };
+export { Timestamps2 };

package/dist/chunks/{schema-1jjzsk9c.js → pty-qhehnkc2.js}

@@ -1,54 +1,54 @@
 import {
-  collectBoundedResponseBody
-} from "./schema-jve7t217.js";
+  Service53
+} from "./pty-eqyz6y0f.js";
 import {
-  MAX_MARKDOWN_BYTES,
-  convertHTMLToMarkdown
-} from "./schema-bybkghrn.js";
+  MAX_MARKDOWN_BYTES2,
+  convertHTMLToMarkdown2
+} from "./pty-a1tpkmh4.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  collectBoundedResponseBody2
+} from "./pty-3v8g72cx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/tool/plugin/webfetch.ts
 var exports_webfetch = {};
 __export(exports_webfetch, {
-  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS,
-  Input: () => Input,
-  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES,
-  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS,
-  Plugin: () => Plugin,
+  DEFAULT_TIMEOUT_SECONDS: () => DEFAULT_TIMEOUT_SECONDS2,
+  Input: () => Input11,
+  MAX_RESPONSE_BYTES: () => MAX_RESPONSE_BYTES2,
+  MAX_TIMEOUT_SECONDS: () => MAX_TIMEOUT_SECONDS2,
+  Plugin: () => Plugin11,
   WebFetchTool: () => exports_webfetch,
-  convertHTMLToMarkdown: () => convertHTMLToMarkdown,
-  description: () => description,
-  extractTextFromHTML: () => extractTextFromHTML,
-  name: () => name
+  convertHTMLToMarkdown: () => convertHTMLToMarkdown2,
+  description: () => description5,
+  extractTextFromHTML: () => extractTextFromHTML2,
+  name: () => name11
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { Duration, Effect, Schema } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { Parser } from "htmlparser2";
-var name = "webfetch";
-var MAX_RESPONSE_BYTES = MAX_MARKDOWN_BYTES;
-var DEFAULT_TIMEOUT_SECONDS = 30;
-var MAX_TIMEOUT_SECONDS = 120;
-var description = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
+var name11 = "webfetch";
+var MAX_RESPONSE_BYTES2 = MAX_MARKDOWN_BYTES2;
+var DEFAULT_TIMEOUT_SECONDS2 = 30;
+var MAX_TIMEOUT_SECONDS2 = 120;
+var description5 = `Fetch content from an HTTP or HTTPS URL and return it as text, markdown, or HTML. Markdown is the default.
 
 Use a more targeted tool when one is available. This tool is read-only. Large text results may be replaced with a preview while the complete output is retained in managed storage.`;
-var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS));
-var Input = Schema.Struct({
+var Timeout = Schema.Finite.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(MAX_TIMEOUT_SECONDS2));
+var Input11 = Schema.Struct({
   url: Schema.String.annotate({ description: "The HTTP or HTTPS URL to fetch content from" }),
   format: Schema.Literals(["text", "markdown", "html"]).annotate({ description: "The format to return the content in. Defaults to markdown." }).pipe(Schema.withDecodingDefaultKey(Effect.succeed("markdown"))),
   timeout: Schema.optionalKey(Timeout).annotate({
-    description: `Optional timeout in seconds (maximum: ${MAX_TIMEOUT_SECONDS})`
+    description: `Optional timeout in seconds (maximum: ${MAX_TIMEOUT_SECONDS2})`
   })
 });
 var Output = Schema.Struct({
   url: Schema.String,
   contentType: Schema.String,
-  format: Input.fields.format,
+  format: Input11.fields.format,
   output: Schema.String
 });
 var acceptHeader = (format) => {
@@ -79,7 +79,7 @@ var assertHttpUrl = (url) => {
     throw new Error("URL must use http:// or https://");
 };
 var execute = (http, url, format, userAgent = openCodeUserAgent) => http.execute(request(url, format, userAgent)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk));
-var collectBody = (response) => collectBoundedResponseBody(response, MAX_RESPONSE_BYTES, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES} byte limit)`));
+var collectBody = (response) => collectBoundedResponseBody2(response, MAX_RESPONSE_BYTES2, () => new Error(`Response too large (exceeds ${MAX_RESPONSE_BYTES2} byte limit)`));
 var mimeFrom = (contentType) => contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
 var isImageAttachment = (mime) => mime.startsWith("image/") && mime !== "image/svg+xml" && mime !== "image/vnd.fastbidsheet";
 var isTextualMime = (mime) => !mime || mime.startsWith("text/") || mime === "application/json" || mime.endsWith("+json") || mime === "application/xml" || mime.endsWith("+xml") || mime === "application/javascript" || mime === "application/x-javascript";
@@ -87,21 +87,21 @@ var convert = (content, contentType, format) => {
   if (!contentType.includes("text/html"))
     return content;
   if (format === "markdown")
-    return convertHTMLToMarkdown(content);
+    return convertHTMLToMarkdown2(content);
   if (format === "text")
-    return extractTextFromHTML(content);
+    return extractTextFromHTML2(content);
   return content;
 };
-var Plugin = {
+var Plugin11 = {
   id: "opencode.tool.webfetch",
   effect: Effect.fn("WebFetchTool.Plugin")(function* (ctx) {
     const http = yield* HttpClient.HttpClient;
-    const permission = yield* exports_permission.Service;
+    const permission = yield* Service53;
     yield* ctx.tool.transform((editor) => editor.add({
-      name,
+      name: name11,
       options: { codemode: false },
-      description,
-      input: Input,
+      description: description5,
+      input: Input11,
       output: Output,
       execute: (input, context) => Effect.gen(function* () {
         yield* Effect.try({
@@ -109,7 +109,7 @@ var Plugin = {
           catch: (error) => error
         });
         yield* permission.assert({
-          action: name,
+          action: name11,
           resources: [input.url],
           save: ["*"],
           metadata: input,
@@ -119,15 +119,15 @@ var Plugin = {
         });
         const { body, contentType } = yield* Effect.gen(function* () {
           const response = yield* execute(http, input.url, input.format).pipe(Effect.catchIf(isCloudflareChallenge, () => execute(http, input.url, input.format, "opencode")));
-          const contentType2 = response.headers["content-type"] || "";
-          const mime = mimeFrom(contentType2);
+          const contentType = response.headers["content-type"] || "";
+          const mime = mimeFrom(contentType);
           if (isImageAttachment(mime))
             return yield* Effect.fail(new Error(`Unsupported fetched image content type: ${mime}`));
           if (!isTextualMime(mime))
             return yield* Effect.fail(new Error(`Unsupported fetched file content type: ${mime}`));
-          return { body: yield* collectBody(response), contentType: contentType2 };
+          return { body: yield* collectBody(response), contentType };
         }).pipe(Effect.timeoutOrElse({
-          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS),
+          duration: Duration.seconds(input.timeout ?? DEFAULT_TIMEOUT_SECONDS2),
           orElse: () => Effect.fail(new Error("Request timed out"))
         }));
         const content = new TextDecoder().decode(body);
@@ -146,12 +146,12 @@ var Plugin = {
     })).pipe(Effect.orDie);
   })
 };
-function extractTextFromHTML(html) {
+function extractTextFromHTML2(html) {
   let text = "";
   let skipDepth = 0;
   const parser = new Parser({
-    onopentag(name2) {
-      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name2))
+    onopentag(name) {
+      if (skipDepth > 0 || ["script", "style", "noscript", "iframe", "object", "embed"].includes(name))
         skipDepth++;
     },
     ontext(input) {
@@ -167,4 +167,4 @@ function extractTextFromHTML(html) {
   parser.end();
   return text.trim();
 }
-export { name, MAX_RESPONSE_BYTES, DEFAULT_TIMEOUT_SECONDS, MAX_TIMEOUT_SECONDS, description, Input, Plugin, extractTextFromHTML, exports_webfetch };
+export { name11, MAX_RESPONSE_BYTES2, DEFAULT_TIMEOUT_SECONDS2, MAX_TIMEOUT_SECONDS2, description5, Input11, Plugin11, extractTextFromHTML2, exports_webfetch };

package/dist/chunks/pty-qnzq15jm.js

@@ -0,0 +1,24 @@
+import {
+  mergeOverlay2
+} from "./pty-tdt6s1r3.js";
+import {
+  Service48
+} from "./pty-vrktewq8.js";
+import {
+  Service62
+} from "./pty-amgxn0m4.js";
+
+// src/plugin/provider/configured.ts
+import { Effect, Option } from "effect";
+var configuredSettings2 = Effect.fn("ProviderPlugin.configuredSettings")(function* (id) {
+  const catalog = yield* Service48;
+  const current = (yield* catalog.provider.get(id))?.settings;
+  const service = yield* Effect.serviceOption(Service62);
+  const entries = Option.isSome(service) ? yield* service.value.entries() : [];
+  return foldSettings2(entries, id, current);
+});
+function foldSettings2(entries, id, initial) {
+  return entries.filter((entry) => entry.type === "document").reduce((settings, entry) => mergeOverlay2(settings, entry.info.providers?.[id]?.settings), initial);
+}
+
+export { configuredSettings2, foldSettings2 };

package/dist/chunks/{schema-9dbv6hqn.js → pty-qs7zdahm.js}

@@ -1,9 +1,8 @@
 import {
-  exports_provider
-} from "./schema-68yag814.js";
-import {
-  __require
-} from "./schema-vpjkya7h.js";
+  ID18,
+  isAISDK2,
+  packageName2
+} from "./pty-tdt6s1r3.js";
 
 // src/plugin/provider/google-vertex.ts
 import { Effect } from "effect";
@@ -33,14 +32,14 @@ function authFetch(fetchWithRuntimeOptions) {
     return typeof fetchWithRuntimeOptions === "function" ? fetchWithRuntimeOptions(input, { ...init, headers }) : fetch(input, { ...init, headers });
   };
 }
-var GoogleVertexPlugin = define({
+var GoogleVertexPlugin2 = define({
   id: "opencode.provider.google.vertex",
   effect: Effect.fn(function* (ctx) {
     yield* ctx.catalog.transform((evt) => {
       for (const item of evt.provider.list()) {
-        if (!exports_provider.isAISDK(item.provider.package))
+        if (!isAISDK2(item.provider.package))
           continue;
-        if (exports_provider.packageName(item.provider.package) !== "@ai-sdk/google-vertex" && !(item.provider.id === exports_provider.ID.googleVertex && exports_provider.packageName(item.provider.package)?.includes("@ai-sdk/openai-compatible")))
+        if (packageName2(item.provider.package) !== "@ai-sdk/google-vertex" && !(item.provider.id === ID18.googleVertex && packageName2(item.provider.package)?.includes("@ai-sdk/openai-compatible")))
           continue;
         const project = resolveProject(item.provider.settings ?? {});
         const location = String(resolveLocation(item.provider.settings ?? {}));
@@ -57,19 +56,19 @@ var GoogleVertexPlugin = define({
       }
     });
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
-      if (evt.model.providerID === exports_provider.ID.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
+      if (evt.model.providerID === ID18.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
         evt.options.fetch = authFetch(evt.options.fetch);
         return;
       }
       if (evt.package === "@ai-sdk/google-vertex/anthropic") {
-        const mod2 = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"));
-        const project2 = resolveProject(evt.options);
-        const location2 = String(resolveLocation(evt.options));
-        const regionalBaseURL = (location2 === "eu" || location2 === "us") && project2 && !evt.options.baseURL ? `https://aiplatform.${location2}.rep.googleapis.com/v1/projects/${project2}/locations/${location2}/publishers/anthropic/models` : undefined;
-        evt.sdk = mod2.createVertexAnthropic({
+        const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"));
+        const project = resolveProject(evt.options);
+        const location = String(resolveLocation(evt.options));
+        const regionalBaseURL = (location === "eu" || location === "us") && project && !evt.options.baseURL ? `https://aiplatform.${location}.rep.googleapis.com/v1/projects/${project}/locations/${location}/publishers/anthropic/models` : undefined;
+        evt.sdk = mod.createVertexAnthropic({
           ...evt.options,
-          project: project2,
-          location: location2,
+          project,
+          location,
           ...regionalBaseURL ? { baseURL: regionalBaseURL } : {}
         });
         return;
@@ -88,11 +87,11 @@ var GoogleVertexPlugin = define({
       });
     }));
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== exports_provider.ID.googleVertex)
+      if (evt.model.providerID !== ID18.googleVertex)
         return;
       evt.language = evt.sdk.languageModel(String(evt.model.modelID ?? evt.model.id).trim());
     }));
   })
 });
 
-export { GoogleVertexPlugin };
+export { GoogleVertexPlugin2 };

package/dist/chunks/{schema-mnyszbxc.js → pty-qsdy395h.js}

@@ -1,20 +1,20 @@
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/config/plugin/entry-observer.ts
 var exports_entry_observer = {};
 __export(exports_entry_observer, {
   ConfigEntryObserver: () => exports_entry_observer,
-  observe: () => observe
+  observe: () => observe2
 });
 import { Effect, Stream } from "effect";
-var observe = Effect.fnUntraced(function* (config, event, reload) {
+var observe2 = Effect.fnUntraced(function* (config, event, reload) {
   const loaded = { entries: yield* config.entries() };
   const refresh = config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(reload));
-  yield* event.subscribe().pipe(Stream.filter((event2) => event2.type === "config.updated"), Stream.runForEach(() => refresh), Effect.forkScoped({ startImmediately: true }));
+  yield* event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => refresh), Effect.forkScoped({ startImmediately: true }));
   loaded.entries = yield* config.entries();
   return loaded;
 });
 
-export { observe, exports_entry_observer };
+export { observe2, exports_entry_observer };

package/dist/chunks/pty-qvbcabdc.js

@@ -0,0 +1,41 @@
+import {
+  absoluteColumn2,
+  absoluteArrayColumn2
+} from "./pty-r8dhm0tv.js";
+import {
+  Timestamps2
+} from "./pty-qfa1cgps.js";
+
+// src/project/sql.ts
+import { isNotNull, isNull, ne, or } from "drizzle-orm";
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+var ProjectTable2 = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: absoluteColumn2().notNull(),
+  vcs: text().$type(),
+  name: text(),
+  icon_url: text(),
+  icon_url_override: text(),
+  icon_color: text(),
+  ...Timestamps2,
+  time_initialized: integer(),
+  sandboxes: absoluteArrayColumn2().notNull(),
+  commands: text({ mode: "json" }).$type()
+});
+var ProjectDirectoryTable2 = sqliteTable("project_directory", {
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  directory: absoluteColumn2().notNull(),
+  type: text().$type(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+function upsertProject2(db, project) {
+  const vcs = project.vcs?.type;
+  return db.insert(ProjectTable2).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
+    target: ProjectTable2.id,
+    set: { vcs: vcs ?? null },
+    setWhere: vcs ? or(isNull(ProjectTable2.vcs), ne(ProjectTable2.vcs, vcs)) : isNotNull(ProjectTable2.vcs)
+  }).run();
+}
+
+export { ProjectTable2, ProjectDirectoryTable2, upsertProject2 };

package/dist/chunks/{schema-y71jz153.js → pty-qydr0h4k.js}

@@ -1,58 +1,61 @@
 import {
-  exports_tool
-} from "./schema-svrgfpe2.js";
+  definition2,
+  execute3,
+  normalizeContent2,
+  normalizedName2,
+  effectiveName2
+} from "./pty-3t738kvx.js";
 import {
-  definition,
-  effectiveName,
-  execute,
-  normalizeContent,
-  normalizedName
-} from "./schema-xx9qfgev.js";
+  create2,
+  catalog2
+} from "./pty-6tf8tr4v.js";
 import {
-  exports_image
-} from "./schema-22x56hdn.js";
+  create3
+} from "./pty-kg06axw8.js";
 import {
-  exports_wildcard
-} from "./schema-edxnhgvj.js";
+  Service57,
+  node61
+} from "./pty-cznc2qrv.js";
 import {
-  exports_hooks
-} from "./schema-xws7arpm.js";
+  Service69,
+  node74
+} from "./pty-s0gfpzhy.js";
 import {
-  exports_state
-} from "./schema-j6s3yjyb.js";
+  match2
+} from "./pty-y1fvbwt7.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./pty-9rqn6x4v.js";
 
 // src/tool.ts
-var exports_tool2 = {};
-__export(exports_tool2, {
-  CallID: () => CallID,
-  Content: () => Content,
-  Error: () => Error2,
-  FileContent: () => FileContent,
-  RegistrationError: () => RegistrationError,
-  Service: () => Service,
-  TextContent: () => TextContent,
-  Tool: () => exports_tool2,
-  node: () => node
+var exports_tool = {};
+__export(exports_tool, {
+  CallID: () => CallID2,
+  Content: () => Content3,
+  Error: () => Error3,
+  FileContent: () => FileContent3,
+  RegistrationError: () => RegistrationError2,
+  Service: () => Service45,
+  TextContent: () => TextContent2,
+  Tool: () => exports_tool,
+  node: () => node48
 });
-import { CallID, Content, Error as Error2, FileContent, TextContent } from "@opencode-ai/schema/tool";
+import { CallID as CallID2, Content as Content3, Error as Error3, 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 Service45 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(Service45, Effect.gen(function* () {
+  const hooks = yield* Service69;
+  const image = yield* Service57;
   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 Service45.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 node48 = makeLocationNode({
+  service: Service45,
   layer,
-  deps: [exports_hooks.node, exports_image.node]
+  deps: [node74, node61]
 });
 
-export { RegistrationError, Service, node, exports_tool2 as exports_tool, CallID, Content, Error2 as Error, FileContent, TextContent };
+export { RegistrationError2, Service45, node48, exports_tool, CallID2, Content3, Error3, FileContent3, TextContent2 };