@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-a5h5qkjp.js

@@ -0,0 +1,128 @@
+import {
+  typeFollowing2
+} from "./repository-2a5m3afh.js";
+import {
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  Service65
+} from "./repository-3mdgf1e2.js";
+import {
+  Service25
+} from "./repository-ztky2hbm.js";
+import {
+  DEFAULT_SEARCH_LIMIT2,
+  DEFAULT_SEARCH_TIMEOUT_MS2,
+  GlobInput2,
+  Entry2
+} from "./repository-j38hs89b.js";
+import {
+  Service58
+} from "./repository-ykpr0q7c.js";
+import {
+  Service19
+} from "./repository-pvp1cs2e.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/tool/plugin/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  GlobTool: () => exports_glob,
+  Input: () => Input11,
+  Output: () => Output7,
+  Plugin: () => Plugin28,
+  name: () => name11,
+  toModelContent: () => toModelContent5
+});
+import { ToolFailure } from "@opencode/ai";
+import { Effect, Schema } from "effect";
+import path from "path";
+var name11 = "glob";
+var Input11 = Schema.Struct({
+  pattern: GlobInput2.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
+  path: Schema.optionalKey(RelativePath2).annotate({
+    description: "Directory to search. Defaults to the current working directory."
+  }),
+  hidden: GlobInput2.fields.hidden.annotate({
+    description: "Include hidden files and directories (default: false)."
+  }),
+  limit: GlobInput2.fields.limit.annotate({
+    description: `Maximum number of matching files to return (default: ${DEFAULT_SEARCH_LIMIT2})`
+  })
+});
+var Output7 = Schema.Array(Entry2);
+var toModelContent5 = (entries, truncated = false) => {
+  const lines = entries.length === 0 ? ["No files found"] : entries.map((item) => item.path);
+  if (truncated)
+    lines.push("", `(Results are truncated: showing first ${entries.length} results. Consider using a more specific path or pattern.)`);
+  return lines.join(`
+`);
+};
+var Plugin28 = {
+  id: "opencode.tool.glob",
+  effect: Effect.fn("GlobTool.Plugin")(function* (ctx) {
+    const environment = yield* Service65;
+    const ripgrep = yield* Service25;
+    const location = yield* Service66;
+    const access = yield* Service19;
+    const permission = yield* Service58;
+    yield* ctx.tool.transform((editor) => editor.add({
+      name: name11,
+      options: { codemode: false },
+      description: 'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+      input: Input11,
+      output: Output7,
+      execute: (input, context) => Effect.gen(function* () {
+        const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path;
+        const source = { type: "tool", messageID: context.messageID, id: context.id };
+        const target = yield* access.resolve({ path: searchPath ?? ".", kind: "directory" });
+        yield* access.authorizeExternal([target], context);
+        yield* permission.assert({
+          action: name11,
+          resources: [input.pattern],
+          save: ["*"],
+          metadata: {
+            root: searchPath ?? ".",
+            path: searchPath,
+            hidden: input.hidden,
+            limit: input.limit
+          },
+          sessionID: context.sessionID,
+          agent: context.agent,
+          source
+        });
+        const type = yield* typeFollowing2(environment.files, target.absolute).pipe(Effect.catchTag("Environment.NotFound", () => Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` }))));
+        if (type !== "directory")
+          return yield* Effect.fail(new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }));
+        const root = target.absolute;
+        const limit = input.limit ?? DEFAULT_SEARCH_LIMIT2;
+        const entries = yield* ripgrep.glob({
+          cwd: root,
+          pattern: input.pattern,
+          hidden: input.hidden,
+          limit: limit + 1
+        }).pipe(Effect.timeoutOrElse({
+          duration: DEFAULT_SEARCH_TIMEOUT_MS2,
+          orElse: () => Effect.fail(new ToolFailure({
+            message: `Search timed out after ${DEFAULT_SEARCH_TIMEOUT_MS2 / 1000} seconds. Consider using a more specific path or pattern.`
+          }))
+        }), Effect.map((result) => result.map((entry) => Entry2.make({
+          ...entry,
+          path: RelativePath2.make(path.relative(location.directory, path.resolve(root, entry.path)))
+        }))));
+        return { entries: entries.slice(0, limit), truncated: entries.length > limit };
+      }).pipe(Effect.map((result) => ({
+        output: result.entries,
+        content: toModelContent5(result.entries.map((entry) => ({ ...entry, path: path.resolve(location.directory, entry.path) })), result.truncated),
+        metadata: { count: result.entries.length, truncated: result.truncated }
+      })), Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to find files matching ${input.pattern}`, error })))
+    })).pipe(Effect.orDie);
+  })
+};
+
+export { name11, Input11, Output7, toModelContent5, Plugin28, exports_glob };

package/dist/chunks/repository-a6k6eb26.js

@@ -0,0 +1,105 @@
+// src/database/migration/20260805200742_import_legacy_credentials.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { sql } from "drizzle-orm";
+import { Effect, Option, Schema } from "effect";
+import { Credential } from "@opencode/schema/credential";
+import { Integration } from "@opencode/schema/integration";
+import { NonNegativeInt } from "@opencode/schema/schema";
+import { Global } from "@opencode/util/global";
+var LegacyOAuth = Schema.Struct({
+  type: Schema.Literal("oauth"),
+  refresh: Schema.String,
+  access: Schema.String,
+  expires: NonNegativeInt,
+  accountId: Schema.optional(Schema.String),
+  enterpriseUrl: Schema.optional(Schema.String)
+});
+var LegacyKey = Schema.Struct({
+  type: Schema.Literal("api"),
+  key: Schema.String,
+  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String))
+});
+var LegacyWellKnown = Schema.Struct({
+  type: Schema.Literal("wellknown"),
+  key: Schema.String,
+  token: Schema.String
+});
+var LegacyValue = Schema.Union([LegacyOAuth, LegacyKey, LegacyWellKnown]);
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+var decodeValue = Schema.decodeUnknownOption(LegacyValue);
+var wellKnownSourcesKey = "wellknown:sources";
+var migration = {
+  id: "20260805200742_import_legacy_credentials",
+  up(tx) {
+    return Effect.gen(function* () {
+      const global = yield* Global.Service;
+      return yield* importLegacyCredentials2(tx, path.join(global.data, "auth.json"));
+    });
+  }
+};
+var _20260805200742_import_legacy_credentials_default = migration;
+function importLegacyCredentials2(tx, filepath) {
+  return Effect.gen(function* () {
+    const content = yield* Effect.promise(() => readFile(filepath, "utf8").catch(() => {
+      return;
+    }));
+    if (content === undefined)
+      return;
+    const input = Option.getOrUndefined(decodeJson(content));
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+      return yield* Effect.fail(new Error("Legacy credential file must contain an object"));
+    }
+    const origins = [];
+    for (const [id, raw] of Object.entries(input)) {
+      const value = Option.getOrUndefined(decodeValue(raw));
+      if (!value)
+        continue;
+      const integrationID = id.replace(/\/+$/, "");
+      if (!integrationID)
+        continue;
+      if (value.type === "wellknown")
+        origins.push(integrationID);
+      if (yield* tx.get(sql`SELECT id FROM credential WHERE integration_id = ${integrationID}`))
+        continue;
+      const credential = value.type === "api" ? Credential.Key.make({ type: "key", key: value.key, metadata: value.metadata }) : value.type === "wellknown" ? Credential.Key.make({ type: "key", key: value.token }) : Credential.OAuth.make({
+        type: "oauth",
+        methodID: Integration.MethodID.make(methodID(integrationID)),
+        refresh: value.refresh,
+        access: value.access,
+        expires: value.expires,
+        metadata: value.accountId || value.enterpriseUrl ? {
+          ...value.accountId ? { accountID: value.accountId } : {},
+          ...value.enterpriseUrl ? { enterpriseUrl: value.enterpriseUrl } : {}
+        } : undefined
+      });
+      const label = credential.type === "oauth" ? "OAuth" : "API key";
+      const now = Date.now();
+      yield* tx.run(sql`
+        INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
+        VALUES (${Credential.ID.create()}, ${integrationID}, ${label}, ${JSON.stringify(credential)}, ${now}, ${now})
+      `);
+    }
+    if (!origins.length)
+      return;
+    const stored = yield* tx.get(sql`SELECT value FROM kv WHERE key = ${wellKnownSourcesKey}`);
+    const decoded = stored ? Option.getOrUndefined(decodeJson(stored.value)) : undefined;
+    const current = Array.isArray(decoded) ? decoded.filter((item) => typeof item === "string") : [];
+    const value = JSON.stringify(Array.from(new Set([...current, ...origins])));
+    const now = Date.now();
+    yield* tx.run(sql`
+      INSERT INTO kv (key, value, time_created, time_updated)
+      VALUES (${wellKnownSourcesKey}, ${value}, ${now}, ${now})
+      ON CONFLICT (key) DO UPDATE SET value = excluded.value, time_updated = excluded.time_updated
+    `);
+  });
+}
+function methodID(integrationID) {
+  if (integrationID === "openai")
+    return "chatgpt-browser";
+  if (["github-copilot", "opencode", "xai"].includes(integrationID))
+    return "device";
+  return "oauth";
+}
+
+export { importLegacyCredentials2, _20260805200742_import_legacy_credentials_default };

package/dist/chunks/repository-a8ygtzbq.js

@@ -0,0 +1,66 @@
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  Key3,
+  make20,
+  combine2
+} from "./repository-rhjbct0v.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/instructions/builtins.ts
+var exports_builtins = {};
+__export(exports_builtins, {
+  InstructionBuiltIns: () => exports_builtins,
+  Service: () => Service38,
+  node: () => node42
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, DateTime, Effect, Layer, Schema } from "effect";
+import { Global } from "@opencode/util/global";
+class Service38 extends Context.Service()("@opencode/InstructionBuiltIns") {
+}
+var layer = Layer.effect(Service38, Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const location = yield* Service66;
+  return Service38.of({
+    load: (sessionID) => Effect.succeed(combine2([
+      make20({
+        key: Key3.make("core/environment"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: Effect.sync(() => [
+          "<env>",
+          `  Current conversation session ID: ${sessionID}`,
+          `  Working directory: ${location.directory}`,
+          `  Workspace root folder: ${location.project.directory}`,
+          `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
+          `  Platform: ${process.platform}`,
+          `  Prefer ${global.tmp} over generic system temporary directories such as /tmp; it is pre-created and approved for external access.`,
+          "</env>"
+        ].join(`
+`)),
+        render: {
+          initial: (environment) => ["Here is some useful information about the environment you are running in:", environment].join(`
+`),
+          changed: (_previous, environment) => ["The environment you are running in is now:", environment].join(`
+`)
+        }
+      }),
+      make20({
+        key: Key3.make("core/date"),
+        codec: Schema.toCodecJson(Schema.String),
+        read: DateTime.nowAsDate.pipe(Effect.map((date) => date.toDateString())),
+        render: {
+          initial: (date) => `Today's date: ${date}`,
+          changed: (_previous, date) => `Today's date is now: ${date}`
+        }
+      })
+    ]))
+  });
+}));
+var node42 = makeLocationNode({ service: Service38, layer, deps: [Global.node, node70] });
+
+export { Service38, node42, exports_builtins };

package/dist/chunks/repository-aa4x36r7.js

@@ -0,0 +1,194 @@
+import {
+  _20260127222353_familiar_lady_ursula_default
+} from "./repository-jzg6c2d5.js";
+import {
+  _20260211171708_add_project_commands_default
+} from "./repository-q3sfg36h.js";
+import {
+  _20260213144116_wakeful_the_professor_default
+} from "./repository-1cnp2v09.js";
+import {
+  _20260225215848_workspace_default
+} from "./repository-rcb2kzg1.js";
+import {
+  _20260227213759_add_session_workspace_id_default
+} from "./repository-msx8hqn2.js";
+import {
+  _20260228203230_blue_harpoon_default
+} from "./repository-bkyjaxrp.js";
+import {
+  _20260303231226_add_workspace_fields_default
+} from "./repository-g86h250q.js";
+import {
+  _20260309230000_move_org_to_state_default
+} from "./repository-jr7sbwjy.js";
+import {
+  _20260312043431_session_message_cursor_default
+} from "./repository-7m9af43g.js";
+import {
+  _20260323234822_events_default
+} from "./repository-j2ntwpah.js";
+import {
+  _20260410174513_workspace_name_default
+} from "./repository-njntx4h6.js";
+import {
+  _20260413175956_chief_energizer_default
+} from "./repository-qrg20bc0.js";
+import {
+  _20260423070820_add_icon_url_override_default
+} from "./repository-z9919s4g.js";
+import {
+  _20260427172553_slow_nightmare_default
+} from "./repository-43n2bw4t.js";
+import {
+  _20260428004200_add_session_path_default
+} from "./repository-n3j8tn72.js";
+import {
+  _20260501142318_next_venus_default
+} from "./repository-d9jj8t3e.js";
+import {
+  _20260504145000_add_sync_owner_default
+} from "./repository-fd410y7t.js";
+import {
+  _20260507164347_add_workspace_time_default
+} from "./repository-e5kj55wp.js";
+import {
+  _20260510033149_session_usage_default
+} from "./repository-f6n9ztr4.js";
+import {
+  _20260511000411_data_migration_state_default
+} from "./repository-q74kybfr.js";
+import {
+  _20260511173437_session_metadata_default
+} from "./repository-53557ph1.js";
+import {
+  _20260601010001_normalize_storage_paths_default
+} from "./repository-7akdwqpd.js";
+import {
+  _20260601202201_amazing_prowler_default
+} from "./repository-wer8tq1h.js";
+import {
+  _20260602002951_lowly_union_jack_default
+} from "./repository-wtztk69x.js";
+import {
+  _20260602182828_add_project_directories_default
+} from "./repository-ssg3fenm.js";
+import {
+  _20260603001617_session_message_projection_indexes_default
+} from "./repository-2c3vjs8z.js";
+import {
+  _20260603040000_session_message_projection_order_default
+} from "./repository-17cy0kzp.js";
+import {
+  _20260603141458_session_input_inbox_default
+} from "./repository-hk9envan.js";
+import {
+  _20260603160727_jittery_ezekiel_stane_default
+} from "./repository-w803qqfp.js";
+import {
+  _20260604172448_event_sourced_session_input_default
+} from "./repository-jwfs4k6c.js";
+import {
+  _20260605003541_add_session_context_snapshot_default
+} from "./repository-mp448xyj.js";
+import {
+  _20260605042240_add_context_epoch_agent_default
+} from "./repository-aqzs7mqg.js";
+import {
+  _20260611035744_credential_default
+} from "./repository-ygaqb7jw.js";
+import {
+  _20260611192811_lush_chimera_default
+} from "./repository-8n3pysct.js";
+import {
+  _20260612174303_project_dir_strategy_default
+} from "./repository-d9fn303g.js";
+import {
+  _20260622142730_simplify_session_context_epoch_default
+} from "./repository-cvy3z8tj.js";
+import {
+  _20260622170816_reset_v2_session_state_default
+} from "./repository-9a4afbnw.js";
+import {
+  _20260622202450_simplify_session_input_default
+} from "./repository-n05xt0ee.js";
+import {
+  _20260804233008_loose_psylocke_default
+} from "./repository-sdp7kfr6.js";
+import {
+  _20260805200742_import_legacy_credentials_default
+} from "./repository-a6k6eb26.js";
+import {
+  _20260808023530_workspace_domain_default
+} from "./repository-4knz6hnm.js";
+import {
+  _20260811161259_execution_claim_attempts_default
+} from "./repository-df08tz66.js";
+import {
+  _20260812181746_session_inbox_default
+} from "./repository-bmr6ed5q.js";
+import {
+  _20260812213948_worktree_default
+} from "./repository-atq7p7m5.js";
+import {
+  _20260819222447_session_viewed_state_default
+} from "./repository-qb87gjwd.js";
+import {
+  _20260823191254_nullable_workspace_binding_default
+} from "./repository-359p4xyc.js";
+import {
+  _20260910120000_clear_v1_session_permission_default
+} from "./repository-y8f7s663.js";
+
+// src/database/migration.gen.ts
+var migrations2 = [
+  _20260127222353_familiar_lady_ursula_default,
+  _20260211171708_add_project_commands_default,
+  _20260213144116_wakeful_the_professor_default,
+  _20260225215848_workspace_default,
+  _20260227213759_add_session_workspace_id_default,
+  _20260228203230_blue_harpoon_default,
+  _20260303231226_add_workspace_fields_default,
+  _20260309230000_move_org_to_state_default,
+  _20260312043431_session_message_cursor_default,
+  _20260323234822_events_default,
+  _20260410174513_workspace_name_default,
+  _20260413175956_chief_energizer_default,
+  _20260423070820_add_icon_url_override_default,
+  _20260427172553_slow_nightmare_default,
+  _20260428004200_add_session_path_default,
+  _20260501142318_next_venus_default,
+  _20260504145000_add_sync_owner_default,
+  _20260507164347_add_workspace_time_default,
+  _20260510033149_session_usage_default,
+  _20260511000411_data_migration_state_default,
+  _20260511173437_session_metadata_default,
+  _20260601010001_normalize_storage_paths_default,
+  _20260601202201_amazing_prowler_default,
+  _20260602002951_lowly_union_jack_default,
+  _20260602182828_add_project_directories_default,
+  _20260603001617_session_message_projection_indexes_default,
+  _20260603040000_session_message_projection_order_default,
+  _20260603141458_session_input_inbox_default,
+  _20260603160727_jittery_ezekiel_stane_default,
+  _20260604172448_event_sourced_session_input_default,
+  _20260605003541_add_session_context_snapshot_default,
+  _20260605042240_add_context_epoch_agent_default,
+  _20260611035744_credential_default,
+  _20260611192811_lush_chimera_default,
+  _20260612174303_project_dir_strategy_default,
+  _20260622142730_simplify_session_context_epoch_default,
+  _20260622170816_reset_v2_session_state_default,
+  _20260622202450_simplify_session_input_default,
+  _20260804233008_loose_psylocke_default,
+  _20260805200742_import_legacy_credentials_default,
+  _20260808023530_workspace_domain_default,
+  _20260811161259_execution_claim_attempts_default,
+  _20260812181746_session_inbox_default,
+  _20260812213948_worktree_default,
+  _20260819222447_session_viewed_state_default,
+  _20260823191254_nullable_workspace_binding_default,
+  _20260910120000_clear_v1_session_permission_default
+];
+
+export { migrations2 };

package/dist/chunks/repository-aaet6srn.js

@@ -0,0 +1,170 @@
+import {
+  NotFound2,
+  WrongKind2,
+  Failed2
+} from "./repository-2a5m3afh.js";
+import {
+  __export
+} from "./repository-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/repository-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/repository-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 };