@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-wxpch4dk.js

@@ -0,0 +1,197 @@
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  Service22,
+  readText2,
+  syncTextBom2
+} from "./repository-h0gkjmvb.js";
+import {
+  Service14
+} from "./repository-58e8mpmb.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service19,
+  resolvePath2
+} from "./repository-pvp1cs2e.js";
+import {
+  fileDiff2
+} from "./repository-6prwharc.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/edit.ts
+var exports_edit = {};
+__export(exports_edit, {
+  EditTool: () => exports_edit,
+  Input: () => Input9,
+  Output: () => Output5,
+  Plugin: () => Plugin26,
+  name: () => name9
+});
+import { ToolFailure } from "@opencode/ai";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { Bom } from "@opencode/util/bom";
+import { Effect, Schema } from "effect";
+var name9 = "edit";
+var Input9 = Schema.Struct({
+  path: Schema.String.annotate({
+    description: "File to edit"
+  }),
+  oldString: Schema.String.annotate({ description: "Exact text to find and replace" }),
+  newString: Schema.String.annotate({ description: "Text to replace oldString with (must differ from oldString)" }),
+  replaceAll: Schema.optionalKey(Schema.Boolean).annotate({
+    description: "Whether to replace every occurrence of oldString. When false, oldString must match exactly once. Defaults to false."
+  })
+});
+var Output5 = Schema.Struct({
+  files: Schema.Array(FileDiff.Info),
+  replacements: Schema.Number
+});
+var crlf = `\r
+`;
+var normalizeForMatch = (value) => value.replace(/[‘’‚‛]/g, "'").replace(/[“”„‟]/g, '"').replace(/[‐‑‒–—―−]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+var findOccurrences = (content, search) => {
+  const result = [];
+  let offset = 0;
+  while ((offset = content.indexOf(search, offset)) !== -1) {
+    result.push({ start: offset, end: offset + search.length });
+    offset += search.length;
+  }
+  return result;
+};
+var findLineOccurrences = (content, search) => {
+  const trailingNewline = search.endsWith(`
+`);
+  const expected = search.split(`
+`);
+  if (trailingNewline)
+    expected.pop();
+  const lines = [...content.matchAll(/[^\n]*(?:\n|$)/g)].filter((match) => match[0] !== "").map((match) => {
+    const newline = match[0].endsWith(`
+`);
+    const text = newline ? match[0].slice(0, -1) : match[0];
+    return {
+      start: match.index,
+      end: match.index + match[0].length,
+      text,
+      contentEnd: match.index + text.length - (text.endsWith("\r") ? 1 : 0),
+      newline
+    };
+  });
+  const candidates = lines.flatMap((line, index) => {
+    const actual = lines.slice(index, index + expected.length);
+    if (actual.length !== expected.length)
+      return [];
+    if (!actual.every((item, lineIndex) => normalizeForMatch(item.text.trimEnd()) === normalizeForMatch(expected[lineIndex].trimEnd())))
+      return [];
+    const last = actual.at(-1);
+    if (trailingNewline && !last.newline)
+      return [];
+    return [{ start: line.start, end: trailingNewline ? last.end : last.contentEnd }];
+  });
+  return candidates.reduce((result, candidate) => {
+    if (result.some((match) => match.end > candidate.start && match.start < candidate.end))
+      return result;
+    result.push(candidate);
+    return result;
+  }, []);
+};
+var Plugin26 = {
+  id: "opencode.tool.edit",
+  effect: Effect.fn("EditTool.Plugin")(function* (ctx) {
+    const access = yield* Service19;
+    const fileMutation = yield* Service22;
+    const environment = yield* Service65;
+    const formatter = yield* Service14;
+    const location = yield* Service66;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name9,
+      options: { codemode: false, permission: "edit" },
+      description: "Edit the contents of a file by finding and replacing exact text. When editing text from Read output, preserve the exact indentation (tabs or spaces) and omit the line-number prefix, such as `1: `. Never include the prefix in oldString or newString. The edit fails if oldString is not found. By default, oldString must identify a UNIQUE location. Multiple matches FAIL unless replaceAll is true. Add more surrounding context to disambiguate, or set replaceAll to true to replace every occurrence. Use replaceAll when the change should apply to every occurrence, such as renaming a variable.",
+      input: Input9,
+      output: Output5,
+      execute: (input, context) => {
+        return Effect.gen(function* () {
+          const permissionSource = {
+            type: "tool",
+            messageID: context.messageID,
+            id: context.id
+          };
+          if (input.oldString === input.newString) {
+            return yield* new ToolFailure({
+              message: "No changes to apply: oldString and newString are identical."
+            });
+          }
+          if (input.oldString === "") {
+            return yield* new ToolFailure({
+              message: "oldString must not be empty. Use write to create or overwrite a file."
+            });
+          }
+          const target = yield* access.resolve({ path: input.path, kind: "file" });
+          yield* access.authorizeExternal([target], context);
+          const original = yield* readText2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `File not found: ${input.path}` }))), Effect.catchTag("Environment.WrongKind", (error) => error.actual === "directory" ? Effect.fail(new ToolFailure({ message: `Path is a directory, not a file: ${input.path}` })) : Effect.fail(new ToolFailure({ message: `Unable to edit ${input.path}`, error }))));
+          const source = original.text;
+          const ending = source.includes(crlf) ? crlf : `
+`;
+          const oldString = input.oldString.replaceAll(crlf, `
+`).replaceAll(`
+`, ending);
+          const newString = input.newString.replaceAll(crlf, `
+`).replaceAll(`
+`, ending);
+          const exact = findOccurrences(source, oldString);
+          const unicode = exact.length > 0 ? [] : findOccurrences(normalizeForMatch(source), normalizeForMatch(oldString));
+          const trailing = exact.length > 0 || unicode.length > 0 ? [] : findLineOccurrences(source, oldString);
+          const matches = exact.length > 0 ? exact : unicode.length > 0 ? unicode : trailing;
+          const replacements = matches.length;
+          const replaced = (input.replaceAll === true ? matches : matches.slice(0, 1)).toReversed().reduce((content, match) => `${content.slice(0, match.start)}${newString}${content.slice(match.end)}`, source);
+          const preview = replacements > 0 && (replacements === 1 || input.replaceAll === true) ? fileDiff2(target.resource, source, replaced) : undefined;
+          yield* permission.assert({
+            action: "edit",
+            resources: [target.resource],
+            save: ["*"],
+            metadata: preview ? { files: [preview] } : undefined,
+            sessionID: context.sessionID,
+            agent: context.agent,
+            source: permissionSource
+          });
+          if (replacements === 0) {
+            return yield* new ToolFailure({
+              message: `Could not find oldString in ${input.path}. It must match exactly, including whitespace and indentation.`
+            });
+          }
+          if (replacements > 1 && input.replaceAll !== true) {
+            return yield* new ToolFailure({
+              message: `Found ${replacements} matches for oldString, but expected exactly one. Add more surrounding context to make oldString unique, or set replaceAll to true to replace every occurrence.`
+            });
+          }
+          const replacementBom = replaced.startsWith("\uFEFF");
+          const result = yield* fileMutation.write({
+            target,
+            content: Bom.join(replaced, original.bom || replacementBom)
+          });
+          const bom = original.bom || replacementBom;
+          const formatted = (yield* formatter.file(target.absolute)) ? yield* syncTextBom2(environment.files, target.absolute, bom) : (yield* readText2(environment.files, target.absolute)).text;
+          return {
+            files: [fileDiff2(result.resource, source, formatted)],
+            replacements
+          };
+        }).pipe(fileMutation.withLock([resolvePath2(location.directory, input.path)]), Effect.map((output) => ({
+          output,
+          content: `Edited ${output.files[0]?.file} (${output.replacements} replacement${output.replacements === 1 ? "" : "s"})`,
+          metadata: { files: output.files }
+        })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to edit ${input.path}`, error })));
+      }
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name9, Input9, Output5, Plugin26, exports_edit };

package/dist/chunks/repository-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 };

package/dist/chunks/repository-x1ezjp6w.js

@@ -0,0 +1,39 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/subagent-completion.ts
+var exports_subagent_completion = {};
+__export(exports_subagent_completion, {
+  NO_TEXT: () => NO_TEXT2,
+  SubagentCompletion: () => exports_subagent_completion,
+  deliver: () => deliver2,
+  text: () => text2
+});
+import { Effect } from "effect";
+var NO_TEXT2 = "Subagent completed without a text response.";
+function text2(message) {
+  if (message?.type !== "assistant")
+    return NO_TEXT2;
+  return message.content.filter((part) => part.type === "text").map((part) => part.text).join("") || NO_TEXT2;
+}
+var deliver2 = Effect.fnUntraced(function* (sessions, jobs, input) {
+  if (input.status === "running")
+    return;
+  const recovery = input.recovery;
+  const text = input.status === "completed" ? input.output ?? NO_TEXT2 : input.status === "error" ? input.error ?? "Subagent failed" : "Subagent cancelled";
+  yield* sessions.synthetic({
+    ...input.notificationID ? { id: input.notificationID } : {},
+    sessionID: recovery.parentSessionID,
+    ...input.resume === false ? { resume: false } : {},
+    description: recovery.description,
+    text: `<subagent sessionID="${recovery.childSessionID}" state="${input.status}" description="${recovery.description}">
+${text}
+</subagent>`,
+    metadata: { source: "subagent", childID: recovery.childSessionID, agent: recovery.agent, state: input.status }
+  });
+  if (input.notificationID)
+    yield* jobs.completeBackground(input.notificationID);
+});
+
+export { NO_TEXT2, text2, deliver2, exports_subagent_completion };

package/dist/chunks/repository-x384g1hs.js

@@ -0,0 +1,338 @@
+import {
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  Service65,
+  node69
+} from "./repository-3mdgf1e2.js";
+import {
+  Content2
+} from "./repository-j38hs89b.js";
+import {
+  detect2
+} from "./repository-3smtnn6g.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/read-filesystem.ts
+var exports_read_filesystem = {};
+__export(exports_read_filesystem, {
+  BinaryFileError: () => BinaryFileError2,
+  FileContent: () => FileContent2,
+  ListEntry: () => ListEntry2,
+  ListPage: () => ListPage2,
+  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES2,
+  MAX_READ_BYTES: () => MAX_READ_BYTES2,
+  MAX_READ_LINES: () => MAX_READ_LINES2,
+  MEDIA_MIMES: () => MEDIA_MIMES2,
+  MediaIngestLimitError: () => MediaIngestLimitError2,
+  OffsetOutOfRangeError: () => OffsetOutOfRangeError2,
+  PageInput: () => PageInput2,
+  PathKindError: () => PathKindError2,
+  ReadToolFileSystem: () => exports_read_filesystem,
+  Service: () => Service3,
+  TextPage: () => TextPage2,
+  node: () => node5,
+  read: () => read2
+});
+import path from "path";
+import { pathToFileURL } from "url";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+import { lookup } from "mime-types";
+var MAX_READ_LINES2 = 2000;
+var MAX_READ_BYTES2 = 50 * 1024;
+var MAX_MEDIA_INGEST_BYTES2 = 20 * 1024 * 1024;
+var FIRST_CHUNK = 256 * 1024;
+var MAX_LINE_LENGTH = 2000;
+var TREE_BASE = 6;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MEDIA_MIMES2 = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
+
+class BinaryFileError2 extends Schema.TaggedError()("ReadTool.BinaryFileError", {
+  resource: Schema.String
+}) {
+  get message() {
+    return `Cannot read binary file: ${this.resource}`;
+  }
+}
+
+class MediaIngestLimitError2 extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
+  resource: Schema.String,
+  maximumBytes: Schema.Number
+}) {
+  get message() {
+    return `Media exceeds ${this.maximumBytes} byte ingestion limit: ${this.resource}`;
+  }
+}
+
+class OffsetOutOfRangeError2 extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
+  get message() {
+    return `Offset ${this.offset} is out of range`;
+  }
+}
+
+class PathKindError2 extends Schema.TaggedError()("ReadTool.PathKindError", {
+  resource: Schema.String,
+  expected: Schema.Literals(["a file", "a file or directory"])
+}) {
+  get message() {
+    return `Path is not ${this.expected}: ${this.resource}`;
+  }
+}
+var PageInput2 = Schema.Struct({
+  offset: Schema.optionalKey(NonNegativeInt2),
+  limit: Schema.optionalKey(NonNegativeInt2.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES2)))
+});
+var FileContent2 = Schema.Struct({
+  type: Schema.Literal("file"),
+  ...Content2.fields
+}).annotate({ identifier: "ReadTool.FileContent" });
+
+class TextPage2 extends Schema.Class("ReadTool.TextPage")({
+  type: Schema.Literal("text-page"),
+  content: Schema.String,
+  mime: Schema.String,
+  offset: PositiveInt2,
+  truncated: Schema.Boolean,
+  next: Schema.optionalKey(PositiveInt2)
+}) {
+}
+var ListEntry2 = Schema.Struct({
+  path: RelativePath2,
+  type: Schema.Literals(["file", "directory", "symlink"])
+}).annotate({ identifier: "ReadTool.ListEntry" });
+
+class ListPage2 extends Schema.Class("ReadTool.ListPage")({
+  type: Schema.Literal("list-page"),
+  entries: Schema.Array(ListEntry2),
+  truncated: Schema.Boolean,
+  next: Schema.optionalKey(PositiveInt2)
+}) {
+}
+
+class Service3 extends Context.Service()("@opencode/ReadToolFileSystem") {
+}
+var mimeType = (value) => lookup(value) || "application/octet-stream";
+var read2 = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
+  const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(Effect.catchTag("Environment.WrongKind", (error) => {
+    if (error.actual !== "directory")
+      return Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }));
+    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }))));
+  }));
+  if (first instanceof ListPage2)
+    return first;
+  const media = detect2(first.bytes);
+  if (MEDIA_MIMES2.has(media)) {
+    if (first.info.size > MAX_MEDIA_INGEST_BYTES2)
+      return yield* new MediaIngestLimitError2({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES2 });
+    const whole = yield* readFile(files, input, resource);
+    return {
+      type: "file",
+      uri: pathToFileURL(input).href,
+      name: path.basename(input),
+      content: Buffer.from(whole.bytes).toString("base64"),
+      encoding: "base64",
+      mime: media
+    };
+  }
+  const paged = first.info.size > MAX_READ_BYTES2 || page.offset !== undefined || page.limit !== undefined;
+  if (!paged) {
+    if (first.bytes.includes(0))
+      return yield* new BinaryFileError2({ resource });
+    return {
+      type: "file",
+      uri: pathToFileURL(input).href,
+      name: path.basename(input),
+      content: new TextDecoder().decode(first.bytes),
+      encoding: "utf8",
+      mime: mimeType(input)
+    };
+  }
+  if (first.bytes.length >= first.info.size) {
+    const result = textPage(first.bytes, true, page);
+    if (result === undefined)
+      return yield* Effect.die("Read page did not settle for a complete first chunk");
+    return yield* makeTextPage(input, resource, result, first.bytes.subarray(0, result.consumed).includes(0));
+  }
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
+  const leaves = [textLeaf(first.bytes)];
+  let bytes = first.bytes.length;
+  let lines = leaves[0].summary.lines;
+  let ended = false;
+  while (true) {
+    const eof = ended || bytes >= first.info.size;
+    if (lines >= offset - 1 || eof) {
+      const tree = textTree(leaves);
+      const start = textOffset(tree, offset - 1);
+      let position = 0;
+      const selected = Buffer.concat(leaves.flatMap((leaf) => {
+        const leafStart = position;
+        position += leaf.summary.bytes;
+        if (position <= start)
+          return [];
+        return [leaf.bytes.subarray(Math.max(0, start - leafStart))];
+      }));
+      const result = textPage(selected, eof, { limit });
+      if (result !== undefined) {
+        const translated = {
+          ...result,
+          offset,
+          ...result.next === undefined ? { next: undefined } : { next: offset + result.next - 1 }
+        };
+        const consumed = start + result.consumed;
+        let checked = 0;
+        const binary = leaves.some((leaf) => {
+          const length = Math.min(leaf.summary.bytes, consumed - checked);
+          checked += leaf.summary.bytes;
+          return length > 0 && leaf.bytes.subarray(0, length).includes(0);
+        });
+        return yield* makeTextPage(input, resource, translated, binary);
+      }
+    }
+    const next = yield* readFile(files, input, resource, { offset: bytes, length: FIRST_CHUNK });
+    if (next.bytes.length === 0) {
+      ended = true;
+      continue;
+    }
+    const leaf = textLeaf(next.bytes);
+    leaves.push(leaf);
+    bytes += leaf.summary.bytes;
+    lines += leaf.summary.lines;
+  }
+});
+var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file" }))));
+var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary) {
+  if (binary)
+    return yield* new BinaryFileError2({ resource });
+  if (result.entries.length === 0 && result.offset !== 1)
+    return yield* new OffsetOutOfRangeError2({ offset: result.offset });
+  return new TextPage2({
+    type: "text-page",
+    content: result.entries.join(`
+`),
+    mime: mimeType(input),
+    offset: result.offset,
+    truncated: result.next !== undefined,
+    ...result.next === undefined ? {} : { next: result.next }
+  });
+});
+var list = (items, page) => {
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
+  const visible = items.flatMap((item) => item.type === "other" ? [] : [
+    ListEntry2.make({
+      path: RelativePath2.make(item.name + (item.type === "directory" ? path.sep : "")),
+      type: item.type
+    })
+  ]).sort((a, b) => a.type === "directory" ? b.type === "directory" ? a.path.localeCompare(b.path) : -1 : b.type === "directory" ? 1 : a.path.localeCompare(b.path));
+  const selected = visible.slice(offset - 1, offset - 1 + limit);
+  const truncated = offset - 1 + selected.length < visible.length;
+  return new ListPage2({
+    type: "list-page",
+    entries: selected,
+    truncated,
+    ...truncated ? { next: offset + selected.length } : {}
+  });
+};
+var textPage = (bytes, eof, page) => {
+  const offset = page.offset || 1;
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
+  const decoded = new TextDecoder().decode(bytes);
+  const split = decoded.split(`
+`);
+  const complete = eof ? split.at(-1) === "" ? split.slice(0, -1) : split : split.slice(0, -1);
+  const available = complete.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  const entries = [];
+  let size = 0;
+  let next;
+  for (const [index, value] of available.slice(offset - 1).entries()) {
+    const line = offset + index;
+    if (entries.length >= limit || size >= MAX_READ_BYTES2) {
+      next = line;
+      break;
+    }
+    const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value;
+    const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0);
+    if (size + lineSize > MAX_READ_BYTES2) {
+      next = line;
+      break;
+    }
+    entries.push(text);
+    size += lineSize;
+  }
+  if (next === undefined && entries.length >= limit && (!eof || offset - 1 + entries.length < available.length))
+    next = offset + entries.length;
+  if (!eof && next === undefined)
+    return;
+  const consumedLines = next === undefined ? available.length : next - 1;
+  const consumed = consumedLines === 0 ? 0 : nthNewline(bytes, consumedLines) ?? bytes.length;
+  return { entries, offset, next, consumed };
+};
+var textLeaf = (bytes) => {
+  let lines = 0;
+  for (const byte of bytes)
+    if (byte === 10)
+      lines++;
+  return { type: "leaf", bytes, summary: { bytes: bytes.length, lines } };
+};
+var textTree = (nodes) => {
+  if (nodes.length === 1)
+    return nodes[0];
+  return textTree(Array.from({ length: Math.ceil(nodes.length / (TREE_BASE * 2)) }, (_, index) => {
+    const children = nodes.slice(index * TREE_BASE * 2, (index + 1) * TREE_BASE * 2);
+    return {
+      type: "branch",
+      children,
+      summary: {
+        bytes: children.reduce((total, child) => total + child.summary.bytes, 0),
+        lines: children.reduce((total, child) => total + child.summary.lines, 0)
+      }
+    };
+  }));
+};
+var textOffset = (tree, newline) => {
+  if (newline === 0)
+    return 0;
+  let node = tree;
+  let remaining = newline;
+  let offset = 0;
+  while (node.type === "branch") {
+    const child = node.children.find((candidate) => {
+      if (remaining <= candidate.summary.lines)
+        return true;
+      remaining -= candidate.summary.lines;
+      offset += candidate.summary.bytes;
+      return false;
+    });
+    if (!child)
+      return tree.summary.bytes;
+    node = child;
+  }
+  const end = nthNewline(node.bytes, remaining);
+  return end === undefined ? tree.summary.bytes : offset + end;
+};
+var nthNewline = (bytes, count) => {
+  let found = 0;
+  for (const [index, byte] of bytes.entries()) {
+    if (byte !== 10)
+      continue;
+    found++;
+    if (found === count)
+      return index + 1;
+  }
+};
+var layer = Layer.effect(Service3, Effect.gen(function* () {
+  const environment = yield* Service65;
+  return Service3.of({
+    list: environment.files.list,
+    read: (path2, resource, page) => read2(environment.files, path2, resource, page)
+  });
+}));
+var node5 = makeLocationNode({ service: Service3, layer, deps: [node69] });
+
+export { MAX_READ_LINES2, MAX_READ_BYTES2, MAX_MEDIA_INGEST_BYTES2, MEDIA_MIMES2, BinaryFileError2, MediaIngestLimitError2, OffsetOutOfRangeError2, PathKindError2, PageInput2, FileContent2, TextPage2, ListEntry2, ListPage2, Service3, read2, node5, exports_read_filesystem };

package/dist/chunks/repository-x61499pn.js

@@ -0,0 +1,18 @@
+// src/github-copilot/chat/map-openai-compatible-finish-reason.ts
+function mapOpenAICompatibleFinishReason2(finishReason) {
+  switch (finishReason) {
+    case "stop":
+      return "stop";
+    case "length":
+      return "length";
+    case "content_filter":
+      return "content-filter";
+    case "function_call":
+    case "tool_calls":
+      return "tool-calls";
+    default:
+      return "other";
+  }
+}
+
+export { mapOpenAICompatibleFinishReason2 };