@dan-ai-studio/dshopencodego 0.1.5

package/lib/index.js

@@ -0,0 +1,2036 @@
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name2);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+
+// src/index.ts
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import * as llm2 from "@deepseek-ai/dsh-llm";
+import { LlmError as LlmError11 } from "@deepseek-ai/dsh-llm";
+
+// src/adapter.ts
+import { getSupportedThinkingLevels, normalizeContext } from "@earendil-works/pi-ai";
+import {
+  attributionHeaders as attributionHeaders4,
+  contentHasImage as contentHasImage2,
+  LlmAdapter,
+  LlmError as LlmError7,
+  ReasoningEffortId
+} from "@deepseek-ai/dsh-llm";
+import { idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
+
+// src/catalog/index.ts
+import { createProvider } from "@earendil-works/pi-ai";
+import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { attributionHeaders as attributionHeaders2, LlmError as LlmError3 } from "@deepseek-ai/dsh-llm";
+
+// src/catalog/constants.ts
+var PROVIDER_ID = "opencode-go";
+var DISPLAY_NAME = "OpenCode Go";
+var DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
+var MODEL_METADATA_URL = "https://models.dev/api.json";
+var MODEL_METADATA_PROVIDER = "opencode-go";
+var METADATA_FETCH_TIMEOUT_MS = 1e4;
+var MODEL_LISTING_MAX_BYTES = 1024 * 1024;
+var MODEL_METADATA_MAX_BYTES = 16 * 1024 * 1024;
+
+// src/catalog/gateway.ts
+import { attributionHeaders, LlmError as LlmError2 } from "@deepseek-ai/dsh-llm";
+
+// src/catalog/json-response.ts
+import { LlmError } from "@deepseek-ai/dsh-llm";
+async function readBoundedJson(response, url, maxBytes) {
+  const declared = Number(response.headers.get("content-length") ?? Number.NaN);
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw new LlmError(`${url} declares ${declared} bytes, over the ${maxBytes}-byte cap`, "DISCOVERY_FAILED");
+  }
+  let text;
+  try {
+    text = await readBoundedText(response, maxBytes);
+  } catch (error) {
+    if (error instanceof LlmError) throw error;
+    throw new LlmError(`could not read ${url}`, "DISCOVERY_FAILED", { cause: error });
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new LlmError(`${url} did not answer with JSON`, "DISCOVERY_FAILED", { cause: error });
+  }
+}
+async function readBoundedText(response, maxBytes) {
+  if (response.body === null) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel().catch(() => {
+        });
+        throw new LlmError(`response exceeds the ${maxBytes}-byte cap`, "DISCOVERY_FAILED");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(merged);
+}
+
+// src/catalog/gateway.ts
+function readModelIds(body) {
+  const data = body?.data;
+  if (!Array.isArray(data)) throw new Error('the model listing has no "data" array');
+  const ids = [];
+  for (const entry of data) {
+    const id = entry?.id;
+    if (typeof id === "string" && id.length > 0) ids.push(id);
+  }
+  return [...new Set(ids)];
+}
+async function fetchModelIds(baseURL, signal) {
+  const url = `${baseURL.replace(/\/+$/, "")}/models`;
+  const timeout = AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS);
+  const response = await fetch(url, {
+    method: "GET",
+    redirect: "error",
+    // An explicit request header rather than `RequestInit.cache`: Node's fetch
+    // does not implement HTTP caching, and the header is what any intermediary
+    // in front of the gateway reads.
+    headers: { ...attributionHeaders(), accept: "application/json", "cache-control": "no-cache" },
+    signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout])
+  }).catch((error) => {
+    throw new LlmError2(`could not reach ${url}`, "DISCOVERY_FAILED", { cause: error });
+  });
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw new LlmError2(`${url} answered HTTP ${response.status}`, "DISCOVERY_FAILED");
+  }
+  const body = await readBoundedJson(response, url, MODEL_LISTING_MAX_BYTES);
+  try {
+    return readModelIds(body);
+  } catch (error) {
+    throw new LlmError2(`${url} returned an invalid model listing`, "DISCOVERY_FAILED", { cause: error });
+  }
+}
+
+// src/catalog/protocol.ts
+var WIRE_PROTOCOLS = [
+  "anthropic-messages",
+  "openai-completions",
+  "openai-responses"
+];
+var NPM_PROTOCOLS = {
+  "@ai-sdk/anthropic": "anthropic-messages",
+  "@ai-sdk/openai": "openai-responses",
+  "@ai-sdk/openai-compatible": "openai-completions"
+};
+var RESPONSES_FAMILIES = ["grok", "gpt", "muse"];
+function protocolOfNpm(npm) {
+  return typeof npm === "string" ? NPM_PROTOCOLS[npm] : void 0;
+}
+function inferProtocol(id) {
+  const lower = id.toLowerCase();
+  return RESPONSES_FAMILIES.some((family) => lower.startsWith(family)) ? "openai-responses" : "openai-completions";
+}
+function asWireProtocol(value) {
+  return value !== void 0 && WIRE_PROTOCOLS.includes(value) ? value : void 0;
+}
+function decideProtocol(id, evidence) {
+  if (evidence.override !== void 0) return { api: evidence.override, source: "override" };
+  if (evidence.builtin !== void 0) return { api: evidence.builtin, source: "builtin" };
+  if (evidence.online !== void 0) return { api: evidence.online, source: "online" };
+  return { api: inferProtocol(id), source: "inferred" };
+}
+
+// src/catalog/metadata.ts
+var LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function validReleaseDate(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return void 0;
+  return Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value ? value : void 0;
+}
+function rates(value) {
+  const cost = record(value);
+  const rate = (key) => {
+    const entry = cost[key];
+    return typeof entry === "number" && Number.isFinite(entry) && entry >= 0 ? entry : 0;
+  };
+  return { input: rate("input"), output: rate("output"), cacheRead: rate("cache_read"), cacheWrite: rate("cache_write") };
+}
+function thinkingLevels(metadata, known) {
+  const options = metadata["reasoning_options"];
+  if (!Array.isArray(options)) return known?.thinkingLevelMap;
+  const map = Object.fromEntries(LEVELS.map((level) => [level, null]));
+  for (const item of options) {
+    const option = record(item);
+    if (option["type"] === "toggle" || option["type"] === "budget_tokens") {
+      map.off = "off";
+      map.high = "high";
+    }
+    if (option["type"] !== "effort" || !Array.isArray(option["values"])) continue;
+    for (const value of option["values"]) {
+      const level = value === "none" ? "off" : value;
+      if (typeof level === "string" && LEVELS.includes(level)) {
+        map[level] = String(value);
+      }
+    }
+  }
+  if (known?.reasoning === true && known.thinkingLevelMap?.off !== null) {
+    map.off ??= known.thinkingLevelMap?.off ?? "off";
+  }
+  return map;
+}
+function familySibling(id, api, documentFamily, entries, builtin) {
+  if (documentFamily !== void 0) {
+    for (const [other, value] of Object.entries(entries)) {
+      if (other === id || record(value)["family"] !== documentFamily) continue;
+      const candidate = builtin.get(other);
+      if (candidate !== void 0 && candidate.api === api) return candidate;
+    }
+  }
+  let best;
+  const lower = id.toLowerCase();
+  for (const [other, candidate] of builtin) {
+    if (other === id || candidate.api !== api) continue;
+    const score = commonPrefixLength(lower, other.toLowerCase());
+    if (score < 3) continue;
+    if (best === void 0 || score > best.score) best = { model: candidate, score };
+  }
+  return best?.model;
+}
+function commonPrefixLength(left, right) {
+  let index = 0;
+  while (index < left.length && index < right.length && left[index] === right[index]) index += 1;
+  return index;
+}
+function compatFor(api, metadata, exact, sibling) {
+  const inherited = exact !== void 0 && exact.api === api ? exact.compat : sibling !== void 0 && sibling.api === api ? sibling.compat : void 0;
+  if (api === "openai-completions") {
+    return {
+      supportsStore: false,
+      supportsDeveloperRole: false,
+      maxTokensField: "max_tokens",
+      ...record(metadata["interleaved"])["field"] === "reasoning_content" ? { requiresReasoningContentOnAssistantMessages: true } : {},
+      ...inherited
+    };
+  }
+  if (api === "openai-responses") {
+    return { sessionAffinityFormat: "openai-nosession", ...inherited };
+  }
+  return inherited ?? {};
+}
+function modelBaseURL(api, baseURL) {
+  const base = baseURL.replace(/\/+$/, "");
+  return api === "anthropic-messages" ? base.replace(/\/v1$/, "") : base;
+}
+function readOnlineMetadata(body, sources) {
+  const provider = record(record(body)[MODEL_METADATA_PROVIDER]);
+  const rawModels = provider["models"];
+  if (rawModels === null || typeof rawModels !== "object" || Array.isArray(rawModels)) {
+    throw new Error(`models.dev has no ${MODEL_METADATA_PROVIDER} models object`);
+  }
+  const providerNpm = provider["npm"];
+  const entries = record(rawModels);
+  const models = /* @__PURE__ */ new Map();
+  const errors = /* @__PURE__ */ new Map();
+  for (const [id, value] of Object.entries(entries)) {
+    const metadata = record(value);
+    try {
+      const exact = sources.builtin.get(id);
+      const override = asWireProtocol(sources.overrides[id]);
+      if (sources.overrides[id] !== void 0 && override === void 0) {
+        throw new Error(`configured protocol "${sources.overrides[id]}" is not one of anthropic-messages, openai-completions, openai-responses`);
+      }
+      const decision = decideProtocol(id, {
+        ...exact?.api === void 0 ? {} : { builtin: exact.api },
+        ...protocolOfNpm(metadata["provider"] === void 0 ? providerNpm : record(metadata["provider"])["npm"] ?? providerNpm) === void 0 ? {} : { online: protocolOfNpm(record(metadata["provider"])["npm"] ?? providerNpm) },
+        ...override === void 0 ? {} : { override }
+      });
+      if (decision === void 0) throw new Error("no protocol could be decided");
+      const api = decision.api;
+      const limit = record(metadata["limit"]);
+      const onlineContext = positiveInteger(limit["context"]);
+      const onlineInputLimit = positiveInteger(limit["input"]);
+      const onlineOutput = positiveInteger(limit["output"]);
+      const builtinContext = exact?.api === api ? positiveInteger(exact.contextWindow) : void 0;
+      const builtinOutput = exact?.api === api ? positiveInteger(exact.maxTokens) : void 0;
+      const contextWindow = onlineContext ?? builtinContext ?? sources.defaults.contextWindow;
+      const maxTokens = onlineOutput ?? builtinOutput ?? sources.defaults.maxTokens;
+      const onlineInput = record(metadata["modalities"])["input"];
+      const input = Array.isArray(onlineInput) && onlineInput.includes("text") ? onlineInput.includes("image") ? ["text", "image"] : ["text"] : exact?.api === api ? exact.input : sources.defaults.input;
+      const reasoning = typeof metadata["reasoning"] === "boolean" ? metadata["reasoning"] : exact?.api === api ? exact.reasoning : false;
+      const family = nonEmptyString(metadata["family"]);
+      const sibling = familySibling(id, api, family, entries, sources.builtin);
+      const cost = rates(metadata["cost"]);
+      const tiers = record(metadata["cost"])["tiers"];
+      if (Array.isArray(tiers)) {
+        const parsed = tiers.flatMap((item) => {
+          const tier = record(record(item)["tier"]);
+          const size = positiveInteger(tier["size"]);
+          return tier["type"] === "context" && size !== void 0 ? [{ ...rates(item), inputTokensAbove: size }] : [];
+        }).sort((a, b) => a.inputTokensAbove - b.inputTokensAbove);
+        if (parsed.length > 0) cost.tiers = parsed;
+      }
+      models.set(id, {
+        id,
+        name: nonEmptyString(metadata["name"]) ?? id,
+        api,
+        protocolSource: decision.source,
+        contextWindow,
+        maxInputTokens: onlineInputLimit,
+        maxTokens,
+        assumedLimits: onlineContext === void 0 && builtinContext === void 0 || onlineOutput === void 0 && builtinOutput === void 0,
+        input,
+        reasoning,
+        thinkingLevelMap: reasoning ? thinkingLevels(metadata, exact?.api === api ? exact : sibling) : void 0,
+        compat: compatFor(api, metadata, exact, sibling),
+        cost,
+        deprecated: metadata["status"] === "deprecated",
+        releaseDate: validReleaseDate(metadata["release_date"])
+      });
+    } catch (error) {
+      errors.set(id, error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { models, errors };
+}
+function toPiModel(facts, baseURL) {
+  return {
+    id: facts.id,
+    name: facts.name,
+    provider: "opencode-go",
+    api: facts.api,
+    baseUrl: modelBaseURL(facts.api, baseURL),
+    reasoning: facts.reasoning,
+    ...facts.thinkingLevelMap === void 0 ? {} : { thinkingLevelMap: facts.thinkingLevelMap },
+    input: [...facts.input],
+    contextWindow: facts.contextWindow,
+    maxTokens: facts.maxTokens,
+    cost: facts.cost,
+    compat: facts.compat
+  };
+}
+
+// src/catalog/index.ts
+function builtinModels(baseURL) {
+  return new Map(getBuiltinModels(PROVIDER_ID).map((model) => [model.id, {
+    ...model,
+    provider: PROVIDER_ID,
+    baseUrl: modelBaseURLFor(model.api, baseURL)
+  }]));
+}
+function modelBaseURLFor(api, baseURL) {
+  const base = baseURL.replace(/\/+$/, "");
+  return api === "anthropic-messages" ? base.replace(/\/v1$/, "") : base;
+}
+function harnessApiKeyAuth() {
+  return {
+    apiKey: {
+      name: "OpenCode Go API key",
+      resolve: () => Promise.resolve({ auth: {}, source: "OpenCode Go API key" })
+    }
+  };
+}
+function buildProvider(baseURL, models) {
+  return createProvider({
+    id: PROVIDER_ID,
+    name: DISPLAY_NAME,
+    baseUrl: baseURL,
+    auth: harnessApiKeyAuth(),
+    models: [...models],
+    api: {
+      "anthropic-messages": anthropicMessagesApi(),
+      "openai-completions": openAICompletionsApi(),
+      "openai-responses": openAIResponsesApi()
+    }
+  });
+}
+var OpencodeGoCatalog = class {
+  options;
+  served;
+  pending;
+  metadataDocument;
+  metadataETag;
+  lastMetadata;
+  constructor(options) {
+    this.options = options;
+  }
+  /** The cached snapshot, refreshed when it is older than the configured TTL. */
+  snapshot(force = false) {
+    if (!force && this.served !== void 0 && Date.now() - this.served.fetchedAtMs < this.options.refreshMs) {
+      return Promise.resolve(this.served);
+    }
+    this.pending ??= this.build().then((snapshot) => {
+      this.served = snapshot;
+      return snapshot;
+    }).finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  /**
+   * The snapshot that can serve one exact model.
+   *
+   * A model this build has never seen forces one revalidation even inside the
+   * TTL, because "unknown" and "newly added" look identical from here.
+   * @param id - the requested model id.
+   * @returns the snapshot holding the model.
+   * @throws {LlmError} `MODEL_METADATA_UNAVAILABLE` when the gateway advertises
+   *   the id but this build cannot configure it, naming the reason.
+   */
+  async forModel(id) {
+    const cached = this.served;
+    let snapshot = await this.snapshot();
+    if (!snapshot.facts.has(id) && snapshot === cached) snapshot = await this.snapshot(true);
+    const reason = snapshot.unavailable.get(id);
+    if (reason !== void 0) {
+      throw new LlmError3(
+        `opencode-go model "${id}" is advertised but cannot be configured: ${reason}; refresh the model list to retry`,
+        "MODEL_METADATA_UNAVAILABLE"
+      );
+    }
+    return snapshot;
+  }
+  /** Revalidate both sources, reusing the metadata document when it is unchanged. */
+  async build() {
+    const builtin = builtinModels(this.options.baseURL);
+    const [listing, metadata] = await Promise.allSettled([
+      fetchModelIds(this.options.baseURL),
+      this.refreshMetadata(builtin)
+    ]);
+    if (metadata.status === "rejected") {
+      this.options.observers?.onFallback?.({
+        url: MODEL_METADATA_URL,
+        error: metadata.reason,
+        kept: this.lastMetadata?.models.size ?? 0
+      });
+    }
+    if (listing.status === "rejected") {
+      const previous = this.served;
+      this.options.observers?.onFallback?.({
+        url: `${this.options.baseURL.replace(/\/+$/, "")}/models`,
+        error: listing.reason,
+        kept: previous?.facts.size ?? 0
+      });
+      const facts = previous?.facts ?? /* @__PURE__ */ new Map();
+      return {
+        facts,
+        unavailable: previous?.unavailable ?? /* @__PURE__ */ new Map(),
+        provider: buildProvider(this.options.baseURL, [...facts.values()].map((fact) => toPiModel(fact, this.options.baseURL))),
+        live: false,
+        listingFailure: listing.reason,
+        fetchedAtMs: Date.now()
+      };
+    }
+    return this.assemble(
+      listing.value,
+      metadata.status === "fulfilled" ? metadata.value : this.lastMetadata,
+      builtin
+    );
+  }
+  /** Merge the listing with the metadata document and the installed entries. */
+  assemble(ids, online, builtin) {
+    const facts = /* @__PURE__ */ new Map();
+    const unavailable = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const parsed = online?.models.get(id);
+      if (parsed !== void 0) {
+        facts.set(id, parsed);
+        continue;
+      }
+      const reason = online?.errors.get(id);
+      if (reason !== void 0) {
+        unavailable.set(id, reason);
+        continue;
+      }
+      facts.set(id, this.inferredFacts(id, builtin));
+    }
+    if (unavailable.size > 0) {
+      this.options.observers?.onUnconfigured?.(
+        [...unavailable].map(([id, reason]) => ({ id, reason }))
+      );
+    }
+    return {
+      facts,
+      unavailable,
+      provider: buildProvider(this.options.baseURL, [...facts.values()].map((fact) => toPiModel(fact, this.options.baseURL))),
+      live: true,
+      fetchedAtMs: Date.now()
+    };
+  }
+  /** Facts for an id no source describes, from the ladder and the route defaults. */
+  inferredFacts(id, builtin) {
+    const exact = builtin.get(id);
+    const api = exact?.api ?? inferFamily(id);
+    const contextWindow = exact !== void 0 ? exact.contextWindow : this.options.defaults.contextWindow;
+    const maxTokens = exact !== void 0 ? exact.maxTokens : this.options.defaults.maxTokens;
+    return {
+      id,
+      name: exact?.name ?? id,
+      api,
+      protocolSource: exact === void 0 ? "inferred" : "builtin",
+      contextWindow,
+      maxInputTokens: void 0,
+      maxTokens,
+      assumedLimits: exact === void 0,
+      input: exact?.input ?? this.options.defaults.input,
+      reasoning: exact?.reasoning ?? false,
+      thinkingLevelMap: exact?.thinkingLevelMap,
+      compat: exact?.compat ?? {},
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      deprecated: false,
+      releaseDate: void 0
+    };
+  }
+  /** Conditional metadata GET: an unchanged document keeps its parsed form. */
+  async refreshMetadata(builtin) {
+    const response = await fetch(MODEL_METADATA_URL, {
+      redirect: "error",
+      headers: {
+        ...attributionHeaders2(),
+        accept: "application/json",
+        "cache-control": "no-cache",
+        ...this.metadataETag === void 0 ? {} : { "if-none-match": this.metadataETag }
+      },
+      signal: AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS)
+    });
+    if (response.status === 304 && this.metadataDocument !== void 0) {
+      await response.body?.cancel().catch(() => {
+      });
+      const parsed2 = readOnlineMetadata(this.metadataDocument, {
+        builtin,
+        defaults: this.options.defaults,
+        overrides: this.options.overrides
+      });
+      this.lastMetadata = parsed2;
+      return parsed2;
+    }
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => {
+      });
+      throw new Error(`models.dev answered ${response.status}`);
+    }
+    const document = await readBoundedJson(response, MODEL_METADATA_URL, MODEL_METADATA_MAX_BYTES);
+    this.metadataDocument = document;
+    this.metadataETag = response.headers.get("etag") ?? void 0;
+    const parsed = readOnlineMetadata(document, {
+      builtin,
+      defaults: this.options.defaults,
+      overrides: this.options.overrides
+    });
+    this.lastMetadata = parsed;
+    return parsed;
+  }
+};
+function inferFamily(id) {
+  const lower = id.toLowerCase();
+  return ["grok", "gpt", "muse"].some((family) => lower.startsWith(family)) ? "openai-responses" : "openai-completions";
+}
+async function discoverCatalogModels(catalog) {
+  const snapshot = await catalog.snapshot(true);
+  if (!snapshot.live) {
+    const detail = snapshot.listingFailure instanceof LlmError3 ? snapshot.listingFailure.message : "the live model listing is unreachable";
+    throw new LlmError3(`dshopencodego: ${detail}; refresh the model list to retry`, "DISCOVERY_FAILED", {
+      cause: snapshot.listingFailure
+    });
+  }
+  return [
+    ...[...snapshot.facts.values()].map((fact) => ({
+      id: fact.id,
+      name: fact.name,
+      contextWindow: fact.contextWindow,
+      maxTokens: fact.maxTokens
+    })),
+    ...[...snapshot.unavailable].map(([id, reason]) => ({ id, name: `${id} (unconfigured: ${reason})` }))
+  ];
+}
+
+// src/config.ts
+import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
+import z from "@deepseek-ai/schemastery";
+var DEFAULT_API_KEY_ENV = "OPENCODE_GO_API_KEY";
+var DEFAULT_REFRESH_MINUTES = 60;
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+var DEFAULT_MAX_REQUEST_IMAGE_BYTES = 6 * 1024 * 1024;
+var DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 144e4;
+var DEFAULT_REQUEST_IMAGE_MAX_BYTES = 4e5;
+var fields = {
+  enabled: z.boolean().default(true),
+  modelVisibility: z.dict(z.boolean().required()).default({}),
+  apiKeyEnv: z.string().role("credential-ref").default(DEFAULT_API_KEY_ENV),
+  baseURL: z.string().default(DEFAULT_BASE_URL),
+  refreshMinutes: z.number().step(1).min(1).max(7 * 24 * 60).default(DEFAULT_REFRESH_MINUTES),
+  streamIdleTimeoutMs: z.number().min(Number.MIN_VALUE).max(MAX_TIMER_DELAY_MS).default(DEFAULT_STREAM_IDLE_TIMEOUT_MS),
+  maxRequestImageBytes: z.number().step(1).min(1).default(DEFAULT_MAX_REQUEST_IMAGE_BYTES),
+  requestImagePixelBudget: z.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET),
+  requestImageMaxBytes: z.number().step(1).min(1).default(DEFAULT_REQUEST_IMAGE_MAX_BYTES),
+  modelLimits: z.dict(z.union([z.const(null), z.object({
+    contextWindow: z.union([z.const(null), z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER)]),
+    maxTokens: z.union([z.const(null), z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER)])
+  })])).default({}),
+  modelProtocols: z.dict(z.string()).default({})
+};
+var PlainConfig = z.object(fields);
+var Config = z.object(Object.fromEntries(
+  Object.entries(fields).map(([key, schema]) => [key, schema.volatile()])
+));
+function readConfig(config) {
+  return Object.fromEntries(Object.keys(fields).map((key) => [key, config[key].get()]));
+}
+function assertBaseURL(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`dshopencodego: baseURL "${raw}" is not a valid URL`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`dshopencodego: baseURL "${raw}" must be http or https`);
+  }
+  if (url.search.length > 0 || url.hash.length > 0) {
+    throw new Error(`dshopencodego: baseURL "${raw}" must not carry a query or fragment`);
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+
+// src/conversion/context.ts
+import { brandString } from "@deepseek-ai/dsh-brand";
+import * as llm from "@deepseek-ai/dsh-llm";
+import { contentHasImage, LlmError as LlmError5, requestImageHandleText } from "@deepseek-ai/dsh-llm";
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
+
+// src/conversion/replay.ts
+import { LlmError as LlmError4 } from "@deepseek-ai/dsh-llm";
+function parseArguments(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function emptyPiUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+function toPiReplayState(message, requestedModel = message.model) {
+  const responseModel = message.api === "anthropic-messages" && message.model !== requestedModel ? message.model : message.responseModel;
+  const response = {
+    kind: "pi-ai",
+    version: 2,
+    api: message.api,
+    provider: message.provider,
+    model: requestedModel,
+    ...responseModel === void 0 ? {} : { responseModel },
+    ...message.responseId === void 0 ? {} : { responseId: message.responseId },
+    ...message.providerThinkingLevel === void 0 ? {} : { providerThinkingLevel: message.providerThinkingLevel },
+    stopReason: message.stopReason
+  };
+  return {
+    response,
+    blocks: message.content.map((block) => {
+      switch (block.type) {
+        case "text":
+          return {
+            type: "text",
+            ...block.textSignature === void 0 ? {} : { textSignature: block.textSignature }
+          };
+        case "thinking":
+          return {
+            type: "reasoning",
+            ...block.thinkingSignature === void 0 ? {} : { thinkingSignature: block.thinkingSignature },
+            ...block.redacted === void 0 ? {} : { redacted: block.redacted }
+          };
+        case "toolCall":
+          return {
+            type: "tool-call",
+            ...block.thoughtSignature === void 0 ? {} : { thoughtSignature: block.thoughtSignature }
+          };
+      }
+    })
+  };
+}
+function invalidReplay(message) {
+  throw new LlmError4(`invalid pi-ai replay state: ${message}`, "INVALID_REPLAY_STATE");
+}
+function readReplayState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return invalidReplay("expected a replay envelope");
+  const envelope = value;
+  const rawResponse = envelope["response"];
+  if (typeof rawResponse !== "object" || rawResponse === null || Array.isArray(rawResponse)) {
+    return invalidReplay("expected a response object");
+  }
+  const response = rawResponse;
+  if (response["kind"] !== "pi-ai") return invalidReplay("unknown state kind");
+  if (response["version"] !== 2) return invalidReplay(`unsupported version ${String(response["version"])}`);
+  for (const key of ["api", "provider", "model"]) {
+    if (typeof response[key] !== "string" || response[key].length === 0) return invalidReplay(`${key} must be a non-empty string`);
+  }
+  if (!["stop", "length", "toolUse", "error", "aborted"].includes(String(response["stopReason"]))) {
+    return invalidReplay("unknown stopReason");
+  }
+  for (const key of ["responseModel", "responseId", "providerThinkingLevel"]) {
+    if (response[key] !== void 0 && typeof response[key] !== "string") return invalidReplay(`${key} must be a string`);
+  }
+  const blocks = envelope["blocks"];
+  if (!Array.isArray(blocks)) return invalidReplay("blocks must be an array");
+  for (const [index, value2] of blocks.entries()) {
+    if (typeof value2 !== "object" || value2 === null || Array.isArray(value2)) return invalidReplay(`block ${index} must be an object`);
+    const block = value2;
+    if (!["text", "reasoning", "tool-call"].includes(String(block["type"]))) {
+      return invalidReplay(`block ${index} has an unknown type`);
+    }
+    for (const signature of ["textSignature", "thinkingSignature", "thoughtSignature"]) {
+      if (block[signature] !== void 0 && typeof block[signature] !== "string") {
+        return invalidReplay(`block ${index} ${signature} must be a string`);
+      }
+    }
+    if (block["redacted"] !== void 0 && typeof block["redacted"] !== "boolean") {
+      return invalidReplay(`block ${index} redacted must be boolean`);
+    }
+  }
+  return { response, blocks };
+}
+function foreignAssistant(message) {
+  const source = message.source.kind === "model" ? message.source : void 0;
+  const content = [];
+  for (const block of message.content) {
+    switch (block.type) {
+      case "text":
+        content.push({ type: "text", text: block.text });
+        break;
+      case "reasoning":
+        content.push({ type: "thinking", thinking: block.text });
+        break;
+      case "tool-call":
+        content.push({
+          type: "toolCall",
+          id: block.id,
+          name: block.name,
+          arguments: parseArguments(block.arguments)
+        });
+        break;
+      case "image":
+        throw new LlmError4("pi-ai chat history cannot represent structured assistant image output", "UNSUPPORTED_CONTENT");
+      default:
+        break;
+    }
+  }
+  return {
+    role: "assistant",
+    content,
+    // Deliberately never equals a catalog API: absent replay state is foreign
+    // even when the source names this same provider and model.
+    api: "dsh-foreign",
+    provider: source?.provider ?? "dsh-foreign",
+    model: source?.model ?? "dsh-foreign",
+    usage: emptyPiUsage(),
+    stopReason: content.some((piece) => piece.type === "toolCall") ? "toolUse" : "stop",
+    timestamp: 0
+  };
+}
+function replayedAssistant(message, source, rawState) {
+  const state = readReplayState(rawState);
+  if (state.response.provider !== source.provider) return invalidReplay("provider does not match assistant source");
+  if (state.response.model !== source.model) return invalidReplay("model does not match assistant source");
+  if (state.blocks.length !== message.content.length) return invalidReplay("block count does not match assistant content");
+  const content = message.content.map((block, index) => {
+    const replay = state.blocks[index];
+    if (replay === void 0 || replay.type !== block.type) return invalidReplay(`block ${index} does not match assistant content`);
+    switch (block.type) {
+      case "text":
+        return {
+          type: "text",
+          text: block.text,
+          ...replay.type === "text" && replay.textSignature !== void 0 ? { textSignature: replay.textSignature } : {}
+        };
+      case "reasoning":
+        return {
+          type: "thinking",
+          thinking: block.text,
+          ...replay.type === "reasoning" && replay.thinkingSignature !== void 0 ? { thinkingSignature: replay.thinkingSignature } : {},
+          ...replay.type === "reasoning" && replay.redacted !== void 0 ? { redacted: replay.redacted } : {}
+        };
+      case "tool-call":
+        return {
+          type: "toolCall",
+          id: block.id,
+          name: block.name,
+          arguments: parseArguments(block.arguments),
+          ...replay.type === "tool-call" && replay.thoughtSignature !== void 0 ? { thoughtSignature: replay.thoughtSignature } : {}
+        };
+      default:
+        return invalidReplay(`block ${index} has an unsupported Harness type`);
+    }
+  });
+  return {
+    role: "assistant",
+    content,
+    api: state.response.api,
+    provider: state.response.provider,
+    // Anthropic reports aliases and fallbacks as `model`, unlike Completions'
+    // informational `responseModel`.
+    model: state.response.api === "anthropic-messages" ? state.response.responseModel ?? state.response.model : state.response.model,
+    ...state.response.responseModel === void 0 ? {} : { responseModel: state.response.responseModel },
+    ...state.response.responseId === void 0 ? {} : { responseId: state.response.responseId },
+    ...state.response.providerThinkingLevel === void 0 ? {} : { providerThinkingLevel: state.response.providerThinkingLevel },
+    usage: emptyPiUsage(),
+    stopReason: state.response.stopReason,
+    timestamp: 0
+  };
+}
+function toPiAssistant(message, onDegrade) {
+  const source = message.source;
+  if (source.kind !== "model" || source.replayState === void 0) return foreignAssistant(message);
+  try {
+    return replayedAssistant(message, source, source.replayState);
+  } catch (error) {
+    if (!(error instanceof LlmError4) || error.code !== "INVALID_REPLAY_STATE") throw error;
+    onDegrade?.(error.message);
+    return foreignAssistant(message);
+  }
+}
+
+// src/conversion/context.ts
+function flattenText(message) {
+  return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function toolMessage(message) {
+  return message.role === "tool" ? message : void 0;
+}
+function assertSupportedImageRoles(messages) {
+  for (const message of messages) {
+    if (message.role !== "user" && toolMessage(message) === void 0 && contentHasImage(message.content)) {
+      throw new LlmError5(`pi-ai cannot represent an image in an in-history ${message.role} message`, "UNSUPPORTED_CONTENT");
+    }
+  }
+}
+function toolsOf(options) {
+  return options.tools?.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    // ToolSchema.parameters is a JSON Schema object; pi-ai's TSchema is
+    // structurally JSON Schema, so it assigns directly.
+    parameters: tool.parameters
+  }));
+}
+function splitSystemPrompt(options) {
+  if (options.system !== void 0) return { systemPrompt: options.system, messages: options.messages };
+  const [first, ...rest] = options.messages;
+  if (first?.role !== "system") return { systemPrompt: void 0, messages: options.messages };
+  const text = flattenText(first);
+  return { systemPrompt: text.length > 0 ? text : void 0, messages: rest };
+}
+function collectImageRefs(blocks, refs) {
+  for (const block of blocks) {
+    if (block.type === "image" && block.offloaded !== true) refs.set(block.attachment.attachmentId, block.attachment);
+  }
+}
+async function prepareRequestImages(messages, attachments, policy, signal) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const message of messages) collectImageRefs(message.content, refs);
+  const ordered = [...refs.values()];
+  const prepared = await Promise.all(ordered.map((ref) => attachments.readImageRequest(
+    ref,
+    { ...requestImageDimensions(ref.width, ref.height, policy.maxPixels), maxBytes: policy.maxBytes },
+    signal
+  )));
+  const versions = /* @__PURE__ */ new Map();
+  for (const [index, ref] of ordered.entries()) versions.set(ref.attachmentId, prepared[index]);
+  return versions;
+}
+async function userContent(blocks, requestImages, resolveImageAccess) {
+  const content = [];
+  for (const block of blocks) {
+    if (block.type === "text") {
+      if (block.text.length > 0) content.push({ type: "text", text: block.text });
+      continue;
+    }
+    if (block.type === "image") {
+      const version = requestImages.get(block.attachment.attachmentId);
+      if (version === void 0) {
+        throw new LlmError5(
+          "dshopencodego: an image in this request has no prepared bytes; image input requires the attachment service",
+          "UNSUPPORTED_CONTENT"
+        );
+      }
+      content.push({
+        type: "text",
+        text: requestImageHandleText(block.attachment, version, resolveImageAccess(block.attachment))
+      });
+      content.push({ type: "image", data: Buffer.from(version.data).toString("base64"), mimeType: version.mediaType });
+    }
+  }
+  return content.every((block) => block.type === "text") ? content.map((block) => block.text).join("") : content;
+}
+function projectImagesForRequest(messages, images, requestImages) {
+  const offloadedImageText2 = llm.offloadedImageText;
+  const placeholder = (ref) => offloadedImageText2(ref, images.resolveImageAccess(ref));
+  if (images.maxRequestImageBytes !== void 0) {
+    const over = llm.requiredImageOffload(
+      messages,
+      { representation: "base64", maxBytes: images.maxRequestImageBytes, byteQuantum: 1 },
+      (block) => requestImages.get(block.attachment.attachmentId).bytes
+    );
+    if (over > 0) {
+      throw new LlmError5(
+        `request images exceed the ${images.maxRequestImageBytes}-byte base64 bound; ${over} more oldest occurrence(s) must be offloaded`,
+        llm.IMAGE_OFFLOAD_REQUIRED_CODE,
+        { offloadImages: over }
+      );
+    }
+  }
+  return llm.projectOffloadedImages(messages, placeholder);
+}
+async function toPiContext(options, images, onReplayDegrade) {
+  assertSupportedImageRoles(options.messages);
+  const split = splitSystemPrompt(options);
+  const resolveImageAccess = images?.resolveImageAccess ?? (() => void 0);
+  const policy = images?.requestImagePolicy ?? { maxPixels: 144e4, maxBytes: 4e5 };
+  const requestImages = images === void 0 ? /* @__PURE__ */ new Map() : await prepareRequestImages(split.messages, images.attachments, policy, options.signal);
+  const history = images === void 0 ? split.messages : projectImagesForRequest(split.messages, images, requestImages);
+  const toolNames = /* @__PURE__ */ new Map();
+  const messages = [];
+  for (const message of history) {
+    const tool = toolMessage(message);
+    if (tool !== void 0) {
+      const content2 = await userContent(tool.content, requestImages, resolveImageAccess);
+      messages.push({
+        role: "toolResult",
+        toolCallId: tool.toolCallId,
+        toolName: toolNames.get(tool.toolCallId) ?? "unknown",
+        content: typeof content2 === "string" ? [{ type: "text", text: content2.length > 0 ? content2 : "(no output)" }] : content2,
+        isError: tool.isError ?? false,
+        timestamp: 0
+      });
+      continue;
+    }
+    if (message.role === "system") {
+      messages.push({ role: "user", content: flattenText(message), timestamp: 0 });
+      continue;
+    }
+    if (message.role === "assistant") {
+      const assistant = toPiAssistant(message, onReplayDegrade);
+      for (const block of assistant.content) {
+        if (block.type === "toolCall") toolNames.set(brandString(block.id), block.name);
+      }
+      messages.push(assistant);
+      continue;
+    }
+    const content = await userContent(message.content, requestImages, resolveImageAccess);
+    messages.push({ role: "user", content, timestamp: 0 });
+  }
+  const tools = toolsOf(options);
+  return {
+    ...split.systemPrompt === void 0 ? {} : { systemPrompt: split.systemPrompt },
+    messages,
+    ...tools === void 0 || tools.length === 0 ? {} : { tools }
+  };
+}
+
+// src/conversion/stream.ts
+import { brandString as brandString2 } from "@deepseek-ai/dsh-brand";
+import {
+  CONTEXT_WINDOW_EXCEEDED_CODE,
+  EMPTY_RESPONSE_CODE,
+  isContextWindowExceededError,
+  isQuotaExceededError,
+  LlmError as LlmError6,
+  QUOTA_EXCEEDED_CODE
+} from "@deepseek-ai/dsh-llm";
+import { isContextOverflow } from "@earendil-works/pi-ai";
+function mapUsage(usage) {
+  return {
+    inputTokens: usage.input,
+    outputTokens: usage.output,
+    totalTokens: usage.totalTokens,
+    ...usage.cacheRead > 0 ? { cacheReadTokens: usage.cacheRead } : {},
+    ...usage.cacheWrite > 0 ? { cacheWriteTokens: usage.cacheWrite } : {}
+  };
+}
+function classifyPiAiError(message) {
+  if (/\b(?:401|403)\b/.test(message)) return "AUTH";
+  if (isQuotaExceededError(message)) return QUOTA_EXCEEDED_CODE;
+  if (/\b429\b|rate.?limit/i.test(message)) return "RATE_LIMIT";
+  if (/\b413\b|payload too large|request body too large|length limit exceeded/i.test(message)) return "INVALID_REQUEST";
+  if (/\b400\b|invalid.?request/i.test(message)) return "INVALID_REQUEST";
+  if (/\b5\d\d\b/.test(message)) return "SERVER";
+  if (/\btime(?:d)?\s*out\b|timeout/i.test(message)) return "TIMEOUT";
+  if (/stream ended (?:before|without)\b/i.test(message)) return "TRANSPORT";
+  if (/\b(?:network|connection|socket|fetch)\b|\bECONN[A-Z]+\b/i.test(message) || /\b(?:other side closed|HTTP2 request did not get a response|WebSocket closed unexpectedly)\b/i.test(message) || /\bterminated\b|premature close/i.test(message)) {
+    return "TRANSPORT";
+  }
+  return "PI_AI_ERROR";
+}
+function mapStopReason(message, contextWindow) {
+  const overflow = isContextOverflow(message, contextWindow) || message.stopReason === "error" && message.errorMessage !== void 0 && isContextWindowExceededError(message.errorMessage);
+  if (overflow) {
+    return {
+      kind: "error",
+      failure: {
+        message: message.errorMessage ?? `pi-ai detected context overflow for model "${message.model}"`,
+        code: CONTEXT_WINDOW_EXCEEDED_CODE
+      }
+    };
+  }
+  switch (message.stopReason) {
+    case "stop":
+      if (message.content.length === 0) {
+        return {
+          kind: "error",
+          failure: {
+            message: `model "${message.model}" returned a completed response with no content`,
+            code: EMPTY_RESPONSE_CODE
+          }
+        };
+      }
+      return { kind: "stop" };
+    case "length":
+      return { kind: "max-tokens" };
+    case "toolUse":
+      return { kind: "tool-calls" };
+    case "pending":
+      return {
+        kind: "error",
+        failure: { message: `pi-ai stream for model "${message.model}" ended pending`, code: "PI_AI_ERROR" }
+      };
+    case "deferred":
+      return {
+        kind: "error",
+        failure: { message: `pi-ai deferred response for model "${message.model}" is not supported`, code: "PI_AI_ERROR" }
+      };
+    case "aborted":
+      return {
+        kind: "aborted",
+        failure: { message: message.errorMessage ?? "pi-ai stream aborted", code: "ABORTED" }
+      };
+    case "error": {
+      const text = message.errorMessage ?? "pi-ai stream error";
+      return { kind: "error", failure: { message: text, code: classifyPiAiError(text) } };
+    }
+  }
+}
+async function* toStreamChunks(events, contextWindow, callerSignal, requestedModel) {
+  const toolCalls = /* @__PURE__ */ new Map();
+  for await (const event of events) {
+    switch (event.type) {
+      case "start":
+        break;
+      case "text_start":
+        yield { type: "block-start", index: event.contentIndex, blockType: "text" };
+        break;
+      case "text_delta":
+        yield { type: "text-delta", index: event.contentIndex, text: event.delta };
+        break;
+      case "text_end":
+        yield { type: "block-end", index: event.contentIndex, block: { type: "text", text: event.content } };
+        break;
+      case "thinking_start":
+        yield { type: "block-start", index: event.contentIndex, blockType: "reasoning" };
+        break;
+      case "thinking_delta":
+        yield { type: "reasoning-delta", index: event.contentIndex, text: event.delta };
+        break;
+      case "thinking_end":
+        yield { type: "block-end", index: event.contentIndex, block: { type: "reasoning", text: event.content } };
+        break;
+      case "toolcall_start": {
+        const partial = event.partial.content[event.contentIndex];
+        toolCalls.set(event.contentIndex, {
+          id: partial?.type === "toolCall" ? partial.id : "",
+          name: partial?.type === "toolCall" ? partial.name : ""
+        });
+        yield { type: "block-start", index: event.contentIndex, blockType: "tool-call" };
+        break;
+      }
+      case "toolcall_delta": {
+        const known = toolCalls.get(event.contentIndex);
+        yield {
+          type: "tool-call-delta",
+          index: event.contentIndex,
+          id: brandString2(known?.id ?? ""),
+          ...known !== void 0 && known.name.length > 0 ? { name: known.name } : {},
+          argumentsDelta: event.delta
+        };
+        break;
+      }
+      case "toolcall_end":
+        yield {
+          type: "block-end",
+          index: event.contentIndex,
+          block: {
+            type: "tool-call",
+            id: brandString2(event.toolCall.id),
+            name: event.toolCall.name,
+            // pi-ai parses the arguments; the Harness vocabulary keeps the raw
+            // JSON string it stores and replays.
+            arguments: JSON.stringify(event.toolCall.arguments)
+          }
+        };
+        break;
+      case "done":
+        yield { type: "usage", usage: mapUsage(event.message.usage) };
+        yield {
+          type: "finish",
+          reason: mapStopReason(event.message, contextWindow),
+          replayState: toPiReplayState(event.message, requestedModel)
+        };
+        return;
+      case "error":
+        yield { type: "usage", usage: mapUsage(event.error.usage) };
+        yield {
+          type: "finish",
+          reason: mapStopReason(
+            callerSignal?.aborted ? { ...event.error, stopReason: "aborted" } : event.error,
+            contextWindow
+          )
+        };
+        return;
+    }
+  }
+  throw new LlmError6("pi-ai event stream ended without a terminal event", "STREAM_CLOSED");
+}
+
+// src/go-limits.ts
+var GO_QUOTAS = {
+  "glm-5.3-flash": { monthlyUsd: 60, monthlyRequests: 31580 },
+  "glm-5.3": { monthlyUsd: 15, monthlyRequests: 1080 },
+  "glm-5.2": { monthlyUsd: 60, monthlyRequests: 4300 },
+  "glm-5.1": { monthlyUsd: 60, monthlyRequests: 4300 },
+  "kimi-k3": { monthlyUsd: 15, monthlyRequests: 490 },
+  "kimi-k2.7-code": { monthlyUsd: 60, monthlyRequests: 6750 },
+  "kimi-k2.6": { monthlyUsd: 60, monthlyRequests: 5750 },
+  "longcat-2.0": { monthlyUsd: 60, monthlyRequests: 57200 },
+  "mimo-v2.6-flash": { monthlyUsd: 60, monthlyRequests: 150400 },
+  "mimo-v2.6-pro": { monthlyUsd: 15, monthlyRequests: 16300 },
+  "mimo-v2.5": { monthlyUsd: 60, monthlyRequests: 150400 },
+  "mimo-v2.5-pro": { monthlyUsd: 15, monthlyRequests: 16300 },
+  "minimax-m3": { monthlyUsd: 60, monthlyRequests: 16e3 },
+  "minimax-m2.7": { monthlyUsd: 60, monthlyRequests: 17e3 },
+  "minimax-m2.5": { monthlyUsd: 60 },
+  "muse-spark-1.3-contributor": { monthlyUsd: 60, monthlyRequests: 226600 },
+  "muse-spark-1.2-contributor": { monthlyUsd: 60, monthlyRequests: 226600 },
+  "qwen3.8-max": { monthlyUsd: 15, monthlyRequests: 810 },
+  "qwen3.8-flash": { monthlyUsd: 30, monthlyRequests: 27e3 },
+  "qwen3.7-max": { monthlyUsd: 30, monthlyRequests: 840 },
+  "qwen3.7-plus": { monthlyUsd: 60, monthlyRequests: 21600 },
+  "qwen3.6-plus": { monthlyUsd: 60, monthlyRequests: 16300 },
+  "deepseek-v4.1-flash": { monthlyUsd: 60, monthlyRequests: 13e4 },
+  "deepseek-v4-pro": { monthlyUsd: 15, monthlyRequests: 5200 },
+  "deepseek-v4-flash": { monthlyUsd: 30, monthlyRequests: 65e3 },
+  "deepseek-v4-flash-vision-exp": { monthlyUsd: 15, monthlyRequests: 32500 },
+  "hy4-preview": { monthlyUsd: 30, monthlyRequests: 6770 },
+  "hy3": { monthlyUsd: 60, monthlyRequests: 21500 },
+  "space-bunny-free": { monthlyUsd: "unlimited", monthlyRequests: "unlimited" },
+  "grok-4.7": { monthlyUsd: 15, monthlyRequests: 845 },
+  "grok-4.6": { monthlyUsd: 15, monthlyRequests: 845 },
+  "gpt-6-luna": { monthlyUsd: 15, monthlyRequests: 21130 },
+  "gpt-5.6-luna": { monthlyUsd: 15, monthlyRequests: 10250 }
+};
+function goQuotaFor(id) {
+  return Object.hasOwn(GO_QUOTAS, id) ? GO_QUOTAS[id] : void 0;
+}
+function monthlyRequestsRank(quota) {
+  if (quota === void 0) return -1;
+  const requests = quota.monthlyRequests;
+  if (requests === "unlimited") return Number.MAX_SAFE_INTEGER;
+  if (requests === void 0) return quota.monthlyUsd === "unlimited" ? Number.MAX_SAFE_INTEGER : -1;
+  return requests;
+}
+
+// src/models.ts
+var DEFAULT_ENABLED_COUNT = 5;
+function isTrainingTier(model) {
+  return /contributor/i.test(model.id) || /contributor/i.test(model.name);
+}
+function recommendedIds(models) {
+  const ranked = models.filter((model) => model.configurationMissing === void 0 && model.deprecated !== true && !isTrainingTier(model)).toSorted((left, right) => monthlyRequestsRank(goQuotaFor(right.id)) - monthlyRequestsRank(goQuotaFor(left.id)) || left.id.localeCompare(right.id));
+  return new Set(ranked.slice(0, DEFAULT_ENABLED_COUNT).map((model) => model.id));
+}
+function isModelEnabled(model, visibility) {
+  if (model.configurationMissing !== void 0) return false;
+  const explicit = visibility !== void 0 && Object.hasOwn(visibility, model.id) ? visibility[model.id] : void 0;
+  if (typeof explicit === "boolean") return explicit;
+  return typeof model.recommended === "boolean" ? model.recommended : model.deprecated !== true;
+}
+function validReleaseDate2(value) {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
+}
+function isNewModel(model, now = Date.now()) {
+  if (model.deprecated === true || !validReleaseDate2(model.releaseDate)) return false;
+  const days = Math.floor(now / 864e5) - Date.parse(model.releaseDate) / 864e5;
+  return days >= 0 && days < 7;
+}
+function sortModels(models, now = Date.now()) {
+  const rank = (model) => model.deprecated === true ? 2 : isNewModel(model, now) ? 0 : 1;
+  return [...models].sort((left, right) => rank(left) - rank(right) || (isNewModel(left, now) && isNewModel(right, now) ? right.releaseDate.localeCompare(left.releaseDate) : 0));
+}
+
+// src/session-header.ts
+import { randomUUID } from "node:crypto";
+import { attributionHeaders as attributionHeaders3 } from "@deepseek-ai/dsh-llm";
+var SESSION_HEADER = "x-opencode-session";
+function opencodeSessionValue(sessionId) {
+  return sessionId !== void 0 && sessionId.length > 0 ? sessionId : randomUUID();
+}
+function providerHeaders(sessionId) {
+  return {
+    [SESSION_HEADER]: opencodeSessionValue(sessionId),
+    ...attributionHeaders3()
+  };
+}
+
+// src/adapter.ts
+var DISABLES_THINKING_WHEN_UNSET = /* @__PURE__ */ new Set(["deepseek", "zai", "qwen", "qwen-chat-template"]);
+function withModelLimit(model, limits) {
+  const limit = limits[model.id];
+  if (limit === null || limit === void 0) return model;
+  return {
+    ...model,
+    contextWindow: limit.contextWindow ?? model.contextWindow,
+    maxTokens: limit.maxTokens ?? model.maxTokens
+  };
+}
+var OpencodeGoAdapter = class extends LlmAdapter {
+  cache;
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /** The catalog for one configuration, rebuilt when its owned facts change. */
+  catalogOf(config) {
+    const key = `${config.baseURL}|${String(config.refreshMinutes)}|${JSON.stringify(config.modelProtocols)}`;
+    if (this.cache?.key !== key) {
+      this.cache = {
+        key,
+        catalog: new OpencodeGoCatalog({
+          baseURL: assertBaseURL(config.baseURL),
+          refreshMs: config.refreshMinutes * 6e4,
+          defaults: {
+            contextWindow: 262144,
+            maxTokens: 32768,
+            input: ["text"]
+          },
+          overrides: config.modelProtocols,
+          observers: {
+            ...this.options.onFallback === void 0 ? {} : { onFallback: this.options.onFallback },
+            ...this.options.onUnconfigured === void 0 ? {} : { onUnconfigured: this.options.onUnconfigured }
+          }
+        })
+      };
+    }
+    return this.cache.catalog;
+  }
+  providerInfo(provider) {
+    return { id: provider, name: DISPLAY_NAME };
+  }
+  async listModels(_provider) {
+    const config = this.options.config();
+    const snapshot = await this.catalogOf(config).snapshot();
+    const facts = [...snapshot.facts.values()];
+    const recommended = recommendedIds(facts);
+    return facts.map((fact) => ({ ...fact, recommended: recommended.has(fact.id) })).filter((fact) => isModelEnabled(fact, config.modelVisibility)).map((fact) => ({
+      provider: PROVIDER_ID,
+      id: fact.id,
+      name: fact.name,
+      inputModalities: [...fact.input]
+    }));
+  }
+  async resolveModel(_provider, model, _signal) {
+    const config = this.options.config();
+    const snapshot = await this.catalogOf(config).forModel(model);
+    const facts = snapshot.facts.get(model);
+    if (facts === void 0) throw new LlmError7(`opencode-go has no model "${model}"`, "UNKNOWN_MODEL");
+    return this.modelInfo(withModelLimit(toPiModel(facts, config.baseURL), config.modelLimits));
+  }
+  /** Describe one model: capacities plus the reasoning levels it really offers. */
+  modelInfo(model) {
+    const reasoning = {};
+    const levels = model.reasoning ? getSupportedThinkingLevels(model) : [];
+    if (levels.length > 0) {
+      const format = model.compat?.thinkingFormat;
+      const fallback = format !== void 0 && DISABLES_THINKING_WHEN_UNSET.has(format) ? levels.includes("high") ? "high" : levels.findLast((level) => level !== "off") : void 0;
+      reasoning.reasoning = {
+        efforts: levels.map((level) => ({
+          id: ReasoningEffortId(level),
+          name: `${level.charAt(0).toUpperCase()}${level.slice(1)}`
+        })),
+        ...fallback === void 0 ? {} : { defaultEffort: ReasoningEffortId(fallback) }
+      };
+    }
+    return {
+      provider: PROVIDER_ID,
+      id: model.id,
+      name: model.name,
+      inputModalities: [...model.input],
+      context: { contextWindow: model.contextWindow },
+      ...reasoning
+    };
+  }
+  /** Validate an explicit effort against the model's own levels, without clamping. */
+  resolveReasoningLevel(model, effort) {
+    if (effort === void 0) return void 0;
+    const supported = getSupportedThinkingLevels(model);
+    if (supported.some((level) => level === effort)) return effort;
+    throw new LlmError7(
+      `opencode-go model "${model.id}" does not support reasoning effort "${effort}"`,
+      "UNSUPPORTED_REASONING_EFFORT"
+    );
+  }
+  async *stream(options) {
+    var _stack = [];
+    try {
+      if (options.stop !== void 0) {
+        throw new LlmError7("dshopencodego does not support GenerateOptions.stop", "UNSUPPORTED_OPTION");
+      }
+      const config = this.options.config();
+      const snapshot = await this.catalogOf(config).forModel(options.model);
+      const facts = snapshot.facts.get(options.model);
+      if (facts === void 0) throw new LlmError7(`opencode-go has no model "${options.model}"`, "UNKNOWN_MODEL");
+      const model = withModelLimit(toPiModel(facts, config.baseURL), config.modelLimits);
+      const outputLimit = config.modelLimits[model.id]?.maxTokens;
+      const maxTokens = outputLimit === null || outputLimit === void 0 ? options.maxTokens : Math.min(options.maxTokens ?? outputLimit, outputLimit);
+      const apiKey = await this.options.resolveApiKey();
+      if (apiKey === void 0 || apiKey.length === 0) {
+        throw new LlmError7("dshopencodego: no credential resolved for the opencode-go route", "MISSING_CREDENTIAL");
+      }
+      const reasoning = this.resolveReasoningLevel(model, options.reasoningEffort);
+      const consumer = new AbortController();
+      const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
+      const watchdog = __using(_stack, idleWatchdog(upstream, config.streamIdleTimeoutMs, "LLM_STREAM_IDLE_TIMEOUT"));
+      try {
+        const containsImage = options.messages.some((message) => contentHasImage2(message.content));
+        if (containsImage && !model.input.includes("image")) {
+          throw new LlmError7(`opencode-go model "${model.id}" does not support image input`, "UNSUPPORTED_CONTENT");
+        }
+        let imageRequest;
+        if (containsImage) {
+          const access = this.options.imageAccess;
+          const store = access?.resolveAttachments();
+          if (access === void 0 || store === void 0) {
+            throw new LlmError7("dshopencodego image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
+          }
+          imageRequest = {
+            attachments: store,
+            resolveImageAccess: (ref) => access.resolveImageAccess(store, ref),
+            maxRequestImageBytes: config.maxRequestImageBytes,
+            requestImagePolicy: { maxPixels: config.requestImagePixelBudget, maxBytes: config.requestImageMaxBytes }
+          };
+        }
+        const context = imageRequest === void 0 ? await toPiContext(options, void 0, this.options.onReplayDegrade) : await toPiContext({ ...options, signal: watchdog.signal }, imageRequest, this.options.onReplayDegrade);
+        const events = snapshot.provider.streamSimple(model, normalizeContext(context), {
+          apiKey,
+          ...reasoning === void 0 || reasoning === "off" ? {} : { reasoning },
+          ...options.temperature === void 0 ? {} : { temperature: options.temperature },
+          ...maxTokens === void 0 ? {} : { maxTokens },
+          ...options.sessionId === void 0 ? {} : { sessionId: String(options.sessionId) },
+          signal: watchdog.signal,
+          // The gateway refuses a request without `x-opencode-session`; the
+          // attribution user-agent rides along on the same object.
+          headers: providerHeaders(options.sessionId === void 0 ? void 0 : String(options.sessionId)),
+          // The agent recovery layer owns visible attempts; one adapter call is
+          // one SDK attempt.
+          maxRetries: 0
+        });
+        const iterator = toStreamChunks(events, model.contextWindow, options.signal, model.id)[Symbol.asyncIterator]();
+        let exhausted = false;
+        try {
+          while (true) {
+            const result = await watchdog.next(iterator);
+            if (timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0) {
+              throw new LlmError7("opencode-go stream idle timeout", "TIMEOUT");
+            }
+            if (result.done) {
+              exhausted = true;
+              return;
+            }
+            if (result.value.type === "usage") {
+              this.options.onUsage?.({ model: options.model, usage: result.value.usage });
+            }
+            yield result.value;
+          }
+        } finally {
+          if (!exhausted) {
+            consumer.abort("opencode-go stream consumer stopped");
+            try {
+              await iterator.return(void 0);
+            } catch (_abortedSdkTeardown) {
+            }
+          }
+        }
+      } catch (error) {
+        if (timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0) {
+          throw new LlmError7("opencode-go stream idle timeout", "TIMEOUT", { cause: error });
+        }
+        if (options.signal?.aborted) {
+          throw new LlmError7("opencode-go request aborted by caller", "ABORTED", { cause: error });
+        }
+        throw error;
+      } finally {
+        consumer.abort("opencode-go stream consumer stopped");
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+};
+
+// src/catalog/contract.ts
+function parseGoQuota(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid go quota");
+  const row = value;
+  const usd = row["monthlyUsd"];
+  if (usd !== "unlimited" && (typeof usd !== "number" || !Number.isFinite(usd))) {
+    throw new Error("invalid go quota monthlyUsd");
+  }
+  const requests = row["monthlyRequests"];
+  if (requests !== void 0 && requests !== "unlimited" && (typeof requests !== "number" || !Number.isFinite(requests))) {
+    throw new Error("invalid go quota monthlyRequests");
+  }
+  return {
+    monthlyUsd: usd,
+    ...requests === void 0 ? {} : { monthlyRequests: requests }
+  };
+}
+function parseCost(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid model cost");
+  const row = value;
+  const rate = (key) => {
+    const entry = row[key];
+    if (typeof entry !== "number" || !Number.isFinite(entry) || entry < 0) throw new Error(`invalid model cost "${key}"`);
+    return entry;
+  };
+  return {
+    input: rate("input"),
+    output: rate("output"),
+    ...typeof row["cacheRead"] === "number" ? { cacheRead: rate("cacheRead") } : {},
+    ...typeof row["cacheWrite"] === "number" ? { cacheWrite: rate("cacheWrite") } : {}
+  };
+}
+function parseModel(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid catalog model");
+  const row = value;
+  if (typeof row["id"] !== "string" || row["id"].length === 0) throw new Error("invalid catalog model id");
+  return {
+    id: row["id"],
+    name: typeof row["name"] === "string" ? row["name"] : row["id"],
+    ...typeof row["contextWindow"] === "number" ? { contextWindow: row["contextWindow"] } : {},
+    ...typeof row["maxInputTokens"] === "number" ? { maxInputTokens: row["maxInputTokens"] } : {},
+    ...typeof row["maxTokens"] === "number" ? { maxTokens: row["maxTokens"] } : {},
+    ...typeof row["deprecated"] === "boolean" ? { deprecated: row["deprecated"] } : {},
+    ...typeof row["releaseDate"] === "string" ? { releaseDate: row["releaseDate"] } : {},
+    ...row["goQuota"] === void 0 ? {} : { goQuota: parseGoQuota(row["goQuota"]) },
+    ...row["cost"] === void 0 ? {} : { cost: parseCost(row["cost"]) },
+    ...row["protocolSource"] === "builtin" || row["protocolSource"] === "online" || row["protocolSource"] === "inferred" || row["protocolSource"] === "override" ? { protocolSource: row["protocolSource"] } : {},
+    ...typeof row["assumedLimits"] === "boolean" ? { assumedLimits: row["assumedLimits"] } : {},
+    ...typeof row["configurationMissing"] === "string" ? { configurationMissing: row["configurationMissing"] } : {}
+  };
+}
+function parseCatalogReading(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid catalog reading");
+  const row = value;
+  const counts = row["counts"];
+  if (!Array.isArray(row["models"]) || typeof row["stale"] !== "boolean" || typeof row["fetchedAtMs"] !== "number" || counts === null || typeof counts !== "object") {
+    throw new Error("invalid catalog reading");
+  }
+  const numbers = counts;
+  const count = (key) => {
+    const entry = numbers[key];
+    if (typeof entry !== "number" || !Number.isFinite(entry) || entry < 0) throw new Error(`invalid catalog count "${key}"`);
+    return entry;
+  };
+  return {
+    models: row["models"].map(parseModel),
+    stale: row["stale"],
+    ...typeof row["error"] === "string" ? { error: row["error"] } : {},
+    fetchedAtMs: row["fetchedAtMs"],
+    counts: {
+      total: count("total"),
+      enabled: count("enabled"),
+      deprecated: count("deprecated"),
+      unconfigured: count("unconfigured"),
+      inferred: count("inferred")
+    }
+  };
+}
+var codec = {
+  mode: "strict",
+  typeSymbol: "@dan-ai-studio/dshopencodego#CatalogReading",
+  schema: { parse: parseCatalogReading },
+  create: () => ({ parse: parseCatalogReading })
+};
+var catalogRemote = {
+  package: "@dan-ai-studio/dshopencodego",
+  descriptors: [
+    {
+      id: "@dan-ai-studio/dshopencodego#opencodeGoCatalog/read",
+      service: "opencodeGoCatalog",
+      namespace: "opencodeGoCatalog",
+      method: "read",
+      invocation: { kind: "direct" },
+      parameters: [],
+      result: codec
+    },
+    {
+      id: "@dan-ai-studio/dshopencodego#opencodeGoCatalog/refresh",
+      service: "opencodeGoCatalog",
+      namespace: "opencodeGoCatalog",
+      method: "refresh",
+      invocation: { kind: "direct" },
+      parameters: [],
+      result: codec
+    }
+  ]
+};
+
+// src/usage/contract.ts
+function parseWindow(value, key) {
+  if (value === null || typeof value !== "object") throw new Error(`invalid usage window "${key}"`);
+  const row = value;
+  if (row["status"] !== "ok" && row["status"] !== "rate-limited" || typeof row["percent"] !== "number" || !Number.isFinite(row["percent"]) || typeof row["resetsAt"] !== "string") {
+    throw new Error(`invalid usage window "${key}"`);
+  }
+  return { status: row["status"], percent: row["percent"], resetsAt: row["resetsAt"] };
+}
+function parseUsageWindows(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid usage reading");
+  const row = value;
+  return {
+    ...typeof row["source"] === "string" ? { source: row["source"] } : {},
+    rolling: parseWindow(row["rolling"], "rolling"),
+    weekly: parseWindow(row["weekly"], "weekly"),
+    monthly: parseWindow(row["monthly"], "monthly")
+  };
+}
+function parseTotals(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid meter totals");
+  const row = value;
+  const count = (key) => {
+    const entry = row[key];
+    if (typeof entry !== "number" || !Number.isFinite(entry) || entry < 0) throw new Error(`invalid meter field "${key}"`);
+    return entry;
+  };
+  return {
+    calls: count("calls"),
+    inputTokens: count("inputTokens"),
+    outputTokens: count("outputTokens"),
+    cacheReadTokens: count("cacheReadTokens"),
+    cacheWriteTokens: count("cacheWriteTokens"),
+    totalTokens: count("totalTokens")
+  };
+}
+function parseGoMeter(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid meter reading");
+  const row = value;
+  if (typeof row["sinceMs"] !== "number" || typeof row["atMs"] !== "number" || !Array.isArray(row["models"])) {
+    throw new Error("invalid meter reading");
+  }
+  return {
+    sinceMs: row["sinceMs"],
+    atMs: row["atMs"],
+    totals: parseTotals(row["totals"]),
+    models: row["models"].map((entry) => {
+      if (entry === null || typeof entry !== "object") throw new Error("invalid meter model entry");
+      const model = entry["model"];
+      if (typeof model !== "string") throw new Error("invalid meter model entry");
+      return { model, ...parseTotals(entry) };
+    })
+  };
+}
+var codec2 = (typeSymbol, parse) => ({
+  mode: "strict",
+  typeSymbol,
+  schema: { parse },
+  create: () => ({ parse })
+});
+var usageRemote = {
+  package: "@dan-ai-studio/dshopencodego",
+  descriptors: [
+    {
+      id: "@dan-ai-studio/dshopencodego#opencodeGoUsage/readWindows",
+      service: "opencodeGoUsage",
+      namespace: "opencodeGoUsage",
+      method: "readWindows",
+      invocation: { kind: "direct" },
+      parameters: [],
+      result: codec2("@dan-ai-studio/dshopencodego#GoUsageWindows", parseUsageWindows)
+    },
+    {
+      id: "@dan-ai-studio/dshopencodego#opencodeGoUsage/readMeter",
+      service: "opencodeGoUsage",
+      namespace: "opencodeGoUsage",
+      method: "readMeter",
+      invocation: { kind: "direct" },
+      parameters: [],
+      result: codec2("@dan-ai-studio/dshopencodego#GoMeter", parseGoMeter)
+    }
+  ]
+};
+
+// src/remotes.ts
+var contribution = {
+  package: usageRemote.package,
+  descriptors: [...usageRemote.descriptors, ...catalogRemote.descriptors]
+};
+function registerRemotes(ctx) {
+  ctx.inject(["typert"], (scope) => {
+    scope.effect(() => scope.typert.register({
+      package: contribution.package,
+      face: "host",
+      schemas: [],
+      model: { services: [], events: [], objects: [] },
+      invocations: contribution.descriptors
+    }));
+  });
+}
+
+// src/catalog/service.ts
+import { RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { LlmError as LlmError8 } from "@deepseek-ai/dsh-llm";
+
+// src/catalog/reading.ts
+function catalogReading(snapshot, visibility, listingFailure) {
+  const rows = [
+    ...[...snapshot.facts.values()].map((fact) => {
+      const quota = goQuotaFor(fact.id);
+      const priced = fact.cost.input > 0 || fact.cost.output > 0;
+      return {
+        id: fact.id,
+        name: fact.name,
+        contextWindow: fact.contextWindow,
+        maxTokens: fact.maxTokens,
+        ...fact.maxInputTokens === void 0 ? {} : { maxInputTokens: fact.maxInputTokens },
+        deprecated: fact.deprecated,
+        ...fact.releaseDate === void 0 ? {} : { releaseDate: fact.releaseDate },
+        ...quota === void 0 ? {} : { goQuota: quota },
+        ...!priced ? {} : {
+          cost: {
+            input: fact.cost.input,
+            output: fact.cost.output,
+            cacheRead: fact.cost.cacheRead,
+            cacheWrite: fact.cost.cacheWrite
+          }
+        },
+        protocolSource: fact.protocolSource,
+        assumedLimits: fact.assumedLimits
+      };
+    }),
+    ...[...snapshot.unavailable].map(([id, reason]) => ({ id, name: id, configurationMissing: reason }))
+  ];
+  const recommended = recommendedIds(rows);
+  const models = rows.map((row) => ({ ...row, recommended: recommended.has(row.id) }));
+  const enabled = models.filter((model) => isModelEnabled(model, visibility)).length;
+  return {
+    models: sortModels(models),
+    stale: !snapshot.live,
+    ...!snapshot.live && listingFailure !== void 0 ? { error: listingFailure } : {},
+    fetchedAtMs: snapshot.fetchedAtMs,
+    counts: {
+      total: models.length,
+      enabled,
+      deprecated: models.filter((model) => model.deprecated === true).length,
+      unconfigured: models.filter((model) => model.configurationMissing !== void 0).length,
+      inferred: models.filter((model) => model.protocolSource === "inferred").length
+    }
+  };
+}
+
+// src/catalog/service.ts
+var OpencodeGoCatalogService = class extends TypertRemoteService {
+  options;
+  constructor(ctx, options) {
+    super(ctx, "opencodeGoCatalog");
+    this.options = options;
+  }
+  /** The cached reading. */
+  read() {
+    return this.project(false);
+  }
+  /** Revalidate both sources, then read. */
+  refresh() {
+    return this.project(true);
+  }
+  async project(force) {
+    const catalog = this.options.catalog();
+    const snapshot = await catalog.snapshot(force);
+    const failure = snapshot.listingFailure;
+    return catalogReading(
+      snapshot,
+      this.options.visibility(),
+      failure === void 0 ? void 0 : failure instanceof LlmError8 || failure instanceof Error ? failure.message : String(failure)
+    );
+  }
+};
+
+// src/usage/meter.ts
+var EMPTY = {
+  calls: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  totalTokens: 0
+};
+function add(totals, usage) {
+  const inputTokens = totals.inputTokens + usage.inputTokens;
+  const outputTokens = totals.outputTokens + usage.outputTokens;
+  const cacheReadTokens = totals.cacheReadTokens + (usage.cacheReadTokens ?? 0);
+  const cacheWriteTokens = totals.cacheWriteTokens + (usage.cacheWriteTokens ?? 0);
+  return {
+    calls: totals.calls + 1,
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    // The four counts are disjoint (uncached input, cached input, output), so
+    // their sum is the billed total. The provider's own `totalTokens` is not
+    // used: it is optional, and mixing the two would double-count a cache read.
+    totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens
+  };
+}
+var UsageMeter = class {
+  sinceMs = Date.now();
+  totals = EMPTY;
+  byModel = /* @__PURE__ */ new Map();
+  /**
+   * Record one completed call.
+   * @param model - the model id the call was made with.
+   * @param usage - the provider's own usage for that call.
+   */
+  record(model, usage) {
+    this.totals = add(this.totals, usage);
+    this.byModel.set(model, add(this.byModel.get(model) ?? EMPTY, usage));
+  }
+  /** The current reading, busiest model first. */
+  snapshot(now = Date.now()) {
+    return {
+      sinceMs: this.sinceMs,
+      atMs: now,
+      totals: this.totals,
+      models: [...this.byModel.entries()].map(([model, totals]) => ({ model, ...totals })).sort((left, right) => right.totalTokens - left.totalTokens || left.model.localeCompare(right.model))
+    };
+  }
+};
+
+// src/usage/windows.ts
+import { attributionHeaders as attributionHeaders5, LlmError as LlmError9 } from "@deepseek-ai/dsh-llm";
+var USAGE_MAX_BYTES = 1024 * 1024;
+var USAGE_TIMEOUT_MS = 1e4;
+function parseGoUsage(value) {
+  if (value === null || typeof value !== "object") throw new Error("invalid usage response");
+  const source = value;
+  const result = {};
+  for (const key of ["rolling", "weekly", "monthly"]) {
+    const row = source[key];
+    if (row === null || row === void 0 || row.status !== "ok" && row.status !== "rate-limited" || typeof row.percent !== "number" || !Number.isFinite(row.percent) || row.percent < 0 || typeof row.resetsAt !== "string" || !Number.isFinite(Date.parse(row.resetsAt))) {
+      throw new Error(`invalid usage response: window "${key}" is missing or malformed`);
+    }
+    result[key] = { status: row.status, percent: row.percent, resetsAt: row.resetsAt };
+  }
+  return result;
+}
+async function readUsageWindows(options) {
+  if (options.apiKey === void 0 || options.apiKey.length === 0) {
+    throw new LlmError9("dshopencodego: no credential is configured for the opencode-go route", "USAGE_UNAVAILABLE");
+  }
+  const url = `${options.baseURL.replace(/\/+$/, "")}/usage`;
+  const timeout = AbortSignal.timeout(USAGE_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(url, {
+      redirect: "error",
+      headers: {
+        ...attributionHeaders5(),
+        accept: "application/json",
+        authorization: `Bearer ${options.apiKey}`
+      },
+      signal: options.signal === void 0 ? timeout : AbortSignal.any([options.signal, timeout])
+    });
+  } catch (error) {
+    throw new LlmError9(`could not reach ${url}`, "USAGE_UNAVAILABLE", { cause: error });
+  }
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw new LlmError9(`${url} answered HTTP ${response.status}`, "USAGE_UNAVAILABLE");
+  }
+  const body = await readBoundedJson(response, url, USAGE_MAX_BYTES);
+  try {
+    return {
+      ...parseGoUsage(body?.usage),
+      ...options.source === void 0 ? {} : { source: options.source }
+    };
+  } catch (error) {
+    throw new LlmError9(`${url} returned an invalid usage document`, "USAGE_UNAVAILABLE", { cause: error });
+  }
+}
+
+// src/usage/service.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { RemoteError as RemoteError2, TypertRemoteService as TypertRemoteService2 } from "@deepseek-ai/dsh-typert-protocol";
+import { LlmError as LlmError10 } from "@deepseek-ai/dsh-llm";
+function usageFailure(error, source) {
+  const missing = error instanceof LlmError10 && error.code === "MISSING_CREDENTIAL";
+  return new RemoteError2(
+    "dshopencodego/usage-unavailable",
+    error instanceof Error ? error.message : "OpenCode Go usage is unavailable",
+    missing ? { retryable: false, retainPrevious: false } : { retryable: true, retainPrevious: true, ...source === void 0 ? {} : { source } },
+    { cause: error }
+  );
+}
+var OpencodeGoUsageService = class extends TypertRemoteService2 {
+  identity;
+  options;
+  constructor(ctx, options) {
+    super(ctx, "opencodeGoUsage");
+    this.options = options;
+  }
+  /** The account's three windows, or a domain failure the client can render. */
+  async readWindows() {
+    const baseURL = assertBaseURL(this.options.baseURL());
+    let key;
+    try {
+      key = await this.options.resolveApiKey();
+    } catch (error) {
+      this.identity = void 0;
+      throw usageFailure(error, void 0);
+    }
+    if (key === void 0 || key.length === 0) {
+      this.identity = void 0;
+      throw usageFailure(new LlmError10("No OpenCode Go API key is configured", "MISSING_CREDENTIAL"), void 0);
+    }
+    if (this.identity?.baseURL !== baseURL || this.identity.key !== key) {
+      this.identity = { baseURL, key, source: randomUUID2() };
+    }
+    const { source } = this.identity;
+    try {
+      return await readUsageWindows({ baseURL, apiKey: key, source });
+    } catch (error) {
+      throw usageFailure(error, source);
+    }
+  }
+  /** What this process has spent through the route since it started. */
+  readMeter() {
+    return this.options.meter.snapshot();
+  }
+};
+
+// src/index.ts
+var name = "dshopencodego";
+var inject = ["llm"];
+function isLiveConfig(raw) {
+  return typeof raw === "object" && raw !== null && typeof raw.enabled === "object" && typeof raw.enabled?.get === "function";
+}
+function apply(ctx, raw) {
+  const live = isLiveConfig(raw) ? raw : void 0;
+  const constant = live === void 0 ? PlainConfig(raw ?? {}) : void 0;
+  const current = () => live === void 0 ? constant : readConfig(live);
+  assertBaseURL(current().baseURL);
+  const resolveApiKey = async () => {
+    const ref = current().apiKeyEnv;
+    const credentials = ctx.get("credentials");
+    const hit = credentials !== void 0 ? (await credentials.resolve(credentialRef(ref)))?.value : launchEnvironmentOf(ctx).get(ref)?.value;
+    if (hit !== void 0 && hit.length > 0) return llm2.assertUsableApiKey(hit, name, ref);
+    throw new LlmError11(
+      `dshopencodego: no credential; the profile resolves ${ref}, which is not set \u2014 store ${ref} through the credentials service (the Web Models page writes it) or export it`,
+      "MISSING_CREDENTIAL"
+    );
+  };
+  const meter = new UsageMeter();
+  const adapter = new OpencodeGoAdapter({
+    config: current,
+    resolveApiKey,
+    imageAccess: {
+      resolveAttachments: () => ctx.get("attachments"),
+      resolveImageAccess: (attachments, ref) => llm2.resolveImageAttachmentAccess(
+        attachments,
+        (hostPath) => ctx.get("fs")?.processPathFromHostPath(hostPath),
+        ref
+      )
+    },
+    onFallback: ({ url, error }) => {
+      ctx.logger.warn(`dshopencodego: could not refresh ${url}; using the last known model data (${String(error)})`);
+    },
+    onUnconfigured: (entries) => {
+      ctx.logger.warn(`dshopencodego: gateway models this build cannot configure: ${entries.map((entry) => `${entry.id} (${entry.reason})`).join(", ")}`);
+    },
+    onReplayDegrade: (reason) => {
+      ctx.logger.warn(`dshopencodego: unusable replay state on assistant history; sending provider-neutral content (${reason})`);
+    },
+    onUsage: ({ model, usage }) => {
+      meter.record(model, usage);
+    }
+  });
+  registerRemotes(ctx);
+  ctx.plugin(OpencodeGoUsageService, {
+    baseURL: () => current().baseURL,
+    resolveApiKey,
+    meter
+  });
+  ctx.plugin(OpencodeGoCatalogService, {
+    catalog: () => adapter.catalogOf(current()),
+    visibility: () => current().modelVisibility
+  });
+  let registration;
+  let visibilityFacts = JSON.stringify(current().modelVisibility);
+  const applyRoute = (credentialConfigured) => {
+    const enabled = current().enabled;
+    if (enabled && credentialConfigured && registration === void 0) {
+      try {
+        registration = ctx.llm.registerAdapter([PROVIDER_ID], adapter);
+      } catch (error) {
+        ctx.logger.error(
+          `dshopencodego: not registering the "${PROVIDER_ID}" route \u2014 another adapter already owns it; uninstall or disable the other provider first (${String(error)})`
+        );
+      }
+    } else if ((!enabled || !credentialConfigured) && registration !== void 0) {
+      registration();
+      registration = void 0;
+      if (!enabled) {
+        ctx.logger.info("dshopencodego: disabled by configuration; the route and its models are withdrawn");
+      }
+    }
+  };
+  const syncRoute = () => {
+    const visibility = JSON.stringify(current().modelVisibility);
+    if (visibility !== visibilityFacts) {
+      visibilityFacts = visibility;
+      registration?.replace([PROVIDER_ID]);
+    }
+    const credentials = ctx.get("credentials");
+    const ref = current().apiKeyEnv;
+    if (credentials === void 0) {
+      applyRoute(launchEnvironmentOf(ctx).get(ref)?.value !== void 0);
+      return;
+    }
+    void credentials.describe(credentialRef(ref)).then((info) => {
+      if (ref === current().apiKeyEnv) applyRoute(info.configured);
+    }).catch((error) => {
+      ctx.logger.error(`dshopencodego: credential describe failed; keeping the previous route state (${String(error)})`);
+    });
+  };
+  syncRoute();
+  const undiscover = ctx.llm.registerModelDiscovery(name, async (request) => {
+    if (request.provider !== PROVIDER_ID && !(request.baseURL ?? "").includes("opencode.ai")) {
+      throw new LlmError11(
+        "dshopencodego discovers only OpenCode zen/go endpoints; enter this provider's models by hand",
+        "DISCOVERY_UNSUPPORTED"
+      );
+    }
+    return discoverCatalogModels(adapter.catalogOf(current()));
+  });
+  ctx.effect(() => () => {
+    registration?.();
+    undiscover();
+  });
+  ctx.on("internal/config", function(_raw, next) {
+    const value = next();
+    if (this === ctx.fiber) assertBaseURL(PlainConfig(value).baseURL);
+    return value;
+  });
+  ctx.on("loader/volatile-update", syncRoute);
+  ctx.inject(["credentials"], (credentialsCtx) => {
+    credentialsCtx.on("credentials/reference-updated", (ref) => {
+      if (ref === current().apiKeyEnv) syncRoute();
+    });
+    syncRoute();
+  });
+  ctx.logger.info(`dshopencodego: route "${PROVIDER_ID}" registered as ${DISPLAY_NAME}`);
+}
+export {
+  Config,
+  DEFAULT_API_KEY_ENV,
+  DEFAULT_BASE_URL,
+  DISPLAY_NAME,
+  OpencodeGoAdapter,
+  OpencodeGoCatalog,
+  PROVIDER_ID,
+  PlainConfig,
+  SESSION_HEADER,
+  apply,
+  assertBaseURL,
+  discoverCatalogModels,
+  inject,
+  isModelEnabled,
+  name,
+  opencodeSessionValue,
+  providerHeaders,
+  sortModels
+};