@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-tazgh4e4.js

@@ -0,0 +1,116 @@
+import {
+  __export
+} from "./worktree-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/worktree-tcezcvh9.js

@@ -0,0 +1,63 @@
+import {
+  __export
+} from "./worktree-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/worktree-tdstcens.js

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./worktree-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 };

package/dist/chunks/worktree-th5km1p3.js

@@ -0,0 +1,25 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/worktree/directory.ts
+var exports_directory = {};
+__export(exports_directory, {
+  DirectoryUnavailableError: () => DirectoryUnavailableError2,
+  WorktreeDirectory: () => exports_directory,
+  canonical: () => canonical3
+});
+import { Effect, Schema } from "effect";
+class DirectoryUnavailableError2 extends Schema.TaggedError()("Worktree.DirectoryUnavailableError", { directory: AbsolutePath2 }) {
+}
+var canonical3 = Effect.fnUntraced(function* (fs, input) {
+  const resolved = AbsolutePath2.make(yield* fs.resolve(input));
+  if (!(yield* fs.isDir(resolved)))
+    return yield* new DirectoryUnavailableError2({ directory: input });
+  return resolved;
+});
+
+export { DirectoryUnavailableError2, canonical3, exports_directory };

package/dist/chunks/worktree-tjsj89dc.js

@@ -0,0 +1,54 @@
+import {
+  makeUnsafe2
+} from "./worktree-y71avatq.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/plugin/update.ts
+var exports_update = {};
+__export(exports_update, {
+  PluginUpdate: () => exports_update,
+  Service: () => Service11,
+  node: () => node14
+});
+import { Clock, Context, Effect, Exit, Layer, Option, PubSub, Stream } from "effect";
+import { Npm } from "@opencode/util/npm";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var interval = 24 * 60 * 60 * 1000;
+
+class Service11 extends Context.Service()("@opencode/PluginUpdate") {
+}
+var layer = Layer.effect(Service11, Effect.gen(function* () {
+  const npm = yield* Npm.Service;
+  const locks = makeUnsafe2();
+  const status = new Map;
+  const changes = yield* PubSub.unbounded();
+  return Service11.of({
+    check: (target, options) => locks.withLock(target)(Effect.gen(function* () {
+      const checkedAt = yield* Clock.currentTimeMillis;
+      const current = status.get(target);
+      if (!options?.refresh && current && checkedAt - current.checkedAt < interval)
+        return current.outdated;
+      const outdated = yield* npm.check(target).pipe(Effect.tapCause((cause) => Effect.logWarning("failed to check plugin update", { target, cause })), Effect.option);
+      const value = Option.getOrElse(outdated, () => current?.outdated ?? false);
+      status.set(target, { outdated: value, checkedAt });
+      if ((current?.outdated ?? false) !== value)
+        yield* PubSub.publish(changes, { target, outdated: value, updating: false });
+      return value;
+    })),
+    update: (target) => locks.withLock(target)(Effect.gen(function* () {
+      const outdated = status.get(target)?.outdated ?? false;
+      yield* PubSub.publish(changes, { target, outdated, updating: true });
+      yield* npm.update(target).pipe(Effect.tap(() => Effect.sync(() => status.delete(target))), Effect.onExit((exit) => PubSub.publish(changes, {
+        target,
+        outdated: Exit.isSuccess(exit) ? false : outdated,
+        updating: false
+      })));
+    })),
+    changes: () => Stream.fromPubSub(changes)
+  });
+}));
+var node14 = makeGlobalNode({ service: Service11, layer, deps: [Npm.node] });
+
+export { Service11, node14, exports_update };

package/dist/chunks/worktree-tm64n74p.js

@@ -0,0 +1,272 @@
+import {
+  Metadata2,
+  useragent2,
+  node63
+} from "./worktree-xrd4famk.js";
+import {
+  provenance2,
+  compatible2
+} from "./worktree-w1k39n5e.js";
+import {
+  Service77,
+  node82
+} from "./worktree-r05k2dy1.js";
+import {
+  DeclinedError2
+} from "./worktree-k56d8zdx.js";
+import {
+  CancelledError2
+} from "./worktree-hcaepy0h.js";
+import {
+  Error5
+} from "./worktree-249ffbnn.js";
+import {
+  Service23,
+  node28
+} from "./worktree-nqyaavw9.js";
+import {
+  make14
+} from "./worktree-nhy5jxhy.js";
+import {
+  toLLMMessages2
+} from "./worktree-rfnzy394.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/model-request.ts
+var exports_model_request = {};
+__export(exports_model_request, {
+  Service: () => Service22,
+  SessionModelRequest: () => exports_model_request,
+  baseTranscript: () => baseTranscript2,
+  boundImages: () => boundImages2,
+  layer: () => layer9,
+  node: () => node27,
+  unsupportedParts: () => unsupportedParts2
+});
+import { HttpOptions, LanguageModel, LLM, LLMRequest, Message, SystemPart } from "@opencode/ai";
+import { Cause, Config, Context, Effect, Layer, Result, Stream } from "effect";
+import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+var IMAGE_BYTES_TRIGGER = 25 * 1024 * 1024;
+var IMAGE_BYTES_TARGET = 15 * 1024 * 1024;
+var IMAGE_REMOVED = "[This image was removed to reduce the request size and is no longer visible. Do not make claims about its contents from memory. If needed, retrieve it again with an available tool or ask the user to attach it again.]";
+var responsesWebSocketFlag = (providerID) => `OPENCODE_EXPERIMENTAL_${providerID.replace(/[^a-zA-Z0-9]+/g, "_").toUpperCase()}_RESPONSES_WEBSOCKET`;
+var declineDefect = (cause) => {
+  const decline = cause.reasons.flatMap((reason) => Cause.isDieReason(reason) && (reason.defect instanceof DeclinedError2 || reason.defect instanceof CancelledError2) ? [reason.defect] : [])[0];
+  return decline ? Result.succeed(decline) : Result.fail(cause);
+};
+var baseTranscript2 = (input) => {
+  const providerMetadataKey = input.model.model.route.providerMetadataKey ?? input.model.model.provider;
+  return {
+    providerMetadataKey,
+    system: [
+      input.agent.system ? input.agent.system : make14(input.tools.definitions.map((tool) => tool.name)),
+      input.initial
+    ].filter((part) => part.length > 0).map(SystemPart.make),
+    messages: toLLMMessages2(input.messages, input.model.ref, providerMetadataKey)
+  };
+};
+var mimeToModality = (mime) => {
+  if (mime.startsWith("image/"))
+    return "image";
+  if (mime.startsWith("audio/"))
+    return "audio";
+  if (mime.startsWith("video/"))
+    return "video";
+  if (mime === "application/pdf")
+    return "pdf";
+};
+var unsupportedMedia = (mime, name, capabilities) => {
+  const modality = mimeToModality(mime);
+  if (!modality || capabilities.input.some((item) => item.startsWith(modality)))
+    return;
+  return {
+    type: "text",
+    text: `ERROR: Cannot read ${name ? `"${name}"` : modality} (this model does not support ${modality} input). Inform the user.`
+  };
+};
+var unsupportedParts2 = (messages, capabilities) => messages.map((message) => Message.make({
+  ...message,
+  content: message.content.map((part) => {
+    if (part.type === "media") {
+      return unsupportedMedia(part.mediaType, part.filename, capabilities) ?? part;
+    }
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return part;
+    return {
+      ...part,
+      result: {
+        ...part.result,
+        value: part.result.value.map((item) => {
+          if (item.type !== "file")
+            return item;
+          return unsupportedMedia(item.mime, item.name, capabilities) ?? item;
+        })
+      }
+    };
+  })
+}));
+var boundImages2 = (messages) => {
+  const isImage = (mime) => mime.toLowerCase().startsWith("image/");
+  const size = (data) => typeof data === "string" ? Buffer.byteLength(data) : Math.ceil(data.byteLength / 3) * 4;
+  const imageBytes = messages.reduce((total, message) => total + message.content.reduce((sum, part) => {
+    if (part.type === "media" && isImage(part.mediaType))
+      return sum + size(part.data);
+    if (part.type !== "tool-result" || part.result.type !== "content")
+      return sum;
+    return sum + part.result.value.reduce((bytes, item) => bytes + (item.type === "file" && isImage(item.mime) ? Buffer.byteLength(item.uri) : 0), 0);
+  }, 0), 0);
+  if (imageBytes <= IMAGE_BYTES_TRIGGER)
+    return messages;
+  let removed = 0;
+  return messages.map((message) => Message.make({
+    ...message,
+    content: message.content.map((part) => {
+      if (part.type === "media" && isImage(part.mediaType) && imageBytes - removed > IMAGE_BYTES_TARGET) {
+        removed += size(part.data);
+        return Message.text(IMAGE_REMOVED);
+      }
+      if (part.type !== "tool-result" || part.result.type !== "content")
+        return part;
+      return {
+        ...part,
+        result: {
+          ...part.result,
+          value: part.result.value.map((item) => {
+            if (item.type !== "file" || !isImage(item.mime) || imageBytes - removed <= IMAGE_BYTES_TARGET)
+              return item;
+            removed += Buffer.byteLength(item.uri);
+            return { type: "text", text: IMAGE_REMOVED };
+          })
+        }
+      };
+    })
+  }));
+};
+var sessionHeaders = (session, app) => ({
+  "x-session-affinity": session.id,
+  "X-Session-Id": session.id,
+  ...session.parentID ? { "x-parent-session-id": session.parentID } : {},
+  "User-Agent": useragent2(app),
+  "x-opencode-project": session.projectID,
+  "x-opencode-session": session.id,
+  "x-opencode-client": app.name
+});
+var promptCacheKey = (sessionID) => /^ses_[0-9a-f]{64}$/.test(sessionID) ? sessionID.slice(4) : sessionID;
+var applyModelHooks = (hooks, scope, request) => Effect.gen(function* () {
+  const currentBaseURL = request.model.route.endpoint.baseURL;
+  const event = yield* hooks.trigger("session", "model.request", {
+    ...scope,
+    baseURL: typeof currentBaseURL === "string" ? currentBaseURL : undefined,
+    headers: { ...request.http?.headers }
+  });
+  const route = event.baseURL !== undefined && event.baseURL !== currentBaseURL ? request.model.route.with({ endpoint: { baseURL: event.baseURL } }) : request.model.route;
+  return LLMRequest.update(request, {
+    model: route === request.model.route ? request.model : LanguageModel.update(request.model, { route }),
+    http: new HttpOptions({
+      body: request.http?.body,
+      headers: Object.keys(event.headers).length === 0 ? undefined : event.headers,
+      query: request.http?.query
+    })
+  });
+});
+var httpMiddleware = (hooks, scope) => (request, handler) => Effect.gen(function* () {
+  const before = yield* hooks.trigger("session", "http.request", {
+    ...scope,
+    request: yield* HttpClientRequest.toWeb(request)
+  });
+  let sent = HttpClientRequest.fromWeb(before.request);
+  if (before.request.body)
+    sent = HttpClientRequest.bodyUint8Array(sent, new Uint8Array(yield* Effect.promise(() => before.request.clone().arrayBuffer())), before.request.headers.get("content-type") ?? undefined);
+  const response = yield* handler(sent);
+  const after = yield* hooks.trigger("session", "http.response", {
+    ...scope,
+    request: before.request,
+    response: new Response([204, 205, 304].includes(response.status) ? null : yield* Stream.toReadableStreamEffect(response.stream), { status: response.status, headers: response.headers })
+  });
+  return HttpClientResponse.fromWeb(sent, after.response);
+}).pipe(Effect.mapError((cause) => cause instanceof Error ? cause : new Error(String(cause))));
+
+class Service22 extends Context.Service()("@opencode/SessionModelRequest") {
+}
+var layer9 = Layer.effect(Service22, Effect.gen(function* () {
+  const hooks = yield* Service77;
+  const transport = yield* Service23;
+  const app = yield* Metadata2;
+  const prepare = Effect.fn("SessionModelRequest.prepare")(function* (input) {
+    const session = input.scope.session;
+    const resolved = input.scope.model;
+    const model = resolved.model;
+    const tools = input.scope.tools ?? {
+      definitions: [],
+      execute: () => new Error5({ message: "Tools are not available for this request" })
+    };
+    const registry = new Map(tools.definitions.map((tool) => [tool.name, tool]));
+    const given = new Map(tools.definitions.map((tool) => [{ description: tool.description, input: { ...tool.inputSchema } }, tool]));
+    const definitions = Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition]));
+    const context = {
+      sessionID: session.id,
+      agent: input.scope.contextAgentID ?? input.scope.agentID,
+      model: resolved.ref,
+      system: input.transcript.system,
+      messages: input.transcript.messages,
+      tools: definitions,
+      generation: {},
+      providerOptions: {}
+    };
+    if (input.contextHooks !== false)
+      yield* hooks.trigger("session", "context", context);
+    const hooked = new Map(Object.entries(context.tools).flatMap(([name, definition]) => {
+      const tool = given.get(definition) ?? registry.get(name);
+      if (!tool)
+        return [];
+      return [[name, { ...tool, description: definition.description, inputSchema: definition.input }]];
+    }));
+    const request = yield* applyModelHooks(hooks, { sessionID: session.id, agent: input.scope.agentID, model: resolved.ref, kind: input.kind }, LLM.request({
+      model,
+      http: {
+        headers: sessionHeaders(session, app)
+      },
+      promptCacheKey: promptCacheKey(session.fork?.sessionID ?? session.id),
+      system: context.system,
+      messages: boundImages2(unsupportedParts2(context.messages, resolved.capabilities)),
+      tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),
+      toolChoice: input.toolChoice,
+      generation: Object.keys(context.generation).length === 0 ? undefined : context.generation,
+      providerOptions: Object.keys(context.providerOptions).length === 0 ? undefined : context.providerOptions
+    }));
+    const selected = provenance2(resolved);
+    if (selected && !compatible2(selected, provenance2({ model: request.model, ref: resolved.ref })) && request.messages.some((message) => message.content.some((part) => part.type === "compaction")))
+      return yield* Effect.die(new Error("Provider context is incompatible with the route selected by model request hooks"));
+    const hasHttpHooks = (yield* hooks.has("session", "http.request", resolved.ref.providerID)) || (yield* hooks.has("session", "http.response", resolved.ref.providerID));
+    const webSocket = resolved.capabilities.responsesWebsockets === true ? yield* Config.boolean(responsesWebSocketFlag(resolved.ref.providerID)).pipe(Config.withDefault(false), Effect.orDie) : false;
+    const http = hasHttpHooks ? httpMiddleware(hooks, {
+      sessionID: session.id,
+      agent: input.scope.agentID,
+      model: resolved.ref,
+      kind: input.kind
+    }) : undefined;
+    const options = {
+      ...http ? { http } : {},
+      ...input.webSocket === "session" && webSocket && !hasHttpHooks ? { webSocket: transport.bind(session.id) } : {}
+    };
+    const executeTool = (input) => tools.execute({ ...input, definitions: hooked }).pipe(Effect.catchCauseFilter(declineDefect, (decline) => Effect.fail(decline)));
+    const retry = (event) => hooks.trigger("session", "retry", event).pipe(Effect.asVoid);
+    return {
+      request,
+      options,
+      retry,
+      executeTool
+    };
+  });
+  return Service22.of({ prepare });
+}));
+var node27 = makeLocationNode({
+  service: Service22,
+  layer: layer9,
+  deps: [node82, node28, node63]
+});
+
+export { baseTranscript2, unsupportedParts2, boundImages2, Service22, layer9, node27, exports_model_request };

package/dist/chunks/worktree-tvtrv512.js

@@ -0,0 +1,51 @@
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/id/id.ts
+var exports_id = {};
+__export(exports_id, {
+  Identifier: () => exports_id,
+  ascending: () => ascending2,
+  create: () => createID,
+  descending: () => descending2,
+  timestamp: () => timestamp2
+});
+import { create } from "@opencode/schema/identifier";
+var prefixes = {
+  job: "job",
+  event: "evt",
+  session: "ses",
+  message: "msg",
+  permission: "per",
+  question: "que",
+  part: "prt",
+  pty: "pty",
+  tool: "tool",
+  workspace: "wrk"
+};
+function ascending2(prefix, given) {
+  return generateID(prefix, "ascending", given);
+}
+function descending2(prefix, given) {
+  return generateID(prefix, "descending", given);
+}
+function generateID(prefix, direction, given) {
+  if (!given) {
+    return createID(prefixes[prefix], direction);
+  }
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
+  }
+  return given;
+}
+function createID(prefix, direction, timestamp) {
+  return prefix + "_" + create(direction === "descending", timestamp);
+}
+function timestamp2(id) {
+  const prefix = id.split("_")[0];
+  const hex = id.slice(prefix.length + 1, prefix.length + 13);
+  return Number(BigInt(`0x${hex}`) / 0x1000n);
+}
+
+export { ascending2, descending2, createID, timestamp2, exports_id };