@rebon/cli-darwin-arm64 0.17.2 → 0.18.0

package/bin/compose-runtime/payload/vendor/dsh/llm-core.js

@@ -0,0 +1,269 @@
+// packages/llm/llm/src/brand.ts
+function MessageId(id) {
+  return id;
+}
+function CallId(id) {
+  return id;
+}
+
+// packages/llm/llm/src/never.ts
+function assertNever(value, context) {
+  const rendered = JSON.stringify(value) ?? String(value);
+  throw new Error(`unreachable variant${context ? ` in ${context}` : ""}: ${rendered}`);
+}
+
+// packages/llm/llm/src/call-config.ts
+var AGENT_LOOP_REQUESTS = /* @__PURE__ */ new WeakSet();
+function callConfigEquals(a, b) {
+  if (a.provider !== b.provider || a.model !== b.model || a.reasoningEffort !== b.reasoningEffort || a.temperature !== b.temperature || a.maxTokens !== b.maxTokens) return false;
+  if (a.stop === void 0 || b.stop === void 0) return a.stop === b.stop;
+  return a.stop.length === b.stop.length && a.stop.every((s, i) => s === b.stop?.[i]);
+}
+function markAgentLoopRequest(request) {
+  AGENT_LOOP_REQUESTS.add(request);
+  return request;
+}
+function isAgentLoopRequest(request) {
+  return AGENT_LOOP_REQUESTS.has(request);
+}
+function deepFreeze(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const pending = [{ kind: "visit", node: value }];
+  while (pending.length > 0) {
+    const task = pending.pop();
+    if (task === void 0) continue;
+    if (task.kind === "property") {
+      pending.push({ kind: "visit", node: task.source[task.key] });
+      continue;
+    }
+    const node = task.node;
+    if (node === null || typeof node !== "object") continue;
+    if (node instanceof AbortSignal) continue;
+    if (seen.has(node)) continue;
+    seen.add(node);
+    Object.freeze(node);
+    const keys = Object.keys(node);
+    for (let index = keys.length - 1; index >= 0; index--) {
+      const key = keys[index];
+      if (key === void 0) continue;
+      pending.push({ kind: "property", source: node, key });
+    }
+  }
+  return value;
+}
+
+// packages/llm/llm/src/message.ts
+function freezeMessage(message) {
+  return deepFreeze(structuredClone(message));
+}
+function createMessage(input) {
+  return freezeMessage({
+    ...input,
+    id: MessageId(crypto.randomUUID())
+  });
+}
+function createUserMessage(input) {
+  return createMessage({
+    ...input,
+    role: "user"
+  });
+}
+function createAssistantMessage(input) {
+  return createMessage({
+    role: "assistant",
+    content: input.content,
+    source: {
+      kind: "model",
+      ...input.source
+    }
+  });
+}
+function createToolResultMessage(input) {
+  return createUserMessage({
+    source: { kind: "tool", callId: input.callId },
+    content: [{
+      type: "tool-result",
+      toolCallId: input.callId,
+      content: input.content,
+      isError: input.isError
+    }]
+  });
+}
+
+// packages/llm/llm/src/assembler.ts
+var BlockAssembler = class {
+  partials = /* @__PURE__ */ new Map();
+  order = [];
+  _usage;
+  _finish;
+  _replayState = void 0;
+  /**
+   * Feed one chunk into the assembly state.
+   * @param chunk - the next raw chunk, in stream order.
+   */
+  push(chunk) {
+    switch (chunk.type) {
+      case "block-start": {
+        if (!this.partials.has(chunk.index)) {
+          this.order.push(chunk.index);
+          this.partials.set(chunk.index, {
+            blockType: chunk.blockType,
+            text: "",
+            toolCallArguments: ""
+          });
+        }
+        return;
+      }
+      case "text-delta":
+      case "reasoning-delta": {
+        const partial = this.ensure(chunk.index, chunk.type === "text-delta" ? "text" : "reasoning");
+        if (partial.block) return;
+        partial.text += chunk.text;
+        return;
+      }
+      case "tool-call-delta": {
+        const partial = this.ensure(chunk.index, "tool-call");
+        if (partial.block) return;
+        partial.toolCallId = chunk.id;
+        if (chunk.name) partial.toolCallName = chunk.name;
+        partial.toolCallArguments += chunk.argumentsDelta;
+        return;
+      }
+      case "block-end": {
+        const partial = this.ensure(chunk.index, chunk.block.type);
+        if (partial.block) return;
+        partial.block = chunk.block;
+        return;
+      }
+      case "usage": {
+        this._usage = chunk.usage;
+        return;
+      }
+      case "finish": {
+        this._finish = chunk.reason;
+        this._replayState = chunk.replayState;
+        return;
+      }
+      default:
+        return assertNever(chunk, "BlockAssembler.push");
+    }
+  }
+  ensure(index, blockType) {
+    let partial = this.partials.get(index);
+    if (!partial) {
+      partial = { blockType, text: "", toolCallArguments: "" };
+      this.partials.set(index, partial);
+      this.order.push(index);
+    }
+    return partial;
+  }
+  assemble(partial, index) {
+    if (partial.block) return partial.block;
+    switch (partial.blockType) {
+      case "text":
+        return { type: "text", text: partial.text };
+      case "reasoning":
+        return { type: "reasoning", text: partial.text };
+      case "tool-call":
+        return {
+          type: "tool-call",
+          id: partial.toolCallId ?? CallId(`call-${index}`),
+          name: partial.toolCallName ?? "",
+          arguments: partial.toolCallArguments
+        };
+      default:
+        throw new Error(`cannot assemble incomplete block of type "${partial.blockType}"`);
+    }
+  }
+  /** Invariant accessor: every index in `order` has a partial. */
+  mustGet(index) {
+    const partial = this.partials.get(index);
+    if (!partial) throw new Error(`BlockAssembler invariant violated: no partial for index ${index}`);
+    return partial;
+  }
+  /**
+   * Assemble all blocks seen so far, in stream order.
+   * @returns one block per seen index, except that max-token truncation drops
+   *   tool calls that cannot be executed safely; an open block assembles from
+   *   its accumulated deltas (an unknown block type never closed by `block-end` throws).
+   */
+  blocks() {
+    const blocks = this.order.map((index) => this.assemble(this.mustGet(index), index));
+    return this.finish.kind === "max-tokens" ? blocks.filter((block) => block.type !== "tool-call") : blocks;
+  }
+  /** Usage from the `usage` chunk; undefined until one arrives. */
+  get usage() {
+    return this._usage;
+  }
+  /** Finish reason from the `finish` chunk; `{kind: 'stop'}` when the stream ended without one. */
+  get finish() {
+    return this._finish ?? { kind: "stop" };
+  }
+  /** Adapter-private replay state from the terminal finish chunk, if any. */
+  get replayState() {
+    return this._replayState;
+  }
+  /**
+   * The assembled assistant message.
+   * @param source - producer attribution for the assembled message.
+   * @returns a frozen assistant-role message over `blocks()` (same open-block assembly rules).
+   */
+  message(source = { kind: "plugin", plugin: "dsh-llm/assembler" }) {
+    return createMessage({ role: "assistant", content: this.blocks(), source });
+  }
+};
+
+// packages/llm/llm/src/error.ts
+var STRUCTURED_CONTEXT_OVERFLOW = new RegExp(
+  String.raw`(?:^|[^a-z0-9])context[\s_-](?:length|window)[\s_-]` + String.raw`(?:exceed(?:ed|s)?|overflow(?:ed)?|limit[\s_-]exceeded)(?:$|[^a-z0-9])`,
+  "i"
+);
+var TOO_LARGE_FOR_CONTEXT = new RegExp(
+  String.raw`\b(?:request|prompt|input|messages?)\s+(?:is\s+|are\s+)?` + String.raw`too\s+(?:large|long)\s+for\s+(?:(?:this|the)\s+)?` + String.raw`(?:model(?:'s)?\s+)?context(?:\s+window)?\b`,
+  "i"
+);
+var EXCEEDS_MODEL_CONTEXT = new RegExp(
+  String.raw`\b(?:input|prompt|request|messages?)\b.{0,40}` + String.raw`\b(?:exceed(?:s|ed)?|overflows?|is\s+larger\s+than)\b.{0,40}` + String.raw`\b(?:the\s+)?(?:model(?:'s)?\s+)?context(?:\s+(?:length|window))?\b`,
+  "i"
+);
+function errorChain(value) {
+  const path = /* @__PURE__ */ new Set();
+  const render = (current) => {
+    if (path.has(current)) return "<circular cause>";
+    path.add(current);
+    try {
+      if (!(current instanceof Error)) {
+        if (typeof current === "object" && current !== null) {
+          const descriptor = Object.getOwnPropertyDescriptor(current, "message");
+          if (descriptor !== void 0 && "value" in descriptor && typeof descriptor.value === "string") {
+            return descriptor.value;
+          }
+        }
+        return String(current);
+      }
+      const message = current.message === "" ? current.name : current.message;
+      const members = current instanceof AggregateError && current.errors.length > 0 ? ` [${current.errors.map(render).join("; ")}]` : "";
+      const causeText = current.cause === void 0 || current.cause === null ? "" : render(current.cause);
+      const cause = causeText === "" || causeText === message ? "" : `: ${causeText}`;
+      return `${message}${members}${cause}`;
+    } catch {
+      return "<unrenderable value>";
+    } finally {
+      path.delete(current);
+    }
+  };
+  return render(value);
+}
+export {
+  BlockAssembler,
+  callConfigEquals,
+  createAssistantMessage,
+  createMessage,
+  createToolResultMessage,
+  createUserMessage,
+  deepFreeze,
+  errorChain,
+  freezeMessage,
+  isAgentLoopRequest,
+  markAgentLoopRequest
+};