@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-a8mtf1n7.js

@@ -0,0 +1,282 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service80,
+  node85
+} from "./worktree-ecj1wrg9.js";
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service76,
+  node81
+} from "./worktree-1e9w7pgh.js";
+import {
+  ID18,
+  Current3,
+  Info33,
+  UpdateInput4,
+  Event19,
+  Vcs3
+} from "./worktree-pjmw00w1.js";
+import {
+  ProjectTable2,
+  upsertProject2
+} from "./worktree-dj2t23y0.js";
+import {
+  WorktreeTable2
+} from "./worktree-m0jqrx5p.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/project.ts
+var exports_project = {};
+__export(exports_project, {
+  Current: () => Current2,
+  ID: () => ID17,
+  Info: () => Info32,
+  NotFoundError: () => NotFoundError10,
+  Project: () => exports_project,
+  Service: () => Service75,
+  UpdateInput: () => UpdateInput3,
+  Vcs: () => Vcs2,
+  node: () => node80,
+  root: () => root2
+});
+import { Context, Effect, Layer, Schema } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { and, asc, desc, eq, gte, isNull, lte } from "drizzle-orm";
+import path from "path";
+import { Worktree } from "@opencode/schema/worktree";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { Hash } from "@opencode/util/hash";
+var ID17 = ID18;
+var Vcs2 = Vcs3;
+var Current2 = Current3;
+var Info32 = Info33;
+var UpdateInput3 = UpdateInput4;
+
+class NotFoundError10 extends Schema.TaggedError()("Project.NotFoundError", {
+  projectID: ID17
+}) {
+}
+var root2 = Effect.fn("Project.root")(function* (fs, input, markers = [".git", ".hg"]) {
+  return yield* fs.up({ targets: [...markers], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0] ? AbsolutePath2.make(path.dirname(matches[0])) : undefined), Effect.orElseSucceed(() => {
+    return;
+  }));
+});
+
+class Service75 extends Context.Service()("@opencode/Project") {
+}
+function fromRow(row) {
+  const icon = row.icon_url || row.icon_url_override || row.icon_color ? {
+    url: row.icon_url ?? undefined,
+    override: row.icon_url_override ?? undefined,
+    color: row.icon_color ?? undefined
+  } : undefined;
+  return {
+    id: row.id,
+    canonical: row.worktree,
+    vcs: row.vcs ?? undefined,
+    name: row.name ?? undefined,
+    icon,
+    commands: row.commands ?? undefined,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      initialized: row.time_initialized ?? undefined
+    },
+    sandboxes: row.sandboxes
+  };
+}
+var layer = Layer.effect(Service75, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service76;
+  const proc = yield* AppProcess.Service;
+  const bus = yield* Service79;
+  const db = (yield* Service80).db;
+  const announcing = new Set;
+  const persist = Effect.fnUntraced(function* (project) {
+    const previous = yield* db.select({ canonical: ProjectTable2.worktree }).from(ProjectTable2).where(eq(ProjectTable2.id, project.id)).get().pipe(Effect.orDie);
+    yield* upsertProject2(db, project).pipe(Effect.orDie);
+    if (previous && previous.canonical !== project.canonical && !(yield* fs.exists(previous.canonical).pipe(Effect.orElseSucceed(() => true)))) {
+      const row = yield* db.update(ProjectTable2).set({ worktree: project.canonical }).where(eq(ProjectTable2.id, project.id)).returning().get().pipe(Effect.orDie);
+      if (row)
+        yield* bus.publish(Event19.Updated, fromRow(row));
+    }
+    if (!project.vcs)
+      return project;
+    const directories = [
+      { projectID: project.id, directory: project.canonical }
+    ];
+    if (project.directory !== project.canonical)
+      directories.push({
+        projectID: project.id,
+        directory: project.directory,
+        strategy: project.vcs.type === "git" ? "git" : undefined
+      });
+    for (const item of directories) {
+      const key = item.projectID + "\x00" + item.directory;
+      if (announcing.has(key))
+        continue;
+      announcing.add(key);
+      yield* Effect.gen(function* () {
+        const stored = yield* db.select({ directory: WorktreeTable2.directory }).from(WorktreeTable2).where(and(eq(WorktreeTable2.project_id, item.projectID), eq(WorktreeTable2.directory, item.directory))).get().pipe(Effect.orDie);
+        if (stored)
+          return;
+        const directory = AbsolutePath2.make(yield* fs.resolve(item.directory));
+        const markerless = yield* db.select({ id: ProjectTable2.id, directory: ProjectTable2.worktree }).from(ProjectTable2).where(and(isNull(ProjectTable2.vcs), gte(ProjectTable2.worktree, directory), lte(ProjectTable2.worktree, AbsolutePath2.make(directory + "￿")))).all().pipe(Effect.orDie);
+        const adopted = yield* Effect.filter(markerless, (candidate) => Effect.gen(function* () {
+          if (candidate.id === item.projectID)
+            return false;
+          if (!FSUtil.contains(directory, candidate.directory))
+            return false;
+          const found = yield* fs.up({ targets: [".git", ".hg"], start: candidate.directory, stop: directory, mode: "first" }).pipe(Effect.orElseSucceed(() => []));
+          if (!found[0])
+            return false;
+          return (yield* fs.resolve(path.dirname(found[0]))) === directory;
+        }));
+        yield* bus.publish(Worktree.Event.Resolved, {
+          projectID: item.projectID,
+          directory: item.directory,
+          previous: project.previous ?? ID17.global,
+          ...adopted.length ? { adopted: adopted.map((candidate) => candidate.id) } : {}
+        }, {
+          commit: () => db.insert(WorktreeTable2).values({ project_id: item.projectID, directory: item.directory, strategy: item.strategy }).onConflictDoNothing().run().pipe(Effect.orDie, Effect.asVoid)
+        });
+      }).pipe(Effect.ensuring(Effect.sync(() => announcing.delete(key))));
+    }
+    return project;
+  });
+  const list = Effect.fn("Project.list")(function* () {
+    const rows = yield* db.select().from(ProjectTable2).orderBy(desc(ProjectTable2.time_updated), asc(ProjectTable2.id)).all().pipe(Effect.orDie);
+    return rows.map(fromRow);
+  });
+  const update = Effect.fn("Project.update")(function* (input) {
+    const row = yield* db.update(ProjectTable2).set({
+      worktree: input.canonical,
+      name: input.name === undefined ? undefined : input.name || null,
+      icon_url_override: input.icon?.override === undefined ? undefined : input.icon.override || null,
+      icon_color: input.icon?.color === undefined ? undefined : input.icon.color || null,
+      commands: input.commands?.start === undefined ? undefined : input.commands.start ? { start: input.commands.start } : null,
+      time_updated: Date.now()
+    }).where(eq(ProjectTable2.id, input.projectID)).returning().get().pipe(Effect.orDie);
+    if (!row)
+      return yield* new NotFoundError10({ projectID: input.projectID });
+    const project = fromRow(row);
+    yield* bus.publish(Event19.Updated, project);
+    return project;
+  });
+  const cached = Effect.fnUntraced(function* (dir) {
+    return yield* fs.readFileString(path.join(dir, "opencode")).pipe(Effect.map((value) => value.trim()), Effect.map((value) => value ? ID17.make(value) : undefined), Effect.orElseSucceed(() => {
+      return;
+    }));
+  });
+  const remote = Effect.fnUntraced(function* (repo) {
+    const origin = yield* git.remote.get(repo);
+    if (!origin)
+      return;
+    const normalized = url(origin);
+    if (!normalized)
+      return;
+    return ID17.make(Hash.fast(`git-remote:${normalized}`));
+  });
+  function url(input) {
+    const value = input.trim();
+    if (!value)
+      return;
+    const parsed = URL.parse(value);
+    if (parsed) {
+      if (parsed.protocol === "file:")
+        return;
+      return parts(parsed.hostname, parsed.pathname);
+    }
+    const scp = value.match(/^([^@/:]+@)?([^/:]+):(.+)$/);
+    if (scp)
+      return parts(scp[2], scp[3]);
+    return;
+  }
+  function parts(host, name) {
+    const pathname = name.replace(/^\/+/, "").replace(/\.git\/?$/, "").replace(/\/+$/, "");
+    if (!host || !pathname)
+      return;
+    return `${host.toLowerCase()}/${pathname}`;
+  }
+  const rootCommit = Effect.fnUntraced(function* (repo) {
+    const root = (yield* git.history.rootCommits(repo))[0];
+    return root ? ID17.make(root) : undefined;
+  });
+  const hgRoot = Effect.fnUntraced(function* (worktree) {
+    const result = yield* proc.run(ChildProcess.make("hg", ["log", "-r", "roots(all())", "-T", `{node}
+`], {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    })).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!result || result.exitCode !== 0)
+      return;
+    const node = result.stdout.toString("utf8").split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted()[0];
+    return node ? ID17.make(node) : undefined;
+  });
+  const hgDiscover = Effect.fnUntraced(function* (dotHg) {
+    const worktree = AbsolutePath2.make(path.dirname(dotHg));
+    const store = AbsolutePath2.make(dotHg);
+    const previous = yield* cached(store);
+    const id = previous ?? (yield* hgRoot(worktree));
+    return {
+      previous,
+      id: id ?? ID17.global,
+      directory: worktree,
+      vcs: { type: "hg", store }
+    };
+  });
+  const resolve = Effect.fn("Project.resolve")(function* (input, _options) {
+    const directory = AbsolutePath2.make(yield* fs.resolve(input));
+    const native = yield* fs.up({ targets: [".git", ".hg"], start: directory, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
+      return;
+    }));
+    const repo = native && path.basename(native) === ".git" ? yield* git.repo.discover(AbsolutePath2.make(path.dirname(native))) : undefined;
+    if (repo) {
+      const previous = yield* cached(repo.commonDirectory);
+      const id = (yield* remote(repo)) ?? previous ?? (yield* rootCommit(repo));
+      const canonical = repo.gitDirectory === repo.commonDirectory ? repo.worktree : yield* git.worktree.list(repo).pipe(Effect.map((items) => items.find((item) => item.kind === "main")?.directory ?? repo.worktree), Effect.orElseSucceed(() => repo.worktree));
+      return yield* persist({
+        previous,
+        id: id ?? ID17.global,
+        directory: repo.worktree,
+        canonical,
+        vcs: { type: "git", store: repo.commonDirectory }
+      });
+    }
+    const hg = native && path.basename(native) === ".hg" ? yield* hgDiscover(AbsolutePath2.make(native)) : undefined;
+    if (hg) {
+      return yield* persist({
+        ...hg,
+        canonical: hg.directory
+      });
+    }
+    return yield* persist({
+      id: ID17.make(Hash.fast(`directory:${directory}`)),
+      directory,
+      canonical: directory,
+      vcs: undefined
+    });
+  });
+  return Service75.of({ list, update, resolve });
+}));
+var node80 = makeGlobalNode({
+  service: Service75,
+  layer,
+  deps: [node84, node85, FSUtil.node, node81, AppProcess.node]
+});
+
+export { ID17, Vcs2, Current2, Info32, UpdateInput3, NotFoundError10, root2, Service75, node80, exports_project };

package/dist/chunks/worktree-a9ab9jmj.js

@@ -0,0 +1,97 @@
+import {
+  ID12,
+  isAISDK2,
+  packageName2
+} from "./worktree-9qn3qky1.js";
+
+// src/plugin/provider/google-vertex.ts
+import { Effect } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+function resolveProject(options) {
+  return options.project ?? process.env.GOOGLE_VERTEX_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GCP_PROJECT ?? process.env.GCLOUD_PROJECT;
+}
+function resolveLocation(options) {
+  return options.location ?? process.env.GOOGLE_VERTEX_LOCATION ?? process.env.GOOGLE_CLOUD_LOCATION ?? process.env.VERTEX_LOCATION ?? "us-central1";
+}
+function vertexEndpoint(location) {
+  if (location === "global")
+    return "aiplatform.googleapis.com";
+  return `${location}-aiplatform.googleapis.com`;
+}
+function replaceVertexVars(value, project, location) {
+  return value.replaceAll("${GOOGLE_VERTEX_PROJECT}", project ?? "${GOOGLE_VERTEX_PROJECT}").replaceAll("${GOOGLE_VERTEX_LOCATION}", location).replaceAll("${GOOGLE_VERTEX_ENDPOINT}", vertexEndpoint(location));
+}
+function authFetch(fetchWithRuntimeOptions) {
+  return async (input, init) => {
+    const { GoogleAuth } = await import("google-auth-library");
+    const auth = new GoogleAuth({ scopes: ["https://www.googleapis.com/auth/cloud-platform"] });
+    const client = await auth.getClient();
+    const token = await client.getAccessToken();
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${token.token}`);
+    return typeof fetchWithRuntimeOptions === "function" ? fetchWithRuntimeOptions(input, { ...init, headers }) : fetch(input, { ...init, headers });
+  };
+}
+var GoogleVertexPlugin2 = define({
+  id: "opencode.provider.google.vertex",
+  effect: Effect.fn(function* (ctx) {
+    yield* ctx.catalog.transform((evt) => {
+      for (const item of evt.provider.list()) {
+        if (!isAISDK2(item.provider.package))
+          continue;
+        if (packageName2(item.provider.package) !== "@ai-sdk/google-vertex" && !(item.provider.id === ID12.googleVertex && packageName2(item.provider.package)?.includes("@ai-sdk/openai-compatible")))
+          continue;
+        const project = resolveProject(item.provider.settings ?? {});
+        const location = String(resolveLocation(item.provider.settings ?? {}));
+        evt.provider.update(item.provider.id, (provider) => {
+          if (project && provider.activation === "auto")
+            provider.activation = "enabled";
+          provider.settings = {
+            ...provider.settings,
+            ...project ? { project } : {},
+            location,
+            ...typeof provider.settings?.baseURL === "string" ? { baseURL: replaceVertexVars(provider.settings.baseURL, project, location) } : {}
+          };
+        });
+      }
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.model.providerID === ID12.googleVertex && evt.package.includes("@ai-sdk/openai-compatible")) {
+        evt.options.fetch = authFetch(evt.options.fetch);
+        return;
+      }
+      if (evt.package === "@ai-sdk/google-vertex/anthropic") {
+        const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex/anthropic"));
+        const project = resolveProject(evt.options);
+        const location = String(resolveLocation(evt.options));
+        const regionalBaseURL = (location === "eu" || location === "us") && project && !evt.options.baseURL ? `https://aiplatform.${location}.rep.googleapis.com/v1/projects/${project}/locations/${location}/publishers/anthropic/models` : undefined;
+        evt.sdk = mod.createVertexAnthropic({
+          ...evt.options,
+          project,
+          location,
+          ...regionalBaseURL ? { baseURL: regionalBaseURL } : {}
+        });
+        return;
+      }
+      if (evt.package !== "@ai-sdk/google-vertex")
+        return;
+      const mod = yield* Effect.promise(() => import("@ai-sdk/google-vertex"));
+      const project = resolveProject(evt.options);
+      const location = resolveLocation(evt.options);
+      const options = { ...evt.options };
+      delete options.fetch;
+      evt.sdk = mod.createVertex({
+        ...options,
+        project,
+        location
+      });
+    }));
+    yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
+      if (evt.model.providerID !== ID12.googleVertex)
+        return;
+      evt.language = evt.sdk.languageModel(String(evt.model.modelID ?? evt.model.id).trim());
+    }));
+  })
+});
+
+export { GoogleVertexPlugin2 };

package/dist/chunks/worktree-aaet6srn.js

@@ -0,0 +1,170 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./worktree-2a5m3afh.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/environment/memory.ts
+var exports_memory = {};
+__export(exports_memory, {
+  EnvironmentMemory: () => exports_memory,
+  makeMemoryDriver: () => makeMemoryDriver2
+});
+import path from "node:path";
+import { Effect, PlatformError } from "effect";
+import { make } from "effect/unstable/process/ChildProcessSpawner";
+var makeMemoryDriver2 = () => {
+  const nodes = new Map([["/", { type: "directory", mtimeMs: Date.now() }]]);
+  const key = (value) => path.posix.resolve("/", value);
+  const info = (node) => ({
+    type: node.type,
+    size: node.type === "file" ? node.bytes.length : node.type === "symlink" ? new TextEncoder().encode(node.target).length : 0,
+    mtimeMs: node.mtimeMs
+  });
+  const resolveKey = (value, followFinal, seen = new Set) => {
+    const normalized = key(value);
+    const parts = normalized.split("/").filter(Boolean);
+    const base = "/";
+    const walk = (current, index) => {
+      if (index === parts.length)
+        return current;
+      const part = parts[index];
+      const candidate = path.posix.join(current, part);
+      const node = nodes.get(candidate);
+      if (node?.type !== "symlink" || !followFinal && index === parts.length - 1)
+        return walk(candidate, index + 1);
+      if (seen.has(candidate))
+        return;
+      seen.add(candidate);
+      const target = path.posix.resolve(path.posix.dirname(candidate), node.target);
+      return resolveKey(path.posix.join(target, ...parts.slice(index + 1)), followFinal, seen);
+    };
+    return walk(base, 0);
+  };
+  const lookup = (value) => nodes.get(resolveKey(value, false) ?? key(value));
+  const requireParent = (value) => {
+    const parentPath = path.posix.dirname(key(value));
+    const parent = nodes.get(resolveKey(parentPath, true) ?? parentPath);
+    if (!parent)
+      throw new Error(`Parent directory does not exist: ${path.posix.dirname(value)}`);
+    if (parent.type !== "directory")
+      throw new Error(`Parent is not a directory: ${path.posix.dirname(value)}`);
+  };
+  const mkdirSync = (value) => {
+    const target = resolveKey(value, false) ?? key(value);
+    const existing = nodes.get(target);
+    if (existing?.type === "directory")
+      return;
+    if (existing)
+      throw new Error(`Path is not a directory: ${value}`);
+    const parent = path.posix.dirname(target);
+    if (parent !== target)
+      mkdirSync(parent);
+    nodes.set(target, { type: "directory", mtimeMs: Date.now() });
+  };
+  const failed = (value, cause) => new Failed2({ path: value, cause });
+  const overrides = {
+    stat: (value) => Effect.suspend(() => {
+      const node = lookup(value);
+      return node ? Effect.succeed(info(node)) : Effect.fail(new NotFound2({ path: value }));
+    }),
+    read: (value, range) => Effect.gen(function* () {
+      const original = lookup(value);
+      if (!original)
+        return yield* new NotFound2({ path: value });
+      if (original.type === "directory")
+        return yield* new WrongKind2({ path: value, actual: "directory" });
+      const resolved = resolveKey(value, true);
+      const node = resolved === undefined ? undefined : nodes.get(resolved);
+      if (!node)
+        return yield* new NotFound2({ path: value });
+      if (node.type !== "file")
+        return yield* new WrongKind2({ path: value, actual: node.type });
+      const bytes = range === undefined ? node.bytes : node.bytes.subarray(range.offset, range.offset + range.length);
+      return { info: info(node), bytes: bytes.slice() };
+    }),
+    write: (value, bytes) => Effect.try({
+      try: () => {
+        mkdirSync(path.posix.dirname(key(value)));
+        const existing = lookup(value);
+        if (existing?.type === "directory")
+          throw new Error(`Path is a directory: ${value}`);
+        const target = existing?.type === "symlink" ? resolveKey(value, true) : resolveKey(value, false);
+        if (!target)
+          throw new Error(`Cannot resolve symlink: ${value}`);
+        requireParent(target);
+        nodes.set(target, { type: "file", bytes: bytes.slice(), mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    }),
+    list: (value) => Effect.gen(function* () {
+      const target = resolveKey(value, true) ?? key(value);
+      const node = nodes.get(target);
+      if (!node)
+        return yield* new NotFound2({ path: value });
+      if (node.type !== "directory")
+        return yield* new WrongKind2({ path: value, actual: node.type });
+      return [...nodes.entries()].filter(([entry]) => entry !== target && path.posix.dirname(entry) === target).map(([entry, child]) => ({ name: path.posix.basename(entry), type: child.type })).sort((a, b) => a.name.localeCompare(b.name));
+    }),
+    remove: (value) => Effect.sync(() => {
+      const target = resolveKey(value, false) ?? key(value);
+      for (const entry of nodes.keys()) {
+        if (entry === target || entry.startsWith(`${target}/`))
+          nodes.delete(entry);
+      }
+    }),
+    move: (from, to) => Effect.gen(function* () {
+      const source = resolveKey(from, false) ?? key(from);
+      const node = nodes.get(source);
+      if (!node)
+        return yield* new NotFound2({ path: from });
+      yield* Effect.try({
+        try: () => {
+          const requested = resolveKey(to, false) ?? key(to);
+          const destination = nodes.get(requested)?.type === "directory" ? path.posix.join(requested, path.posix.basename(source)) : requested;
+          if (node.type === "directory" && destination.startsWith(`${source}/`)) {
+            throw new Error(`Cannot move a directory into itself: ${from}`);
+          }
+          const existing = nodes.get(destination);
+          if (node.type === "directory" && existing && existing.type !== "directory") {
+            throw new Error(`Cannot overwrite a non-directory with a directory: ${to}`);
+          }
+          requireParent(destination);
+          const moved = [...nodes.entries()].filter(([entry]) => entry === source || entry.startsWith(`${source}/`));
+          for (const [entry] of moved)
+            nodes.delete(entry);
+          for (const [entry, child] of moved)
+            nodes.set(`${destination}${entry.slice(source.length)}`, child);
+        },
+        catch: (cause) => failed(from, cause)
+      });
+    }),
+    mkdir: (value) => Effect.try({ try: () => mkdirSync(value), catch: (cause) => failed(value, cause) })
+  };
+  const spawner = make((command) => Effect.suspend(() => {
+    const description = command._tag === "StandardCommand" ? command.command : "pipeline";
+    return Effect.fail(PlatformError.systemError({
+      _tag: "Unknown",
+      module: "EnvironmentMemory",
+      method: "spawn",
+      pathOrDescriptor: description,
+      cause: failed(description, new Error("The memory driver cannot spawn processes"))
+    }));
+  }));
+  return {
+    spawner,
+    overrides,
+    symlink: (target, value) => Effect.try({
+      try: () => {
+        requireParent(value);
+        nodes.set(resolveKey(value, false) ?? key(value), { type: "symlink", target, mtimeMs: Date.now() });
+      },
+      catch: (cause) => failed(value, cause)
+    })
+  };
+};
+
+export { makeMemoryDriver2, exports_memory };

package/dist/chunks/worktree-adeb4z1j.js

@@ -0,0 +1,40 @@
+import {
+  Service35
+} from "./worktree-vkez6a4k.js";
+import {
+  awaitActivation2
+} from "./worktree-1x11rq2a.js";
+import {
+  Service46
+} from "./worktree-7c3npc5w.js";
+import {
+  unavailable2
+} from "./worktree-fxbjtjnd.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/shell.ts
+var exports_shell3 = {};
+__export(exports_shell3, {
+  SessionShell: () => exports_shell3,
+  start: () => start2
+});
+import { Effect } from "effect";
+var start2 = Effect.fn("SessionShell.start")(function* (input) {
+  const instances = yield* Service35;
+  const shell = yield* awaitActivation2.pipe(Effect.andThen(Service46), instances.provide(input.session));
+  const info = yield* shell.create({
+    command: input.command,
+    cwd: input.session.location.directory,
+    timeout: 0,
+    metadata: { sessionID: input.session.id, background: true }
+  });
+  return {
+    info,
+    result: shell.result(info),
+    output: shell.output(info.id, { limit: 1024 * 1024 }).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.succeed(unavailable2)))
+  };
+});
+
+export { start2, exports_shell3 };

package/dist/chunks/worktree-af5trqkr.js

@@ -0,0 +1,10 @@
+// src/github-copilot/chat/openai-compatible-chat-options.ts
+import { z } from "zod/v4";
+var openaiCompatibleProviderOptions2 = z.object({
+  user: z.string().optional(),
+  reasoningEffort: z.string().optional(),
+  textVerbosity: z.string().optional(),
+  thinking_budget: z.number().optional()
+});
+
+export { openaiCompatibleProviderOptions2 };

package/dist/chunks/worktree-afrmfg78.js

@@ -0,0 +1,16 @@
+// src/github-copilot/openai-compatible-error.ts
+import { z } from "zod/v4";
+var openaiCompatibleErrorDataSchema2 = z.object({
+  error: z.object({
+    message: z.string(),
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
+  })
+});
+var defaultOpenAICompatibleErrorStructure2 = {
+  errorSchema: openaiCompatibleErrorDataSchema2,
+  errorToMessage: (data) => data.error.message
+};
+
+export { openaiCompatibleErrorDataSchema2, defaultOpenAICompatibleErrorStructure2 };