@volter/twin-pinecone 0.1.0

package/src/index.ts

@@ -0,0 +1,91 @@
+// @volter/twin-pinecone — the Pinecone (pinecone.io) vector-database API twin, built on the
+// shared @volter/world-core kernel. Host-split REST transport: control plane (api.pinecone.io — index/
+// collection management) + per-index data plane (a minted host — vector upsert/fetch/update/
+// delete, REAL cosine/dotproduct/euclidean similarity query with a REAL Mongo-style metadata
+// filter, namespaces, describe_index_stats). State lives entirely in the kernel action log (no
+// side-store). API-first vendor: no mirror, no UI capabilities (ui-scope.json).
+//
+// INTEGRATED EMBEDDING IS A TODO: callers supply their own vectors today. The QUERY itself is a
+// genuine strong done: exact brute-force top-K is a faithful, CORRECT superset of Pinecone's
+// approximate-NN recall (see README ## Coverage). (Conformance/capability tooling lives in @volter/world-tooling, a dev dependency —
+// NOT shipped.)
+export {
+  handlePineconeTwinRequest,
+  routePineconeSurface,
+  mintHost,
+  recoverIndexFromHost,
+  pineconeTwinSnapshot,
+  PINECONE_RESOURCE_TYPES,
+} from './pinecone-twin.ts';
+export type {
+  PineconeRequest,
+  PineconeResponse,
+  PineconeSurface,
+  PineconeResourceType,
+  PineconeTwinSnapshot,
+} from './pinecone-twin.ts';
+export { createPineconeTwinFetch, createPineconeTwinServer, type PineconeTwinFetchOptions } from './pinecone-server.ts';
+export {
+  mapIndex,
+  mapVector,
+  pullPineconeIndexes,
+  pullPineconeVectors,
+  syncPineconeFromReal,
+} from './pinecone-connector.ts';
+export type { PineconeLikeClient, PineconeRealIndex, PineconeRealVector, PineconeBudgetedOptions } from './pinecone-connector.ts';
+// The client-side rate budget — the fail-closed backstop every live call goes through. The
+// MECHANISM is the kernel's shared, vendor-agnostic `RateBudget`; what lives here is this vendor's
+// DECLARATION (window/ceiling/per-method weights) plus `guardPineconeClient`, the choke point the
+// connector entrypoints apply unconditionally. Exported so an operator can inspect spend
+// (`snapshot`) and a caller can catch `PineconeBudgetError` by type; there is deliberately no export
+// that disables the guard.
+export {
+  PINECONE_BUDGETED_METHODS,
+  PINECONE_BUDGET_CEILING,
+  PINECONE_BUDGET_MAX_RETRY_AFTER_S,
+  PINECONE_BUDGET_WINDOW_MS,
+  PINECONE_CALL_WEIGHTS,
+  PINECONE_RATE_BUDGET,
+  PineconeBudget,
+  PineconeBudgetError,
+  pineconeBudgetPath,
+  pineconeCallWeight,
+  pineconeClientBudget,
+  guardPineconeClient,
+} from './pinecone-budget.ts';
+export type { PineconeBudgetErrorKind, PineconeBudgetOptions, PineconeBudgetReservation, PineconeBudgetSnapshot } from './pinecone-budget.ts';
+export { matchesFilter } from './pinecone-filter.ts';
+export type { PineconeFilter } from './pinecone-filter.ts';
+export { cosineSimilarity, dotProduct, squaredEuclideanDistance, scoreVector, sortByScore } from './pinecone-similarity.ts';
+export type { PineconeMetric } from './pinecone-similarity.ts';
+
+// Registry descriptor: the pack self-describes so tooling can discover it.
+import type { TwinPack } from '@volter/world-core';
+import { PINECONE_RATE_BUDGET as RATE_BUDGET } from './pinecone-budget.ts';
+export const pack: TwinPack = {
+  // The SAME object pinecone-budget.ts declares at module load — one source of truth, so registering
+  // the pack and importing the connector can never arm two different ceilings.
+  rateBudget: RATE_BUDGET,
+  vendor: 'pinecone',
+  transport: 'rest',
+  archetype: 'crud',
+  bin: 'world-pinecone',
+  resources: ['index', 'collection', 'vector'],
+  specSource: 'pinecone-conformance.ts (endpoint/resource inventory grounded against the installed @pinecone-database/pinecone SDK\'s own generated TypeScript-fetch client, fetched read-only via npm during the build — see spec-sources.json)',
+  description: 'Pinecone vector-database twin — index/collection management (control plane), vector upsert/fetch/update/delete, REAL brute-force cosine/dotproduct/euclidean similarity query with a REAL Mongo-style metadata filter evaluator, namespaces, describe_index_stats, host-split control/data-plane routing. Kernel-backed. No mirror (API-first vendor).',
+  browserRouting: { apiPathPrefix: '/', loaderHost: 'https://api.pinecone.io' },
+  // INTERCEPTION RULING — hostsNone, the pack's own home for it: control/data host split with
+  // per-index data-plane hostnames ({index}-{project}.svc.{env}.pinecone.io, see the pack
+  // README) — SDK is pointed at the twin by explicit host config.
+  hostsNone:
+    "control/data host split with per-index data-plane hostnames ({index}-{project}.svc.{env}.pinecone.io, see the pack README) — SDK is pointed at the twin by explicit host config",
+  // Adoption, moved off the central maps unchanged (descriptor-first back-migration, adding-a-twin.md §3,
+  // 2026-08-31).
+  adoption: {
+    // Pinecone's official Python SDK under its current name and its deprecated one - repos carry both.
+    pypi: ['pinecone', 'pinecone-client'],
+    sdks: ['@pinecone-database/pinecone'],
+    scopes: ['@pinecone-database/'],
+    envStems: ['PINECONE'],
+  },
+};

package/src/pinecone-budget.ts

@@ -0,0 +1,457 @@
+// Pinecone's CLIENT-SIDE RATE BUDGET — the pack's DECLARATION (the numbers) plus `guardPineconeClient`,
+// the choke point every live Pinecone call goes through. The MECHANISM — the durable token-keyed
+// ledger, the rolling window, reserve-under-lock, the `Retry-After`/429 cooldown, fail-CLOSED on a
+// corrupt ledger — lives ONCE in the vendor-agnostic kernel (`@volter/world-core` → `rateBudget.ts`).
+// Read that module's header for the full rationale AND for the honest list of what the guard does
+// NOT guarantee (an injected clock or ledger path still defeats it — it guards carelessness, not
+// malice). This module is modeled on notion-budget.ts, the reference injected-client decorator.
+//
+// ── WHY PINECONE NEEDS ONE ──────────────────────────────────────────────────────────
+// Pinecone publishes a detailed DATA-PLANE limits table (docs.pinecone.io/reference/api/
+// database-limits): per namespace per second, Query/Upsert/Delete/Update 100 each, and update- or
+// delete-by-metadata only 5/s; per index per second, List 200, Fetch 100, DescribeIndexStats 100;
+// per project, Inference 100/s and 2000/min. Its 429 body names the namespace and the QPS limit.
+// But the CONTROL PLANE — `listIndexes` / `describeIndex`, which is what this connector's index pull
+// actually calls — has NO published row at all. And this connector's `listVectors` is not one vendor
+// endpoint but an AGGREGATION: a real implementation loops `listIndexes()` then `listPaginated()` per
+// index per namespace, so a single call fans out across the whole project.
+//
+// ── HOW THE CEILING WAS CHOSEN ──────────────────────────────────────────────────────────────
+// The control-plane endpoint this connector calls has NO PUBLISHED LIMIT, so the ceiling is not
+// derived from Pinecone's data-plane table (which would be far looser: List alone is 200/s per index).
+// It is pinned to the kernel's conservative fallback instead (DEFAULT_RATE_BUDGET: 60 weighted units
+// / 60s at weight 2 = 30 calls/minute) — no more permissive than an undeclared vendor already gets.
+// Worth recording: the tightest documented Pinecone figure is 5/s for by-metadata mutations, 20x
+// tighter than plain ops, so "Pinecone is generous" is only true endpoint by endpoint.
+//
+// ── WHAT THIS DOES NOT DO: PACE ─────────────────────────────────────────────────────────────
+// It bounds the 60s AVERAGE; it does NOT bound the instantaneous rate. The window has no
+// spacing, so a tight `await` loop can legitimately fire the whole allowance in a fraction of a
+// second. In that shape the vendor's own 429 can arrive BEFORE this ceiling does, and the backstop
+// is then the COOLDOWN: the guard reads the back-off off the thrown error (or the response's
+// exhaustion headers) and refuses every later call without touching the vendor. So the honest claim
+// is "bounds the 60s average, and converts the vendor's first 429 into a hard stop" — never
+// "refuses before the vendor ever 429s". Pacing is the CALLER's job; this module REFUSES, it never
+// sleeps (see the kernel header: it is deliberately not a scheduler). A tighter window would not
+// close the gap, it would only turn every legitimate multi-page pull into a cascade of refusals.
+//
+// ── HOW THE WEIGHTS WERE CHOSEN (and what is a judgement call) ──────────────────────────────
+// `listVectors` costs 4, twice `listIndexes`. A JUDGEMENT CALL about THIS CONNECTOR's shape rather
+// than a published cost: `listVectors` is the pack's own aggregation shape (see
+// pinecone-connector.ts's header), and behind it a real implementation walks every index and every
+// namespace with a cursor, so one call is an unbounded number of requests. Doubling its price halves
+// how far a runaway walk gets while barely touching a normal pull.
+import {
+  declareRateBudget,
+  rateBudgetPath,
+  rateBudgetWeight,
+  RateBudget,
+  RateBudgetError,
+  type RateBudgetDeclaration,
+  type RateBudgetOptions,
+  type RateBudgetReservation,
+  type RateBudgetSnapshot,
+} from '@volter/world-core';
+import type { PineconeLikeClient } from './pinecone-connector.ts';
+
+const VENDOR = 'pinecone';
+
+/** Rolling window, in ms. Spend older than this is pruned. */
+export const PINECONE_BUDGET_WINDOW_MS = 60_000;
+
+/** Weighted units allowed inside one window. See the header for where this number comes from. */
+export const PINECONE_BUDGET_CEILING = 60;
+
+/** Seconds. A `Retry-After` above this means the credential is throttled hard — fail loudly. */
+export const PINECONE_BUDGET_MAX_RETRY_AFTER_S = 300;
+
+/** Per-call cost, keyed by the client method the guard is about to invoke. See the header. */
+export const PINECONE_CALL_WEIGHTS = {
+  /** `listVectors` — the per-index, per-namespace paginated aggregation. */
+  fanout: 4,
+  /** Every other modeled call (`listIndexes`, and anything unclassified). */
+  other: 2,
+} as const;
+
+/**
+ * The client methods this pack PRICES BY NAME, as dotted paths into the injected client.
+ *
+ * Two kinds of entry: (a) every method this connector actually calls, and (b) an endpoint the
+ * VENDOR documents in a distinct tier which a consumer can reach through the guarded client even
+ * though this connector never calls it (see the weights section of the header). Used to build the
+ * guarded surface — and, in the pack's own suite, the counting fake.
+ *
+ * NOT a closed list, and not a claim about the injected client's shape. A path the real client does
+ * not have is SKIPPED (this connector's members are optional; inventing one would turn "observe
+ * nothing" into "call something that isn't there"), and a method absent from this list is still
+ * PRICED at `defaultWeight` when a caller reaches for it — an unmodeled endpoint must never be
+ * free, and dropping one would be worse than free because it would be invisible.
+ */
+export const PINECONE_BUDGETED_METHODS = [
+  'listIndexes',
+  'listVectors',
+] as const;
+
+/** THE PACK'S DECLARATION — pure data, the only Pinecone-specific thing in the whole budget. */
+export const PINECONE_RATE_BUDGET: RateBudgetDeclaration = {
+  windowMs: PINECONE_BUDGET_WINDOW_MS,
+  ceiling: PINECONE_BUDGET_CEILING,
+  defaultWeight: PINECONE_CALL_WEIGHTS.other,
+  maxRetryAfterSeconds: PINECONE_BUDGET_MAX_RETRY_AFTER_S,
+  // Ordered: the kernel prices FIRST-MATCH-WINS, so the tightest tier is listed first.
+  rules: [
+    { match: "(^|\\.)listVectors$", weight: PINECONE_CALL_WEIGHTS.fanout },
+  ],
+  reason:
+    "Pinecone publishes a detailed DATA-plane limits table (per namespace/s: query/upsert/delete/update 100, " +
+    "by-metadata mutations only 5; per index/s: List 200, Fetch 100) but NO limit at all for the CONTROL-plane " +
+    "listIndexes/describeIndex this connector calls. With no documented figure for the endpoint actually used, " +
+    "this ceiling is pinned to the kernel's conservative fallback (60 units / 60s at weight 2 = 30 calls/min) " +
+    "rather than borrowed from the looser data-plane rows — no more permissive than an undeclared vendor " +
+    "already gets. listVectors costs 4 because it is this pack's own cross-index, per-namespace paginated " +
+    "aggregation, not a single vendor endpoint — a judgement call, not a published cost. Pinecone's limits page " +
+    "does not document Retry-After; the 429/exhaustion cooldown is the backstop.",
+};
+
+// Declared at module load, so merely importing this module (which `pinecone-connector.ts` does) is
+// enough to arm the real ceiling. A budget constructed BEFORE this runs falls back to the kernel's
+// DEFAULT_RATE_BUDGET — which is tighter in call COUNT but prices every call at 2, so for a vendor
+// with an expensive endpoint the fallback is CHEAPER there, not safer. `RateBudget` reads its policy
+// LIVE precisely so this declaration takes effect the moment it lands, and constructing through the
+// subclass below (whose module IS this one) makes the ordering a non-issue in practice.
+declareRateBudget(VENDOR, PINECONE_RATE_BUDGET);
+
+/** Price one Pinecone call by its client method key (a dotted path, e.g. `listIndexes`). */
+export function pineconeCallWeight(method: string): number {
+  return rateBudgetWeight(VENDOR, method);
+}
+
+/** Where Pinecone's ledger lives. Token-keyed and cwd-independent by default (the vendor limits per
+ *  credential, so a cwd-scoped ledger would hand the same credential a fresh allowance in every
+ *  checkout, worktree and CI matrix leg); pass `root` to opt into world-scoped accounting. */
+export function pineconeBudgetPath(opts: { root?: string; token?: string } | string = {}): string {
+  const o = typeof opts === 'string' ? { root: opts } : opts;
+  // VENDOR spread LAST: a loosely-typed `{ vendor: 'other', … }` slipping through (TypeScript's
+  // excess-property check only catches object literals) must not redirect this pack's ledger to
+  // another vendor's file.
+  return rateBudgetPath({ ...o, vendor: VENDOR });
+}
+
+/** Construction options for Pinecone's budget. The vendor is fixed; everything else may only TIGHTEN. */
+export type PineconeBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+
+/**
+ * Pinecone's budget — the shared kernel guard bound to this vendor's declaration. A real subclass,
+ * not an alias, so `budget instanceof PineconeBudget` means "a budget that accounts against this
+ * vendor's ledger under this vendor's ceiling": another vendor's `RateBudget` (with its own,
+ * possibly larger, ceiling) is NOT assignable where one of these is required.
+ */
+export class PineconeBudget extends RateBudget {
+  constructor(opts: PineconeBudgetOptions = {}) {
+    super({ ...opts, vendor: VENDOR });
+  }
+}
+
+export type { RateBudgetErrorKind as PineconeBudgetErrorKind } from '@volter/world-core';
+export { RateBudgetError as PineconeBudgetError } from '@volter/world-core';
+export type PineconeBudgetReservation = RateBudgetReservation;
+export type PineconeBudgetSnapshot = RateBudgetSnapshot;
+
+/** What every budgeted connector entrypoint accepts. There is deliberately no option that turns the
+ *  guard OFF — only ones that say WHICH ledger and clock to account against. */
+export type PineconeBudgetedOptions = {
+  /** An existing budget to share across calls. Omit and one is constructed. Cannot be null. */
+  budget?: PineconeBudget;
+  /** Construction options for the default budget (ledger path, clock). Cannot loosen it. */
+  budgetOptions?: PineconeBudgetOptions;
+};
+
+/** Pull the budget wiring out of a caller's opts bag, so an entrypoint can forward it verbatim. */
+export function pineconeBudgetOf(opts: PineconeBudgetedOptions): PineconeBudgetedOptions {
+  return {
+    ...(opts.budget !== undefined ? { budget: opts.budget } : {}),
+    ...(opts.budgetOptions !== undefined ? { budgetOptions: opts.budgetOptions } : {}),
+  };
+}
+
+// ── the choke point ─────────────────────────────────────────────────────────────────────────
+
+/**
+ * Marks a client this module has already wrapped, so guarding twice cannot charge twice.
+ *
+ * A MODULE-PRIVATE `Symbol()`, deliberately not `Symbol.for()`: a global-registry symbol is
+ * reachable BY NAME, so any caller could stamp `client[Symbol.for(…)] = anything` on a RAW client and
+ * the guard would hand it straight back UNGUARDED — a one-line bypass of the whole budget. With a
+ * private symbol the only way to be branded is to have been wrapped by this function. The cost is
+ * that two copies of this module in one dependency tree would each wrap (double-charging a call);
+ * that is the SAFE direction, and over-charging is the tradeoff this module takes everywhere else.
+ */
+const GUARDED: unique symbol = Symbol('@volter/twin-pinecone.budget.guarded');
+
+type Guarded = { [GUARDED]?: unknown };
+
+/** Is this client already behind a budget? Returns the budget it is behind, if so. */
+export function pineconeClientBudget(client: unknown): RateBudget | undefined {
+  const mark = (client as Guarded | null)?.[GUARDED];
+  // Belt and braces: only a REAL budget counts as "already guarded". A non-RateBudget value here
+  // could only come from a forged brand, and the answer to a forgery is to wrap anyway.
+  return mark instanceof RateBudget ? mark : undefined;
+}
+
+/** Charge a call keyed by `method`, invoke it, settle. Returns whatever the call returned. */
+type Charge = (method: string, invoke: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown;
+
+/**
+ * Wrap an INJECTED Pinecone client so EVERY call it makes is charged against the shared budget
+ * BEFORE the request goes out. This pack's connector never constructs the transport itself (the
+ * consumer injects a client that satisfies `PineconeLikeClient` structurally), so the guard is a
+ * DECORATOR rather than a factory — which is exactly why every connector entrypoint applies it
+ * UNCONDITIONALLY instead of trusting the caller to have done it.
+ *
+ * IDEMPOTENT: wrapping an already-guarded client returns it unchanged, so a caller who forgot is
+ * protected and a caller who wrapped deliberately is not double-charged.
+ *
+ * A method that THROWS is still inspected: an SDK typically RAISES on a 429 rather than returning
+ * it, and that error's back-off is exactly the signal that must become a persisted cooldown. Losing
+ * it would leave the ledger cheerfully spending into a throttled credential. The original error is
+ * always re-raised afterwards — the budget never swallows a vendor failure — EXCEPT when the
+ * back-off is beyond the cap, where the budget's own louder "stop calling" error takes precedence.
+ */
+export function guardPineconeClient(client: PineconeLikeClient, opts: PineconeBudgetedOptions = {}): PineconeLikeClient {
+  // There is no value a caller can pass to end up with an UNGUARDED client. `null`/`undefined` (or
+  // omitting it) build the default budget; anything that is not a REAL `PineconeBudget` is refused
+  // loudly rather than trusted — a duck-typed stand-in with a no-op `checkBudget` would otherwise be
+  // the one clean way around the guard. Validated BEFORE the already-guarded early return, so
+  // `guardPineconeClient(alreadyGuarded, { budget: impostor })` is refused too rather than silently
+  // ignoring the impostor.
+  if (opts.budget !== undefined && opts.budget !== null && !(opts.budget instanceof PineconeBudget)) {
+    throw new Error('guardPineconeClient: `budget` must be a PineconeBudget — refusing to guard a Pinecone client with an unverified rate guard');
+  }
+  if (pineconeClientBudget(client)) return client;
+  const budget = opts.budget instanceof PineconeBudget
+    ? opts.budget
+    : new PineconeBudget({
+      // The default ledger is keyed by a hash of the credential — the vendor limits per credential,
+      // so a cwd-scoped ledger would hand it a fresh allowance per worktree/CI leg.
+      //
+      // HONESTLY: this pack does NOT hold the credential — the consumer's injected client does — so
+      // `PINECONE_API_KEY` is a BEST-EFFORT stand-in for it, not the real thing. If that env var names a
+      // different account than the injected client, spend is booked against the wrong ledger; if it
+      // is unset, every unattributed Pinecone credential on the machine shares one (over-tight,
+      // which is the safe direction). A caller who knows the credential should say so:
+      // `budgetOptions: { token }` overrides this, and does so deliberately last in the spread.
+      ...(process.env.PINECONE_API_KEY !== undefined ? { token: process.env.PINECONE_API_KEY } : {}),
+      ...(opts.budgetOptions ?? {}),
+    });
+
+  /** Settle a reservation from whatever the call produced. May THROW (a back-off past the cap). */
+  const settle = (weight: number, reservation: RateBudgetReservation, v: unknown): void => {
+    const status = responseStatus(v);
+    const headers = responseHeaders(v);
+    if (status !== undefined || headers !== undefined) budget.recordCall(weight, headers, { status, reservation });
+    else budget.recordCall(weight, undefined, { reservation });
+  };
+
+  /**
+   * Settle once the call RESOLVED: the vendor has answered. recordCall arms any cooldown before
+   * it throws (a back-off beyond the cap), so that refusal is swallowed and the answer kept — a
+   * write the vendor accepted is never reported failed and performed again on retry. A resolved
+   * answer that carries a non-2xx status still lets the louder refusal win.
+   */
+  const settleAnswered = (weight: number, reservation: RateBudgetReservation, v: unknown): void => {
+    try {
+      settle(weight, reservation, v);
+    } catch (e) {
+      const status = responseStatus(v);
+      if (!(e instanceof RateBudgetError) || (status !== undefined && (status < 200 || status >= 300))) throw e;
+    }
+  };
+
+  /**
+   * Charge, call, settle — for a MODELED method, whose interface declares it `async`. Refusing
+   * REJECTS rather than throwing synchronously, so `client.x().catch(…)` behaves exactly as it does
+   * on an unguarded client. `checkBudget` RESERVES under lock, so nothing after its line runs when
+   * the budget refuses: the request is never made.
+   */
+  const chargeAsync = (method: string, invoke: (...args: unknown[]) => unknown) =>
+    async (...args: unknown[]): Promise<unknown> => {
+      const weight = budget.weightFor(method);
+      const reservation = budget.checkBudget(weight);
+      try {
+        const res = await invoke(...args);
+        settleAnswered(weight, reservation, res);
+        return res;
+      } catch (e) {
+        settle(weight, reservation, e); // may throw its own louder refusal, which wins
+        throw e;
+      }
+    };
+
+  /**
+   * Charge, call, settle — for an UNMODELED member reached through the passthrough Proxy, where the
+   * shape is unknown.
+   *
+   * Deliberately NOT `async`. Some vendor SDKs (twilio-shaped ones) build requests through
+   * SYNCHRONOUS chained accessors — `client.a.b('sid').c.create()` — where the intermediate calls
+   * return a resource context, not a promise. An `async` wrapper would turn every one of those into
+   * a `Promise` and `.c` would come back `undefined`: the guard would BREAK the client instead of
+   * guarding it. So a non-thenable return is treated as an accessor — still charged (we cannot know
+   * before calling, and over-charging is the safe direction) and wrapped, so the eventual async leaf
+   * is charged too rather than escaping the budget. The cost of the sync shape is that a REFUSAL on
+   * this path throws synchronously instead of rejecting; that is the honest signal for an accessor,
+   * and the modeled surface above (every method this connector actually calls) does not have it.
+   */
+  const charge: Charge = (method, invoke) => (...args) => {
+    const weight = budget.weightFor(method);
+    const reservation = budget.checkBudget(weight);
+    let out: unknown;
+    try {
+      out = invoke(...args);
+    } catch (e) {
+      settle(weight, reservation, e); // may throw its own louder refusal, which wins
+      throw e;
+    }
+    if (!isThenable(out)) {
+      settle(weight, reservation, undefined);
+      return out !== null && (typeof out === 'object' || typeof out === 'function')
+        ? proxyThrough({}, out as object, method, charge)
+        : out;
+    }
+    return out.then(
+      (res) => { settleAnswered(weight, reservation, res); return res; },
+      (e: unknown) => { settle(weight, reservation, e); throw e; },
+    );
+  };
+
+  // Build the charged surface from PINECONE_BUDGETED_METHODS (see its docstring for why an absent path is
+  // SKIPPED rather than stubbed).
+  const guarded: Record<string, unknown> & Guarded = {};
+  for (const path of PINECONE_BUDGETED_METHODS) {
+    const segs = path.split('.');
+    const leaf = segs[segs.length - 1]!;
+    let owner: Record<string, unknown> | undefined = client as unknown as Record<string, unknown>;
+    for (const seg of segs.slice(0, -1)) owner = owner?.[seg] as Record<string, unknown> | undefined;
+    if (typeof owner?.[leaf] !== 'function') continue;
+    const realOwner = owner;
+    let node: Record<string, unknown> = guarded;
+    for (const seg of segs.slice(0, -1)) node = (node[seg] ??= {}) as Record<string, unknown>;
+    // The method is resolved at CALL time, not here, so a client whose method is swapped later is
+    // still charged for whatever it actually runs.
+    node[leaf] = chargeAsync(path, (...args) => (realOwner[leaf] as (...a: unknown[]) => unknown).apply(realOwner, args));
+  }
+  Object.defineProperty(guarded, GUARDED, { value: budget, enumerable: false });
+
+  // The surface above is what this connector calls. A real client has MORE — and a consumer who
+  // needs any of it must not be forced to keep the RAW client alongside, because every call through
+  // that would be unbudgeted. So the guarded object is a Proxy: known members come from the map
+  // above, anything else is taken from the real client and PRICED at `defaultWeight`.
+  return proxyThrough(guarded, client as object, '', charge) as PineconeLikeClient;
+}
+
+/**
+ * Members JavaScript itself asks for. Wrapping any of these turns the object into something that
+ * looks thenable / mis-reports its own identity, which breaks `await`, `instanceof` and logging —
+ * so they always come from the target untouched, never priced.
+ */
+const NEVER_WRAP = new Set(['then', 'catch', 'finally', 'constructor', 'prototype', 'toJSON', 'toString', 'valueOf', 'inspect']);
+
+/** Does this look like a promise? (Only a thenable gets the settle-on-resolution treatment.) */
+function isThenable(v: unknown): v is Promise<unknown> {
+  return v !== null && (typeof v === 'object' || typeof v === 'function') && typeof (v as { then?: unknown }).then === 'function';
+}
+
+/**
+ * Symbols that name an ITERATION PROTOCOL. Reaching for one of these on a vendor object is how a
+ * paginator is driven (`for await (const page of client.things.list())`), i.e. it is the doorway to
+ * an unbounded sequence of REQUESTS — exactly what this budget exists to bound — so they are charged
+ * and their result is kept behind the proxy. Every other symbol (`Symbol.toStringTag`,
+ * `nodejs.util.inspect.custom`, …) is metadata rather than a request and passes through untouched.
+ */
+const ITERATOR_SYMBOLS = new Set<symbol>([Symbol.asyncIterator, Symbol.iterator]);
+
+/**
+ * Serve `known` where it has the member; otherwise price a passthrough to `real`. Applied
+ * recursively, so a namespace member this pack never modeled is charged at `defaultWeight` rather
+ * than coming back `undefined`.
+ *
+ * CALLABLE NAMESPACES (§9 finding): a member can be BOTH a function and a namespace — twilio's
+ * `client.messages` is called as `client.messages(sid)` to get one message's context AND read as
+ * `client.messages.list()`. An earlier version returned the modeled node as a plain object whenever
+ * this pack modeled any child of it, which silently DROPPED the call signature and every unmodeled
+ * sibling — the module's own docstring calls a dropped member "worse than free, because it is
+ * invisible", and that is what it was doing. So when `real` is callable the proxy target is a
+ * function and an `apply` trap charges the call, while `known` stays the source of modeled members.
+ */
+function proxyThrough(known: object, real: object, prefix: string, charge: Charge, owner?: object): object {
+  const callable = typeof real === 'function';
+  // The target must itself be callable for the `apply` trap to exist at all. `known` stays the
+  // source of modeled members, read explicitly below rather than through the target.
+  const target: object = callable ? function proxied() { /* every call goes through the trap */ } : known;
+  return new Proxy(target, {
+    apply(_t, _thisArg, args: unknown[]) {
+      // Calling the namespace is itself a request-builder hop: charge it, and keep the result
+      // behind the proxy (charge() re-proxies a non-thenable) so the eventual leaf is charged too.
+      // `owner` is the object the function was read from — dropping it would silently break every
+      // method that relies on `this`.
+      return charge(prefix || 'call', (...a) => (real as (...x: unknown[]) => unknown).apply(owner, a))(...args);
+    },
+    get(_t, prop, receiver) {
+      if (typeof prop === 'symbol') {
+        const ownSym = Reflect.get(known, prop, receiver);
+        if (ownSym !== undefined) return ownSym; // the GUARDED brand, and anything we model
+        const fromSym = (real as Record<symbol, unknown> | null)?.[prop];
+        if (ITERATOR_SYMBOLS.has(prop) && typeof fromSym === 'function') {
+          return charge(`${prefix}[${prop.description ?? 'iterator'}]`, (...args) => (fromSym as (...a: unknown[]) => unknown).apply(real, args));
+        }
+        return fromSym;
+      }
+      const name = String(prop);
+      if (NEVER_WRAP.has(name)) return Reflect.get(known, prop, receiver);
+      const key = prefix ? `${prefix}.${name}` : name;
+      const own = Reflect.get(known, prop, receiver);
+      const from = (real as Record<string, unknown> | null)?.[name];
+      // A member we model: the charged wrapper (a function) or a namespace we must keep descending
+      // into, so an unmodeled sibling is still priced rather than dropped.
+      if (typeof own === 'function') return own;
+      if (own && typeof own === 'object') {
+        // `from` may be an object OR a CALLABLE namespace — both keep descending, which is what
+        // preserves `client.messages(sid)` alongside the modeled `client.messages.list()`.
+        return from && (typeof from === 'object' || typeof from === 'function')
+          ? proxyThrough(own, from, key, charge, real)
+          : own;
+      }
+      if (own !== undefined) return own;
+      // A member only the real client has. Functions go through proxyThrough too, so one that also
+      // carries members (a callable namespace) keeps both its call signature and its siblings.
+      if (typeof from === 'function') return proxyThrough({}, from, key, charge, real);
+      if (from && typeof from === 'object') return proxyThrough({}, from, key, charge, real);
+      return from;
+    },
+    has(_t, prop) {
+      return Reflect.has(known, prop) || (real !== null && Reflect.has(real, prop));
+    },
+  });
+}
+
+/** The HTTP status a value carries, if it looks like one (an SDK error, or a raw response). */
+function responseStatus(v: unknown): number | undefined {
+  const s = (v as { status?: unknown } | null)?.status;
+  return typeof s === 'number' && Number.isFinite(s) ? s : undefined;
+}
+
+/**
+ * Response/error headers as a plain lower-cased record, or `undefined` when there are none. Accepts
+ * a `Headers` instance, a `Map`, or a plain object — an SDK's error type changes shape across
+ * versions and none of the three is worth depending on.
+ */
+function responseHeaders(v: unknown): Record<string, string> | undefined {
+  const h = (v as { headers?: unknown } | null)?.headers;
+  if (!h || typeof h !== 'object') return undefined;
+  const out: Record<string, string> = {};
+  if (typeof (h as Headers).forEach === 'function') {
+    (h as Headers).forEach((value: string, key: string) => { out[String(key).toLowerCase()] = String(value); });
+  } else {
+    for (const [k, value] of Object.entries(h as Record<string, unknown>)) out[k.toLowerCase()] = String(value);
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}