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

package/dist/chunks/{schema-r9srg7kj.js → event-logger-65rxya3j.js}

@@ -1,70 +1,76 @@
 import {
-  exports_runner
-} from "./schema-0rz7yd7x.js";
+  Service80,
+  node85
+} from "./event-logger-4vtp7hga.js";
 import {
-  exports_run_coordinator
-} from "./schema-f8wvq04h.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_inbox
-} from "./schema-3rcd4hwd.js";
+  Service44,
+  node47
+} from "./event-logger-c2khgprk.js";
 import {
-  toSessionError
-} from "./schema-d6pj50wp.js";
+  Service33,
+  node36
+} from "./event-logger-yhtqjkzd.js";
 import {
-  exports_service
-} from "./schema-6bxzghb6.js";
+  SessionEvent2
+} from "./event-logger-mntxs535.js";
 import {
-  exports_job
-} from "./schema-dt5yw4ma.js";
+  make14
+} from "./event-logger-djtdz80w.js";
 import {
-  exports_store
-} from "./schema-a4wk7wxx.js";
+  DrainResult2,
+  Service28
+} from "./event-logger-xw0r27ex.js";
 import {
-  UserInterruptedError
-} from "./schema-2sqw2jjm.js";
+  UserInterruptedError2
+} from "./event-logger-n6wnzfnt.js";
 import {
-  SessionEvent
-} from "./schema-a83yvq99.js";
+  Service72,
+  node77
+} from "./event-logger-xf2wyvfy.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  toSessionError2
+} from "./event-logger-d3qtrs71.js";
 import {
-  exports_database
-} from "./schema-8scqw7rh.js";
+  nextPromotable2
+} from "./event-logger-aymbgepw.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/session/execution.ts
 var exports_execution = {};
 __export(exports_execution, {
-  Service: () => Service,
+  Service: () => Service27,
   SessionExecution: () => exports_execution,
-  layer: () => layer,
-  node: () => node,
-  noopLayer: () => noopLayer,
-  terminal: () => terminal
+  layer: () => layer11,
+  node: () => node32,
+  noopLayer: () => noopLayer2,
+  terminal: () => terminal2
 });
 import { Cause, Context, Effect, Exit, Layer } from "effect";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-class Service extends Context.Service()("@opencode/SessionExecution") {
+class Service27 extends Context.Service()("@opencode/SessionExecution") {
 }
-function terminal(exit, reason) {
+function terminal2(exit, reason) {
   if (Exit.isSuccess(exit))
     return { type: "succeeded" };
   if (Cause.hasInterrupts(exit.cause))
     return { type: "interrupted", reason: reason ?? "shutdown" };
   const failure = Cause.squash(exit.cause);
-  if (failure instanceof UserInterruptedError)
+  if (failure instanceof UserInterruptedError2)
     return { type: "interrupted", reason: "user" };
-  return { type: "failed", error: toSessionError(failure) };
+  return { type: "failed", error: toSessionError2(failure) };
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const store = yield* exports_store.Service;
-  const instances = yield* exports_service.Service;
-  const bus = yield* exports_bus.Service;
-  const jobs = yield* exports_job.Service;
-  const db = (yield* exports_database.Service).db;
+var layer11 = Layer.effect(Service27, Effect.gen(function* () {
+  const store = yield* Service72;
+  const instances = yield* Service33;
+  const bus = yield* Service79;
+  const jobs = yield* Service44;
+  const db = (yield* Service80).db;
   const reportLifecycle = (sessionID, effect) => effect.pipe(Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to publish Session execution lifecycle", cause).pipe(Effect.annotateLogs({ sessionID }))), Effect.asVoid);
   const claimOnCommit = (sessionID) => ({
     commit: () => store.claim(sessionID)
@@ -76,41 +82,41 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const session = yield* store.get(sessionID);
     if (!session)
       return yield* Effect.die(new Error(`Session not found: ${sessionID}`));
-    const result = yield* exports_runner.Service.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(instances.provide(session), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
-    return yield* exports_runner.DrainResult.$match(result, {
+    const result = yield* Service28.use((runner) => runner.drain({ sessionID, force, continuation, promotable })).pipe(instances.provide(session), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID }))));
+    return yield* DrainResult2.$match(result, {
       Complete: () => Effect.void,
-      Moved: (result2) => drain(sessionID, false, result2.continuation, promotable)
+      Moved: (result) => drain(sessionID, false, result.continuation, promotable)
     });
   });
-  const coordinator = yield* exports_run_coordinator.make({
-    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
+  const coordinator = yield* make14({
+    started: (sessionID) => reportLifecycle(sessionID, bus.publish(SessionEvent2.Execution.Started, { sessionID }, claimOnCommit(sessionID))),
     drain: (sessionID, force, promotable) => drain(sessionID, force, undefined, promotable),
     settled: (sessionID, exit, reason) => reportLifecycle(sessionID, Effect.gen(function* () {
-      const outcome = terminal(exit, reason);
+      const outcome = terminal2(exit, reason);
       if (outcome.type === "succeeded") {
-        yield* bus.publish(SessionEvent.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
+        yield* bus.publish(SessionEvent2.Execution.Succeeded, { sessionID }, releaseOnCommit(sessionID));
         return;
       }
       if (outcome.type === "interrupted") {
         if (outcome.reason === "user")
           yield* jobs.cancel(sessionID);
-        yield* bus.publish(SessionEvent.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
+        yield* bus.publish(SessionEvent2.Execution.Interrupted, { sessionID, reason: outcome.reason }, outcome.reason === "shutdown" ? undefined : releaseOnCommit(sessionID));
         return;
       }
-      yield* bus.publish(SessionEvent.Execution.Failed, {
+      yield* bus.publish(SessionEvent2.Execution.Failed, {
         sessionID,
         error: outcome.error
       }, releaseOnCommit(sessionID));
     }))
   });
-  return Service.of({
+  return Service27.of({
     active: coordinator.active,
     isActive: coordinator.isActive,
     interrupt: (sessionID, options) => Effect.gen(function* () {
       const interrupted = yield* coordinator.interrupt(sessionID, "user");
       if (!options?.continue)
         return interrupted;
-      const next = yield* exports_inbox.nextPromotable(db, sessionID, "input");
+      const next = yield* nextPromotable2(db, sessionID, "input");
       if (next === undefined)
         return interrupted;
       if (next.delivery === "steer" || next.type === "compaction" || next.type === "move")
@@ -122,12 +128,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     awaitIdle: coordinator.awaitIdle
   });
 }));
-var node = makeGlobalNode({
-  service: Service,
-  layer,
-  deps: [exports_store.node, exports_service.node, exports_bus.node, exports_database.node, exports_job.node]
+var node32 = makeGlobalNode({
+  service: Service27,
+  layer: layer11,
+  deps: [node77, node36, node84, node85, node47]
 });
-var noopLayer = Layer.succeed(Service, Service.of({
+var noopLayer2 = Layer.succeed(Service27, Service27.of({
   active: Effect.succeed(new Set),
   isActive: () => Effect.succeed(false),
   resume: () => Effect.void,
@@ -136,4 +142,4 @@ var noopLayer = Layer.succeed(Service, Service.of({
   awaitIdle: () => Effect.void
 }));
 
-export { Service, terminal, layer, node, noopLayer, exports_execution };
+export { Service27, terminal2, layer11, node32, noopLayer2, exports_execution };

package/dist/chunks/{schema-nec1705c.js → event-logger-65xfkb7w.js}

@@ -1,23 +1,22 @@
 import {
-  exports_wildcard
-} from "./schema-edxnhgvj.js";
+  ps2
+} from "./event-logger-12m9a30f.js";
 import {
-  lazy
-} from "./schema-8w9tzfz1.js";
+  lazy2
+} from "./event-logger-88xbtdfr.js";
 import {
-  exports_select
-} from "./schema-xvqr7khp.js";
+  match2
+} from "./event-logger-y1fvbwt7.js";
 import {
-  __export,
-  __require
-} from "./schema-vpjkya7h.js";
+  __export
+} from "./event-logger-9rqn6x4v.js";
 
 // src/shell/parse.ts
 var exports_parse = {};
 __export(exports_parse, {
   ShellParse: () => exports_parse,
-  scan: () => scan,
-  scanPortable: () => scanPortable
+  scan: () => scan2,
+  scanPortable: () => scanPortable2
 });
 import { Effect } from "effect";
 import { fileURLToPath } from "url";
@@ -166,27 +165,27 @@ var ARITY = {
   "yarn run": 3
 };
 var PREFIX_LENGTH = Math.max(...Object.values(ARITY));
-var scan = Effect.fnUntraced(function* (command, shell, cwd, options) {
+var scan2 = Effect.fnUntraced(function* (command, shell, cwd, options) {
   if (options?.portable)
-    return yield* scanPortable(command, shell, cwd);
+    return yield* scanPortable2(command, shell, cwd);
   return yield* scanLegacy(command, shell, cwd);
 });
 var scanLegacy = Effect.fnUntraced(function* (command, shell, cwd) {
   const parsers = yield* Effect.promise(load);
-  const powershell = exports_select.ps(shell);
+  const powershell = ps2(shell);
   const tree = (powershell ? parsers.ps : parsers.bash).parse(command);
   if (!tree)
     return yield* Effect.fail(new Error("Failed to parse shell command"));
-  return yield* Effect.acquireUseRelease(Effect.succeed(tree), (tree2) => Effect.sync(() => tree2.rootNode.descendantsOfType("command").reduce((result, node) => {
+  return yield* Effect.acquireUseRelease(Effect.succeed(tree), (tree) => Effect.sync(() => tree.rootNode.descendantsOfType("command").reduce((result, node) => {
     if (!node)
       return result;
-    const command2 = parts(node);
-    const tokens = command2.map((part) => part.text);
+    const command = parts(node);
+    const tokens = command.map((part) => part.text);
     if (tokens.length === 0)
       return result;
     const name = powershell ? tokens[0].toLowerCase() : tokens[0];
     if (CWD.has(name)) {
-      result.directories.push(...directoryArgs(command2, powershell, cwd, shell));
+      result.directories.push(...directoryArgs(command, powershell, cwd, shell));
       return result;
     }
     result.commands.push({
@@ -194,14 +193,14 @@ var scanLegacy = Effect.fnUntraced(function* (command, shell, cwd) {
       save: `${prefix(tokens).join(" ")} *`
     });
     return result;
-  }, { commands: [], directories: [] })), (tree2) => Effect.sync(() => tree2.delete()));
+  }, { commands: [], directories: [] })), (tree) => Effect.sync(() => tree.delete()));
 });
-var scanPortable = Effect.fnUntraced(function* (command, shell, cwd) {
+var scanPortable2 = Effect.fnUntraced(function* (command, shell, cwd) {
   const { ShellScan } = yield* Effect.tryPromise({
     try: () => import("../shell/scan.js"),
     catch: (cause) => new Error(`Portable shell scanner failed to load: ${cause}`, { cause })
   });
-  const powershell = exports_select.ps(shell);
+  const powershell = ps2(shell);
   const result = powershell ? ShellScan.scanPowerShell(command) : ShellScan.scan(command);
   if (result.kind === "opaque")
     return yield* Effect.fail(new Error(`Portable shell scanner cannot analyze command: ${result.reason}`));
@@ -228,7 +227,7 @@ var scanPortable = Effect.fnUntraced(function* (command, shell, cwd) {
     const selected = prefix(words.slice(0, PREFIX_LENGTH));
     const conventional = `${selected.join(" ")} *`;
     const end = item.wordEnds?.[selected.length - 1];
-    const save = !powershell || end === undefined || exports_wildcard.match(item.resource, conventional) ? conventional : (() => {
+    const save = !powershell || end === undefined || match2(item.resource, conventional) ? conventional : (() => {
       const boundary = item.wordEnds?.find((value) => value >= end && (value >= item.resource.length || /\s/.test(item.resource[value]))) ?? end;
       const separator = /^\s+(?:`(?:\r\n|\r|\n)\s*)?/.exec(item.resource.slice(boundary))?.[0];
       return `${item.resource.slice(0, boundary)}${separator ?? " "}*`;
@@ -246,7 +245,7 @@ function parts(node) {
     if (!child)
       return [];
     if (child.type === "command_elements")
-      return Array.from({ length: child.childCount }).flatMap((_2, itemIndex) => {
+      return Array.from({ length: child.childCount }).flatMap((_, itemIndex) => {
         const item = child.child(itemIndex);
         if (!item || item.type === "command_argument_sep" || item.type === "redirection")
           return [];
@@ -264,9 +263,9 @@ function directoryArgs(command, powershell, cwd, shell) {
   let path2 = false;
   for (const part of command.slice(1)) {
     if (path2) {
-      const value2 = directoryArgument(part.text, powershell, cwd, shell);
-      if (value2)
-        directories.push(value2);
+      const value = directoryArgument(part.text, powershell, cwd, shell);
+      if (value)
+        directories.push(value);
       path2 = false;
       continue;
     }
@@ -324,7 +323,7 @@ function resolve(asset) {
     return asset;
   return fileURLToPath(new URL(asset, import.meta.url));
 }
-var load = lazy(initialize);
+var load = lazy2(initialize);
 async function initialize() {
   const { Parser, Language } = await import("web-tree-sitter");
   await Parser.init({ locateFile: () => resolve(shellParserWasm.runtime) });
@@ -339,4 +338,4 @@ async function initialize() {
   return { bash, ps };
 }
 
-export { scan, scanPortable, exports_parse };
+export { scan2, scanPortable2, exports_parse };

package/dist/chunks/{schema-c77ad0vh.js → event-logger-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/{schema-svrgfpe2.js → event-logger-6tf8tr4v.js}

@@ -1,17 +1,17 @@
 import {
-  definition,
-  normalizedName
-} from "./schema-xx9qfgev.js";
+  definition2,
+  normalizedName2
+} from "./event-logger-3t738kvx.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-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/{schema-pxfvvnmb.js → event-logger-6vq97qmv.js}

@@ -1,24 +1,24 @@
 import {
-  webSearchPreviewArgsSchema
-} from "./schema-7n9qwqk4.js";
+  codeInterpreterArgsSchema2
+} from "./event-logger-eh3zwz77.js";
 import {
-  fileSearchArgsSchema
-} from "./schema-wj4sxzqa.js";
+  fileSearchArgsSchema2
+} from "./event-logger-e73j6tqm.js";
 import {
-  codeInterpreterArgsSchema
-} from "./schema-5a5ch9ts.js";
+  webSearchArgsSchema2
+} from "./event-logger-3wcehsnq.js";
 import {
-  webSearchArgsSchema
-} from "./schema-gy500k2r.js";
+  webSearchPreviewArgsSchema2
+} from "./event-logger-dap0rakb.js";
 import {
-  imageGenerationArgsSchema
-} from "./schema-4b2tz2m9.js";
+  imageGenerationArgsSchema2
+} from "./event-logger-4y7fprxs.js";
 
 // src/github-copilot/responses/openai-responses-prepare-tools.ts
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
-function getResponsesHostedTool(tool) {
+function getResponsesHostedTool2(tool) {
   switch (tool.id) {
     case "openai.file_search":
       return { name: tool.name, type: "file_search", responseType: "file_search" };
@@ -33,7 +33,7 @@ function getResponsesHostedTool(tool) {
   }
   return;
 }
-function prepareResponsesTools({
+function prepareResponsesTools2({
   tools,
   toolChoice,
   strictJsonSchema
@@ -46,7 +46,7 @@ function prepareResponsesTools({
   const hostedTools = tools.flatMap((tool) => {
     if (tool.type !== "provider")
       return [];
-    const hostedTool = getResponsesHostedTool(tool);
+    const hostedTool = getResponsesHostedTool2(tool);
     return hostedTool ? [hostedTool] : [];
   });
   const selectedToolName = toolChoice?.type === "tool" ? toolChoice.toolName : undefined;
@@ -56,7 +56,7 @@ function prepareResponsesTools({
       functionality: `ambiguous tool choice '${selectedToolName}': multiple tool definitions share this name`
     });
   }
-  const selectedHostedTool = selectedTools[0]?.type === "provider" ? getResponsesHostedTool(selectedTools[0]) : undefined;
+  const selectedHostedTool = selectedTools[0]?.type === "provider" ? getResponsesHostedTool2(selectedTools[0]) : undefined;
   const ambiguousHostedResponse = toolChoice?.type === "none" || toolChoice?.type === "tool" ? undefined : hostedTools.find((tool) => new Set(hostedTools.filter((candidate) => candidate.responseType === tool.responseType).map((item) => item.name)).size > 1);
   if (ambiguousHostedResponse) {
     const names = new Set(hostedTools.filter((tool) => tool.responseType === ambiguousHostedResponse.responseType).map((tool) => tool.name));
@@ -87,7 +87,7 @@ function prepareResponsesTools({
       case "provider": {
         switch (tool.id) {
           case "openai.file_search": {
-            const args = fileSearchArgsSchema.parse(tool.args);
+            const args = fileSearchArgsSchema2.parse(tool.args);
             openaiTools.push({
               type: "file_search",
               vector_store_ids: args.vectorStoreIds,
@@ -101,7 +101,7 @@ function prepareResponsesTools({
             break;
           }
           case "openai.web_search_preview": {
-            const args = webSearchPreviewArgsSchema.parse(tool.args);
+            const args = webSearchPreviewArgsSchema2.parse(tool.args);
             openaiTools.push({
               type: "web_search_preview",
               search_context_size: args.searchContextSize,
@@ -110,7 +110,7 @@ function prepareResponsesTools({
             break;
           }
           case "openai.web_search": {
-            const args = webSearchArgsSchema.parse(tool.args);
+            const args = webSearchArgsSchema2.parse(tool.args);
             openaiTools.push({
               type: "web_search",
               filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : undefined,
@@ -120,7 +120,7 @@ function prepareResponsesTools({
             break;
           }
           case "openai.code_interpreter": {
-            const args = codeInterpreterArgsSchema.parse(tool.args);
+            const args = codeInterpreterArgsSchema2.parse(tool.args);
             openaiTools.push({
               type: "code_interpreter",
               container: args.container == null ? { type: "auto", file_ids: undefined } : typeof args.container === "string" ? args.container : { type: "auto", file_ids: args.container.fileIds }
@@ -128,7 +128,7 @@ function prepareResponsesTools({
             break;
           }
           case "openai.image_generation": {
-            const args = imageGenerationArgsSchema.parse(tool.args);
+            const args = imageGenerationArgsSchema2.parse(tool.args);
             openaiTools.push({
               type: "image_generation",
               background: args.background,
@@ -182,4 +182,4 @@ function prepareResponsesTools({
   }
 }
 
-export { getResponsesHostedTool, prepareResponsesTools };
+export { getResponsesHostedTool2, prepareResponsesTools2 };