dsh-opencode-go 0.1.0

package/lib/index.js

@@ -0,0 +1,1158 @@
+var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : 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 { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { LlmError as LlmError6, assertUsableApiKey, resolveImageAttachmentAccess } from "@deepseek-ai/dsh-llm";
+
+// src/adapter.ts
+import { randomUUID } from "node:crypto";
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import {
+  LlmAdapter,
+  LlmError as LlmError5,
+  ReasoningEffortId,
+  attributionHeaders as attributionHeaders2,
+  contentHasImage as contentHasImage2
+} from "@deepseek-ai/dsh-llm";
+
+// src/conversion/context.ts
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { contentHasImage, IMAGE_OFFLOAD_REQUIRED_CODE, LlmError as LlmError2, offloadedImageText, projectOffloadedImages, requestImageHandleText, requiredImageOffload } from "@deepseek-ai/dsh-llm";
+
+// src/conversion/replay.ts
+import { LlmError } 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 LlmError(`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");
+  }
+  if (response["responseModel"] !== void 0 && typeof response["responseModel"] !== "string") return invalidReplay("responseModel must be a string");
+  if (response["responseId"] !== void 0 && typeof response["responseId"] !== "string") return invalidReplay("responseId must be a string");
+  if (response["providerThinkingLevel"] !== void 0 && typeof response["providerThinkingLevel"] !== "string") return invalidReplay("providerThinkingLevel 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 LlmError("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 if source names the same provider/model as this request.
+    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 } : {}
+        };
+      /* v8 ignore next -- readReplayState rejects unknown replay tags, so an equal plugin-added Harness tag cannot reach this switch */
+      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 LlmError) || error.code !== "INVALID_REPLAY_STATE") throw error;
+    onDegrade?.(error.message);
+    return foreignAssistant(message);
+  }
+}
+
+// src/conversion/context.ts
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
+
+// src/conversion/config.ts
+var DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20 * 1024 * 1024;
+var DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 2048 * 2048;
+var DEFAULT_REQUEST_IMAGE_MAX_BYTES = 1024 * 1024;
+
+// src/conversion/context.ts
+function flattenText(message) {
+  return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function toolResultText(blocks) {
+  return blocks.map((block) => block.type === "text" ? block.text : block.type === "tool-result" ? toolResultText(block.content) : "").join("");
+}
+function assertSupportedImageRoles(messages) {
+  for (const message of messages) {
+    if (message.role !== "user" && contentHasImage(message.content)) {
+      throw new LlmError2(
+        `pi-ai cannot represent an image in an in-history ${message.role} message`,
+        "UNSUPPORTED_CONTENT"
+      );
+    }
+  }
+}
+async function userContent(blocks, requestImages, resolveImageAccess) {
+  const content = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        if (block.text.length > 0) content.push({ type: "text", text: block.text });
+        break;
+      case "image": {
+        const version = requestImages.get(block.attachment.attachmentId);
+        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
+        });
+        break;
+      }
+      case "tool-result":
+        {
+          const nested = await userContent(block.content, requestImages, resolveImageAccess);
+          if (typeof nested === "string") {
+            if (nested.length > 0) content.push({ type: "text", text: nested });
+          } else {
+            content.push(...nested);
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  if (content.every((block) => block.type === "text")) return content.map((block) => block.text).join("");
+  return content;
+}
+function collectImageRefs(blocks, refs) {
+  for (const block of blocks) {
+    if (block.type === "image") {
+      if (block.offloaded !== true) refs.set(block.attachment.attachmentId, block.attachment);
+    } else if (block.type === "tool-result") {
+      collectImageRefs(block.content, refs);
+    }
+  }
+}
+async function prepareRequestImages(messages, attachments, budget, signal) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const message of messages) collectImageRefs(message.content, refs);
+  const orderedRefs = [...refs.values()];
+  const prepared = await Promise.all(orderedRefs.map(
+    (ref) => attachments.readImageRequest(ref, requestImageTarget(ref, budget), signal)
+  ));
+  const versions = /* @__PURE__ */ new Map();
+  for (const [index, ref] of orderedRefs.entries()) {
+    versions.set(ref.attachmentId, prepared[index]);
+  }
+  return versions;
+}
+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
+    // (TypeBox) 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 piContext(systemPrompt, options, messages) {
+  const tools = toolsOf(options);
+  return {
+    ...systemPrompt !== void 0 ? { systemPrompt } : {},
+    messages,
+    ...tools !== void 0 && tools.length > 0 ? { tools } : {}
+  };
+}
+function appendAssistant(message, messages, toolNames, onReplayDegrade) {
+  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);
+}
+function textOnlyContext(options, onReplayDegrade) {
+  assertSupportedImageRoles(options.messages);
+  const split = splitSystemPrompt(options);
+  const toolNames = /* @__PURE__ */ new Map();
+  const messages = [];
+  for (const message of split.messages) {
+    if (contentHasImage(message.content)) {
+      throw new LlmError2("pi-ai image conversion requires the durable attachment service", "UNSUPPORTED_CONTENT");
+    }
+    if (message.role === "system") {
+      messages.push({ role: "user", content: flattenText(message), timestamp: 0 });
+      continue;
+    }
+    if (message.role === "assistant") {
+      appendAssistant(message, messages, toolNames, onReplayDegrade);
+      continue;
+    }
+    const text = flattenText(message);
+    const results = message.content.filter((block) => block.type === "tool-result");
+    if (text.length > 0 || results.length === 0) messages.push({ role: "user", content: text, timestamp: 0 });
+    for (const result of results) {
+      messages.push({
+        role: "toolResult",
+        toolCallId: result.toolCallId,
+        toolName: toolNames.get(result.toolCallId) ?? "unknown",
+        content: [{
+          type: "text",
+          text: toolResultText(result.content) || "(no output)"
+        }],
+        isError: result.isError ?? false,
+        timestamp: 0
+      });
+    }
+  }
+  return piContext(split.systemPrompt, options, messages);
+}
+function requestImageTarget(ref, budget) {
+  return { ...requestImageDimensions(ref.width, ref.height, budget.maxPixels), maxBytes: budget.maxBytes };
+}
+function toPiContext(options, images, onReplayDegrade) {
+  return images === void 0 ? textOnlyContext(options, onReplayDegrade) : toPiContextWithImages(options, images, onReplayDegrade);
+}
+async function toPiContextWithImages(options, images, onReplayDegrade) {
+  const { attachments, resolveImageAccess, maxRequestImageBytes } = images;
+  const requestImagePolicy = images.requestImagePolicy ?? {
+    maxPixels: DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET,
+    maxBytes: DEFAULT_REQUEST_IMAGE_MAX_BYTES
+  };
+  assertSupportedImageRoles(options.messages);
+  const split = splitSystemPrompt(options);
+  const requestImages = await prepareRequestImages(split.messages, attachments, requestImagePolicy, options.signal);
+  if (maxRequestImageBytes !== void 0) {
+    const offloadImages = requiredImageOffload(
+      split.messages,
+      { representation: "base64", maxBytes: maxRequestImageBytes },
+      (block) => requestImages.get(block.attachment.attachmentId).bytes
+    );
+    if (offloadImages > 0) {
+      throw new LlmError2(
+        `pi-ai request images exceed the ${maxRequestImageBytes}-byte base64 bound; ${offloadImages} more oldest occurrence(s) must be offloaded.`,
+        IMAGE_OFFLOAD_REQUIRED_CODE,
+        { offloadImages }
+      );
+    }
+  }
+  const exactMessages = projectOffloadedImages(
+    split.messages,
+    (ref) => offloadedImageText(ref, resolveImageAccess(ref))
+  );
+  const toolNames = /* @__PURE__ */ new Map();
+  const messages = [];
+  for (const message of exactMessages) {
+    if (message.role === "system") {
+      messages.push({ role: "user", content: flattenText(message), timestamp: 0 });
+      continue;
+    }
+    if (message.role === "assistant") {
+      appendAssistant(message, messages, toolNames, onReplayDegrade);
+      continue;
+    }
+    const regular = message.content.filter((block) => block.type !== "tool-result");
+    const content = await userContent(regular, requestImages, resolveImageAccess);
+    const results = message.content.filter((block) => block.type === "tool-result");
+    if (content.length > 0 || results.length === 0) {
+      messages.push({ role: "user", content, timestamp: 0 });
+    }
+    for (const result of results) {
+      const resultContent = await userContent(result.content, requestImages, resolveImageAccess);
+      messages.push({
+        role: "toolResult",
+        toolCallId: result.toolCallId,
+        toolName: toolNames.get(result.toolCallId) ?? "unknown",
+        content: typeof resultContent === "string" ? [{ type: "text", text: resultContent || "(no output)" }] : resultContent,
+        isError: result.isError ?? false,
+        timestamp: 0
+      });
+    }
+  }
+  return piContext(split.systemPrompt, options, messages);
+}
+
+// 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 LlmError3, 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|failed to buffer the request body:\s*length limit exceeded|payload too large|request body too large/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 piAiOverflow = isContextOverflow(message, contextWindow);
+  const harnessOverflow = message.stopReason === "error" && message.errorMessage !== void 0 && isContextWindowExceededError(message.errorMessage);
+  if (piAiOverflow || harnessOverflow) {
+    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 toolIds = /* @__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];
+        const id = partial?.type === "toolCall" ? partial.id : "";
+        const name2 = partial?.type === "toolCall" ? partial.name : "";
+        toolIds.set(event.contentIndex, { id, name: name2 });
+        yield { type: "block-start", index: event.contentIndex, blockType: "tool-call" };
+        break;
+      }
+      case "toolcall_delta": {
+        const known = toolIds.get(event.contentIndex);
+        yield {
+          type: "tool-call-delta",
+          index: event.contentIndex,
+          id: brandString2(known?.id ?? ""),
+          ...known?.name !== 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 hands back the PARSED arguments; the harness vocabulary
+            // keeps the raw string.
+            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 LlmError3("pi-ai event stream ended without done/error", "STREAM_CLOSED");
+}
+
+// src/adapter.ts
+import { idleWatchdog, timeoutOf } from "@deepseek-ai/dsh-timeout";
+
+// src/catalog.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, LlmError as LlmError4 } from "@deepseek-ai/dsh-llm";
+var PROVIDER_ID = "opencode-go";
+var DISPLAY_NAME = "OpenCode Go";
+var DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
+var CATALOG_ADDITIONS = [
+  {
+    id: "deepseek-v4.1-flash",
+    siblingId: "deepseek-v4-flash",
+    inputSiblingId: "deepseek-v4-flash-vision-exp",
+    name: "DeepSeek V4.1 Flash"
+  }
+];
+var MODELS_FETCH_TIMEOUT_MS = 1e4;
+function curatedModels(baseURL) {
+  const models = /* @__PURE__ */ new Map();
+  for (const model of getBuiltinModels("opencode-go")) {
+    models.set(model.id, { ...model, provider: PROVIDER_ID, baseUrl: baseURL });
+  }
+  for (const addition of CATALOG_ADDITIONS) {
+    if (models.has(addition.id)) continue;
+    const sibling = models.get(addition.siblingId);
+    if (sibling === void 0) continue;
+    const inputSibling = models.get(addition.inputSiblingId);
+    if (inputSibling === void 0) continue;
+    models.set(addition.id, {
+      ...sibling,
+      id: addition.id,
+      name: addition.name,
+      input: [...inputSibling.input],
+      provider: PROVIDER_ID,
+      baseUrl: baseURL
+    });
+  }
+  if (models.size === 0) {
+    throw new LlmError4(
+      "llm-opencode-go: pi-ai's installed catalog describes no opencode-go models; cannot seed the curated table",
+      "INVALID_CONFIG"
+    );
+  }
+  return models;
+}
+function readLiveModelIds(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 ids;
+}
+async function fetchLiveModelIds(baseURL) {
+  const url = `${baseURL.replace(/\/+$/, "")}/models`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: { accept: "application/json", ...attributionHeaders() },
+      signal: AbortSignal.timeout(MODELS_FETCH_TIMEOUT_MS)
+    });
+  } catch (error) {
+    throw new LlmError4(`could not reach ${url}`, "DISCOVERY_FAILED", { cause: error });
+  }
+  if (!response.ok) {
+    throw new LlmError4(`${url} answered ${response.status}`, "DISCOVERY_FAILED");
+  }
+  return readLiveModelIds(await response.json());
+}
+function harnessApiKeyAuth() {
+  return {
+    apiKey: {
+      name: "OpenCode API key",
+      /* v8 ignore next -- pi-ai calls resolve only for a request without an apiKey override, and this adapter always passes one */
+      resolve: () => Promise.resolve({ auth: {}, source: "OpenCode 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 {
+  /**
+   * @param baseURL - The endpoint the gateway serves; also the listing base.
+   * @param refreshMs - How long one live resolution stays authoritative.
+   * @param onFallback - Observes a failed live listing and how many curated
+   *   models kept serving because of it.
+   * @param onOmitted - Observes live ids the curated table cannot route.
+   */
+  constructor(baseURL, refreshMs, onFallback, onOmitted) {
+    this.baseURL = baseURL;
+    this.refreshMs = refreshMs;
+    this.onFallback = onFallback;
+    this.onOmitted = onOmitted;
+  }
+  served;
+  pending;
+  /**
+   * The current catalog, fetching when expired or never fetched.
+   * @returns the snapshot now serving, shared by concurrent callers.
+   */
+  snapshot() {
+    if (this.served !== void 0 && Date.now() - this.served.fetchedAtMs < this.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;
+  }
+  /** One resolution: intersect the curated table with the live listing. */
+  async build() {
+    const curated = curatedModels(this.baseURL);
+    let liveIds;
+    let failure;
+    try {
+      liveIds = await fetchLiveModelIds(this.baseURL);
+    } catch (error) {
+      failure = error;
+    }
+    if (liveIds === void 0) {
+      this.onFallback({ url: `${this.baseURL.replace(/\/+$/, "")}/models`, error: failure, kept: curated.size });
+      return {
+        models: curated,
+        provider: buildProvider(this.baseURL, [...curated.values()]),
+        live: false,
+        fetchedAtMs: Date.now()
+      };
+    }
+    const live = new Set(liveIds);
+    const omitted = liveIds.filter((id) => !curated.has(id));
+    if (omitted.length > 0) this.onOmitted(omitted);
+    const served = [...curated.values()].filter((model) => live.has(model.id));
+    return {
+      models: new Map(served.map((model) => [model.id, model])),
+      provider: buildProvider(this.baseURL, served),
+      live: true,
+      fetchedAtMs: Date.now()
+    };
+  }
+};
+async function discoverCatalogModels(catalog) {
+  const snapshot = await catalog.snapshot();
+  if (!snapshot.live) {
+    throw new LlmError4("llm-opencode-go: the live model listing is unreachable; try again later", "DISCOVERY_FAILED");
+  }
+  return [...snapshot.models.values()].map((model) => ({
+    id: model.id,
+    name: model.name,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  }));
+}
+
+// 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_API_KEY";
+var DEFAULT_REFRESH_MINUTES = 60;
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+var Config = z.object({
+  enabled: z.boolean().default(true),
+  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),
+  // The image defaults are the generic pi-ai adapter's: one normalized
+  // request image fits the budget, and fifteen of them fit the payload cap.
+  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)
+});
+function assertBaseURL(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`llm-opencode-go: baseURL "${raw}" is not a valid URL`);
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error(`llm-opencode-go: baseURL "${raw}" must be http or https`);
+  }
+  if (url.search.length > 0 || url.hash.length > 0) {
+    throw new Error(`llm-opencode-go: baseURL "${raw}" must not carry a query or fragment`);
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+
+// src/adapter.ts
+function opencodeSessionValue(sessionId) {
+  return sessionId !== void 0 && sessionId.length > 0 ? sessionId : randomUUID();
+}
+var OpencodeGoAdapter = class extends LlmAdapter {
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  /**
+   * One catalog instance per endpoint/refresh pair. A settings write that
+   * changes either gets a fresh resolver (and a fresh live-listing fetch) on
+   * the next operation; an unchanged configuration keeps its cached snapshot
+   * for the whole refresh interval.
+   */
+  catalogCache;
+  /**
+   * The catalog resolver for one configuration, rebuilding on the facts it
+   * owns. Public for the plugin's discovery registration, which resolves the
+   * current configuration the same way the adapter does.
+   * @param config - the configuration whose endpoint and refresh interval the
+   *   resolver serves; a change to either yields a fresh resolver.
+   * @returns the resolver caching one snapshot per endpoint/refresh pair.
+   */
+  catalogOf(config) {
+    const key = `${config.baseURL}|${String(config.refreshMinutes)}`;
+    if (this.catalogCache?.key !== key) {
+      this.catalogCache = {
+        key,
+        catalog: new OpencodeGoCatalog(
+          assertBaseURL(config.baseURL),
+          config.refreshMinutes * 6e4,
+          /* v8 ignore next -- the plugin always passes both observers; the defaults exist for direct construction */
+          this.options.onFallback ?? (() => {
+          }),
+          /* v8 ignore next -- the plugin always passes both observers; the defaults exist for direct construction */
+          this.options.onOmitted ?? (() => {
+          })
+        )
+      };
+    }
+    return this.catalogCache.catalog;
+  }
+  providerInfo(provider) {
+    return { id: provider, name: DISPLAY_NAME };
+  }
+  async listModels(_provider) {
+    const snapshot = await this.catalogOf(this.options.config()).snapshot();
+    return [...snapshot.models.values()].map((model) => ({
+      provider: PROVIDER_ID,
+      id: model.id,
+      name: model.name,
+      inputModalities: [...model.input]
+    }));
+  }
+  async resolveModel(_provider, model, _signal) {
+    const snapshot = await this.catalogOf(this.options.config()).snapshot();
+    const resolved = snapshot.models.get(model);
+    if (resolved === void 0) {
+      throw new LlmError5(`opencode-go has no model "${model}"`, "UNKNOWN_MODEL");
+    }
+    return this.modelInfo(resolved);
+  }
+  /** Describe one model: capacities plus the reasoning levels it actually offers. */
+  modelInfo(model) {
+    const reasoning = {};
+    if (model.reasoning) {
+      reasoning.reasoning = {
+        efforts: getSupportedThinkingLevels(model).map((level) => ({
+          id: ReasoningEffortId(level),
+          name: `${level.charAt(0).toUpperCase()}${level.slice(1)}`
+        }))
+      };
+    }
+    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 LlmError5(
+      `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 LlmError5("llm-opencode-go does not support GenerateOptions.stop", "UNSUPPORTED_OPTION");
+      }
+      const config = this.options.config();
+      const snapshot = await this.catalogOf(config).snapshot();
+      const model = snapshot.models.get(options.model);
+      if (model === void 0) {
+        throw new LlmError5(`opencode-go has no model "${options.model}"`, "UNKNOWN_MODEL");
+      }
+      const apiKey = await this.options.resolveApiKey();
+      if (apiKey === void 0 || apiKey.length === 0) {
+        throw new LlmError5("llm-opencode-go: no credential resolved for the 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 LlmError5(`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 LlmError5("llm-opencode-go 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 ? toPiContext(options, void 0, this.options.onReplayDegrade) : await toPiContext({ ...options, signal: watchdog.signal }, imageRequest, this.options.onReplayDegrade);
+        const events = snapshot.provider.streamSimple(model, context, {
+          apiKey,
+          ...reasoning === void 0 || reasoning === "off" ? {} : { reasoning },
+          ...options.temperature === void 0 ? {} : { temperature: options.temperature },
+          ...options.maxTokens === void 0 ? {} : { maxTokens: options.maxTokens },
+          ...options.sessionId === void 0 ? {} : { sessionId: String(options.sessionId) },
+          signal: watchdog.signal,
+          // Harness-owned request identity: the gateway refuses requests without
+          // `x-opencode-session` and profiles clients by User-Agent, and
+          // attribution merges last in pi-ai's client.
+          headers: {
+            "x-opencode-session": opencodeSessionValue(options.sessionId === void 0 ? void 0 : String(options.sessionId)),
+            ...attributionHeaders2()
+          },
+          // 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 LlmError5("opencode-go stream idle timeout", "TIMEOUT");
+            }
+            if (result.done) {
+              exhausted = true;
+              return;
+            }
+            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 LlmError5("opencode-go stream idle timeout", "TIMEOUT", { cause: error });
+        }
+        if (options.signal?.aborted) {
+          throw new LlmError5("opencode-go request aborted by caller", "ABORTED", { cause: error });
+        }
+        throw error;
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+};
+
+// src/index.ts
+var name = "llm-opencode-go";
+var inject = ["llm"];
+var NS = "llm-opencode-go";
+function apply(ctx, raw) {
+  const entry = Config(raw);
+  assertBaseURL(entry.baseURL);
+  let current = () => entry;
+  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 assertUsableApiKey(hit, name, ref);
+    throw new LlmError6(
+      `llm-opencode-go: no credential; the profile resolves ${ref}, which is not set \u2014 store ${ref} through the credentials service or export it`,
+      "MISSING_CREDENTIAL"
+    );
+  };
+  const logger = {
+    fallback: ({ error }) => {
+      ctx.logger.warn(`llm-opencode-go: live model listing unreachable; serving the curated table until the next refresh (${String(error)})`);
+    },
+    omitted: (ids) => {
+      ctx.logger.info(`llm-opencode-go: live listing carries ids the curated table cannot route; omitted: ${ids.join(", ")}`);
+    }
+  };
+  const adapter = new OpencodeGoAdapter({
+    config: () => current(),
+    resolveApiKey,
+    imageAccess: {
+      resolveAttachments: () => ctx.get("attachments"),
+      resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(
+        attachments,
+        (hostPath) => ctx.get("fs")?.processPathFromHostPath(hostPath),
+        ref
+      )
+    },
+    onFallback: logger.fallback,
+    onOmitted: logger.omitted,
+    onReplayDegrade: (reason) => {
+      ctx.logger.warn(`llm-opencode-go: unusable replay state on assistant history; sending provider-neutral content (${reason})`);
+    }
+  });
+  let registration;
+  const applyRoute = (configured) => {
+    if (configured && current().enabled && registration === void 0) {
+      try {
+        registration = ctx.llm.registerAdapter([PROVIDER_ID], adapter);
+      } catch (error) {
+        ctx.logger.error(`llm-opencode-go: not registering the "${PROVIDER_ID}" route (${String(error)})`);
+      }
+    } else if ((!configured || !current().enabled) && registration !== void 0) {
+      registration();
+      registration = void 0;
+      if (!current().enabled) {
+        ctx.logger.info("llm-opencode-go: disabled by configuration; the route and its models are withdrawn");
+      }
+    }
+  };
+  const syncRoute = () => {
+    const credentials = ctx.get("credentials");
+    if (credentials === void 0) {
+      applyRoute(launchEnvironmentOf(ctx).get(current().apiKeyEnv)?.value !== void 0);
+      return;
+    }
+    void credentials.describe(credentialRef(current().apiKeyEnv)).then((info) => {
+      applyRoute(info.configured);
+    }).catch((error) => {
+      ctx.logger.error(`llm-opencode-go: 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 LlmError6(
+        "llm-opencode-go 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.inject(["settings"], (settingsCtx) => {
+    settingsCtx.settings.installSection(ctx, NS, Config, entry, {
+      validate: (value) => {
+        assertBaseURL(value.baseURL);
+      },
+      setSource: (source) => {
+        current = source;
+      },
+      onChange: () => {
+        syncRoute();
+      }
+    });
+  });
+  ctx.inject(["credentials"], (credentialsCtx) => {
+    credentialsCtx.on("credentials/reference-updated", (ref) => {
+      if (ref === current().apiKeyEnv) syncRoute();
+    });
+    syncRoute();
+  });
+  ctx.logger.info(`llm-opencode-go: route "${PROVIDER_ID}" registered as ${DISPLAY_NAME}`);
+}
+export {
+  Config,
+  DEFAULT_BASE_URL,
+  DISPLAY_NAME,
+  NS,
+  OpencodeGoAdapter,
+  OpencodeGoCatalog,
+  PROVIDER_ID,
+  apply,
+  assertBaseURL,
+  discoverCatalogModels,
+  inject,
+  name,
+  readLiveModelIds
+};