@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-whczfbjh.js

@@ -0,0 +1,176 @@
+import {
+  useragent2
+} from "./aisdk-native-cjg4xdhd.js";
+import {
+  Service79
+} from "./aisdk-native-11nvngjf.js";
+import {
+  OAuth3,
+  Event18
+} from "./aisdk-native-111hscse.js";
+import {
+  ID11,
+  MethodID2
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  ID18
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  Family2
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  bootstrap2
+} from "./aisdk-native-pjvnvgmy.js";
+
+// src/plugin/provider/digitalocean.ts
+import { define } from "@opencode/plugin/effect/plugin";
+import { Clock, Deferred, Effect, Option, Schedule, Schema, Semaphore, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+var providerID = ID18.make("digitalocean");
+var integrationID = ID11.make("digitalocean");
+var methodID = MethodID2.make("browser");
+var clientID = "b1a6c5158156caac821fd1b30253ca8acb52454a48fa744420e41889cb589f82";
+var authorizeEndpoint = "https://cloud.digitalocean.com/v1/oauth/authorize";
+var routersEndpoint = "https://api.digitalocean.com/v2/gen-ai/models/routers";
+var callbackPort = 1456;
+var callbackPath = "/auth/callback";
+var tokenPath = "/auth/token";
+var RoutersResponse = Schema.Struct({
+  model_routers: Schema.Array(Schema.Struct({ name: Schema.NonEmptyString }))
+});
+var decodeCallback = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({
+  access_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.String),
+  state: Schema.optional(Schema.String),
+  error: Schema.optional(Schema.String),
+  error_description: Schema.optional(Schema.String)
+})));
+var oauth = {
+  integrationID,
+  method: {
+    id: methodID,
+    type: "oauth",
+    label: "Login with DigitalOcean"
+  },
+  authorize: () => Effect.gen(function* () {
+    const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
+    const token = yield* Deferred.make();
+    const { createServer } = yield* Effect.promise(() => import("node:http"));
+    const server = createServer((request, response) => {
+      const url = new URL(request.url ?? "/", "http://localhost");
+      if (request.method === "GET" && url.pathname === callbackPath) {
+        response.writeHead(200, { "Content-Type": "text/html" }).end(bootstrap2({ tokenPath, provider: "DigitalOcean" }));
+        return;
+      }
+      if (request.method === "POST" && url.pathname === tokenPath) {
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.on("end", () => {
+          const body = Option.getOrUndefined(decodeCallback(Buffer.concat(chunks).toString("utf8")));
+          const error = body?.error_description || body?.error;
+          const access = body?.access_token;
+          if (error || !access || body?.state !== state) {
+            const message = error || (access ? "Invalid OAuth state" : "Missing access token");
+            Effect.runFork(Deferred.fail(token, new Error(message)));
+            response.writeHead(400, { "Content-Type": "application/json" }).end(JSON.stringify({ error: message }));
+            return;
+          }
+          const expires = Number.parseInt(body.expires_in ?? "0", 10);
+          Effect.runFork(Deferred.succeed(token, {
+            access,
+            expiresIn: Number.isFinite(expires) && expires > 0 ? expires : 60 * 60 * 24 * 30
+          }));
+          response.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ ok: true }));
+        });
+        return;
+      }
+      response.writeHead(404).end("Not found");
+    });
+    const port = yield* listen(server);
+    yield* Effect.addFinalizer(() => Effect.sync(() => server.close()));
+    const redirect = `http://localhost:${port}${callbackPath}`;
+    return {
+      mode: "auto",
+      url: `${authorizeEndpoint}?${new URLSearchParams({
+        response_type: "token",
+        client_id: clientID,
+        redirect_uri: redirect,
+        scope: "genai:read inference:query",
+        state
+      })}`,
+      instructions: "Complete authorization in your browser. This window will close automatically.",
+      callback: Effect.gen(function* () {
+        const payload = yield* Deferred.await(token);
+        return OAuth3.make({
+          type: "oauth",
+          methodID,
+          access: payload.access,
+          refresh: "",
+          expires: (yield* Clock.currentTimeMillis) + payload.expiresIn * 1000
+        });
+      })
+    };
+  })
+};
+var DigitalOceanPlugin2 = define({
+  id: "opencode.provider.digitalocean",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service79;
+    const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = { routers: [] };
+    const load = Effect.fn("DigitalOceanPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active(integrationID);
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      if (credential?.type !== "oauth" || credential.methodID !== methodID) {
+        loaded.access = undefined;
+        loaded.routers = [];
+        return;
+      }
+      if (loaded.access !== credential.access) {
+        loaded.access = credential.access;
+        loaded.routers = [];
+      }
+      if (credential.expires !== 0 && credential.expires <= (yield* Clock.currentTimeMillis))
+        return;
+      const result = yield* http.execute(HttpClientRequest.get(routersEndpoint).pipe(HttpClientRequest.bearerToken(credential.access), HttpClientRequest.acceptJson, HttpClientRequest.setHeader("User-Agent", useragent2(ctx.app)))).pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(RoutersResponse)), Effect.timeout("10 seconds"), Effect.catch((cause) => Effect.logWarning("failed to sync DigitalOcean routers", { cause }).pipe(Effect.as(undefined))));
+      if (result)
+        loaded.routers = result.model_routers;
+    });
+    yield* ctx.integration.transform((draft) => {
+      draft.method.update(oauth);
+    });
+    yield* ctx.catalog.transform((evt) => {
+      if (!evt.provider.get(providerID))
+        return;
+      for (const router of loaded.routers) {
+        const id = `router:${router.name}`;
+        if (evt.model.get(providerID, id))
+          continue;
+        evt.model.update(providerID, id, (draft) => {
+          draft.name = router.name;
+          draft.family = Family2.make("digitalocean-inference-routers");
+          draft.capabilities = { tools: true, input: ["text"], output: ["text"] };
+          draft.limit = { context: 128000, output: 8192 };
+        });
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event18.Switched).pipe(Stream.filter((event) => event.data.integrationID === integrationID), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.repeat(Schedule.spaced("5 minutes")), Effect.forkScoped);
+  })
+});
+function listen(server) {
+  return Effect.callback((resume) => {
+    const onError = (error) => resume(Effect.fail(error));
+    server.once("error", onError);
+    server.listen(callbackPort, "localhost", () => {
+      server.off("error", onError);
+      resume(Effect.succeed(callbackPort));
+    });
+  }).pipe(Effect.mapError((cause) => ("code" in cause) && cause.code === "EADDRINUSE" ? new Error(`DigitalOcean login needs local port ${callbackPort}, but it is already in use. Stop the process using that port and try again.`) : cause));
+}
+
+export { DigitalOceanPlugin2 };

package/dist/chunks/aisdk-native-wtztk69x.js

@@ -0,0 +1,24 @@
+// src/database/migration/20260602002951_lowly_union_jack.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602002951_lowly_union_jack",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`permission\` (
+          \`id\` text PRIMARY KEY,
+          \`project_id\` text NOT NULL,
+          \`action\` text NOT NULL,
+          \`resource\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`fk_permission_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+      yield* tx.run(`CREATE UNIQUE INDEX \`permission_project_action_resource_idx\` ON \`permission\` (\`project_id\`,\`action\`,\`resource\`);`);
+    });
+  }
+};
+var _20260602002951_lowly_union_jack_default = migration;
+
+export { _20260602002951_lowly_union_jack_default };

package/dist/chunks/aisdk-native-wvvbdh4b.js

@@ -0,0 +1,279 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  ID2
+} from "./aisdk-native-0mesazry.js";
+import {
+  Service78,
+  login2,
+  node83
+} from "./aisdk-native-qx0n0hnh.js";
+import {
+  lazy2
+} from "./aisdk-native-88xbtdfr.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/pty.ts
+var exports_pty = {};
+__export(exports_pty, {
+  CreateInput: () => CreateInput2,
+  Event: () => Event3,
+  ExitedError: () => ExitedError2,
+  Info: () => Info2,
+  NotFoundError: () => NotFoundError2,
+  Pty: () => exports_pty,
+  Service: () => Service15,
+  UpdateInput: () => UpdateInput2,
+  node: () => node18
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Pty } from "@opencode/schema/pty";
+import { Event as Event3 } from "@opencode/schema/pty";
+var BUFFER_LIMIT = 1024 * 1024 * 2;
+var EXITED_LIMIT = 25;
+var pty = lazy2(() => import("#pty"));
+var Info2 = Pty.Info;
+var CreateInput2 = Pty.CreateInput;
+var UpdateInput2 = Pty.UpdateInput;
+
+class NotFoundError2 extends Schema.TaggedError()("Pty.NotFoundError", {
+  ptyID: ID2
+}) {
+}
+
+class ExitedError2 extends Schema.TaggedError()("Pty.ExitedError", {
+  ptyID: ID2
+}) {
+}
+
+class Service15 extends Context.Service()("@opencode/Pty") {
+}
+var layer = Layer.effect(Service15, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const location = yield* Service73;
+  const shell = yield* Service78;
+  const context = yield* Effect.context();
+  const runFork = Effect.runForkWith(context);
+  const sessions = new Map;
+  const exitOrder = [];
+  function notifyEnd(session, event) {
+    for (const subscriber of session.subscribers.values()) {
+      if (!subscriber.active) {
+        subscriber.end = event;
+        continue;
+      }
+      try {
+        subscriber.onEnd(event);
+      } catch {}
+    }
+    session.subscribers.clear();
+  }
+  function teardown(session) {
+    for (const listener of session.listeners)
+      listener.dispose();
+    session.listeners.length = 0;
+    if (session.info.status === "running") {
+      try {
+        session.process.kill();
+      } catch {}
+    }
+    notifyEnd(session, {});
+  }
+  yield* Effect.addFinalizer(() => Effect.sync(() => {
+    for (const session of sessions.values())
+      teardown(session);
+    sessions.clear();
+    exitOrder.length = 0;
+  }));
+  const requireSession = Effect.fn("Pty.requireSession")(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return yield* new NotFoundError2({ ptyID: id });
+    return session;
+  });
+  const removeSession = Effect.fnUntraced(function* (id) {
+    const session = sessions.get(id);
+    if (!session)
+      return;
+    sessions.delete(id);
+    const index = exitOrder.indexOf(id);
+    if (index !== -1)
+      exitOrder.splice(index, 1);
+    yield* Effect.logInfo("removing session", { id });
+    teardown(session);
+    yield* bus.publish(Pty.Event.Deleted, { id: session.info.id });
+  });
+  const remove = Effect.fn("Pty.remove")(function* (id) {
+    yield* requireSession(id);
+    yield* removeSession(id);
+  });
+  const list = Effect.fn("Pty.list")(function* () {
+    return Array.from(sessions.values()).map((session) => session.info);
+  });
+  const get = Effect.fn("Pty.get")(function* (id) {
+    return (yield* requireSession(id)).info;
+  });
+  const create = Effect.fn("Pty.create")(function* (input) {
+    const id = ID2.ascending();
+    const command = input.command || (yield* shell.resolve({ priority: "config" }));
+    const args = login2(command) ? [...input.args ?? [], "-l"] : [...input.args ?? []];
+    const cwd = input.cwd || location.directory;
+    const env = {
+      ...process.env,
+      ...input.env,
+      TERM: "xterm-256color",
+      OPENCODE_TERMINAL: "1"
+    };
+    if (process.platform === "win32") {
+      env.LC_ALL = "C.UTF-8";
+      env.LC_CTYPE = "C.UTF-8";
+      env.LANG = "C.UTF-8";
+    }
+    yield* Effect.logInfo("creating session", { id, cmd: command, args, cwd });
+    const { spawn } = yield* Effect.promise(() => pty());
+    const proc = yield* Effect.sync(() => spawn(command, args, { name: "xterm-256color", cwd, env }));
+    const info = {
+      id,
+      title: input.title || `Terminal ${id.slice(-4)}`,
+      command,
+      args,
+      cwd,
+      status: "running",
+      pid: proc.pid
+    };
+    const session = {
+      info,
+      process: proc,
+      buffer: "",
+      bufferCursor: 0,
+      cursor: 0,
+      subscribers: new Map,
+      listeners: []
+    };
+    sessions.set(id, session);
+    session.listeners.push(proc.onData((chunk) => {
+      session.cursor += chunk.length;
+      for (const [token, subscriber] of session.subscribers.entries()) {
+        if (!subscriber.active) {
+          subscriber.pending.push(chunk);
+          continue;
+        }
+        try {
+          subscriber.onData(chunk);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      }
+      session.buffer += chunk;
+      if (session.buffer.length <= BUFFER_LIMIT)
+        return;
+      const excess = session.buffer.length - BUFFER_LIMIT;
+      session.buffer = session.buffer.slice(excess);
+      session.bufferCursor += excess;
+    }), proc.onExit(({ exitCode }) => {
+      if (session.info.status === "exited")
+        return;
+      session.info.status = "exited";
+      session.info.exitCode = exitCode;
+      notifyEnd(session, { exitCode });
+      exitOrder.push(id);
+      runFork(Effect.gen(function* () {
+        yield* Effect.logInfo("session exited", { id, exitCode });
+        yield* bus.publish(Pty.Event.Exited, { id, exitCode });
+        while (exitOrder.length > EXITED_LIMIT) {
+          const oldest = exitOrder[0];
+          if (!oldest)
+            break;
+          yield* removeSession(oldest);
+        }
+      }));
+    }));
+    yield* bus.publish(Pty.Event.Created, { info });
+    return info;
+  });
+  const update = Effect.fn("Pty.update")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (input.title)
+      session.info.title = input.title;
+    if (input.size && session.info.status === "running")
+      session.process.resize(input.size.cols, input.size.rows);
+    yield* bus.publish(Pty.Event.Updated, { info: session.info });
+    return session.info;
+  });
+  const write = Effect.fn("Pty.write")(function* (id, data) {
+    const session = yield* requireSession(id);
+    if (session.info.status === "running")
+      session.process.write(data);
+  });
+  const attach = Effect.fn("Pty.attach")(function* (id, input) {
+    const session = yield* requireSession(id);
+    if (session.info.status !== "running")
+      return yield* new ExitedError2({ ptyID: id });
+    yield* Effect.logInfo("client attached to session", { id, directory: location.directory });
+    const token = {};
+    const subscriber = {
+      onData: input.onData,
+      onEnd: input.onEnd,
+      active: false,
+      detached: false,
+      pending: []
+    };
+    session.subscribers.set(token, subscriber);
+    const start = session.bufferCursor;
+    const end = session.cursor;
+    const from = input.cursor === -1 ? end : typeof input.cursor === "number" && Number.isSafeInteger(input.cursor) ? Math.max(0, input.cursor) : 0;
+    const replay = (() => {
+      if (!session.buffer || from >= end)
+        return "";
+      const offset = Math.max(0, from - start);
+      if (offset >= session.buffer.length)
+        return "";
+      return session.buffer.slice(offset);
+    })();
+    return {
+      replay,
+      cursor: end,
+      write: (data) => {
+        if (session.info.status === "running")
+          session.process.write(data);
+      },
+      activate: () => {
+        if (subscriber.active || subscriber.detached)
+          return;
+        subscriber.active = true;
+        try {
+          for (const chunk of subscriber.pending)
+            subscriber.onData(chunk);
+          subscriber.pending.length = 0;
+          if (subscriber.end)
+            subscriber.onEnd(subscriber.end);
+        } catch {
+          session.subscribers.delete(token);
+        }
+      },
+      detach: () => {
+        subscriber.detached = true;
+        subscriber.pending.length = 0;
+        subscriber.end = undefined;
+        session.subscribers.delete(token);
+      }
+    };
+  });
+  return Service15.of({ list, get, create, update, remove, write, attach });
+}));
+var node18 = makeLocationNode({
+  service: Service15,
+  layer,
+  deps: [node84, node78, node83]
+});
+
+export { Info2, CreateInput2, UpdateInput2, NotFoundError2, ExitedError2, Service15, node18, exports_pty, Event3 };

package/dist/chunks/aisdk-native-wzcb8dk1.js

@@ -0,0 +1,109 @@
+import {
+  BlockedError2
+} from "./aisdk-native-h05a6ep0.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/plan.ts
+var exports_plan = {};
+__export(exports_plan, {
+  PlanPlugin: () => exports_plan,
+  Plugin: () => Plugin30
+});
+import { Message, ToolFailure } from "@opencode/ai";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Agent } from "@opencode/schema/agent";
+import { Global } from "@opencode/util/global";
+import { Effect, Stream } from "effect";
+import path from "path";
+var plan = Agent.ID.make("plan");
+var enter = (directory) => `<system-reminder>
+You are in Plan mode. Discuss the plan with the user directly in the conversation. Do not create or update plan files unless the user explicitly asks you to; when they do, write them only in:
+${directory}
+
+Do not modify any other files or ask a subagent to do so.
+
+You remain in Plan mode until the user switches agents. If the user asks you to implement changes, do not do so. Tell them they need to switch agents.
+</system-reminder>`;
+var leave = `<system-reminder>
+You are NO LONGER in Plan mode. The previous Plan restrictions no longer apply. Any Plan mode instructions from earlier in this conversation are no longer active.
+</system-reminder>`;
+var Plugin30 = define({
+  id: "opencode.plan",
+  effect: Effect.fn(function* (ctx) {
+    const global = yield* Global.Service;
+    const directory = path.join(global.home, ".opencode", "plan");
+    const enterReminder = enter(directory);
+    yield* ctx.agent.transform((editor) => {
+      editor.update(plan, (item) => {
+        item.name = Agent.Name.make("Plan");
+        item.description = "Read-only agent for exploring the codebase and planning work before implementation.";
+        item.mode = "primary";
+        item.permissions.push({ action: "question", resource: "*", effect: "allow" });
+        item.permissions.push({ action: "edit", resource: "*", effect: "deny" });
+        item.permissions.push({ action: "edit", resource: path.join(directory, "*"), effect: "allow" });
+        item.permissions.push({ action: "external_directory", resource: path.join(directory, "*"), effect: "allow" });
+      });
+    });
+    yield* ctx.tool.hook("execute.after", (event) => {
+      if (event.agent !== plan)
+        return Effect.void;
+      if (event.status !== "error")
+        return Effect.void;
+      if (event.tool !== "edit" && event.tool !== "write" && event.tool !== "patch")
+        return Effect.void;
+      if (!(event.error.error instanceof BlockedError2))
+        return Effect.void;
+      event.error = new ToolFailure({
+        message: `Cannot use ${event.tool} to modify files outside the Plan directory: ${directory}`
+      });
+      return Effect.void;
+    });
+    yield* ctx.session.hook("context", (event) => {
+      const reminder = lastReminder(event.messages, enterReminder);
+      const missing = event.agent === plan && reminder !== enterReminder;
+      const stale = event.agent !== plan && reminder === enterReminder;
+      const text = missing ? enterReminder : stale ? leave : undefined;
+      if (!text)
+        return Effect.void;
+      const at = event.messages.at(-1)?.role === "user" ? event.messages.length - 1 : event.messages.length;
+      event.messages.splice(at, 0, Message.user(text));
+      return ctx.session.synthetic({ sessionID: event.sessionID, text, resume: false }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to persist Plan mode reminder", { sessionID: event.sessionID, cause })));
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "session.created" || event.type === "session.agent.selected"), Stream.runForEach((event) => {
+      const text = switchReminder(event, enterReminder);
+      if (!text)
+        return Effect.void;
+      return ctx.session.synthetic({
+        sessionID: event.data.sessionID,
+        text,
+        resume: false
+      }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to inject Plan mode reminder", { sessionID: event.data.sessionID, cause })));
+    }), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+function switchReminder(event, enterReminder) {
+  if (event.type === "session.created") {
+    if (event.data.agent !== plan)
+      return;
+    return enterReminder;
+  }
+  if (event.data.agent === event.data.previous)
+    return;
+  if (event.data.agent === plan)
+    return enterReminder;
+  if (event.data.previous === plan)
+    return leave;
+  return;
+}
+function lastReminder(messages, enterReminder) {
+  return messages.reduce((found, message) => {
+    const part = message.role === "user" && message.content.length === 1 ? message.content[0] : undefined;
+    if (part?.type !== "text")
+      return found;
+    return part.text === enterReminder || part.text === leave ? part.text : found;
+  }, undefined);
+}
+
+export { Plugin30, exports_plan };

package/dist/chunks/aisdk-native-x0ckcb58.js

@@ -0,0 +1,54 @@
+// src/github-copilot/chat/openai-compatible-prepare-tools.ts
+import { UnsupportedFunctionalityError } from "@ai-sdk/provider";
+function prepareTools2({
+  tools,
+  toolChoice
+}) {
+  tools = tools?.length ? tools : undefined;
+  const toolWarnings = [];
+  if (tools == null) {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+  const openaiCompatTools = [];
+  for (const tool of tools) {
+    if (tool.type === "provider") {
+      toolWarnings.push({ type: "unsupported", feature: `tool type: ${tool.type}` });
+    } else {
+      openaiCompatTools.push({
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: tool.inputSchema
+        }
+      });
+    }
+  }
+  if (toolChoice == null) {
+    return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings };
+  }
+  const type = toolChoice.type;
+  switch (type) {
+    case "auto":
+    case "none":
+    case "required":
+      return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+    case "tool":
+      return {
+        tools: openaiCompatTools,
+        toolChoice: {
+          type: "function",
+          function: { name: toolChoice.toolName }
+        },
+        toolWarnings
+      };
+    default: {
+      const _exhaustiveCheck = type;
+      throw new UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
+      });
+    }
+  }
+}
+
+export { prepareTools2 };