@rebon/cli-darwin-arm64 0.17.2 → 0.18.0

package/bin/compose-runtime/payload/vendor/dsh/web-search-exa.js

@@ -0,0 +1,122 @@
+// packages/web/web-search-exa/src/index.ts
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import z from "@deepseek-ai/schemastery";
+
+// packages/web/web-search-exa/src/provider.ts
+import { WebError } from "@deepseek-ai/dsh-web";
+var EXA_PROVIDER_ID = "exa";
+var EXA_DEFAULT_BASE_URL = "https://api.exa.ai";
+var EXA_DEFAULT_SEARCH_TYPE = "auto";
+var EXA_DEFAULT_HIGHLIGHTS_PER_RESULT = 1;
+var USER_AGENT = "deepseek-harness/0.0.1";
+function mapExaResult(result) {
+  const snippet = result.highlights?.find((highlight) => highlight.trim().length > 0);
+  if (snippet === void 0) return void 0;
+  return {
+    url: result.url,
+    ...result.title != null && result.title.length > 0 ? { title: result.title } : {},
+    snippet,
+    ...result.publishedDate != null && result.publishedDate.length > 0 ? { publishedAt: result.publishedDate } : {}
+  };
+}
+function mapExaResponse(response) {
+  const sources = (response.results ?? []).map(mapExaResult).filter((source) => source !== void 0);
+  return { sources, truncated: false };
+}
+var ExaSearchProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  id = EXA_PROVIDER_ID;
+  available() {
+    return this.options.apiKey.length > 0 && isValidBaseUrl(this.options.baseURL) && isPositiveInteger(this.options.highlightsPerResult) && (this.options.numResults === void 0 || isPositiveInteger(this.options.numResults));
+  }
+  async search(request, signal) {
+    const numResults = request.maxResults ?? this.options.numResults;
+    let response;
+    try {
+      response = await fetch(`${this.options.baseURL}/search`, {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          "authorization": `Bearer ${this.options.apiKey}`,
+          "content-type": "application/json",
+          "accept": "application/json",
+          "user-agent": USER_AGENT
+        },
+        body: JSON.stringify({
+          query: request.query,
+          type: this.options.searchType,
+          contents: { highlights: { highlightsPerUrl: this.options.highlightsPerResult } },
+          ...numResults !== void 0 ? { numResults } : {}
+        }),
+        ...signal !== void 0 ? { signal } : {}
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw new WebError("Exa search aborted", "WEB_ABORTED", { cause: error });
+      throw new WebError(`Exa search request failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+    }
+    if (!response.ok) {
+      const status = response.status;
+      let message = `Exa API error (HTTP ${status})`;
+      try {
+        const parsed = await response.json();
+        const detail = parsed.error ?? parsed.message;
+        if (detail !== void 0 && detail.length > 0) message = detail;
+      } catch (error) {
+        if (isAbortError(error)) throw new WebError("Exa search aborted", "WEB_ABORTED", { cause: error });
+      }
+      throw new WebError(message, "WEB_PROVIDER_ERROR");
+    }
+    try {
+      const payload = await response.json();
+      return mapExaResponse(payload);
+    } catch (error) {
+      if (isAbortError(error)) throw new WebError("Exa search aborted", "WEB_ABORTED", { cause: error });
+      throw new WebError(`Exa returned an unprocessable response body: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+    }
+  }
+};
+function isValidBaseUrl(baseURL) {
+  return URL.canParse(baseURL);
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value > 0;
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError";
+}
+
+// packages/web/web-search-exa/src/index.ts
+var name = "web-search-exa";
+var inject = ["web"];
+var Config = z.object({
+  apiKey: z.string(),
+  baseURL: z.string(),
+  searchType: z.union(["auto", "keyword", "neural"]),
+  numResults: z.number().step(1).min(1),
+  highlightsPerResult: z.number().step(1).min(1)
+});
+function apply(ctx, config) {
+  ctx.web.registerSearchProvider(new ExaSearchProvider({
+    // Every environment layer may name this key: the product trusts the
+    // project it is launched in, and the managed store is not involved here.
+    apiKey: config.apiKey ?? launchEnvironmentOf(ctx).get("EXA_API_KEY")?.value ?? "",
+    baseURL: config.baseURL ?? EXA_DEFAULT_BASE_URL,
+    searchType: config.searchType ?? EXA_DEFAULT_SEARCH_TYPE,
+    highlightsPerResult: config.highlightsPerResult ?? EXA_DEFAULT_HIGHLIGHTS_PER_RESULT,
+    ...config.numResults !== void 0 ? { numResults: config.numResults } : {}
+  }));
+}
+export {
+  Config,
+  EXA_DEFAULT_BASE_URL,
+  EXA_DEFAULT_HIGHLIGHTS_PER_RESULT,
+  EXA_DEFAULT_SEARCH_TYPE,
+  EXA_PROVIDER_ID,
+  ExaSearchProvider,
+  apply,
+  inject,
+  name
+};

package/bin/compose-runtime/payload/vendor/eventsource-parser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Espen Hovlandsdal <espen@hovlandsdal.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/compose-runtime/payload/vendor/eventsource-parser/index.js

@@ -0,0 +1,177 @@
+class ParseError extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+}
+const LF = 10, CR = 13, SPACE = 32;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = !0, id, data = "", dataLines = 0, eventType, terminated = !1;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = !1, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = !0, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = !0, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = !1;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+export {
+  ParseError,
+  createParser
+};
+

package/bin/compose-runtime/payload/vendor/eventsource-parser/stream.js

@@ -0,0 +1,48 @@
+// Mini-streams-protocol build of `eventsource-parser/stream`.
+//
+// The published package's EventSourceParserStream extends the WHATWG
+// TransformStream, which bare deno_core does not have. Kernel JS hosts use
+// the Mini streams protocol instead (see js/web.js): a transform is any
+// object with `transformIterable(source) -> asyncIterable`. Parsing itself
+// is the vendored upstream `createParser` (js/vendor/eventsource-parser/
+// index.js), so framing semantics — chunk reassembly, CRLF/BOM, comment
+// skipping, multi-`data:` joining — are byte-identical to the real package.
+// Error semantics mirror upstream: a parse error reaches `onError` when one
+// is supplied, and only `onError: 'terminate'` or a max-buffer-size
+// overflow aborts the stream.
+import { createParser } from './index.js';
+
+export { ParseError } from './index.js';
+
+export class EventSourceParserStream {
+  constructor({ onError, onRetry, onComment, maxBufferSize } = {}) {
+    this._options = { onError, onRetry, onComment, maxBufferSize };
+  }
+
+  transformIterable(source) {
+    const { onError, onRetry, onComment, maxBufferSize } = this._options;
+    return (async function* () {
+      const queue = [];
+      let terminal;
+      const parser = createParser({
+        onEvent: (event) => {
+          queue.push(event);
+        },
+        onError(error) {
+          if (typeof onError === 'function') onError(error);
+          if (onError === 'terminate' || error.type === 'max-buffer-size-exceeded') {
+            terminal = error;
+          }
+        },
+        onRetry,
+        onComment,
+        maxBufferSize,
+      });
+      for await (const chunk of source) {
+        parser.feed(chunk);
+        while (queue.length > 0) yield queue.shift();
+        if (terminal !== undefined) throw terminal;
+      }
+    })();
+  }
+}