@opencode/core 0.0.0-reserved → 2.0.0

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

@@ -0,0 +1,470 @@
+import {
+  Service73
+} from "./aisdk-native-6fyvx278.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  chunksByFile2
+} from "./aisdk-native-tazgh4e4.js";
+import {
+  DiffError2
+} from "./aisdk-native-cxvbe4d1.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/plugin/vcs/git.ts
+var exports_git = {};
+__export(exports_git, {
+  Plugin: () => Plugin20,
+  VcsGitPlugin: () => exports_git
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { AppProcess } from "@opencode/util/process";
+var Plugin20 = define({
+  id: "opencode.vcs.git",
+  effect: Effect.fn("VcsGitPlugin")(function* (ctx) {
+    const location = yield* Service73;
+    if (location.vcs?.type !== "git")
+      return;
+    const processes = yield* AppProcess.Service;
+    const adapter = make(processes, {
+      directory: location.directory,
+      worktree: location.project.directory
+    });
+    yield* ctx.vcs.transform((editor) => {
+      editor.add({
+        id: "git",
+        name: "Git",
+        info: () => adapter.info(),
+        base: () => adapter.base(),
+        branches: (input) => adapter.branches({ search: input.search, limit: input.limit }),
+        status: () => adapter.status(),
+        diff: (input) => adapter.diff(input.mode, { context: input.context, base: input.base })
+      });
+    });
+  })
+});
+function make(proc, input) {
+  const ctx = { git: makeGit(proc), directory: input.directory, worktree: input.worktree };
+  return {
+    info: Effect.fn("VcsGit.info")(function* () {
+      const [current, root] = yield* Effect.all([ctx.git.branch(ctx.directory), ctx.git.defaultBranch(ctx.directory)], {
+        concurrency: 2
+      });
+      return { branch: { current, default: root?.name } };
+    }),
+    base: () => ctx.git.base(ctx.directory),
+    branches: Effect.fn("VcsGit.branches")(function* (options) {
+      return yield* ctx.git.branches(ctx.directory, options);
+    }),
+    status: Effect.fn("VcsGit.status")(function* () {
+      const git = ctx.git;
+      const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined;
+      const [list, stats] = yield* Effect.all([git.status(ctx.directory), ref ? git.stats(ctx.directory, ref) : Effect.succeed([])], { concurrency: 2 });
+      const map = nums(stats);
+      return yield* Effect.forEach(list.toSorted((a, b) => a.file.localeCompare(b.file)), (item) => Effect.gen(function* () {
+        const stat = map.get(item.file) ?? (item.status === "added" ? yield* git.statUntracked(ctx.worktree, item.file) : undefined);
+        return {
+          file: item.file,
+          additions: stat?.additions ?? 0,
+          deletions: stat?.deletions ?? 0,
+          status: item.status
+        };
+      }));
+    }),
+    diff: Effect.fn("VcsGit.diff")(function* (mode, options) {
+      const git = ctx.git;
+      if (mode === "working") {
+        return yield* track(ctx, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined, options);
+      }
+      if (!(yield* git.hasHead(ctx.directory))) {
+        return mode === "committed" ? [] : yield* track(ctx, undefined, options);
+      }
+      const base = options?.base ?? (yield* git.defaultBranch(ctx.directory))?.ref;
+      const ref = base ? yield* git.mergeBase(ctx.directory, base) : undefined;
+      if (!ref) {
+        return yield* new DiffError2({
+          message: base ? `No merge base available for ${base}` : "No review base available"
+        });
+      }
+      return yield* diffAgainstRef(ctx, ref, { ...options, target: mode === "committed" ? "HEAD" : undefined });
+    })
+  };
+}
+var cfg = [
+  "--no-optional-locks",
+  "-c",
+  "core.autocrlf=false",
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "core.longpaths=true",
+  "-c",
+  "core.symlinks=true",
+  "-c",
+  "core.quotepath=false"
+];
+var kind = (code) => {
+  if (code === "??")
+    return "added";
+  if (code.includes("U"))
+    return "modified";
+  if (code.includes("A") && !code.includes("D"))
+    return "added";
+  if (code.includes("D") && !code.includes("A"))
+    return "deleted";
+  return "modified";
+};
+var nuls = (text) => text.split("\x00").filter(Boolean);
+function makeGit(proc) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("git", [...cfg, ...args], {
+      cwd: opts.cwd,
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.orElseSucceed(() => ({ exitCode: 1, text: () => "", truncated: false })));
+  const text = Effect.fnUntraced(function* (args, opts) {
+    return (yield* run(args, opts)).text();
+  });
+  const lines = Effect.fnUntraced(function* (args, opts) {
+    return (yield* text(args, opts)).split(/\r?\n/).map((item) => item.trim()).filter(Boolean);
+  });
+  const configured = Effect.fnUntraced(function* (cwd, list) {
+    const result = yield* run(["config", "init.defaultBranch"], { cwd });
+    const name = result.text().trim();
+    if (!name || !list.includes(name))
+      return;
+    return { name, ref: name };
+  });
+  const primary = Effect.fnUntraced(function* (cwd) {
+    const list = yield* lines(["remote"], { cwd });
+    if (list.includes("origin"))
+      return "origin";
+    if (list.length === 1)
+      return list[0];
+    if (list.includes("upstream"))
+      return "upstream";
+    return list[0];
+  });
+  const branch = Effect.fn("VcsGit.branch")(function* (cwd) {
+    const result = yield* run(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const branches = Effect.fn("VcsGit.branches")(function* (cwd, options) {
+    const search = options?.search?.trim().replace(/[*?[\]\\]/g, "\\$&");
+    return (yield* lines([
+      "for-each-ref",
+      "--ignore-case",
+      "--sort=refname",
+      "--sort=-committerdate",
+      "--format=%(refname:short)",
+      ...options?.limit ? [`--count=${options.limit}`] : [],
+      ...search ? [`refs/heads/*${search}*`, `refs/remotes/*${search}*`] : ["refs/heads", "refs/remotes"]
+    ], { cwd })).filter((item) => !item.endsWith("/HEAD"));
+  });
+  const defaultBranch = Effect.fn("VcsGit.defaultBranch")(function* (cwd) {
+    const remote = yield* primary(cwd);
+    if (remote) {
+      const head = yield* run(["symbolic-ref", `refs/remotes/${remote}/HEAD`], { cwd });
+      if (head.exitCode === 0) {
+        const ref = head.text().trim().replace(/^refs\/remotes\//, "");
+        const name = ref.startsWith(`${remote}/`) ? ref.slice(`${remote}/`.length) : "";
+        if (name)
+          return { name, ref };
+      }
+    }
+    const list = yield* lines(["for-each-ref", "--format=%(refname:short)", "refs/heads"], { cwd });
+    const next = yield* configured(cwd, list);
+    if (next)
+      return next;
+    if (list.includes("main"))
+      return { name: "main", ref: "main" };
+    if (list.includes("master"))
+      return { name: "master", ref: "master" };
+  });
+  const resolve = Effect.fnUntraced(function* (cwd, ref) {
+    const result = yield* run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fnUntraced(function* (cwd, commit, ref) {
+    if (!/^[a-f0-9]{40,64}$/.test(commit))
+      return false;
+    return (yield* run(["merge-base", "--is-ancestor", commit, ref], { cwd })).exitCode === 0;
+  });
+  const namedRef = Effect.fnUntraced(function* (cwd, input) {
+    if (input === "HEAD" || input.endsWith("/HEAD") || /[~^:@{}\s]/.test(input))
+      return;
+    const ref = (yield* text(["rev-parse", "--symbolic-full-name", "--verify", "--end-of-options", input], {
+      cwd
+    })).trim();
+    if (!/^refs\/(heads|remotes)\/.+/.test(ref) || ref.endsWith("/HEAD") || !(yield* resolve(cwd, ref)))
+      return;
+    return { name: ref.replace(/^refs\/heads\//, "").replace(/^refs\/remotes\/[^/]+\//, ""), ref };
+  });
+  const base = Effect.fn("VcsGit.base")(function* (cwd) {
+    if (!(yield* hasHead(cwd)))
+      return null;
+    const current = yield* branch(cwd);
+    if (!current)
+      return yield* new DiffError2({ message: "Choose a review base" });
+    const history = (yield* lines(["reflog", "show", "--max-count=256", "--format=%H%x00%gs", `refs/heads/${current}`], {
+      cwd
+    })).flatMap((line) => {
+      const match = /^([a-f0-9]+)\0(.+)$/.exec(line);
+      return match ? [{ commit: match[1], message: match[2] }] : [];
+    });
+    const renamed = history.some((entry) => entry.message.startsWith("Branch: renamed "));
+    const creation = renamed ? undefined : history.find((entry) => entry.message.startsWith("branch: Created from "));
+    const origin = creation?.message.slice("branch: Created from ".length);
+    if (creation && origin) {
+      const candidate = yield* namedRef(cwd, origin);
+      if (candidate && candidate.name !== current && (yield* ancestor(cwd, creation.commit, "HEAD")) && (yield* ancestor(cwd, creation.commit, candidate.ref))) {
+        return { ...candidate, source: "reflog" };
+      }
+    }
+    const root = yield* defaultBranch(cwd);
+    if (!root || current !== root.name)
+      return yield* new DiffError2({ message: "Choose a review base" });
+    const candidate = yield* namedRef(cwd, root.ref);
+    if (!candidate)
+      return yield* new DiffError2({ message: "The default review base is unavailable" });
+    return { name: root.name, ref: candidate.ref, source: "default" };
+  });
+  const hasHead = Effect.fn("VcsGit.hasHead")(function* (cwd) {
+    const result = yield* run(["rev-parse", "--verify", "HEAD"], { cwd });
+    return result.exitCode === 0;
+  });
+  const mergeBase = Effect.fn("VcsGit.mergeBase")(function* (cwd, base) {
+    const ref = yield* resolve(cwd, base);
+    if (!ref)
+      return;
+    const result = yield* run(["merge-base", ref, "HEAD"], { cwd });
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const status = Effect.fn("VcsGit.statusNames")(function* (cwd) {
+    return nuls(yield* text(["status", "--porcelain=v1", "--untracked-files=all", "--no-renames", "-z", "--", "."], { cwd })).flatMap((item) => {
+      const file = item.slice(3);
+      if (!file)
+        return [];
+      const code = item.slice(0, 2);
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsGit.diffNames")(function* (cwd, ref, target) {
+    const result = yield* run(["diff", "--no-ext-diff", "--no-renames", "--name-status", "-z", ref, ...target ? [target] : [], "--", "."], { cwd });
+    if (result.exitCode !== 0)
+      return yield* new DiffError2({ message: "Unable to list Git changes" });
+    const list = nuls(result.text());
+    return list.flatMap((code, idx) => {
+      if (idx % 2 !== 0)
+        return [];
+      const file = list[idx + 1];
+      if (!code || !file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const stats = Effect.fn("VcsGit.stats")(function* (cwd, ref, target) {
+    return nuls(yield* text(["diff", "--no-ext-diff", "--no-renames", "--numstat", "-z", ref, ...target ? [target] : [], "--", "."], { cwd })).flatMap((item) => {
+      const a = item.indexOf("\t");
+      const b = item.indexOf("\t", a + 1);
+      if (a === -1 || b === -1)
+        return [];
+      const file = item.slice(b + 1);
+      if (!file)
+        return [];
+      const adds = item.slice(0, a);
+      const dels = item.slice(a + 1, b);
+      const additions = adds === "-" ? 0 : Number.parseInt(adds || "0", 10);
+      const deletions = dels === "-" ? 0 : Number.parseInt(dels || "0", 10);
+      return [
+        {
+          file,
+          additions: Number.isFinite(additions) ? additions : 0,
+          deletions: Number.isFinite(deletions) ? deletions : 0
+        }
+      ];
+    });
+  });
+  const patch = Effect.fn("VcsGit.patch")(function* (cwd, ref, file, options) {
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const patchAll = Effect.fn("VcsGit.patchAll")(function* (cwd, ref, options) {
+    const result = yield* run([
+      "diff",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      ref,
+      ...options?.target ? [options.target] : [],
+      "--",
+      "."
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const patchUntracked = Effect.fn("VcsGit.patchUntracked")(function* (cwd, file, options) {
+    const result = yield* run([
+      "diff",
+      "--no-index",
+      "--patch",
+      "--no-ext-diff",
+      "--no-renames",
+      `--unified=${options?.context ?? 3}`,
+      "--",
+      "/dev/null",
+      file
+    ], { cwd, maxOutputBytes: options?.maxOutputBytes });
+    return { text: result.truncated ? "" : result.text(), truncated: result.truncated };
+  });
+  const statUntracked = Effect.fn("VcsGit.statUntracked")(function* (cwd, file) {
+    const result = yield* run(["diff", "--no-index", "--numstat", "--", "/dev/null", file], {
+      cwd,
+      maxOutputBytes: 4096
+    });
+    if (result.truncated)
+      return;
+    const parts = result.text().split("\t");
+    if (parts.length < 2)
+      return;
+    const additions = parts[0] === "-" ? 0 : Number.parseInt(parts[0] || "0", 10);
+    const deletions = parts[1] === "-" ? 0 : Number.parseInt(parts[1] || "0", 10);
+    return {
+      file,
+      additions: Number.isFinite(additions) ? additions : 0,
+      deletions: Number.isFinite(deletions) ? deletions : 0
+    };
+  });
+  return {
+    branch,
+    branches,
+    base,
+    defaultBranch,
+    hasHead,
+    mergeBase,
+    status,
+    diff,
+    stats,
+    patch,
+    patchAll,
+    patchUntracked,
+    statUntracked
+  };
+}
+var nums = (list) => new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }]));
+var merge = (...lists) => {
+  const out = new Map;
+  lists.flat().forEach((item) => {
+    if (!out.has(item.file))
+      out.set(item.file, item);
+  });
+  return [...out.values()];
+};
+var emptyBatch = () => ({ patches: new Map, capped: false });
+var batchPatches = Effect.fnUntraced(function* (ctx, ref, list, options) {
+  if (list.length === 0)
+    return emptyBatch();
+  const result = yield* ctx.git.patchAll(ctx.directory, ref, {
+    target: options?.target,
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
+  });
+  return {
+    patches: chunksByFile2(result, (index) => list[index]?.file),
+    capped: result.truncated
+  };
+});
+var nativePatch = Effect.fnUntraced(function* (ctx, ref, item, options) {
+  const result = item.code === "??" || !ref ? yield* ctx.git.patchUntracked(ctx.worktree, item.file, {
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
+  }) : yield* ctx.git.patch(ctx.worktree, ref, item.file, {
+    target: options?.target,
+    context: options?.context ?? PATCH_CONTEXT_LINES2,
+    maxOutputBytes: MAX_PATCH_BYTES2
+  });
+  if (!result.truncated && result.text)
+    return result.text;
+  return emptyPatch2(item.file);
+});
+var totalPatch = (file, patch, total) => {
+  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES2)
+    return { patch, capped: false };
+  return { patch: emptyPatch2(file), capped: true };
+};
+var patchForItem = Effect.fnUntraced(function* (ctx, ref, item, batch, capped, options) {
+  if (capped)
+    return emptyPatch2(item.file);
+  const batched = batch.patches.get(item.file);
+  if (batched !== undefined)
+    return batched;
+  if (item.code !== "??" && batch.capped)
+    return emptyPatch2(item.file);
+  return yield* nativePatch(ctx, ref, item, options);
+});
+var files = Effect.fnUntraced(function* (ctx, ref, list, map, batch, options) {
+  const next = [];
+  let total = 0;
+  let capped = false;
+  for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
+    const stat = map.get(item.file) ?? (!options?.target && item.status === "added" ? yield* ctx.git.statUntracked(ctx.worktree, item.file) : undefined);
+    const patch = yield* patchForItem(ctx, ref, item, batch, capped, options);
+    const result = capped ? { patch, capped: true } : totalPatch(item.file, patch, total);
+    capped = capped || result.capped;
+    if (!capped) {
+      total += Buffer.byteLength(result.patch);
+      capped = total >= MAX_TOTAL_PATCH_BYTES2;
+    }
+    next.push({
+      file: item.file,
+      patch: result.patch,
+      additions: stat?.additions ?? 0,
+      deletions: stat?.deletions ?? 0,
+      status: item.status
+    });
+  }
+  return next;
+});
+var diffAgainstRef = Effect.fnUntraced(function* (ctx, ref, options) {
+  const [list, stats, extra] = yield* Effect.all([
+    ctx.git.diff(ctx.directory, ref, options?.target),
+    ctx.git.stats(ctx.directory, ref, options?.target),
+    options?.target ? Effect.succeed([]) : ctx.git.status(ctx.directory)
+  ], { concurrency: 3 });
+  return yield* files(ctx, ref, merge(list, extra.filter((item) => item.code === "??")), nums(stats), yield* batchPatches(ctx, ref, list, options), options);
+});
+var track = Effect.fnUntraced(function* (ctx, ref, options) {
+  if (!ref)
+    return yield* files(ctx, ref, yield* ctx.git.status(ctx.directory), new Map, emptyBatch(), options);
+  return yield* diffAgainstRef(ctx, ref, options);
+});
+
+export { Plugin20, exports_git };

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

@@ -0,0 +1,74 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/shell/result.ts
+var exports_result = {};
+__export(exports_result, {
+  ShellResult: () => exports_result,
+  metadata: () => metadata2,
+  notice: () => notice2,
+  notification: () => notification2,
+  output: () => output2,
+  unavailable: () => unavailable2,
+  userNotification: () => userNotification2
+});
+var missing = "Shell command output is no longer available.";
+var unavailable2 = {
+  output: missing,
+  cursor: Buffer.byteLength(missing),
+  size: Buffer.byteLength(missing),
+  truncated: false
+};
+function output2(result) {
+  return {
+    output: result.capture?.output ?? unavailable2.output,
+    truncated: result.capture?.truncated ?? false,
+    ...result.info.exit !== undefined ? { exit: result.info.exit } : {},
+    ...result.info.status === "timeout" ? { timeout: true } : {}
+  };
+}
+function notice2(output) {
+  if (output.timeout)
+    return "Command timed out before completion.";
+  if (output.exit !== undefined)
+    return `Command exited with code ${output.exit}.`;
+}
+function metadata2(output) {
+  return {
+    truncated: output.truncated,
+    ...output.exit !== undefined ? { exit: output.exit } : {},
+    ...output.timeout !== undefined ? { timeout: output.timeout } : {}
+  };
+}
+function notification2(input) {
+  return {
+    text: `<shell id="${input.jobID ?? input.shellID}" state="${input.state}" command="${input.command}">
+${input.text}
+</shell>`,
+    metadata: {
+      source: "shell",
+      shellID: input.shellID,
+      ...input.jobID !== undefined ? { jobID: input.jobID } : {},
+      state: input.state,
+      ...input.output ? metadata2(input.output) : {}
+    }
+  };
+}
+function userNotification2(result) {
+  const captured = output2(result);
+  const status = result.info.status === "killed" ? "Command cancelled." : notice2(captured) ?? "Command exited with code unknown.";
+  const message = notification2({
+    shellID: result.info.id,
+    command: result.info.command,
+    state: result.info.status === "killed" ? "cancelled" : "completed",
+    text: `${captured.output}
+
+${status}`,
+    output: captured
+  });
+  return { ...message, text: `The following shell command was executed by the user:
+${message.text}` };
+}
+
+export { unavailable2, output2, notice2, metadata2, notification2, userNotification2, exports_result };

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

@@ -0,0 +1,146 @@
+// src/github-copilot/chat/convert-to-openai-compatible-chat-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import { convertToBase64 } from "@ai-sdk/provider-utils";
+function getOpenAIMetadata(message) {
+  return message?.providerOptions?.copilot ?? {};
+}
+function convertToOpenAICompatibleChatMessages2(prompt) {
+  const messages = [];
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content,
+          ...metadata
+        });
+        break;
+      }
+      case "user": {
+        if (content.length === 1 && content[0].type === "text") {
+          messages.push({
+            role: "user",
+            content: content[0].text,
+            ...getOpenAIMetadata(content[0])
+          });
+          break;
+        }
+        messages.push({
+          role: "user",
+          content: content.map((part) => {
+            const partMetadata = getOpenAIMetadata(part);
+            switch (part.type) {
+              case "text": {
+                return { type: "text", text: part.text, ...partMetadata };
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+                  return {
+                    type: "image_url",
+                    image_url: {
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
+                    },
+                    ...partMetadata
+                  };
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`
+                  });
+                }
+              }
+            }
+          }),
+          ...metadata
+        });
+        break;
+      }
+      case "assistant": {
+        let text = "";
+        let reasoningText;
+        let reasoningOpaque;
+        const toolCalls = [];
+        for (const part of content) {
+          const partMetadata = getOpenAIMetadata(part);
+          const partOpaque = part.providerOptions?.copilot?.reasoningOpaque;
+          if (partOpaque && !reasoningOpaque) {
+            reasoningOpaque = partOpaque;
+          }
+          switch (part.type) {
+            case "text": {
+              text += part.text;
+              break;
+            }
+            case "reasoning": {
+              if (part.text)
+                reasoningText = part.text;
+              break;
+            }
+            case "tool-call": {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: "function",
+                function: {
+                  name: part.toolName,
+                  arguments: JSON.stringify(part.input)
+                },
+                ...partMetadata
+              });
+              break;
+            }
+          }
+        }
+        messages.push({
+          role: "assistant",
+          content: text || null,
+          tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+          reasoning_text: reasoningOpaque ? reasoningText : undefined,
+          reasoning_opaque: reasoningOpaque,
+          ...metadata
+        });
+        break;
+      }
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "execution-denied":
+              contentValue = output.reason ?? "Tool execution denied.";
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
+          const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+          messages.push({
+            role: "tool",
+            tool_call_id: toolResponse.toolCallId,
+            content: contentValue,
+            ...toolResponseMetadata
+          });
+        }
+        break;
+      }
+      default: {
+        const _exhaustiveCheck = role;
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+      }
+    }
+  }
+  return messages;
+}
+
+export { convertToOpenAICompatibleChatMessages2 };