@legioncodeinc/honeycomb 0.1.0

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "@legioncodeinc/honeycomb",
+  "version": "0.1.0",
+  "//go-public": "Go-public switches are flipped: scoped name, public+provenance publishConfig live, `private` removed. CI auth is npm Trusted Publishing (OIDC); there is NO NPM_TOKEN. The go-live procedure is RELEASING.md 'Cut the release': the first publish is a one-time manual 2FA bootstrap that creates the package, after which every CI publish from release.yaml is tokenless OIDC.",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "description": "Honeycomb monorepo foundation: a long-lived daemon plus thin clients for six coding harnesses, the unified honeycomb CLI, the MCP server, and the embed daemon.",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "//build-order": "Fixed dependency direction enforced by import direction under one tsc pass: (1) core = src/shared + src/daemon-client, (2) connector-base = src/daemon, (3) plugins/native = embeddings, (4) connectors = harnesses/* + mcp + src/cli, (5) assembled distribution = esbuild per-target bundles (PRD-001b). tsc compiles the whole graph in one pass; dependents never import upward, so the single tsc invocation respects this order. PRD-001b appends '&& node esbuild.config.mjs' to the build script; that seam is intentional.",
+  "bin": {
+    "honeycomb": "bundle/cli.js"
+  },
+  "//exports": "PRD-019e: @legioncodeinc/honeycomb subpath exports. The core entry (.) is the fetch-only, browser-safe HoneycombClient (`@legioncodeinc/honeycomb`); the three framework helpers ship as separate entry points (`@legioncodeinc/honeycomb/react`, `/vercel`, `/openai`) reusing the core's token/actor model. react + ai are peerDependencies (never bundled into core).",
+  "exports": {
+    ".": "./sdk/index.js",
+    "./react": "./sdk/react.js",
+    "./vercel": "./sdk/vercel.js",
+    "./openai": "./sdk/openai.js"
+  },
+  "files": [
+    "bundle",
+    "sdk",
+    "daemon",
+    "assets/styles.css",
+    "assets/tokens",
+    "assets/logos/honeycomb-memory-cluster.svg",
+    "assets/logos/fonts",
+    "harnesses/claude-code/bundle",
+    "harnesses/claude-code/.claude-plugin",
+    "harnesses/claude-code/hooks",
+    "harnesses/codex/bundle",
+    "harnesses/codex/package.json",
+    "harnesses/cursor/bundle",
+    "harnesses/hermes/bundle",
+    "harnesses/pi/bundle",
+    "harnesses/openclaw/dist",
+    "harnesses/openclaw/openclaw.plugin.json",
+    "harnesses/openclaw/package.json",
+    "mcp/bundle",
+    "embeddings/embed-daemon.js",
+    ".claude-plugin",
+    "scripts/ensure-tree-sitter.mjs",
+    "scripts/ensure-embed-deps.mjs",
+    "README.md"
+  ],
+  "scripts": {
+    "prebuild": "node scripts/sync-versions.mjs",
+    "version": "node scripts/sync-versions.mjs && git add .claude-plugin/plugin.json harnesses/claude-code/.claude-plugin/plugin.json harnesses/openclaw/openclaw.plugin.json harnesses/openclaw/package.json harnesses/codex/package.json .claude-plugin/marketplace.json",
+    "build": "tsc && node esbuild.config.mjs",
+    "bundle": "node esbuild.config.mjs",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "dup": "jscpd src harnesses mcp embeddings",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "smoke:golden-path": "node scripts/golden-path-smoke.mjs",
+    "smoke:login": "node scripts/login-smoke.mjs",
+    "smoke:data-api": "node scripts/dogfood-acceptance-smoke.mjs",
+    "eval:recall": "node scripts/eval-recall.mjs",
+    "eval:prime": "node scripts/eval-prime.mjs",
+    "bench:hybrid": "node scripts/bench-hybrid.mjs",
+    "deeplake:stress": "node scripts/deeplake-stress.mjs",
+    "audit:openclaw": "node scripts/audit-openclaw-bundle.mjs",
+    "audit:sql": "node scripts/audit-sql-safety.mjs",
+    "mutation": "npm run mutation:sql && npm run mutation:prune && npm run mutation:normalize && npm run mutation:state",
+    "mutation:sql": "stryker run stryker/sql.json",
+    "mutation:prune": "stryker run stryker/prune.json",
+    "mutation:normalize": "stryker run stryker/normalize.json",
+    "mutation:state": "stryker run stryker/state.json",
+    "pack:check": "node scripts/pack-check.mjs",
+    "rebuild:native": "node scripts/ensure-tree-sitter.mjs",
+    "ensure:embed-deps": "node scripts/ensure-embed-deps.mjs",
+    "ci": "npm run typecheck && npm run dup && npm run test && npm run audit:sql",
+    "postinstall": "node scripts/ensure-tree-sitter.mjs && node scripts/ensure-embed-deps.mjs",
+    "prepack": "npm run build",
+    "smoke:daemon-bundle": "node scripts/smoke-daemon-bundle.mjs"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.0",
+    "@stryker-mutator/core": "^8.7.1",
+    "@stryker-mutator/vitest-runner": "^8.7.1",
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.31",
+    "@types/react-dom": "^18.3.7",
+    "@vitest/coverage-v8": "^3.2.6",
+    "esbuild": "^0.28.1",
+    "fast-check": "^4.8.0",
+    "jscpd": "^4.0.5",
+    "jsdom": "^25.0.1",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.6"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "//peerDependencies": "PRD-019e: react powers @legioncodeinc/honeycomb/react; ai powers @legioncodeinc/honeycomb/vercel. Both are OPTIONAL peers (peerDependenciesMeta) so the core entry stays dependency-free for Node/Bun/browser. The core client (.) pulls in NEITHER.",
+  "peerDependencies": {
+    "ai": ">=3.0.0",
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "ai": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.14",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@noble/ciphers": "^2.2.0",
+    "hono": "^4.12.25",
+    "tree-sitter-wasms": "^0.1.13",
+    "web-tree-sitter": "^0.22.6",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3"
+  },
+  "//optionalDependencies": "PRD-025 D-2: the embedding RUNTIME (@huggingface/transformers + its ONNX native runtime, ~600 MB with the nomic-embed-text-v1.5 model acquired at first-run) ships as an OPTIONAL dependency, NOT in the `files` allowlist. This keeps the published @legioncodeinc/honeycomb tarball LEAN (the model is downloaded + cached on the daemon's first warmup, not packed — AC-7) and keeps `npm i` fast for everyone; a `--no-optional` / slimmed / offline install simply runs recall on the BM25/ILIKE lexical fallback (no quality cliff — D-4). The embed daemon dynamic-imports this only at warmup, so the bundle + CI never require it.",
+  "optionalDependencies": {
+    "@huggingface/transformers": "^3.8.1"
+  },
+  "//overrides": "Dependabot transitive-devDependency remediation. All are DEV-only and never ship (the `files` allowlist packs built bundles, not node_modules), so consumer risk is nil — these clear the dev/CI tree. tmp ^0.2.6 fixes GHSA-ph9p-34f9-6g65 (HIGH path traversal) + GHSA-52f5-9888-hmc6 (symlink write), reached only via @stryker-mutator/core -> @inquirer/prompts -> external-editor -> tmp (which calls only tmpNameSync, stable across the 0.0.33->0.2.x major). esbuild ^0.28.1 fixes GHSA-g7r4-m6w7-qqqr (Windows dev-server file read) in vitest's nested copy; the direct dep is already 0.28.1. @babel/core ^7.29.6 fixes GHSA-4x5r-pxfx-6jf8 (sourceMappingURL file read) under @stryker-mutator/instrumenter. ajv ^8.20.0 fixes GHSA-2g4f-4pwh-qvx6 ($data ReDoS) under @stryker-mutator/core's schema validator — a same-major bump (8.17.1 -> 8.20.x), preferred over npm audit's suggested breaking @stryker-mutator/core 9.x major. Validated by npm run mutation (exercises tmp+babel+ajv schema load) + npm run ci/build (exercises esbuild).",
+  "overrides": {
+    "tmp": "^0.2.6",
+    "esbuild": "^0.28.1",
+    "@babel/core": "^7.29.6",
+    "ajv": "^8.20.0"
+  }
+}

package/scripts/ensure-embed-deps.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// PRD-025 Wave 2 (D-2 / D-3 / AC-1 / AC-7) — first-run embedding-deps heal.
+//
+// Mirrors scripts/ensure-tree-sitter.mjs: a fast, NON-FATAL sanity check run from
+// the `postinstall` hook. It HEALS NOTHING heavy and DOWNLOADS NOTHING here — the
+// ~600 MB model is acquired LATER, lazily, on the daemon's first warmup (D-2: the
+// model is acquired at first run, NEVER packed into the npm tarball; D-3: the
+// download is background-warm and never blocks login or the first recall). This
+// script only REPORTS whether the optional inference stack
+// (`@huggingface/transformers`) resolved, so a consumer sees one clear line at
+// install time instead of an opaque failure when the daemon later tries to warm.
+//
+// Why it stays in the `files` allowlist + `postinstall`: parity with
+// ensure-tree-sitter (the install hook references it by path), and a deterministic,
+// non-fatal install experience. It ALWAYS exits 0 (unless strict CI mode) — an
+// end-user `npm i` must NEVER hard-break because the optional embed stack is absent;
+// embeddings simply stay OFF until the deps are present (the BM25 lexical fallback
+// has no quality cliff — PRD-025 D-4).
+
+import { createRequire } from "node:module";
+
+const ROOT = process.cwd();
+const require = createRequire(`${ROOT}/`);
+
+// Recursion guard for nested npm calls (parity with ensure-tree-sitter).
+if (process.env.ENSURE_EMBED_RUNNING) process.exit(0);
+
+// The opt-OUT (PRD-025 D-1): an explicit `HONEYCOMB_EMBEDDINGS=false`/`0` means the
+// user does not want embeddings — say so and exit cleanly, never probing.
+const raw = (process.env.HONEYCOMB_EMBEDDINGS ?? "").trim().toLowerCase();
+if (raw === "false" || raw === "0") {
+  console.error(
+    "[ensure-embed-deps] HONEYCOMB_EMBEDDINGS opt-out set — embeddings disabled, recall is lexical-only. Skipping.",
+  );
+  process.exit(0);
+}
+
+// The optional inference stack. It is an `optionalDependency` (~600 MB with its
+// native ONNX runtime), so a slimmed / offline / `--no-optional` install legitimately
+// lacks it. Resolve-only: we do NOT import it (importing would load native bindings
+// at install time — exactly what we avoid; the daemon loads it lazily on warmup).
+let present = true;
+try {
+  require.resolve("@huggingface/transformers");
+} catch {
+  present = false;
+}
+
+if (present) {
+  console.error(
+    "[ensure-embed-deps] OK — @huggingface/transformers present. The nomic-embed-text-v1.5 model " +
+      "(~600 MB) downloads + caches on first daemon warmup (one time), then reuses the cached dir.",
+  );
+  process.exit(0);
+}
+
+// Absent: this is the COMMON, non-error case for a lean install. Embeddings stay OFF
+// and recall is the BM25/ILIKE lexical fallback (no quality cliff — D-4). In strict CI
+// mode a missing optional stack can be made a hard signal; otherwise it is informational.
+const strict = process.env.HONEYCOMB_STRICT_POSTINSTALL === "1";
+console.error(
+  "[ensure-embed-deps] @huggingface/transformers not installed — semantic recall is OFF; recall " +
+    "falls back to lexical (BM25/ILIKE), which is fine. To enable semantic recall, install the " +
+    "optional embedding deps (`npm i @huggingface/transformers`) and restart the daemon." +
+    (strict ? " (strict mode — failing this install)" : " (non-fatal)"),
+);
+process.exit(strict ? 1 : 0);

package/scripts/ensure-tree-sitter.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// Confirms the tree-sitter WASM parser stack is present and loadable after install
+// (PRD-014 codebase graph, D-1). This script HEALS NOTHING and COMPILES NOTHING:
+// the parser is `web-tree-sitter` (a WASM/emscripten runtime) + `tree-sitter-wasms`
+// (prebuilt `.wasm` grammars), so there is no native binding to build, no node-gyp,
+// no C/C++ toolchain, and no per-platform/per-ABI compile. That is the whole point
+// of choosing WASM over native `tree-sitter` + `tree-sitter-<lang>`: the install is
+// deterministic and identical across the CI matrix (ubuntu Node 22/24 + windows-smoke),
+// with no postinstall compile that could break Windows or linux-arm64.
+//
+// Why this file still exists (and stays in the `files` allowlist + `postinstall`):
+//   1. Backwards-compatible name — the build script + CI reference `rebuild:native`
+//      and `postinstall` by this path; keeping it avoids churn in those surfaces.
+//   2. A fast, non-fatal SANITY check: if a consumer's install dropped a grammar
+//      `.wasm` (a partial extract, a pruned `node_modules`), we say so clearly
+//      rather than letting the daemon fail later with an opaque WASM load error.
+//
+// It ALWAYS exits 0 (unless explicitly run in strict CI mode and a grammar is
+// genuinely missing): an end-user consumer must never get a hard install break from
+// this hook.
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+
+const ROOT = process.cwd();
+const require = createRequire(`${ROOT}/`);
+
+// Recursion guard for nested npm calls (kept for parity with prior behaviour).
+if (process.env.ENSURE_TS_RUNNING) process.exit(0);
+
+// The nine PRD-014 languages map to these grammar `.wasm` files (TS routes both
+// `tree-sitter-typescript` and `tree-sitter-tsx`). Located by resolving the
+// `tree-sitter-wasms` package and reading its `out/` directory — the SAME anchor
+// the runtime extractor uses (`src/daemon/runtime/codebase/extract.ts`).
+const GRAMMARS = [
+  "tree-sitter-typescript",
+  "tree-sitter-tsx",
+  "tree-sitter-javascript",
+  "tree-sitter-python",
+  "tree-sitter-go",
+  "tree-sitter-rust",
+  "tree-sitter-java",
+  "tree-sitter-ruby",
+  "tree-sitter-c",
+  "tree-sitter-cpp",
+];
+
+// Greenfield / not-yet-installed short-circuit: if the parser deps are not present
+// (a checkout before `npm install`, or a slimmed environment), there is nothing to
+// check. Log and exit 0 so `npm install` / `npm run rebuild:native` never breaks.
+let wasmDir;
+try {
+  wasmDir = require.resolve("tree-sitter-wasms/package.json").replace(/package\.json$/, "out/");
+} catch {
+  console.error(
+    "[ensure-tree-sitter] web-tree-sitter / tree-sitter-wasms not installed yet — nothing to check. Skipping.",
+  );
+  process.exit(0);
+}
+
+// Confirm the web-tree-sitter runtime resolves too (it carries its own
+// `tree-sitter.wasm` emscripten runtime loaded at parse time).
+let runtimeOk = true;
+try {
+  require.resolve("web-tree-sitter");
+} catch {
+  runtimeOk = false;
+}
+
+const missing = GRAMMARS.filter((g) => !existsSync(`${wasmDir}${g}.wasm`));
+
+if (runtimeOk && missing.length === 0) {
+  console.error(
+    `[ensure-tree-sitter] OK — web-tree-sitter runtime + ${GRAMMARS.length} WASM grammars present (no native build needed).`,
+  );
+  process.exit(0);
+}
+
+// Something is missing. In strict CI mode (HONEYCOMB_STRICT_POSTINSTALL=1) this is a
+// hard failure so a partial install surfaces as a red check; otherwise it is a
+// non-fatal warning so an end-user install never breaks.
+const strict = process.env.HONEYCOMB_STRICT_POSTINSTALL === "1";
+console.error(
+  "[ensure-tree-sitter] WARNING: tree-sitter WASM stack incomplete — " +
+    (runtimeOk ? "" : "web-tree-sitter runtime not resolvable; ") +
+    (missing.length ? `missing grammars: ${missing.join(", ")}. ` : "") +
+    "Re-run `npm install` to restore the parser deps." +
+    (strict ? " (strict mode — failing this install)" : " (non-fatal)"),
+);
+process.exit(strict ? 1 : 0);

package/sdk/index.js

@@ -0,0 +1,312 @@
+// dist/src/sdk/contracts.js
+function notImplemented(what) {
+  throw new Error(`PRD-019e: not implemented \u2014 ${what}`);
+}
+var HoneycombError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var ApiError = class extends HoneycombError {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+var NetworkError = class extends HoneycombError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+};
+var TimeoutError = class extends HoneycombError {
+  timeoutMs;
+  constructor(message, timeoutMs) {
+    super(message);
+    this.timeoutMs = timeoutMs;
+  }
+};
+function defaultRetryPolicy() {
+  return {
+    maxAttempts(method) {
+      return method === "GET" ? 3 : 1;
+    },
+    backoffMs(attempt) {
+      return attempt * 100;
+    }
+  };
+}
+
+// dist/src/sdk/client.js
+var DEFAULT_TIMEOUT_MS = 3e4;
+var SECRET_REDACTED = "[REDACTED]";
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function isTokenTransportSafe(baseUrl) {
+  let parsed;
+  try {
+    parsed = new URL(baseUrl);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol === "https:")
+    return true;
+  if (parsed.protocol === "http:")
+    return LOOPBACK_HOSTS.has(parsed.hostname);
+  return false;
+}
+var HEADER_ACTOR = "x-honeycomb-actor";
+var HEADER_ACTOR_TYPE = "x-honeycomb-actor-type";
+var HEADER_RUNTIME_PATH = "x-honeycomb-runtime-path";
+var HEADER_SESSION = "x-honeycomb-session";
+var SESSION_GROUP_PREFIXES = ["/api/memories", "/memory"];
+function isSdkSessionGroupPath(path) {
+  return SESSION_GROUP_PREFIXES.some((p) => path === p || path.startsWith(`${p}/`) || path.startsWith(`${p}?`));
+}
+function createHoneycombClient(opts) {
+  const fetchImpl = opts.fetch ?? ((input, init) => fetch(input, init));
+  const retry = opts.retry ?? defaultRetryPolicy();
+  const clientTimeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const baseUrl = opts.daemonUrl.replace(/\/+$/, "");
+  const tokenTransportSafe = isTokenTransportSafe(baseUrl);
+  let sdkSessionCounter = 0;
+  function mintSdkSessionId() {
+    sdkSessionCounter += 1;
+    return `sdk-${opts.actor}-${sdkSessionCounter}`;
+  }
+  function buildHeaders(hasBody, path) {
+    const headers = {
+      [HEADER_ACTOR]: opts.actor,
+      [HEADER_ACTOR_TYPE]: opts.actorType,
+      // The SDK is a plugin-path thin client; the daemon enforces, we stamp (D-6).
+      [HEADER_RUNTIME_PATH]: "plugin"
+    };
+    if (isSdkSessionGroupPath(path))
+      headers[HEADER_SESSION] = mintSdkSessionId();
+    if (hasBody)
+      headers["content-type"] = "application/json";
+    if (opts.token !== void 0 && opts.token.length > 0 && tokenTransportSafe) {
+      headers.authorization = `Bearer ${opts.token}`;
+    }
+    return headers;
+  }
+  async function dispatchOnce(req, budgetMs) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, budgetMs);
+    try {
+      const init = {
+        method: req.method,
+        headers: buildHeaders(req.body !== void 0, req.path),
+        signal: controller.signal
+      };
+      if (req.body !== void 0)
+        init.body = JSON.stringify(req.body);
+      return await fetchImpl(`${baseUrl}${req.path}`, init);
+    } catch (err) {
+      if (timedOut) {
+        throw new TimeoutError(`request to ${req.path} exceeded ${budgetMs}ms`, budgetMs);
+      }
+      throw new NetworkError(`transport failure calling ${req.path}`, err);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  function isTransientStatus(status) {
+    return status === 429 || status >= 500 && status <= 599;
+  }
+  function sleep(ms) {
+    if (ms <= 0)
+      return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function request(req) {
+    const budgetMs = req.timeoutMs ?? clientTimeoutMs;
+    const maxAttempts = retry.maxAttempts(req.method);
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      let res;
+      try {
+        res = await dispatchOnce(req, budgetMs);
+      } catch (err) {
+        lastError = err;
+        if (err instanceof TimeoutError)
+          throw err;
+        if (attempt < maxAttempts) {
+          await sleep(retry.backoffMs(attempt));
+          continue;
+        }
+        throw err;
+      }
+      if (res.ok)
+        return await parseBody(res);
+      if (isTransientStatus(res.status) && attempt < maxAttempts) {
+        lastError = new ApiError(`daemon returned ${res.status} for ${req.path}`, res.status, await safeBody(res));
+        await sleep(retry.backoffMs(attempt));
+        continue;
+      }
+      throw new ApiError(`daemon returned ${res.status} for ${req.path}`, res.status, await safeBody(res));
+    }
+    if (lastError !== void 0)
+      throw lastError;
+    throw new NetworkError(`request to ${req.path} failed after ${maxAttempts} attempts`);
+  }
+  async function parseBody(res) {
+    const text = await res.text();
+    if (text.length === 0)
+      return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  async function safeBody(res) {
+    try {
+      return await parseBody(res);
+    } catch {
+      return void 0;
+    }
+  }
+  const memory = {
+    async search(query, o) {
+      const body = await request({
+        method: "POST",
+        path: "/api/memories/recall",
+        body: o?.limit !== void 0 ? { query, limit: o.limit } : { query }
+      });
+      if (body?.results !== void 0)
+        return body.results;
+      return (body?.hits ?? []).map((h) => ({
+        path: h.id ?? "",
+        text: h.text ?? "",
+        ...h.score !== void 0 ? { score: h.score } : {}
+      }));
+    },
+    async store(text, o) {
+      await request({
+        method: "POST",
+        path: "/api/memories",
+        body: o?.path !== void 0 ? { content: text, normalizedContent: o.path } : { content: text }
+      });
+    },
+    async get(path) {
+      return await request({
+        method: "GET",
+        path: `/api/memories/${encodeURIComponent(path)}`
+      });
+    },
+    async list(prefix) {
+      const qs = prefix !== void 0 ? `?prefix=${encodeURIComponent(prefix)}` : "";
+      const body = await request({
+        method: "GET",
+        path: `/api/memories${qs}`
+      });
+      return body?.results ?? [];
+    }
+  };
+  const hooks = {
+    async call(endpoint, body) {
+      return await request({ method: "POST", path: `/api/hooks/${endpoint}`, body });
+    }
+  };
+  const connectors = {
+    async list() {
+      return await listOf("/api/connectors");
+    }
+  };
+  const documents = {
+    async list() {
+      return await listOf("/api/documents");
+    }
+  };
+  const sources = {
+    async list() {
+      return await listOf("/api/sources");
+    }
+  };
+  const skills = {
+    async list() {
+      return await listOf("/api/skills");
+    }
+  };
+  const goals = {
+    async list() {
+      return await listOf("/api/goals");
+    },
+    async add(goal) {
+      await request({ method: "POST", path: "/api/goals", body: { goal } });
+    }
+  };
+  const health = {
+    async check() {
+      const body = await request({ method: "GET", path: "/health" });
+      return { ok: body?.ok === true || body?.status === "ok" };
+    }
+  };
+  async function listOf(path) {
+    const body = await request({ method: "GET", path });
+    if (Array.isArray(body))
+      return body;
+    if (body !== null && typeof body === "object") {
+      const values = Object.values(body);
+      const arr = values.find((v) => Array.isArray(v));
+      if (Array.isArray(arr))
+        return arr;
+    }
+    return [];
+  }
+  const secrets = {
+    async list(prefix) {
+      const body = await request({ method: "GET", path: "/api/secrets" });
+      const names = body?.names ?? [];
+      const filtered = prefix !== void 0 ? names.filter((n) => n.startsWith(prefix)) : names;
+      return filtered.map((name) => ({ name }));
+    },
+    async exec(command) {
+      const body = await request({
+        method: "POST",
+        path: "/api/secrets/exec",
+        body: { command }
+      });
+      const redactedOutput = typeof body?.redactedOutput === "string" ? body.redactedOutput : SECRET_REDACTED;
+      return { redactedOutput };
+    }
+  };
+  return {
+    async remember(text, o) {
+      await memory.store(text, o);
+    },
+    async recall(query, o) {
+      return await memory.search(query, o);
+    },
+    memory,
+    hooks,
+    connectors,
+    documents,
+    sources,
+    skills,
+    goals,
+    health,
+    secrets
+  };
+}
+export {
+  ApiError,
+  DEFAULT_TIMEOUT_MS,
+  HoneycombError,
+  NetworkError,
+  SECRET_REDACTED,
+  TimeoutError,
+  createHoneycombClient,
+  defaultRetryPolicy,
+  isTokenTransportSafe,
+  notImplemented
+};

package/sdk/openai.js

@@ -0,0 +1,63 @@
+// dist/src/sdk/openai.js
+var OPENAI_TOOL_RECALL = "honeycomb_recall";
+var OPENAI_TOOL_REMEMBER = "honeycomb_remember";
+function createOpenAiTools() {
+  return [
+    {
+      type: "function",
+      function: {
+        name: OPENAI_TOOL_RECALL,
+        description: "Recall relevant memories from Honeycomb for a query.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "The text to recall memories for." },
+            limit: { type: "number", description: "Max results to return." }
+          },
+          required: ["query"],
+          additionalProperties: false
+        }
+      }
+    },
+    {
+      type: "function",
+      function: {
+        name: OPENAI_TOOL_REMEMBER,
+        description: "Store a memory in Honeycomb.",
+        parameters: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "The memory text to store." },
+            path: { type: "string", description: "Optional memory path to store under." }
+          },
+          required: ["text"],
+          additionalProperties: false
+        }
+      }
+    }
+  ];
+}
+async function dispatchOpenAiToolCall(client, name, args) {
+  const a = args !== null && typeof args === "object" ? args : {};
+  switch (name) {
+    case OPENAI_TOOL_RECALL: {
+      const query = String(a.query ?? "");
+      const limit = typeof a.limit === "number" ? a.limit : void 0;
+      return await client.recall(query, limit !== void 0 ? { limit } : void 0);
+    }
+    case OPENAI_TOOL_REMEMBER: {
+      const text = String(a.text ?? "");
+      const path = typeof a.path === "string" ? a.path : void 0;
+      await client.remember(text, path !== void 0 ? { path } : void 0);
+      return { ok: true };
+    }
+    default:
+      throw new Error(`dispatchOpenAiToolCall: unknown tool "${name}"`);
+  }
+}
+export {
+  OPENAI_TOOL_RECALL,
+  OPENAI_TOOL_REMEMBER,
+  createOpenAiTools,
+  dispatchOpenAiToolCall
+};

package/sdk/package.json

@@ -0,0 +1 @@
+{"type":"module"}