@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-t0x5rdq8.js

@@ -0,0 +1,53 @@
+import {
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/filesystem/location-watcher-policy.ts
+var exports_location_watcher_policy = {};
+__export(exports_location_watcher_policy, {
+  LocationWatcherPolicy: () => exports_location_watcher_policy,
+  Service: () => Service12,
+  node: () => node15
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Scope } from "effect";
+class Service12 extends Context.Service()("@opencode/LocationWatcherPolicy") {
+}
+var layer = Layer.effect(Service12, Effect.gen(function* () {
+  const listeners = new Set;
+  const state = create3({
+    name: "location-watcher-policy",
+    initial: () => ({ ignore: [] }),
+    editor: (editor) => ({
+      add: (ignore) => editor.ignore.push(...ignore),
+      list: () => editor.ignore
+    }),
+    notify: () => Effect.forEach(listeners, (listener) => listener(current()), { discard: true })
+  });
+  const current = () => state.get().ignore;
+  const observe = Effect.fn("LocationWatcherPolicy.observe")(function* (listener) {
+    const scope = yield* Scope.Scope;
+    let active = true;
+    const dispose = Effect.sync(() => {
+      if (!active)
+        return;
+      active = false;
+      listeners.delete(listener);
+    });
+    listeners.add(listener);
+    yield* Scope.addFinalizer(scope, dispose);
+    return { dispose };
+  });
+  return Service12.of({
+    transform: state.transform,
+    reload: state.reload,
+    current,
+    observe
+  });
+}));
+var node15 = makeLocationNode({ service: Service12, layer, deps: [] });
+
+export { Service12, node15, exports_location_watcher_policy };

package/dist/chunks/repository-t2x602yk.js

@@ -0,0 +1,74 @@
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  ID16
+} from "./repository-pye8sh6e.js";
+import {
+  ID14
+} from "./repository-nxamnhdf.js";
+import {
+  Event19
+} from "./repository-sztg2hv4.js";
+import {
+  ID13
+} from "./repository-0zkv00cg.js";
+import {
+  Service73
+} from "./repository-gtm8txn9.js";
+import {
+  get3
+} from "./repository-j5xt7epv.js";
+
+// src/plugin/provider/modal.ts
+import { Effect, Semaphore, Stream } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+var providerID = ID16.make("modal");
+var ModalPlugin2 = define({
+  id: "opencode.provider.modal",
+  effect: Effect.fn(function* (ctx) {
+    const catalog = yield* Service73;
+    const bus = yield* Service78;
+    const loading = Semaphore.makeUnsafe(1);
+    const loaded = {};
+    const load = Effect.fn("ModalPlugin.load")(function* () {
+      const connection = yield* ctx.integration.connection.active("modal");
+      const credential = connection ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => {
+        return;
+      })) : undefined;
+      const apiKey = credential?.type === "key" ? credential.key : process.env.MODAL_PROXY_TOKEN;
+      const provider = yield* catalog.provider.get(providerID);
+      const baseURL = typeof provider?.settings?.baseURL === "string" ? provider.settings.baseURL : undefined;
+      if (!apiKey || !baseURL) {
+        loaded.baseURL = undefined;
+        loaded.models = undefined;
+        return;
+      }
+      loaded.baseURL = baseURL;
+      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === providerID);
+      loaded.models = yield* Effect.tryPromise({
+        try: () => get3(baseURL, apiKey, existing),
+        catch: (cause) => cause
+      }).pipe(Effect.catch((cause) => Effect.logWarning("failed to sync Modal models", { cause }).pipe(Effect.as(undefined))));
+    });
+    yield* ctx.catalog.transform((evt) => {
+      const item = evt.provider.get(providerID);
+      if (!item)
+        return;
+      if (!loaded.models)
+        return;
+      for (const id of item.models.keys()) {
+        if (!loaded.models.has(ID14.make(id)))
+          evt.model.remove(item.provider.id, id);
+      }
+      for (const [id, model] of loaded.models) {
+        evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)));
+      }
+    });
+    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())));
+    yield* bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => event.data.integrationID === ID13.make("modal")), Stream.runForEach(refresh), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh().pipe(Effect.forkScoped);
+  })
+});
+
+export { ModalPlugin2 };

package/dist/chunks/repository-t59s3hhv.js

@@ -0,0 +1,226 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  node50
+} from "./repository-shg3amz7.js";
+import {
+  Service2,
+  node4
+} from "./repository-sgk3431w.js";
+import {
+  Service36
+} from "./repository-jqh9b0xq.js";
+import {
+  node18,
+  ID2
+} from "./repository-qt3bdkqw.js";
+import {
+  Service5,
+  node7
+} from "./repository-cmwkp3r5.js";
+import {
+  requirements2,
+  list2
+} from "./repository-mppgq2kn.js";
+import {
+  make6,
+  LoadError2
+} from "./repository-1j4qb6e1.js";
+import {
+  Updated2,
+  Service4,
+  node6
+} from "./repository-sksn9mf1.js";
+import {
+  Service6,
+  node8
+} from "./repository-h71w788e.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/supervisor.ts
+var exports_supervisor = {};
+__export(exports_supervisor, {
+  PluginSupervisor: () => exports_supervisor,
+  layer: () => layer3,
+  node: () => node3
+});
+import { Event } from "@opencode/schema/config";
+import { Cause, Effect, Layer, Queue, Stream } from "effect";
+import path from "path";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Npm } from "@opencode/util/npm";
+var resolve = Effect.fn("PluginSupervisor.resolve")(function* (modules, pre, post, operations, install, running) {
+  const matches = (selector, target) => selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target);
+  const definitions = [...pre, ...post];
+  const enabled = new Set(definitions.map((plugin) => plugin.id));
+  const packages = new Map;
+  const pending = new Set;
+  const failures = new Map;
+  const plugins = () => [...definitions, ...packages.values()];
+  for (const operation of operations) {
+    if (operation.type === "remove") {
+      if (operation.target === "*")
+        failures.clear();
+      plugins().filter((plugin) => matches(operation.target, plugin.id)).forEach((plugin) => enabled.delete(plugin.id));
+      continue;
+    }
+    const matched = plugins().filter((plugin) => matches(operation.target, plugin.id));
+    const selectsPlugins = matched.length > 0 || operation.target === "*" || operation.target.endsWith(".*") || operation.target.startsWith("opencode.");
+    if (selectsPlugins) {
+      matched.forEach((plugin) => enabled.add(plugin.id));
+      continue;
+    }
+    const plugin = yield* modules.load(operation, { install }).pipe(Effect.catchCause((cause) => {
+      const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+      const error = Cause.squash(cause);
+      return Effect.logWarning("failed to load plugin", { target: operation.target, ref, cause }).pipe(Effect.as({ error: error instanceof LoadError2 ? error.message : "Plugin failed to load", ref }));
+    }));
+    if ("pending" in plugin) {
+      pending.add(operation.target);
+      continue;
+    }
+    if ("error" in plugin) {
+      failures.set(operation.target, {
+        source: pluginSource(operation.target),
+        state: { status: "failed", error: plugin.error, ref: plugin.ref },
+        features: { server: true }
+      });
+      const retained = packages.get(operation.target) ?? running.get(operation.target);
+      if (!retained)
+        continue;
+      packages.set(operation.target, retained);
+      enabled.add(retained.id);
+      continue;
+    }
+    failures.delete(operation.target);
+    const previous = packages.get(operation.target);
+    if (previous)
+      enabled.delete(previous.id);
+    packages.set(operation.target, plugin);
+    enabled.add(plugin.id);
+  }
+  const ordered = [
+    ...pre.filter((plugin) => enabled.has(plugin.id)),
+    ...[...packages.values()].filter((plugin) => enabled.has(plugin.id)),
+    ...post.filter((plugin) => enabled.has(plugin.id))
+  ];
+  const duplicate = (plugin, index) => ordered.findIndex((other) => other.id === plugin.id) !== index;
+  return {
+    plugins: ordered.filter((plugin, index) => !duplicate(plugin, index)),
+    packages: new Map([...packages].filter(([, plugin]) => enabled.has(plugin.id))),
+    failures: [
+      ...failures.values(),
+      ...ordered.filter(duplicate).map((plugin) => ({
+        id: ID2.make(plugin.id),
+        source: plugin.source ?? { type: "builtin" },
+        state: { status: "failed", error: `Duplicate plugin ID: ${plugin.id}` },
+        features: { server: true, ...plugin.features }
+      }))
+    ],
+    pending: [...pending]
+  };
+});
+var layer3 = Layer.effectDiscard(Effect.gen(function* () {
+  const registry = yield* Service36;
+  const sdk = yield* Service4;
+  const instance = yield* Service5;
+  const sources = yield* Service2;
+  const modules = yield* make6();
+  const bus = yield* Service78;
+  const updates = yield* Service6;
+  const internal = yield* list2();
+  let release = yield* registry.hold();
+  yield* Effect.addFinalizer(() => release ?? Effect.void);
+  yield* Effect.addFinalizer(registry.close);
+  let packages = new Set;
+  let running = new Map;
+  let outdated = new Set;
+  const updating = new Set;
+  let generation = 0;
+  let observed = 0;
+  const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+    const current = ++generation;
+    const pre = [
+      ...internal.pre.map((plugin) => ({ ...plugin, revision: "internal", source: { type: "builtin" } })),
+      ...sdk.all(),
+      ...instance.all()
+    ];
+    const post = internal.post.map((plugin) => ({
+      ...plugin,
+      revision: "internal",
+      source: { type: "builtin" }
+    }));
+    const operations = yield* sources.operations();
+    const immediate = yield* resolve(modules, pre, post, operations, false, running);
+    const source = (source) => source.type === "package" ? {
+      ...source,
+      ...outdated.has(source.target) ? { outdated: true } : {},
+      ...updating.has(source.target) ? { updating: true } : {}
+    } : source;
+    const apply = (resolved) => registry.activate(resolved.plugins.map((plugin) => plugin.source ? { ...plugin, source: source(plugin.source) } : plugin), resolved.failures.map((failure) => ({ ...failure, source: source(failure.source) })));
+    yield* apply(immediate);
+    const resolved = immediate.pending.length ? yield* resolve(modules, pre, post, operations, true, running) : immediate;
+    if (resolved !== immediate)
+      yield* apply(resolved);
+    running = resolved.packages;
+    const targets = new Set([...resolved.plugins, ...resolved.failures].flatMap((plugin) => plugin.source?.type === "package" ? [plugin.source.target] : []));
+    packages = targets;
+    yield* Effect.forEach(targets, (target) => updates.check(target).pipe(Effect.map((available) => [target, available])), { concurrency: "unbounded" }).pipe(Effect.flatMap((checked) => {
+      if (current !== generation)
+        return Effect.void;
+      const next = new Set(checked.flatMap(([target, available]) => available ? [target] : []));
+      if (next.size === outdated.size && [...next].every((target) => outdated.has(target)))
+        return Effect.void;
+      outdated = next;
+      return apply(resolved);
+    }), Effect.forkScoped({ startImmediately: true }));
+  });
+  const triggers = yield* Queue.sliding(1);
+  const notify = Effect.gen(function* () {
+    observed++;
+    if (!release)
+      release = yield* registry.hold();
+    yield* Queue.offer(triggers, observed);
+  });
+  const watch = (stream) => stream.pipe(Stream.runForEach(() => notify), Effect.forkScoped({ startImmediately: true }));
+  yield* watch(sources.changes());
+  yield* watch(modules.changes());
+  yield* watch(Stream.fromEffectRepeat(Effect.sleep("24 hours")));
+  yield* watch(bus.subscribe([Event.Updated, Updated2]));
+  yield* watch(updates.changes().pipe(Stream.filter((update) => packages.has(update.target)), Stream.tap((update) => Effect.sync(() => {
+    update.outdated ? outdated.add(update.target) : outdated.delete(update.target);
+    update.updating ? updating.add(update.target) : updating.delete(update.target);
+  }))));
+  yield* Stream.concat(Stream.succeed(0), Stream.fromQueue(triggers).pipe(Stream.debounce("100 millis"))).pipe(Stream.runForEach((target) => Effect.gen(function* () {
+    yield* activate().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })));
+    if (observed !== target)
+      return;
+    const settled = release;
+    release = undefined;
+    if (settled)
+      yield* settled;
+  })), Effect.forkScoped({ startImmediately: true }));
+}));
+var nodeDeps = [
+  node18,
+  node6,
+  node7,
+  node4,
+  node8,
+  node83,
+  Npm.node,
+  node50,
+  requirements2
+];
+function pluginSource(target) {
+  if (path.isAbsolute(target))
+    return { type: "local", path: target };
+  return { type: "package", target };
+}
+var node3 = makeLocationNode({ name: "plugin-supervisor", layer: layer3, deps: nodeDeps });
+
+export { layer3, node3, exports_supervisor };

package/dist/chunks/repository-tat7nwhe.js

@@ -0,0 +1,48 @@
+import {
+  Service78
+} from "./repository-x6rcf4cj.js";
+import {
+  Service46,
+  Event11
+} from "./repository-bkhh0yw4.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/wellknown/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  Plugin: () => Plugin44,
+  WellKnownPlugin: () => exports_plugin
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Stream } from "effect";
+var Plugin44 = define({
+  id: "opencode.wellknown",
+  effect: Effect.fn(function* (ctx) {
+    const bus = yield* Service78;
+    const wellknown = yield* Service46;
+    yield* wellknown.entries().pipe(Effect.orDie);
+    yield* ctx.integration.transform((editor) => {
+      wellknown.snapshot().forEach((entry) => {
+        if (!entry.manifest.auth)
+          return;
+        editor.update(entry.integrationID, (integration) => {
+          integration.name = new URL(entry.origin).hostname;
+        });
+        editor.method.update({
+          integrationID: entry.integrationID,
+          method: {
+            id: "login",
+            type: "command",
+            label: "Log in",
+            command: [...entry.manifest.auth.command]
+          }
+        });
+      });
+    });
+    yield* bus.subscribe(Event11.Updated).pipe(Stream.runForEach(() => ctx.integration.reload()), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin44, exports_plugin };

package/dist/chunks/repository-tazgh4e4.js

@@ -0,0 +1,116 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/vcs/patch.ts
+var exports_patch2 = {};
+__export(exports_patch2, {
+  MAX_PATCH_BYTES: () => MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES: () => MAX_TOTAL_PATCH_BYTES2,
+  PATCH_CONTEXT_LINES: () => PATCH_CONTEXT_LINES2,
+  VcsPatch: () => exports_patch2,
+  addPatch: () => addPatch2,
+  chunksByFile: () => chunksByFile2,
+  countPatch: () => countPatch2,
+  deletePatch: () => deletePatch2,
+  emptyPatch: () => emptyPatch2,
+  fileFromPatchChunk: () => fileFromPatchChunk2,
+  splitGitPatch: () => splitGitPatch2
+});
+import { formatPatch, structuredPatch } from "diff";
+var PATCH_CONTEXT_LINES2 = 2147483647;
+var MAX_PATCH_BYTES2 = 1e7;
+var MAX_TOTAL_PATCH_BYTES2 = 1e7;
+var emptyPatch2 = (file) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }));
+var addPatch2 = (file, content) => formatPatch(structuredPatch(file, file, "", content, "", "", { context: 0 }));
+var deletePatch2 = (file, content) => formatPatch(structuredPatch(file, file, content, "", "", "", { context: 0 }));
+var countPatch2 = (patch) => {
+  let additions = 0;
+  let deletions = 0;
+  for (const line of patch.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      additions++;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      deletions++;
+  }
+  return { additions, deletions };
+};
+var parseQuotedPath = (value) => {
+  let out = "";
+  for (let idx = 1;idx < value.length; idx++) {
+    const char = value[idx];
+    if (char === '"')
+      return { value: out, end: idx + 1 };
+    if (char !== "\\") {
+      out += char;
+      continue;
+    }
+    const next = value[++idx];
+    if (next === "t")
+      out += "\t";
+    else if (next === "n")
+      out += `
+`;
+    else if (next === "r")
+      out += "\r";
+    else if (next === '"' || next === "\\")
+      out += next;
+    else
+      out += next ?? "";
+  }
+};
+var parsePathToken = (value) => {
+  if (!value.startsWith('"'))
+    return value.split("\t")[0];
+  return parseQuotedPath(value)?.value ?? value;
+};
+var fileFromDiffPath = (value) => {
+  if (!value || value === "/dev/null")
+    return;
+  const file = parsePathToken(value);
+  if (file.startsWith("a/") || file.startsWith("b/"))
+    return file.slice(2);
+  return file;
+};
+var fileFromGitHeader = (header) => {
+  if (header.startsWith('"')) {
+    const first = parseQuotedPath(header);
+    const second = first ? header.slice(first.end).trimStart() : undefined;
+    if (!second)
+      return;
+    if (!second.startsWith('"'))
+      return fileFromDiffPath(second);
+    return fileFromDiffPath(parseQuotedPath(second)?.value);
+  }
+  const separator = header.indexOf(" b/");
+  if (separator === -1)
+    return;
+  return fileFromDiffPath(header.slice(separator + 1));
+};
+var fileFromPatchChunk2 = (chunk) => {
+  const next = /^\+\+\+ (.+)$/m.exec(chunk)?.[1];
+  const before = /^--- (.+)$/m.exec(chunk)?.[1];
+  const file = fileFromDiffPath(next) ?? fileFromDiffPath(before);
+  if (file)
+    return file;
+  const header = /^diff --git (.+)$/m.exec(chunk)?.[1];
+  return fileFromGitHeader(header ?? "");
+};
+var splitGitPatch2 = (patch) => {
+  const starts = [...patch.text.matchAll(/(?:^|\n)diff --git /g)].map((match) => match[0].startsWith(`
+`) ? match.index + 1 : match.index);
+  const chunks = starts.map((start, index) => patch.text.slice(start, starts[index + 1] ?? patch.text.length));
+  if (!patch.truncated)
+    return chunks;
+  return chunks.slice(0, -1);
+};
+var chunksByFile2 = (patch, fallback) => splitGitPatch2(patch).reduce((acc, chunk, index) => {
+  const file = fileFromPatchChunk2(chunk) ?? fallback(index);
+  if (!file)
+    return acc;
+  acc.set(file, (acc.get(file) ?? "") + chunk);
+  return acc;
+}, new Map);
+
+export { PATCH_CONTEXT_LINES2, MAX_PATCH_BYTES2, MAX_TOTAL_PATCH_BYTES2, emptyPatch2, addPatch2, deletePatch2, countPatch2, fileFromPatchChunk2, splitGitPatch2, chunksByFile2, exports_patch2 };

package/dist/chunks/repository-tcezcvh9.js

@@ -0,0 +1,63 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/filesystem/protected.ts
+var exports_protected = {};
+__export(exports_protected, {
+  Protected: () => exports_protected,
+  isHome: () => isHome2,
+  names: () => names3,
+  paths: () => paths2
+});
+import os from "os";
+import path from "path";
+var home = os.homedir();
+function isHome2(directory) {
+  return path.resolve(directory) === path.resolve(home);
+}
+var DARWIN_HOME = [
+  "Music",
+  "Pictures",
+  "Movies",
+  "Downloads",
+  "Desktop",
+  "Documents",
+  "Public",
+  "Applications",
+  "Library"
+];
+var DARWIN_LIBRARY = [
+  "Application Support/AddressBook",
+  "Calendars",
+  "Mail",
+  "Messages",
+  "Safari",
+  "Cookies",
+  "Application Support/com.apple.TCC",
+  "PersonalizationPortrait",
+  "Metadata/CoreSpotlight",
+  "Suggestions"
+];
+var DARWIN_ROOT = ["/.DocumentRevisions-V100", "/.Spotlight-V100", "/.Trashes", "/.fseventsd"];
+var WIN32_HOME = ["AppData", "Downloads", "Desktop", "Documents", "Pictures", "Music", "Videos", "OneDrive"];
+function names3() {
+  if (process.platform === "darwin")
+    return new Set(DARWIN_HOME);
+  if (process.platform === "win32")
+    return new Set(WIN32_HOME);
+  return new Set;
+}
+function paths2() {
+  if (process.platform === "darwin")
+    return [
+      ...DARWIN_HOME.map((name) => path.join(home, name)),
+      ...DARWIN_LIBRARY.map((name) => path.join(home, "Library", name)),
+      ...DARWIN_ROOT
+    ];
+  if (process.platform === "win32")
+    return WIN32_HOME.map((name) => path.join(home, name));
+  return [];
+}
+
+export { isHome2, names3, paths2, exports_protected };

package/dist/chunks/repository-tdstcens.js

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/session/usage.ts
+var exports_usage = {};
+__export(exports_usage, {
+  SessionUsage: () => exports_usage,
+  add: () => add2,
+  calculateCost: () => calculateCost2,
+  record: () => record2,
+  tokens: () => tokens2
+});
+import { Money } from "@opencode/schema/money";
+var finite = (value) => Number.isFinite(value) ? value : 0;
+var safe = (value) => Math.max(0, finite(value ?? 0));
+var tokens2 = (usage) => ({
+  input: safe(usage?.nonCachedInputTokens),
+  output: safe(usage?.visibleOutputTokens),
+  reasoning: safe(usage?.reasoningTokens),
+  cache: {
+    read: safe(usage?.cacheReadInputTokens),
+    write: safe(usage?.cacheWriteInputTokens)
+  }
+});
+function calculateCost2(costs, usage) {
+  const context = usage.input + usage.cache.read + usage.cache.write;
+  const tier = costs.filter((cost) => cost.tier?.type === "context" && context > cost.tier.size).toSorted((a, b) => (b.tier?.size ?? 0) - (a.tier?.size ?? 0))[0];
+  const cost = tier ?? costs.find((cost) => cost.tier === undefined);
+  if (!cost)
+    return Money.USD.zero;
+  return Money.USD.make((usage.input * finite(cost.input) + (usage.output + usage.reasoning) * finite(cost.output) + usage.cache.read * finite(cost.cache.read) + usage.cache.write * finite(cost.cache.write)) / 1e6);
+}
+var record2 = (usage, costs) => {
+  const normalized = tokens2(usage);
+  return { tokens: normalized, cost: calculateCost2(costs, normalized) };
+};
+var add2 = (a, b) => ({
+  cost: Money.USD.make(a.cost + b.cost),
+  tokens: {
+    input: a.tokens.input + b.tokens.input,
+    output: a.tokens.output + b.tokens.output,
+    reasoning: a.tokens.reasoning + b.tokens.reasoning,
+    cache: {
+      read: a.tokens.cache.read + b.tokens.cache.read,
+      write: a.tokens.cache.write + b.tokens.cache.write
+    }
+  }
+});
+
+export { tokens2, calculateCost2, record2, add2, exports_usage };