@takk/racs 1.0.0

package/dist/integrations/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/integrations/index.ts"],"names":[],"mappings":";;;AAsEO,SAAS,eAAA,CACd,gBACA,OAAA,EACc;AACd,EAAA,OAAO;AAAA,IACL,MAAA,EAAQ,CAAC,OAAA,EAAS,MAAA,KAAiB,eAAe,YAAA,CAAa,OAAA,EAAS,SAAS,MAAM,CAAA;AAAA,IACvF,SAAS,CAAC,OAAA,KAAkB,cAAA,CAAe,aAAA,CAAc,SAAS,OAAO;AAAA,GAC3E;AACF;AAmDO,SAAS,cAAA,CACd,IAAA,EACA,QAAA,EACA,OAAA,EACY;AACZ,EAAA,MAAM,YAAA,GAAe,SAAS,uBAAA,IAA2B,CAAA;AACzD,EAAA,MAAM,MAAA,uBAAa,GAAA,EAAyB;AAC5C,EAAA,OAAO,IAAA,CAAK,EAAA,CAAG,CAAC,KAAA,KAAU;AACxB,IAAA,IAAI,KAAA,CAAM,SAAS,gBAAA,EAAkB;AACnC,MAAA,MAAM,OAAA,GAAU,MAAM,MAAA,CAAO,OAAA;AAC7B,MAAA,IAAI,YAAY,MAAA,EAAW;AACzB,QAAA;AAAA,MACF;AACA,MAAA,MAAM,QAAA,GAAW,KAAA,CAAM,MAAA,CAAO,iBAAA,CAAkB,KAAK,IAAI,CAAA;AACzD,MAAA,IAAI;AACF,QAAA,QAAA,CAAS,MAAA;AAAA,UACP,OAAA;AAAA,UACA,CAAA,qCAAA,EAAwC,QAAQ,CAAA,GAAA,EAC3C,KAAA,CAAM,OAAO,iBAAiB,CAAA,kCAAA;AAAA,SACrC;AAAA,MACF,CAAA,CAAA,MAAQ;AAAA,MAGR;AACA,MAAA,MAAA,CAAO,IAAI,OAAA,EAAS;AAAA,QAClB,SAAA,EAAW,MAAM,MAAA,CAAO,SAAA;AAAA,QACxB,WAAA,EAAa,CAAA;AAAA,QACb,QAAA,EAAU;AAAA,OACX,CAAA;AACD,MAAA;AAAA,IACF;AACA,IAAA,IAAI,KAAA,CAAM,SAAS,cAAA,EAAgB;AACjC,MAAA;AAAA,IACF;AAEA,IAAA,KAAA,MAAW,CAAC,OAAA,EAAS,KAAK,CAAA,IAAK,MAAA,EAAQ;AACrC,MAAA,IAAI,KAAA,CAAM,SAAA,KAAc,KAAA,CAAM,IAAA,CAAK,SAAA,EAAW;AAC5C,QAAA;AAAA,MACF;AACA,MAAA,IAAI,MAAM,QAAA,EAAU;AAGlB,QAAA,KAAA,CAAM,QAAA,GAAW,KAAA;AACjB,QAAA;AAAA,MACF;AACA,MAAA,KAAA,CAAM,WAAA,IAAe,CAAA;AACrB,MAAA,IAAI,KAAA,CAAM,eAAe,YAAA,EAAc;AACrC,QAAA,MAAA,CAAO,OAAO,OAAO,CAAA;AACrB,QAAA,IAAI;AACF,UAAA,QAAA,CAAS,QAAQ,OAAO,CAAA;AAAA,QAC1B,CAAA,CAAA,MAAQ;AAAA,QAER;AAAA,MACF;AACA,MAAA;AAAA,IACF;AAAA,EACF,CAAC,CAAA;AACH;AAmCA,SAAS,YAAA,CAAa,OAAmB,OAAA,EAAuD;AAC9F,EAAA,MAAM,IAAA,GAAO,OAAA,GAAU,KAAA,CAAM,KAAK,CAAA;AAClC,EAAA,IAAI,SAAS,MAAA,EAAW;AACtB,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,MAAM,OAAA,GAAU,MAAM,kBAAA,IAAsB,CAAA;AAC5C,EAAA,MAAM,OAAA,GAAU,MAAM,kBAAA,IAAsB,CAAA;AAC5C,EAAA,IAAI,OAAA,GAAU,CAAA,IAAK,IAAA,CAAK,mBAAA,KAAwB,MAAA,EAAW;AACzD,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,IAAI,OAAA,GAAU,CAAA,IAAK,IAAA,CAAK,mBAAA,KAAwB,MAAA,EAAW;AACzD,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,MAAM,QACJ,OAAA,IAAW,IAAA,CAAK,uBAAuB,CAAA,CAAA,GAAK,OAAA,IAAW,KAAK,mBAAA,IAAuB,CAAA,CAAA;AACrF,EAAA,OAAO,KAAA,GAAQ,GAAA;AACjB;AAoDO,SAAS,kBAAA,CACd,IAAA,EACA,UAAA,EACA,OAAA,EACY;AACZ,EAAA,MAAM,OAAA,GAAU,SAAS,OAAA,IAAW,YAAA;AACpC,EAAA,MAAM,UAAU,OAAA,EAAS,OAAA;AACzB,EAAA,OAAO,IAAA,CAAK,EAAA,CAAG,CAAC,KAAA,KAAU;AACxB,IAAA,IAAI,KAAA,CAAM,SAAS,gBAAA,EAAkB;AACnC,MAAA;AAAA,IACF;AACA,IAAA,MAAM,OAAA,GAAU,YAAA,CAAa,KAAA,CAAM,KAAA,EAAO,OAAO,CAAA;AACjD,IAAA,MAAM,IAAA,GAA6B;AAAA,MACjC,OAAA;AAAA,MACA,KAAA,EAAO,KAAA;AAAA,MACP,QAAA,EAAU;AAAA,QACR,GAAI,KAAA,CAAM,KAAA,CAAM,SAAA,KAAc,MAAA,GAAY,EAAE,SAAA,EAAW,KAAA,CAAM,KAAA,CAAM,SAAA,EAAU,GAAI,EAAC;AAAA,QAClF,GAAA,EAAK,KAAA,CAAM,GAAA,GAAM,MAAA,GAAS;AAAA,OAC5B;AAAA,MACA,GAAI,OAAA,KAAY,MAAA,GAAY,EAAE,OAAA,KAAY;AAAC,KAC7C;AACA,IAAA,IAAI;AACF,MAAA,UAAA,CAAW,QAAQ,IAAI,CAAA;AAAA,IACzB,CAAA,CAAA,MAAQ;AAAA,IAGR;AAAA,EACF,CAAC,CAAA;AACH;AA4CO,SAAS,iBAAiB,IAAA,EAAoC;AACnE,EAAA,OAAO;AAAA,IACL,YAAA,CAAa,MAAgC,OAAA,EAA4B;AACvE,MAAA,OAAO,KAAK,IAAA,CAAK,EAAE,GAAG,IAAA,EAAM,KAAA,EAAO,SAAS,CAAA;AAAA,IAC9C;AAAA,GACF;AACF;AAmDO,SAAS,aAAA,CACd,IAAA,EACA,OAAA,EACA,OAAA,EACY;AACZ,EAAA,MAAM,qBAAqB,MAAY;AACrC,IAAA,KAAA,MAAW,QAAA,IAAY,QAAQ,SAAA,EAAW;AACxC,MAAA,IAAA,CAAK,UAAA,CAAW,EAAE,QAAA,EAAU,CAAA;AAAA,IAC9B;AAAA,EACF,CAAA;AACA,EAAA,OAAA,CAAQ,EAAA,CAAG,eAAe,kBAAkB,CAAA;AAC5C,EAAA,OAAA,CAAQ,EAAA,CAAG,gBAAgB,kBAAkB,CAAA;AAC7C,EAAA,OAAO,MAAY;AACjB,IAAA,OAAA,CAAQ,GAAA,CAAI,eAAe,kBAAkB,CAAA;AAC7C,IAAA,OAAA,CAAQ,GAAA,CAAI,gBAAgB,kBAAkB,CAAA;AAAA,EAChD,CAAA;AACF","file":"index.cjs","sourcesContent":["/**\n * Sibling-package bridges of RACS (Remote Agent Context Store): four adapters wiring a\n * running engine to the rest of the @takk family, @takk/noeticos parameter tuning,\n * @takk/behavioralai behavioral observability, @takk/modelchain model routing, and\n * @takk/keymesh credential rotation.\n *\n * Optional-peer pattern: every sibling shape in this module is a LOCAL structural\n * interface. Nothing here imports a sibling package at runtime or at the type level, so\n * the siblings stay optional peer dependencies, the published real objects satisfy these\n * shapes structurally, and the zero-runtime-dependency invariant of the package survives\n * intact. Hosts pass ready instances in, exactly as they do with `KvLike` stores.\n *\n * Privacy posture, shared by every bridge: only prefix keys (hashes), token counts, USD\n * figures derived from counts, agent identifiers, and hit flags ever cross a bridge.\n * Prompt content never does, RACS never holds it in the first place.\n *\n * @packageDocumentation\n */\n\nimport type { CachePlan, CacheUsage, PlanInput, PricingTable, ProviderId, RACS } from '../types.js';\n\n/**\n * Structural freeze surface of a @takk/noeticos runtime, as {@link noeticosBridge}\n * consumes it.\n *\n * The published package exposes freezing as the module-level functions\n * `freezeTuning(runtime, agentId, reason)` and `releaseTuning(runtime, agentId)` next to\n * the `NoeticOS` runtime interface; {@link noeticosAdapter} folds that pair into this\n * object in one line. Any other tuning runtime can satisfy the same two methods directly.\n */\nexport interface NoeticOSLike {\n  /** Pauses parameter tuning for the agent, recording the reason in the audit trail. */\n  freeze(agentId: string, reason: string): void;\n  /** Resumes parameter tuning for the agent. Releasing a non-frozen agent is a no-op. */\n  release(agentId: string): void;\n}\n\n/**\n * Module shape of the real @takk/noeticos package, structurally: the two module-level\n * tuning functions the bridge needs. Members are method-style on purpose, method\n * parameters are checked bivariantly, so the published functions, whose first parameter\n * is the concrete `NoeticOS` runtime, satisfy `unknown` here without this module ever\n * naming the sibling type.\n */\nexport interface NoeticosModuleLike {\n  /** The published `freezeTuning(runtime, agentId, reason)`. */\n  freezeTuning(runtime: unknown, agentId: string, reason: string): void;\n  /** The published `releaseTuning(runtime, agentId)`. */\n  releaseTuning(runtime: unknown, agentId: string): void;\n}\n\n/**\n * Folds the real @takk/noeticos module surface into a {@link NoeticOSLike} bound to one\n * runtime, in one line per method.\n *\n * @param noeticosModule - The imported module, or any object carrying `freezeTuning` and\n *   `releaseTuning` with the published signatures.\n * @param runtime - The `NoeticOS` runtime the functions act on, opaque to this package.\n * @returns A {@link NoeticOSLike} bound to that runtime.\n *\n * @example\n * ```ts\n * import * as noeticos from '@takk/noeticos';\n * import { noeticosAdapter } from '@takk/racs/integrations';\n *\n * const runtime = noeticos.createNoeticOS();\n * const like = noeticosAdapter(noeticos, runtime);\n * like.freeze('support-agent', 'manual maintenance window');\n * ```\n */\nexport function noeticosAdapter(\n  noeticosModule: NoeticosModuleLike,\n  runtime: unknown,\n): NoeticOSLike {\n  return {\n    freeze: (agentId, reason): void => noeticosModule.freezeTuning(runtime, agentId, reason),\n    release: (agentId): void => noeticosModule.releaseTuning(runtime, agentId),\n  };\n}\n\n/** Per-agent freeze bookkeeping of {@link noeticosBridge}. */\ninterface FreezeState {\n  /** Prefix key the lineage drifted to, the baseline stable plans are counted against. */\n  prefixKey: string;\n  /** Consecutive zero-drift plans observed since the latest drift. */\n  stablePlans: number;\n  /** The drifting plan's own `'plan.created'` event is still pending and must not count. */\n  skipNext: boolean;\n}\n\n/**\n * Freezes @takk/noeticos parameter tuning across prompt-prefix discontinuities.\n *\n * Rationale: parameter tuning must not learn across a prefix discontinuity, the reward\n * landscape moved. A drifted prefix changes hit ratio, latency, and cost all at once, so\n * reward samples taken right after the drift would be credited to parameter choices that\n * had nothing to do with them.\n *\n * Behavior: on every `'prefix.drifted'` event carrying an agentId (it flows in from\n * {@link PlanInput.agentId}), the bridge freezes that agent with a reason naming the\n * changed segments, then counts subsequent `'plan.created'` events for the agent with\n * zero drift and releases after `releaseAfterStablePlans` of them (default 3). A new\n * drift during the count re-freezes, which refreshes the audit trail, and restarts the\n * count.\n *\n * Disposal: the returned function only unsubscribes from telemetry. Agents frozen at\n * that moment stay frozen, releasing tuning silently would be a policy decision only the\n * host can take.\n *\n * @example\n * ```ts\n * import * as noeticos from '@takk/noeticos';\n * import { createRACS } from '@takk/racs';\n * import { noeticosAdapter, noeticosBridge } from '@takk/racs/integrations';\n *\n * const racs = createRACS();\n * const runtime = noeticos.createNoeticOS();\n * const dispose = noeticosBridge(racs, noeticosAdapter(noeticos, runtime), {\n *   releaseAfterStablePlans: 3,\n * });\n * // Plans carrying an agentId now freeze that agent's tuning on prefix drift:\n * racs.plan({\n *   agentId: 'support-agent',\n *   provider: 'anthropic',\n *   model: 'claude-sonnet-4-5',\n *   segments: [{ id: 'system', role: 'system', stability: 'stable', content: SYSTEM }],\n * });\n * ```\n */\nexport function noeticosBridge(\n  racs: RACS,\n  noeticos: NoeticOSLike,\n  options?: { readonly releaseAfterStablePlans?: number },\n): () => void {\n  const releaseAfter = options?.releaseAfterStablePlans ?? 3;\n  const frozen = new Map<string, FreezeState>();\n  return racs.on((event) => {\n    if (event.type === 'prefix.drifted') {\n      const agentId = event.report.agentId;\n      if (agentId === undefined) {\n        return;\n      }\n      const segments = event.report.changedSegmentIds.join(', ');\n      try {\n        noeticos.freeze(\n          agentId,\n          `RACS prefix drift: changed segments [${segments}], ` +\n            `${event.report.invalidatedTokens} cached prefix tokens invalidated.`,\n        );\n      } catch {\n        // Telemetry listeners must not throw, see TelemetryListener; a failing sibling\n        // call is contained here instead of leaning on the engine's safety net.\n      }\n      frozen.set(agentId, {\n        prefixKey: event.report.prefixKey,\n        stablePlans: 0,\n        skipNext: true,\n      });\n      return;\n    }\n    if (event.type !== 'plan.created') {\n      return;\n    }\n    // The prefix key embeds the agent identity, so matching on it is matching the agent.\n    for (const [agentId, state] of frozen) {\n      if (state.prefixKey !== event.plan.prefixKey) {\n        continue;\n      }\n      if (state.skipNext) {\n        // The drifting plan emits 'prefix.drifted' first and 'plan.created' second; the\n        // skip flag keeps that plan from counting toward its own release.\n        state.skipNext = false;\n        break;\n      }\n      state.stablePlans += 1;\n      if (state.stablePlans >= releaseAfter) {\n        frozen.delete(agentId);\n        try {\n          noeticos.release(agentId);\n        } catch {\n          // Same containment as freeze above.\n        }\n      }\n      break;\n    }\n  });\n}\n\n/**\n * The synthetic turn {@link behavioralaiBridge} reports, a narrow structural slice of\n * the sibling's `TurnObservation`, field names verbatim from the published\n * @takk/behavioralai types.\n */\nexport interface CacheTurnObservation {\n  /** Behavioral profile the turn belongs to, the bridge's `options.agentId`. */\n  readonly agentId: string;\n  /** End-to-end latency in milliseconds. Declared for shape parity, never populated. */\n  readonly latencyMs?: number;\n  /** Cache-write spend of the call in USD, present when pricing covers the model. */\n  readonly costUsd?: number;\n  /** Always false, a recorded usage is a completed call. */\n  readonly error?: boolean;\n  /** Keys and counts only: the prefix key (a hash) and the hit flag. */\n  readonly metadata?: Readonly<Record<string, string>>;\n}\n\n/**\n * Structural observation surface of a @takk/behavioralai engine. The real\n * `BehavioralAI.observe(turn)` returns a drift report; the bridge has no use for it, so\n * the return type stays `unknown`.\n */\nexport interface BehavioralAILike {\n  /** Ingests one observed turn into the behavioral fingerprint. */\n  observe(turn: CacheTurnObservation): unknown;\n}\n\n/**\n * Cache-write spend of one usage record in USD, `undefined` when the table does not\n * cover the model or misses a TTL tier the call wrote to: an unpriceable turn is omitted\n * entirely rather than underreported.\n */\nfunction writeCostUsd(usage: CacheUsage, pricing: PricingTable | undefined): number | undefined {\n  const card = pricing?.[usage.model];\n  if (card === undefined) {\n    return undefined;\n  }\n  const write5m = usage.cacheWriteTokens5m ?? 0;\n  const write1h = usage.cacheWriteTokens1h ?? 0;\n  if (write5m > 0 && card.cacheWrite5mPerMTok === undefined) {\n    return undefined;\n  }\n  if (write1h > 0 && card.cacheWrite1hPerMTok === undefined) {\n    return undefined;\n  }\n  const spend =\n    write5m * (card.cacheWrite5mPerMTok ?? 0) + write1h * (card.cacheWrite1hPerMTok ?? 0);\n  return spend / 1_000_000;\n}\n\n/**\n * Turns the cache itself into a behaviorally observed agent of @takk/behavioralai.\n *\n * Behavior: on every `'usage.recorded'` event the bridge reports one synthetic turn\n * under `options.agentId` (default `'racs-cache'`): `error` false, `metadata` carrying\n * the prefix key (when the usage was linked to a plan) and the hit flag as\n * `'true' | 'false'`, and `costUsd` set to the call's cache-write spend when pricing\n * covers the model. A healthy cache fingerprints as near-zero write cost and hit\n * `'true'` almost always, so a hit-ratio collapse, a burst of misses paying write\n * premiums, shifts the fingerprint and surfaces as behavioral drift in the sibling.\n *\n * Pricing design, the simplest honest one: the per-turn write cost is computed from the\n * usage record's own write token counts and the table passed in `options.pricing` (same\n * shape as `RACSOptions.pricing`). Reading `racs.stats` instead would only offer\n * cumulative aggregates, and deriving per-turn deltas from those would need shadow state\n * and would misattribute under interleaved recording. Without pricing coverage `costUsd`\n * is omitted, never guessed.\n *\n * Privacy posture: keys and counts only. The bridge forwards the prefix key (a hash), a\n * hit flag, and a USD figure derived from token counts. Prompt content never crosses.\n *\n * @example\n * ```ts\n * import { createBehavioralAI } from '@takk/behavioralai';\n * import { createRACS } from '@takk/racs';\n * import { behavioralaiBridge } from '@takk/racs/integrations';\n *\n * const racs = createRACS();\n * const behavioral = createBehavioralAI();\n * const dispose = behavioralaiBridge(racs, behavioral, {\n *   pricing: {\n *     'claude-sonnet-4-5': {\n *       inputPerMTok: 3,\n *       cacheReadPerMTok: 0.3,\n *       cacheWrite5mPerMTok: 3.75,\n *       cacheWrite1hPerMTok: 6,\n *     },\n *   },\n * });\n * racs.record({\n *   provider: 'anthropic',\n *   model: 'claude-sonnet-4-5',\n *   prefixKey: plan.prefixKey,\n *   inputTokens: 5000,\n *   cacheReadTokens: 4200,\n * });\n * // -> behavioral.observe({ agentId: 'racs-cache', costUsd: 0, error: false,\n * //      metadata: { prefixKey: plan.prefixKey, hit: 'true' } })\n * ```\n */\nexport function behavioralaiBridge(\n  racs: RACS,\n  behavioral: BehavioralAILike,\n  options?: { readonly agentId?: string; readonly pricing?: PricingTable },\n): () => void {\n  const agentId = options?.agentId ?? 'racs-cache';\n  const pricing = options?.pricing;\n  return racs.on((event) => {\n    if (event.type !== 'usage.recorded') {\n      return;\n    }\n    const costUsd = writeCostUsd(event.usage, pricing);\n    const turn: CacheTurnObservation = {\n      agentId,\n      error: false,\n      metadata: {\n        ...(event.usage.prefixKey !== undefined ? { prefixKey: event.usage.prefixKey } : {}),\n        hit: event.hit ? 'true' : 'false',\n      },\n      ...(costUsd !== undefined ? { costUsd } : {}),\n    };\n    try {\n      behavioral.observe(turn);\n    } catch {\n      // Telemetry listeners must not throw, see TelemetryListener; a failing sibling\n      // call is contained here instead of leaning on the engine's safety net.\n    }\n  });\n}\n\n/** Per-model cache planning surface returned by {@link modelchainBridge}. */\nexport interface ModelchainCachePlanner {\n  /**\n   * Plans the cache for one routed model: `base` is the model-agnostic plan input,\n   * `modelId` is the id the router actually picked. Because the deterministic prefix key\n   * includes the model, every routed model gets its own prefix key, fingerprint lineage,\n   * and keep-warm schedule, which is exactly right: provider caches are per-model, a\n   * prefix cached for one model is cold for every other.\n   */\n  planForModel(base: Omit<PlanInput, 'model'>, modelId: string): CachePlan;\n}\n\n/**\n * Pure helper for @takk/modelchain routed traffic: per-model cache plans from one shared\n * base input. No subscriptions, no state, just {@link RACS.plan} with the routed model\n * spliced in.\n *\n * @example\n * ```ts\n * import { createModelchain } from '@takk/modelchain';\n * import { createRACS } from '@takk/racs';\n * import { modelchainBridge } from '@takk/racs/integrations';\n *\n * const racs = createRACS();\n * const planner = modelchainBridge(racs);\n * const router = createModelchain({ models });\n *\n * const response = await router.complete({ prompt: userTurn, system: SYSTEM });\n * // CompletionResponse.modelId names the model the router picked; plan its cache:\n * const plan = planner.planForModel(\n *   {\n *     provider: 'openai',\n *     segments: [\n *       { id: 'system', role: 'system', stability: 'stable', content: SYSTEM },\n *       { id: 'turn', role: 'dynamic', stability: 'volatile', content: userTurn },\n *     ],\n *     reuse: { intervalSeconds: 45 },\n *   },\n *   response.modelId,\n * );\n * ```\n */\nexport function modelchainBridge(racs: RACS): ModelchainCachePlanner {\n  return {\n    planForModel(base: Omit<PlanInput, 'model'>, modelId: string): CachePlan {\n      return racs.plan({ ...base, model: modelId });\n    },\n  };\n}\n\n/**\n * The keymesh telemetry events that signal credentials in flux, names verbatim from the\n * published @takk/keymesh event union. The bridge subscribes to `'key.rotated'` and\n * `'circuit.open'`; `'all.exhausted'` is part of the structural surface so hosts can\n * hang their own handlers off the same {@link KeymeshLike} object.\n */\nexport type KeymeshCredentialEventName = 'key.rotated' | 'circuit.open' | 'all.exhausted';\n\n/**\n * Structural on/off pair of a keymesh client, the `KeymeshExtras` surface every\n * `createKeymesh` client carries. The real methods are generic over the full event\n * union; this narrowed method pair is satisfied by them structurally.\n */\nexport interface KeymeshLike {\n  /** Subscribes a handler to one telemetry event. */\n  on(event: KeymeshCredentialEventName, handler: (event: unknown) => void): void;\n  /** Unsubscribes a previously subscribed handler. */\n  off(event: KeymeshCredentialEventName, handler: (event: unknown) => void): void;\n}\n\n/**\n * Invalidates provider-scoped cache state when @takk/keymesh signals credentials in\n * flux: on `'key.rotated'` and on `'circuit.open'` the bridge calls\n * `racs.invalidate({ provider })` once per provider in `options.providers`, clearing\n * fingerprints, keep-warm schedules, and resource registry entries, with one\n * `'resource.action'` delete event per dropped resource for the host to mirror.\n *\n * Why rotation invalidates: cache entries and cachedContent handles may be scoped to the\n * credential or workspace that created them. Gemini `cachedContents` especially, a\n * resource created under a rotated or disabled key may be unreachable or orphaned, and\n * silently still billing storage. Routing-key and breakpoint caches can land in a\n * different account-side namespace under the new credential. Re-planning from scratch\n * costs one write premium; planning against a dead handle costs failed calls. The same\n * logic covers `'circuit.open'`: a credential in cooldown leaves its provider-side\n * resources unrefreshable, so they expire mid-schedule anyway.\n *\n * @example\n * ```ts\n * import { createKeymesh } from '@takk/keymesh';\n * import { createRACS } from '@takk/racs';\n * import { keymeshBridge } from '@takk/racs/integrations';\n *\n * const racs = createRACS();\n * const gemini = createKeymesh({ provider: geminiAdapter, keys: geminiKeys });\n * const dispose = keymeshBridge(racs, gemini, { providers: ['google'] });\n * // From here a rotation or an opened circuit clears every google-attributed prefix\n * // and the host re-plans, recreating provider resources under the new credential.\n * ```\n */\nexport function keymeshBridge(\n  racs: RACS,\n  keymesh: KeymeshLike,\n  options: { readonly providers: readonly ProviderId[] },\n): () => void {\n  const onCredentialChange = (): void => {\n    for (const provider of options.providers) {\n      racs.invalidate({ provider });\n    }\n  };\n  keymesh.on('key.rotated', onCredentialChange);\n  keymesh.on('circuit.open', onCredentialChange);\n  return (): void => {\n    keymesh.off('key.rotated', onCredentialChange);\n    keymesh.off('circuit.open', onCredentialChange);\n  };\n}\n"]}

package/dist/integrations/index.d.cts

@@ -0,0 +1,285 @@
+import { P as PlanInput, a as CachePlan, R as RACS, h as PricingTable, j as ProviderId } from '../types-DQ7-9sk3.cjs';
+
+/**
+ * Sibling-package bridges of RACS (Remote Agent Context Store): four adapters wiring a
+ * running engine to the rest of the @takk family, @takk/noeticos parameter tuning,
+ * @takk/behavioralai behavioral observability, @takk/modelchain model routing, and
+ * @takk/keymesh credential rotation.
+ *
+ * Optional-peer pattern: every sibling shape in this module is a LOCAL structural
+ * interface. Nothing here imports a sibling package at runtime or at the type level, so
+ * the siblings stay optional peer dependencies, the published real objects satisfy these
+ * shapes structurally, and the zero-runtime-dependency invariant of the package survives
+ * intact. Hosts pass ready instances in, exactly as they do with `KvLike` stores.
+ *
+ * Privacy posture, shared by every bridge: only prefix keys (hashes), token counts, USD
+ * figures derived from counts, agent identifiers, and hit flags ever cross a bridge.
+ * Prompt content never does, RACS never holds it in the first place.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Structural freeze surface of a @takk/noeticos runtime, as {@link noeticosBridge}
+ * consumes it.
+ *
+ * The published package exposes freezing as the module-level functions
+ * `freezeTuning(runtime, agentId, reason)` and `releaseTuning(runtime, agentId)` next to
+ * the `NoeticOS` runtime interface; {@link noeticosAdapter} folds that pair into this
+ * object in one line. Any other tuning runtime can satisfy the same two methods directly.
+ */
+interface NoeticOSLike {
+    /** Pauses parameter tuning for the agent, recording the reason in the audit trail. */
+    freeze(agentId: string, reason: string): void;
+    /** Resumes parameter tuning for the agent. Releasing a non-frozen agent is a no-op. */
+    release(agentId: string): void;
+}
+/**
+ * Module shape of the real @takk/noeticos package, structurally: the two module-level
+ * tuning functions the bridge needs. Members are method-style on purpose, method
+ * parameters are checked bivariantly, so the published functions, whose first parameter
+ * is the concrete `NoeticOS` runtime, satisfy `unknown` here without this module ever
+ * naming the sibling type.
+ */
+interface NoeticosModuleLike {
+    /** The published `freezeTuning(runtime, agentId, reason)`. */
+    freezeTuning(runtime: unknown, agentId: string, reason: string): void;
+    /** The published `releaseTuning(runtime, agentId)`. */
+    releaseTuning(runtime: unknown, agentId: string): void;
+}
+/**
+ * Folds the real @takk/noeticos module surface into a {@link NoeticOSLike} bound to one
+ * runtime, in one line per method.
+ *
+ * @param noeticosModule - The imported module, or any object carrying `freezeTuning` and
+ *   `releaseTuning` with the published signatures.
+ * @param runtime - The `NoeticOS` runtime the functions act on, opaque to this package.
+ * @returns A {@link NoeticOSLike} bound to that runtime.
+ *
+ * @example
+ * ```ts
+ * import * as noeticos from '@takk/noeticos';
+ * import { noeticosAdapter } from '@takk/racs/integrations';
+ *
+ * const runtime = noeticos.createNoeticOS();
+ * const like = noeticosAdapter(noeticos, runtime);
+ * like.freeze('support-agent', 'manual maintenance window');
+ * ```
+ */
+declare function noeticosAdapter(noeticosModule: NoeticosModuleLike, runtime: unknown): NoeticOSLike;
+/**
+ * Freezes @takk/noeticos parameter tuning across prompt-prefix discontinuities.
+ *
+ * Rationale: parameter tuning must not learn across a prefix discontinuity, the reward
+ * landscape moved. A drifted prefix changes hit ratio, latency, and cost all at once, so
+ * reward samples taken right after the drift would be credited to parameter choices that
+ * had nothing to do with them.
+ *
+ * Behavior: on every `'prefix.drifted'` event carrying an agentId (it flows in from
+ * {@link PlanInput.agentId}), the bridge freezes that agent with a reason naming the
+ * changed segments, then counts subsequent `'plan.created'` events for the agent with
+ * zero drift and releases after `releaseAfterStablePlans` of them (default 3). A new
+ * drift during the count re-freezes, which refreshes the audit trail, and restarts the
+ * count.
+ *
+ * Disposal: the returned function only unsubscribes from telemetry. Agents frozen at
+ * that moment stay frozen, releasing tuning silently would be a policy decision only the
+ * host can take.
+ *
+ * @example
+ * ```ts
+ * import * as noeticos from '@takk/noeticos';
+ * import { createRACS } from '@takk/racs';
+ * import { noeticosAdapter, noeticosBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const runtime = noeticos.createNoeticOS();
+ * const dispose = noeticosBridge(racs, noeticosAdapter(noeticos, runtime), {
+ *   releaseAfterStablePlans: 3,
+ * });
+ * // Plans carrying an agentId now freeze that agent's tuning on prefix drift:
+ * racs.plan({
+ *   agentId: 'support-agent',
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-5',
+ *   segments: [{ id: 'system', role: 'system', stability: 'stable', content: SYSTEM }],
+ * });
+ * ```
+ */
+declare function noeticosBridge(racs: RACS, noeticos: NoeticOSLike, options?: {
+    readonly releaseAfterStablePlans?: number;
+}): () => void;
+/**
+ * The synthetic turn {@link behavioralaiBridge} reports, a narrow structural slice of
+ * the sibling's `TurnObservation`, field names verbatim from the published
+ * @takk/behavioralai types.
+ */
+interface CacheTurnObservation {
+    /** Behavioral profile the turn belongs to, the bridge's `options.agentId`. */
+    readonly agentId: string;
+    /** End-to-end latency in milliseconds. Declared for shape parity, never populated. */
+    readonly latencyMs?: number;
+    /** Cache-write spend of the call in USD, present when pricing covers the model. */
+    readonly costUsd?: number;
+    /** Always false, a recorded usage is a completed call. */
+    readonly error?: boolean;
+    /** Keys and counts only: the prefix key (a hash) and the hit flag. */
+    readonly metadata?: Readonly<Record<string, string>>;
+}
+/**
+ * Structural observation surface of a @takk/behavioralai engine. The real
+ * `BehavioralAI.observe(turn)` returns a drift report; the bridge has no use for it, so
+ * the return type stays `unknown`.
+ */
+interface BehavioralAILike {
+    /** Ingests one observed turn into the behavioral fingerprint. */
+    observe(turn: CacheTurnObservation): unknown;
+}
+/**
+ * Turns the cache itself into a behaviorally observed agent of @takk/behavioralai.
+ *
+ * Behavior: on every `'usage.recorded'` event the bridge reports one synthetic turn
+ * under `options.agentId` (default `'racs-cache'`): `error` false, `metadata` carrying
+ * the prefix key (when the usage was linked to a plan) and the hit flag as
+ * `'true' | 'false'`, and `costUsd` set to the call's cache-write spend when pricing
+ * covers the model. A healthy cache fingerprints as near-zero write cost and hit
+ * `'true'` almost always, so a hit-ratio collapse, a burst of misses paying write
+ * premiums, shifts the fingerprint and surfaces as behavioral drift in the sibling.
+ *
+ * Pricing design, the simplest honest one: the per-turn write cost is computed from the
+ * usage record's own write token counts and the table passed in `options.pricing` (same
+ * shape as `RACSOptions.pricing`). Reading `racs.stats` instead would only offer
+ * cumulative aggregates, and deriving per-turn deltas from those would need shadow state
+ * and would misattribute under interleaved recording. Without pricing coverage `costUsd`
+ * is omitted, never guessed.
+ *
+ * Privacy posture: keys and counts only. The bridge forwards the prefix key (a hash), a
+ * hit flag, and a USD figure derived from token counts. Prompt content never crosses.
+ *
+ * @example
+ * ```ts
+ * import { createBehavioralAI } from '@takk/behavioralai';
+ * import { createRACS } from '@takk/racs';
+ * import { behavioralaiBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const behavioral = createBehavioralAI();
+ * const dispose = behavioralaiBridge(racs, behavioral, {
+ *   pricing: {
+ *     'claude-sonnet-4-5': {
+ *       inputPerMTok: 3,
+ *       cacheReadPerMTok: 0.3,
+ *       cacheWrite5mPerMTok: 3.75,
+ *       cacheWrite1hPerMTok: 6,
+ *     },
+ *   },
+ * });
+ * racs.record({
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-5',
+ *   prefixKey: plan.prefixKey,
+ *   inputTokens: 5000,
+ *   cacheReadTokens: 4200,
+ * });
+ * // -> behavioral.observe({ agentId: 'racs-cache', costUsd: 0, error: false,
+ * //      metadata: { prefixKey: plan.prefixKey, hit: 'true' } })
+ * ```
+ */
+declare function behavioralaiBridge(racs: RACS, behavioral: BehavioralAILike, options?: {
+    readonly agentId?: string;
+    readonly pricing?: PricingTable;
+}): () => void;
+/** Per-model cache planning surface returned by {@link modelchainBridge}. */
+interface ModelchainCachePlanner {
+    /**
+     * Plans the cache for one routed model: `base` is the model-agnostic plan input,
+     * `modelId` is the id the router actually picked. Because the deterministic prefix key
+     * includes the model, every routed model gets its own prefix key, fingerprint lineage,
+     * and keep-warm schedule, which is exactly right: provider caches are per-model, a
+     * prefix cached for one model is cold for every other.
+     */
+    planForModel(base: Omit<PlanInput, 'model'>, modelId: string): CachePlan;
+}
+/**
+ * Pure helper for @takk/modelchain routed traffic: per-model cache plans from one shared
+ * base input. No subscriptions, no state, just {@link RACS.plan} with the routed model
+ * spliced in.
+ *
+ * @example
+ * ```ts
+ * import { createModelchain } from '@takk/modelchain';
+ * import { createRACS } from '@takk/racs';
+ * import { modelchainBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const planner = modelchainBridge(racs);
+ * const router = createModelchain({ models });
+ *
+ * const response = await router.complete({ prompt: userTurn, system: SYSTEM });
+ * // CompletionResponse.modelId names the model the router picked; plan its cache:
+ * const plan = planner.planForModel(
+ *   {
+ *     provider: 'openai',
+ *     segments: [
+ *       { id: 'system', role: 'system', stability: 'stable', content: SYSTEM },
+ *       { id: 'turn', role: 'dynamic', stability: 'volatile', content: userTurn },
+ *     ],
+ *     reuse: { intervalSeconds: 45 },
+ *   },
+ *   response.modelId,
+ * );
+ * ```
+ */
+declare function modelchainBridge(racs: RACS): ModelchainCachePlanner;
+/**
+ * The keymesh telemetry events that signal credentials in flux, names verbatim from the
+ * published @takk/keymesh event union. The bridge subscribes to `'key.rotated'` and
+ * `'circuit.open'`; `'all.exhausted'` is part of the structural surface so hosts can
+ * hang their own handlers off the same {@link KeymeshLike} object.
+ */
+type KeymeshCredentialEventName = 'key.rotated' | 'circuit.open' | 'all.exhausted';
+/**
+ * Structural on/off pair of a keymesh client, the `KeymeshExtras` surface every
+ * `createKeymesh` client carries. The real methods are generic over the full event
+ * union; this narrowed method pair is satisfied by them structurally.
+ */
+interface KeymeshLike {
+    /** Subscribes a handler to one telemetry event. */
+    on(event: KeymeshCredentialEventName, handler: (event: unknown) => void): void;
+    /** Unsubscribes a previously subscribed handler. */
+    off(event: KeymeshCredentialEventName, handler: (event: unknown) => void): void;
+}
+/**
+ * Invalidates provider-scoped cache state when @takk/keymesh signals credentials in
+ * flux: on `'key.rotated'` and on `'circuit.open'` the bridge calls
+ * `racs.invalidate({ provider })` once per provider in `options.providers`, clearing
+ * fingerprints, keep-warm schedules, and resource registry entries, with one
+ * `'resource.action'` delete event per dropped resource for the host to mirror.
+ *
+ * Why rotation invalidates: cache entries and cachedContent handles may be scoped to the
+ * credential or workspace that created them. Gemini `cachedContents` especially, a
+ * resource created under a rotated or disabled key may be unreachable or orphaned, and
+ * silently still billing storage. Routing-key and breakpoint caches can land in a
+ * different account-side namespace under the new credential. Re-planning from scratch
+ * costs one write premium; planning against a dead handle costs failed calls. The same
+ * logic covers `'circuit.open'`: a credential in cooldown leaves its provider-side
+ * resources unrefreshable, so they expire mid-schedule anyway.
+ *
+ * @example
+ * ```ts
+ * import { createKeymesh } from '@takk/keymesh';
+ * import { createRACS } from '@takk/racs';
+ * import { keymeshBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const gemini = createKeymesh({ provider: geminiAdapter, keys: geminiKeys });
+ * const dispose = keymeshBridge(racs, gemini, { providers: ['google'] });
+ * // From here a rotation or an opened circuit clears every google-attributed prefix
+ * // and the host re-plans, recreating provider resources under the new credential.
+ * ```
+ */
+declare function keymeshBridge(racs: RACS, keymesh: KeymeshLike, options: {
+    readonly providers: readonly ProviderId[];
+}): () => void;
+
+export { type BehavioralAILike, type CacheTurnObservation, type KeymeshCredentialEventName, type KeymeshLike, type ModelchainCachePlanner, type NoeticOSLike, type NoeticosModuleLike, behavioralaiBridge, keymeshBridge, modelchainBridge, noeticosAdapter, noeticosBridge };

package/dist/integrations/index.d.ts

@@ -0,0 +1,285 @@
+import { P as PlanInput, a as CachePlan, R as RACS, h as PricingTable, j as ProviderId } from '../types-DQ7-9sk3.js';
+
+/**
+ * Sibling-package bridges of RACS (Remote Agent Context Store): four adapters wiring a
+ * running engine to the rest of the @takk family, @takk/noeticos parameter tuning,
+ * @takk/behavioralai behavioral observability, @takk/modelchain model routing, and
+ * @takk/keymesh credential rotation.
+ *
+ * Optional-peer pattern: every sibling shape in this module is a LOCAL structural
+ * interface. Nothing here imports a sibling package at runtime or at the type level, so
+ * the siblings stay optional peer dependencies, the published real objects satisfy these
+ * shapes structurally, and the zero-runtime-dependency invariant of the package survives
+ * intact. Hosts pass ready instances in, exactly as they do with `KvLike` stores.
+ *
+ * Privacy posture, shared by every bridge: only prefix keys (hashes), token counts, USD
+ * figures derived from counts, agent identifiers, and hit flags ever cross a bridge.
+ * Prompt content never does, RACS never holds it in the first place.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Structural freeze surface of a @takk/noeticos runtime, as {@link noeticosBridge}
+ * consumes it.
+ *
+ * The published package exposes freezing as the module-level functions
+ * `freezeTuning(runtime, agentId, reason)` and `releaseTuning(runtime, agentId)` next to
+ * the `NoeticOS` runtime interface; {@link noeticosAdapter} folds that pair into this
+ * object in one line. Any other tuning runtime can satisfy the same two methods directly.
+ */
+interface NoeticOSLike {
+    /** Pauses parameter tuning for the agent, recording the reason in the audit trail. */
+    freeze(agentId: string, reason: string): void;
+    /** Resumes parameter tuning for the agent. Releasing a non-frozen agent is a no-op. */
+    release(agentId: string): void;
+}
+/**
+ * Module shape of the real @takk/noeticos package, structurally: the two module-level
+ * tuning functions the bridge needs. Members are method-style on purpose, method
+ * parameters are checked bivariantly, so the published functions, whose first parameter
+ * is the concrete `NoeticOS` runtime, satisfy `unknown` here without this module ever
+ * naming the sibling type.
+ */
+interface NoeticosModuleLike {
+    /** The published `freezeTuning(runtime, agentId, reason)`. */
+    freezeTuning(runtime: unknown, agentId: string, reason: string): void;
+    /** The published `releaseTuning(runtime, agentId)`. */
+    releaseTuning(runtime: unknown, agentId: string): void;
+}
+/**
+ * Folds the real @takk/noeticos module surface into a {@link NoeticOSLike} bound to one
+ * runtime, in one line per method.
+ *
+ * @param noeticosModule - The imported module, or any object carrying `freezeTuning` and
+ *   `releaseTuning` with the published signatures.
+ * @param runtime - The `NoeticOS` runtime the functions act on, opaque to this package.
+ * @returns A {@link NoeticOSLike} bound to that runtime.
+ *
+ * @example
+ * ```ts
+ * import * as noeticos from '@takk/noeticos';
+ * import { noeticosAdapter } from '@takk/racs/integrations';
+ *
+ * const runtime = noeticos.createNoeticOS();
+ * const like = noeticosAdapter(noeticos, runtime);
+ * like.freeze('support-agent', 'manual maintenance window');
+ * ```
+ */
+declare function noeticosAdapter(noeticosModule: NoeticosModuleLike, runtime: unknown): NoeticOSLike;
+/**
+ * Freezes @takk/noeticos parameter tuning across prompt-prefix discontinuities.
+ *
+ * Rationale: parameter tuning must not learn across a prefix discontinuity, the reward
+ * landscape moved. A drifted prefix changes hit ratio, latency, and cost all at once, so
+ * reward samples taken right after the drift would be credited to parameter choices that
+ * had nothing to do with them.
+ *
+ * Behavior: on every `'prefix.drifted'` event carrying an agentId (it flows in from
+ * {@link PlanInput.agentId}), the bridge freezes that agent with a reason naming the
+ * changed segments, then counts subsequent `'plan.created'` events for the agent with
+ * zero drift and releases after `releaseAfterStablePlans` of them (default 3). A new
+ * drift during the count re-freezes, which refreshes the audit trail, and restarts the
+ * count.
+ *
+ * Disposal: the returned function only unsubscribes from telemetry. Agents frozen at
+ * that moment stay frozen, releasing tuning silently would be a policy decision only the
+ * host can take.
+ *
+ * @example
+ * ```ts
+ * import * as noeticos from '@takk/noeticos';
+ * import { createRACS } from '@takk/racs';
+ * import { noeticosAdapter, noeticosBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const runtime = noeticos.createNoeticOS();
+ * const dispose = noeticosBridge(racs, noeticosAdapter(noeticos, runtime), {
+ *   releaseAfterStablePlans: 3,
+ * });
+ * // Plans carrying an agentId now freeze that agent's tuning on prefix drift:
+ * racs.plan({
+ *   agentId: 'support-agent',
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-5',
+ *   segments: [{ id: 'system', role: 'system', stability: 'stable', content: SYSTEM }],
+ * });
+ * ```
+ */
+declare function noeticosBridge(racs: RACS, noeticos: NoeticOSLike, options?: {
+    readonly releaseAfterStablePlans?: number;
+}): () => void;
+/**
+ * The synthetic turn {@link behavioralaiBridge} reports, a narrow structural slice of
+ * the sibling's `TurnObservation`, field names verbatim from the published
+ * @takk/behavioralai types.
+ */
+interface CacheTurnObservation {
+    /** Behavioral profile the turn belongs to, the bridge's `options.agentId`. */
+    readonly agentId: string;
+    /** End-to-end latency in milliseconds. Declared for shape parity, never populated. */
+    readonly latencyMs?: number;
+    /** Cache-write spend of the call in USD, present when pricing covers the model. */
+    readonly costUsd?: number;
+    /** Always false, a recorded usage is a completed call. */
+    readonly error?: boolean;
+    /** Keys and counts only: the prefix key (a hash) and the hit flag. */
+    readonly metadata?: Readonly<Record<string, string>>;
+}
+/**
+ * Structural observation surface of a @takk/behavioralai engine. The real
+ * `BehavioralAI.observe(turn)` returns a drift report; the bridge has no use for it, so
+ * the return type stays `unknown`.
+ */
+interface BehavioralAILike {
+    /** Ingests one observed turn into the behavioral fingerprint. */
+    observe(turn: CacheTurnObservation): unknown;
+}
+/**
+ * Turns the cache itself into a behaviorally observed agent of @takk/behavioralai.
+ *
+ * Behavior: on every `'usage.recorded'` event the bridge reports one synthetic turn
+ * under `options.agentId` (default `'racs-cache'`): `error` false, `metadata` carrying
+ * the prefix key (when the usage was linked to a plan) and the hit flag as
+ * `'true' | 'false'`, and `costUsd` set to the call's cache-write spend when pricing
+ * covers the model. A healthy cache fingerprints as near-zero write cost and hit
+ * `'true'` almost always, so a hit-ratio collapse, a burst of misses paying write
+ * premiums, shifts the fingerprint and surfaces as behavioral drift in the sibling.
+ *
+ * Pricing design, the simplest honest one: the per-turn write cost is computed from the
+ * usage record's own write token counts and the table passed in `options.pricing` (same
+ * shape as `RACSOptions.pricing`). Reading `racs.stats` instead would only offer
+ * cumulative aggregates, and deriving per-turn deltas from those would need shadow state
+ * and would misattribute under interleaved recording. Without pricing coverage `costUsd`
+ * is omitted, never guessed.
+ *
+ * Privacy posture: keys and counts only. The bridge forwards the prefix key (a hash), a
+ * hit flag, and a USD figure derived from token counts. Prompt content never crosses.
+ *
+ * @example
+ * ```ts
+ * import { createBehavioralAI } from '@takk/behavioralai';
+ * import { createRACS } from '@takk/racs';
+ * import { behavioralaiBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const behavioral = createBehavioralAI();
+ * const dispose = behavioralaiBridge(racs, behavioral, {
+ *   pricing: {
+ *     'claude-sonnet-4-5': {
+ *       inputPerMTok: 3,
+ *       cacheReadPerMTok: 0.3,
+ *       cacheWrite5mPerMTok: 3.75,
+ *       cacheWrite1hPerMTok: 6,
+ *     },
+ *   },
+ * });
+ * racs.record({
+ *   provider: 'anthropic',
+ *   model: 'claude-sonnet-4-5',
+ *   prefixKey: plan.prefixKey,
+ *   inputTokens: 5000,
+ *   cacheReadTokens: 4200,
+ * });
+ * // -> behavioral.observe({ agentId: 'racs-cache', costUsd: 0, error: false,
+ * //      metadata: { prefixKey: plan.prefixKey, hit: 'true' } })
+ * ```
+ */
+declare function behavioralaiBridge(racs: RACS, behavioral: BehavioralAILike, options?: {
+    readonly agentId?: string;
+    readonly pricing?: PricingTable;
+}): () => void;
+/** Per-model cache planning surface returned by {@link modelchainBridge}. */
+interface ModelchainCachePlanner {
+    /**
+     * Plans the cache for one routed model: `base` is the model-agnostic plan input,
+     * `modelId` is the id the router actually picked. Because the deterministic prefix key
+     * includes the model, every routed model gets its own prefix key, fingerprint lineage,
+     * and keep-warm schedule, which is exactly right: provider caches are per-model, a
+     * prefix cached for one model is cold for every other.
+     */
+    planForModel(base: Omit<PlanInput, 'model'>, modelId: string): CachePlan;
+}
+/**
+ * Pure helper for @takk/modelchain routed traffic: per-model cache plans from one shared
+ * base input. No subscriptions, no state, just {@link RACS.plan} with the routed model
+ * spliced in.
+ *
+ * @example
+ * ```ts
+ * import { createModelchain } from '@takk/modelchain';
+ * import { createRACS } from '@takk/racs';
+ * import { modelchainBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const planner = modelchainBridge(racs);
+ * const router = createModelchain({ models });
+ *
+ * const response = await router.complete({ prompt: userTurn, system: SYSTEM });
+ * // CompletionResponse.modelId names the model the router picked; plan its cache:
+ * const plan = planner.planForModel(
+ *   {
+ *     provider: 'openai',
+ *     segments: [
+ *       { id: 'system', role: 'system', stability: 'stable', content: SYSTEM },
+ *       { id: 'turn', role: 'dynamic', stability: 'volatile', content: userTurn },
+ *     ],
+ *     reuse: { intervalSeconds: 45 },
+ *   },
+ *   response.modelId,
+ * );
+ * ```
+ */
+declare function modelchainBridge(racs: RACS): ModelchainCachePlanner;
+/**
+ * The keymesh telemetry events that signal credentials in flux, names verbatim from the
+ * published @takk/keymesh event union. The bridge subscribes to `'key.rotated'` and
+ * `'circuit.open'`; `'all.exhausted'` is part of the structural surface so hosts can
+ * hang their own handlers off the same {@link KeymeshLike} object.
+ */
+type KeymeshCredentialEventName = 'key.rotated' | 'circuit.open' | 'all.exhausted';
+/**
+ * Structural on/off pair of a keymesh client, the `KeymeshExtras` surface every
+ * `createKeymesh` client carries. The real methods are generic over the full event
+ * union; this narrowed method pair is satisfied by them structurally.
+ */
+interface KeymeshLike {
+    /** Subscribes a handler to one telemetry event. */
+    on(event: KeymeshCredentialEventName, handler: (event: unknown) => void): void;
+    /** Unsubscribes a previously subscribed handler. */
+    off(event: KeymeshCredentialEventName, handler: (event: unknown) => void): void;
+}
+/**
+ * Invalidates provider-scoped cache state when @takk/keymesh signals credentials in
+ * flux: on `'key.rotated'` and on `'circuit.open'` the bridge calls
+ * `racs.invalidate({ provider })` once per provider in `options.providers`, clearing
+ * fingerprints, keep-warm schedules, and resource registry entries, with one
+ * `'resource.action'` delete event per dropped resource for the host to mirror.
+ *
+ * Why rotation invalidates: cache entries and cachedContent handles may be scoped to the
+ * credential or workspace that created them. Gemini `cachedContents` especially, a
+ * resource created under a rotated or disabled key may be unreachable or orphaned, and
+ * silently still billing storage. Routing-key and breakpoint caches can land in a
+ * different account-side namespace under the new credential. Re-planning from scratch
+ * costs one write premium; planning against a dead handle costs failed calls. The same
+ * logic covers `'circuit.open'`: a credential in cooldown leaves its provider-side
+ * resources unrefreshable, so they expire mid-schedule anyway.
+ *
+ * @example
+ * ```ts
+ * import { createKeymesh } from '@takk/keymesh';
+ * import { createRACS } from '@takk/racs';
+ * import { keymeshBridge } from '@takk/racs/integrations';
+ *
+ * const racs = createRACS();
+ * const gemini = createKeymesh({ provider: geminiAdapter, keys: geminiKeys });
+ * const dispose = keymeshBridge(racs, gemini, { providers: ['google'] });
+ * // From here a rotation or an opened circuit clears every google-attributed prefix
+ * // and the host re-plans, recreating provider resources under the new credential.
+ * ```
+ */
+declare function keymeshBridge(racs: RACS, keymesh: KeymeshLike, options: {
+    readonly providers: readonly ProviderId[];
+}): () => void;
+
+export { type BehavioralAILike, type CacheTurnObservation, type KeymeshCredentialEventName, type KeymeshLike, type ModelchainCachePlanner, type NoeticOSLike, type NoeticosModuleLike, behavioralaiBridge, keymeshBridge, modelchainBridge, noeticosAdapter, noeticosBridge };