@coderifts/agent-guard 4.2.0 → 4.3.0

package/dist/esm/adapters/anthropic.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Anthropic tool_use adapter over withCodeRifts (ID632 slice 2 — same thin pattern as OpenAI).
+ *
+ * Thin SHAPE converter only. Guard logic stays in withCodeRifts; this module:
+ *   1. calls withCodeRifts with the same input shape,
+ *   2. maps each ProtectedTool → Anthropic Messages API tool definition,
+ *   3. returns Anthropic-shaped tools PLUS the untouched assurance objects
+ *      (registry_report, composition_assurance, receipt_thread).
+ *
+ * Honesty (do not "upgrade" assurance):
+ *   - composition_assurance is passed through EXACTLY as the core reported it
+ *     (COMPOSITION_CALL_POLICY_COMPLETE may still be false; inescapable_runtime may be false).
+ *   - The adapter converts tool SHAPE for the model API; it does not claim product-level
+ *     inescapability the core does not claim.
+ *
+ * Only-protected-tools (6/D at the adapter surface):
+ *   - `tools` is derived ONLY from the frozen registry's ProtectedTool list.
+ *   - Raw tools never appear in the returned Anthropic table. The host may still hold a raw
+ *     reference outside this table; that boundary stays the host's responsibility.
+ *
+ * Ergonomics (5–10 lines): pass raw tools + client + operation → Anthropic-ready guarded tools.
+ * Mirrors src/adapters/openai.ts — only the target tool shape differs.
+ */
+import type { WithCodeRiftsInput, WithCodeRiftsResult, CompositionAssurance, ReceiptThreadHandle } from '../with-coderifts.js';
+import type { ProtectedTool, RegistryCoverageReport } from '../tool-registry.js';
+/**
+ * Anthropic Messages API `tools[]` element (tool_use definition).
+ * @see https://docs.anthropic.com/en/docs/agents-and-tools/tool-use/overview
+ */
+export type AnthropicTool = {
+    name: string;
+    description?: string;
+    /** JSON Schema object for the tool input (Anthropic `input_schema`). */
+    input_schema: Record<string, unknown>;
+};
+/**
+ * Result of withCodeRiftsAnthropic — Anthropic tool definitions + core assurance, unflattened.
+ *
+ * `tools` is the ONLY list intended for the model/runtime tool table. `protected_tools` is the
+ * same guarded list (with execute) for host dispatch after tool_use blocks — never the raw tools.
+ */
+export type WithCodeRiftsAnthropicResult = {
+    /** Anthropic-shaped tools for messages.create — only protected/guarded tools. */
+    tools: AnthropicTool[];
+    /**
+     * Guarded ProtectedTool list from withCodeRifts (same tools as `tools`, with execute).
+     * Host dispatches model tool_use through these only. Never raw tools.
+     */
+    protected_tools: ProtectedTool[];
+    /** Untouched registry report — registry's own truth. */
+    registry_report: RegistryCoverageReport;
+    /**
+     * Product-level assurance — deliberately narrower than the registry.
+     * Passed through untouched; may still show inescapable_runtime:false and
+     * residual composition_call_policy_incomplete.
+     */
+    composition_assurance: CompositionAssurance;
+    /** Per-composition receipt cursor — NOT product-truth chain evidence. */
+    receipt_thread: ReceiptThreadHandle;
+    repository?: string;
+};
+/**
+ * Map one ProtectedTool → Anthropic tool definition (shape only; no execute).
+ * Prefer tool.inputSchema when it is a plain object; otherwise empty object schema.
+ */
+export declare function protectedToolToAnthropic(tool: ProtectedTool): AnthropicTool;
+/**
+ * Convert a list of ProtectedTool into Anthropic tool definitions.
+ * Does NOT call the guard — pure shape map over an already-protected list.
+ */
+export declare function toAnthropicTools(protectedTools: readonly ProtectedTool[]): AnthropicTool[];
+/**
+ * Build Anthropic-ready guarded tools from raw tools + client + operation.
+ *
+ * Calls withCodeRifts internally (guard logic stays in the core). Returns:
+ *   - `tools` — Anthropic messages API shape ({ name, description?, input_schema })
+ *   - `protected_tools` — same guarded tools for host execute dispatch
+ *   - assurance objects from the core, passed through untouched
+ *
+ * @param input Same shape as withCodeRifts (WithCodeRiftsInput).
+ */
+export declare function withCodeRiftsAnthropic(input: WithCodeRiftsInput): WithCodeRiftsAnthropicResult;
+/**
+ * Shape-only adapter over an existing WithCodeRiftsResult (composition style).
+ * Prefer withCodeRiftsAnthropic when starting from raw tools.
+ *
+ * Does not re-run the guard; does not invent assurance.
+ */
+export declare function anthropicToolAdapter(result: WithCodeRiftsResult): WithCodeRiftsAnthropicResult;
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/esm/adapters/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../../src/adapters/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEjF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,iFAAiF;IACjF,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB;;;OAGG;IACH,eAAe,EAAE,aAAa,EAAE,CAAC;IACjC,wDAAwD;IACxD,eAAe,EAAE,sBAAsB,CAAC;IACxC;;;;OAIG;IACH,qBAAqB,EAAE,oBAAoB,CAAC;IAC5C,yEAAyE;IACzE,cAAc,EAAE,mBAAmB,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAgB3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,GAAG,aAAa,EAAE,CAE1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,4BAA4B,CAG9F;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,4BAA4B,CAc9F"}

package/dist/esm/adapters/anthropic.js

@@ -0,0 +1,91 @@
+/**
+ * Anthropic tool_use adapter over withCodeRifts (ID632 slice 2 — same thin pattern as OpenAI).
+ *
+ * Thin SHAPE converter only. Guard logic stays in withCodeRifts; this module:
+ *   1. calls withCodeRifts with the same input shape,
+ *   2. maps each ProtectedTool → Anthropic Messages API tool definition,
+ *   3. returns Anthropic-shaped tools PLUS the untouched assurance objects
+ *      (registry_report, composition_assurance, receipt_thread).
+ *
+ * Honesty (do not "upgrade" assurance):
+ *   - composition_assurance is passed through EXACTLY as the core reported it
+ *     (COMPOSITION_CALL_POLICY_COMPLETE may still be false; inescapable_runtime may be false).
+ *   - The adapter converts tool SHAPE for the model API; it does not claim product-level
+ *     inescapability the core does not claim.
+ *
+ * Only-protected-tools (6/D at the adapter surface):
+ *   - `tools` is derived ONLY from the frozen registry's ProtectedTool list.
+ *   - Raw tools never appear in the returned Anthropic table. The host may still hold a raw
+ *     reference outside this table; that boundary stays the host's responsibility.
+ *
+ * Ergonomics (5–10 lines): pass raw tools + client + operation → Anthropic-ready guarded tools.
+ * Mirrors src/adapters/openai.ts — only the target tool shape differs.
+ */
+import { withCodeRifts } from '../with-coderifts.js';
+/** Empty JSON Schema object — used when a ProtectedTool has no inputSchema. */
+const EMPTY_INPUT_SCHEMA = Object.freeze({
+    type: 'object',
+    properties: {},
+});
+/**
+ * Map one ProtectedTool → Anthropic tool definition (shape only; no execute).
+ * Prefer tool.inputSchema when it is a plain object; otherwise empty object schema.
+ */
+export function protectedToolToAnthropic(tool) {
+    const input_schema = tool.inputSchema != null
+        && typeof tool.inputSchema === 'object'
+        && !Array.isArray(tool.inputSchema)
+        ? tool.inputSchema
+        : { ...EMPTY_INPUT_SCHEMA };
+    const out = {
+        name: tool.name,
+        input_schema,
+    };
+    if (tool.description != null && tool.description !== '') {
+        out.description = tool.description;
+    }
+    return out;
+}
+/**
+ * Convert a list of ProtectedTool into Anthropic tool definitions.
+ * Does NOT call the guard — pure shape map over an already-protected list.
+ */
+export function toAnthropicTools(protectedTools) {
+    return protectedTools.map(protectedToolToAnthropic);
+}
+/**
+ * Build Anthropic-ready guarded tools from raw tools + client + operation.
+ *
+ * Calls withCodeRifts internally (guard logic stays in the core). Returns:
+ *   - `tools` — Anthropic messages API shape ({ name, description?, input_schema })
+ *   - `protected_tools` — same guarded tools for host execute dispatch
+ *   - assurance objects from the core, passed through untouched
+ *
+ * @param input Same shape as withCodeRifts (WithCodeRiftsInput).
+ */
+export function withCodeRiftsAnthropic(input) {
+    const core = withCodeRifts(input);
+    return anthropicToolAdapter(core);
+}
+/**
+ * Shape-only adapter over an existing WithCodeRiftsResult (composition style).
+ * Prefer withCodeRiftsAnthropic when starting from raw tools.
+ *
+ * Does not re-run the guard; does not invent assurance.
+ */
+export function anthropicToolAdapter(result) {
+    const protected_tools = result.tools;
+    const tools = toAnthropicTools(protected_tools);
+    const out = {
+        tools,
+        protected_tools,
+        registry_report: result.registry_report,
+        composition_assurance: result.composition_assurance,
+        receipt_thread: result.receipt_thread,
+    };
+    if (result.repository !== undefined) {
+        out.repository = result.repository;
+    }
+    return out;
+}
+//# sourceMappingURL=anthropic.js.map

package/dist/esm/adapters/anthropic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.js","sourceRoot":"","sources":["../../../src/adapters/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA+CrD,+EAA+E;AAC/E,MAAM,kBAAkB,GAA4B,MAAM,CAAC,MAAM,CAAC;IAChE,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE,EAAE;CACf,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAmB;IAC1D,MAAM,YAAY,GAChB,IAAI,CAAC,WAAW,IAAI,IAAI;WACrB,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ;WACpC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;QACjC,CAAC,CAAE,IAAI,CAAC,WAAuC;QAC/C,CAAC,CAAC,EAAE,GAAG,kBAAkB,EAAE,CAAC;IAEhC,MAAM,GAAG,GAAkB;QACzB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,YAAY;KACb,CAAC;IACF,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,EAAE,EAAE,CAAC;QACxD,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,cAAwC;IACvE,OAAO,cAAc,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAyB;IAC9D,MAAM,IAAI,GAAwB,aAAa,CAAC,KAAK,CAAC,CAAC;IACvD,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAA2B;IAC9D,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC;IACrC,MAAM,KAAK,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAC;IAChD,MAAM,GAAG,GAAiC;QACxC,KAAK;QACL,eAAe;QACf,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;QACnD,cAAc,EAAE,MAAM,CAAC,cAAc;KACtC,CAAC;IACF,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACpC,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/esm/adapters/gemini.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Google Gemini function-calling adapter over withCodeRifts (ID632 slice 4 —
+ * same thin pattern as OpenAI / Anthropic / LangGraph).
+ *
+ * Thin SHAPE converter only. Guard logic stays in withCodeRifts; this module:
+ *   1. calls withCodeRifts with the same input shape,
+ *   2. maps ProtectedTool[] → Gemini generateContent tools shape,
+ *   3. returns Gemini-shaped tools PLUS the untouched assurance objects
+ *      (registry_report, composition_assurance, receipt_thread).
+ *
+ * Gemini nesting (differs from OpenAI):
+ *   tools: [ { functionDeclarations: [ { name, description?, parameters }, … ] } ]
+ * One tools entry wraps ALL declarations in a single functionDeclarations array —
+ * not one { type: 'function' } object per tool.
+ *
+ * Honesty (do not "upgrade" assurance):
+ *   - composition_assurance is passed through EXACTLY as the core reported it
+ *     (COMPOSITION_CALL_POLICY_COMPLETE may still be false; inescapable_runtime may be false).
+ *   - The adapter converts tool SHAPE for the model API; it does not claim product-level
+ *     inescapability the core does not claim.
+ *
+ * Only-protected-tools (6/D at the adapter surface):
+ *   - `tools` is derived ONLY from the frozen registry's ProtectedTool list.
+ *   - Raw tools never appear in the returned Gemini table. The host may still hold a raw
+ *     reference outside this table; that boundary stays the host's responsibility.
+ *
+ * Ergonomics (5–10 lines): pass raw tools + client + operation → Gemini-ready tools.
+ * Mirrors src/adapters/openai.ts — only the target tool shape differs.
+ */
+import type { WithCodeRiftsInput, WithCodeRiftsResult, CompositionAssurance, ReceiptThreadHandle } from '../with-coderifts.js';
+import type { ProtectedTool, RegistryCoverageReport } from '../tool-registry.js';
+/**
+ * One Gemini function declaration (inside functionDeclarations[]).
+ * @see https://ai.google.dev/gemini-api/docs/function-calling
+ */
+export type GeminiFunctionDeclaration = {
+    name: string;
+    description?: string;
+    /**
+     * OpenAPI-like JSON Schema for function parameters
+     * (Gemini `parameters` — from ProtectedTool.inputSchema).
+     */
+    parameters: Record<string, unknown>;
+};
+/**
+ * Gemini `tools[]` element: a single wrapper holding all functionDeclarations.
+ * Unlike OpenAI (one {type:'function'} per tool), Gemini nests every declaration
+ * under one functionDeclarations array.
+ */
+export type GeminiTool = {
+    functionDeclarations: GeminiFunctionDeclaration[];
+};
+/**
+ * Result of withCodeRiftsGemini — Gemini tool definitions + core assurance, unflattened.
+ *
+ * `tools` is typically a one-element array:
+ *   [ { functionDeclarations: [ …all protected tools… ] } ]
+ * `protected_tools` is the same guarded list (with execute) for host dispatch after functionCall.
+ */
+export type WithCodeRiftsGeminiResult = {
+    /**
+     * Gemini generateContent `tools` array — only protected/guarded tools, nested under
+     * functionDeclarations (usually length 1 wrapper).
+     */
+    tools: GeminiTool[];
+    /**
+     * Guarded ProtectedTool list from withCodeRifts.
+     * Host dispatches model functionCall through these only. Never raw tools.
+     */
+    protected_tools: ProtectedTool[];
+    /** Untouched registry report — registry's own truth. */
+    registry_report: RegistryCoverageReport;
+    /**
+     * Product-level assurance — deliberately narrower than the registry.
+     * Passed through untouched; may still show inescapable_runtime:false and
+     * residual composition_call_policy_incomplete.
+     */
+    composition_assurance: CompositionAssurance;
+    /** Per-composition receipt cursor — NOT product-truth chain evidence. */
+    receipt_thread: ReceiptThreadHandle;
+    repository?: string;
+};
+/**
+ * Map one ProtectedTool → Gemini functionDeclaration (shape only; no execute).
+ * Prefer tool.inputSchema when it is a plain object; otherwise empty object schema.
+ */
+export declare function protectedToolToFunctionDeclaration(tool: ProtectedTool): GeminiFunctionDeclaration;
+/**
+ * Convert ProtectedTool[] into Gemini `tools` array:
+ *   [ { functionDeclarations: [ … ] } ]
+ *
+ * Empty protected list → empty tools array (no empty wrapper).
+ * Does NOT call the guard — pure shape map over an already-protected list.
+ */
+export declare function toGeminiTools(protectedTools: readonly ProtectedTool[]): GeminiTool[];
+/**
+ * Build Gemini-ready guarded tools from raw tools + client + operation.
+ *
+ * Calls withCodeRifts internally (guard logic stays in the core). Returns:
+ *   - `tools` — Gemini shape [ { functionDeclarations: […] } ]
+ *   - `protected_tools` — same guarded tools for host execute dispatch
+ *   - assurance objects from the core, passed through untouched
+ *
+ * @param input Same shape as withCodeRifts (WithCodeRiftsInput).
+ */
+export declare function withCodeRiftsGemini(input: WithCodeRiftsInput): WithCodeRiftsGeminiResult;
+/**
+ * Shape-only adapter over an existing WithCodeRiftsResult (composition style).
+ * Prefer withCodeRiftsGemini when starting from raw tools.
+ *
+ * Does not re-run the guard; does not invent assurance.
+ */
+export declare function geminiToolAdapter(result: WithCodeRiftsResult): WithCodeRiftsGeminiResult;
+//# sourceMappingURL=gemini.d.ts.map

package/dist/esm/adapters/gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../src/adapters/gemini.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEjF;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,oBAAoB,EAAE,yBAAyB,EAAE,CAAC;CACnD,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;OAGG;IACH,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB;;;OAGG;IACH,eAAe,EAAE,aAAa,EAAE,CAAC;IACjC,wDAAwD;IACxD,eAAe,EAAE,sBAAsB,CAAC;IACxC;;;;OAIG;IACH,qBAAqB,EAAE,oBAAoB,CAAC;IAC5C,yEAAyE;IACzE,cAAc,EAAE,mBAAmB,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;GAGG;AACH,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,aAAa,GAAG,yBAAyB,CAgBjG;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,GAAG,UAAU,EAAE,CAKpF;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,GAAG,yBAAyB,CAGxF;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,yBAAyB,CAcxF"}

package/dist/esm/adapters/gemini.js

@@ -0,0 +1,104 @@
+/**
+ * Google Gemini function-calling adapter over withCodeRifts (ID632 slice 4 —
+ * same thin pattern as OpenAI / Anthropic / LangGraph).
+ *
+ * Thin SHAPE converter only. Guard logic stays in withCodeRifts; this module:
+ *   1. calls withCodeRifts with the same input shape,
+ *   2. maps ProtectedTool[] → Gemini generateContent tools shape,
+ *   3. returns Gemini-shaped tools PLUS the untouched assurance objects
+ *      (registry_report, composition_assurance, receipt_thread).
+ *
+ * Gemini nesting (differs from OpenAI):
+ *   tools: [ { functionDeclarations: [ { name, description?, parameters }, … ] } ]
+ * One tools entry wraps ALL declarations in a single functionDeclarations array —
+ * not one { type: 'function' } object per tool.
+ *
+ * Honesty (do not "upgrade" assurance):
+ *   - composition_assurance is passed through EXACTLY as the core reported it
+ *     (COMPOSITION_CALL_POLICY_COMPLETE may still be false; inescapable_runtime may be false).
+ *   - The adapter converts tool SHAPE for the model API; it does not claim product-level
+ *     inescapability the core does not claim.
+ *
+ * Only-protected-tools (6/D at the adapter surface):
+ *   - `tools` is derived ONLY from the frozen registry's ProtectedTool list.
+ *   - Raw tools never appear in the returned Gemini table. The host may still hold a raw
+ *     reference outside this table; that boundary stays the host's responsibility.
+ *
+ * Ergonomics (5–10 lines): pass raw tools + client + operation → Gemini-ready tools.
+ * Mirrors src/adapters/openai.ts — only the target tool shape differs.
+ */
+import { withCodeRifts } from '../with-coderifts.js';
+/** Empty OpenAPI-like JSON Schema — used when a ProtectedTool has no inputSchema. */
+const EMPTY_PARAMETERS = Object.freeze({
+    type: 'object',
+    properties: {},
+});
+/**
+ * Map one ProtectedTool → Gemini functionDeclaration (shape only; no execute).
+ * Prefer tool.inputSchema when it is a plain object; otherwise empty object schema.
+ */
+export function protectedToolToFunctionDeclaration(tool) {
+    const parameters = tool.inputSchema != null
+        && typeof tool.inputSchema === 'object'
+        && !Array.isArray(tool.inputSchema)
+        ? tool.inputSchema
+        : { ...EMPTY_PARAMETERS };
+    const out = {
+        name: tool.name,
+        parameters,
+    };
+    if (tool.description != null && tool.description !== '') {
+        out.description = tool.description;
+    }
+    return out;
+}
+/**
+ * Convert ProtectedTool[] into Gemini `tools` array:
+ *   [ { functionDeclarations: [ … ] } ]
+ *
+ * Empty protected list → empty tools array (no empty wrapper).
+ * Does NOT call the guard — pure shape map over an already-protected list.
+ */
+export function toGeminiTools(protectedTools) {
+    if (protectedTools.length === 0)
+        return [];
+    return [{
+            functionDeclarations: protectedTools.map(protectedToolToFunctionDeclaration),
+        }];
+}
+/**
+ * Build Gemini-ready guarded tools from raw tools + client + operation.
+ *
+ * Calls withCodeRifts internally (guard logic stays in the core). Returns:
+ *   - `tools` — Gemini shape [ { functionDeclarations: […] } ]
+ *   - `protected_tools` — same guarded tools for host execute dispatch
+ *   - assurance objects from the core, passed through untouched
+ *
+ * @param input Same shape as withCodeRifts (WithCodeRiftsInput).
+ */
+export function withCodeRiftsGemini(input) {
+    const core = withCodeRifts(input);
+    return geminiToolAdapter(core);
+}
+/**
+ * Shape-only adapter over an existing WithCodeRiftsResult (composition style).
+ * Prefer withCodeRiftsGemini when starting from raw tools.
+ *
+ * Does not re-run the guard; does not invent assurance.
+ */
+export function geminiToolAdapter(result) {
+    const protected_tools = result.tools;
+    const tools = toGeminiTools(protected_tools);
+    const out = {
+        tools,
+        protected_tools,
+        registry_report: result.registry_report,
+        composition_assurance: result.composition_assurance,
+        receipt_thread: result.receipt_thread,
+    };
+    if (result.repository !== undefined) {
+        out.repository = result.repository;
+    }
+    return out;
+}
+//# sourceMappingURL=gemini.js.map

package/dist/esm/adapters/gemini.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.js","sourceRoot":"","sources":["../../../src/adapters/gemini.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA+DrD,qFAAqF;AACrF,MAAM,gBAAgB,GAA4B,MAAM,CAAC,MAAM,CAAC;IAC9D,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE,EAAE;CACf,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,kCAAkC,CAAC,IAAmB;IACpE,MAAM,UAAU,GACd,IAAI,CAAC,WAAW,IAAI,IAAI;WACrB,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ;WACpC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;QACjC,CAAC,CAAE,IAAI,CAAC,WAAuC;QAC/C,CAAC,CAAC,EAAE,GAAG,gBAAgB,EAAE,CAAC;IAE9B,MAAM,GAAG,GAA8B;QACrC,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,UAAU;KACX,CAAC;IACF,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,EAAE,EAAE,CAAC;QACxD,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,cAAwC;IACpE,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3C,OAAO,CAAC;YACN,oBAAoB,EAAE,cAAc,CAAC,GAAG,CAAC,kCAAkC,CAAC;SAC7E,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAyB;IAC3D,MAAM,IAAI,GAAwB,aAAa,CAAC,KAAK,CAAC,CAAC;IACvD,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAA2B;IAC3D,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC;IACrC,MAAM,KAAK,GAAG,aAAa,CAAC,eAAe,CAAC,CAAC;IAC7C,MAAM,GAAG,GAA8B;QACrC,KAAK;QACL,eAAe;QACf,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;QACnD,cAAc,EAAE,MAAM,CAAC,cAAc;KACtC,CAAC;IACF,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACpC,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/dist/esm/adapters/langgraph.d.ts

@@ -0,0 +1,117 @@
+/**
+ * LangChain / LangGraph tool adapter over withCodeRifts (ID632 slice 3 — same thin
+ * pattern as OpenAI / Anthropic).
+ *
+ * Thin converter only. Guard logic stays in withCodeRifts; this module:
+ *   1. calls withCodeRifts with the same input shape,
+ *   2. maps each ProtectedTool → a framework-agnostic tool descriptor that
+ *      LangChain's tool()/StructuredTool and LangGraph's ToolNode can accept,
+ *   3. returns those descriptors PLUS the untouched assurance objects
+ *      (registry_report, composition_assurance, receipt_thread).
+ *
+ * NO hard dependency on langchain / @langchain/* / langgraph packages. The host
+ * owns the framework import and wires descriptors into tool() / ToolNode /
+ * bind_tools / StateGraph themselves.
+ *
+ * Descriptor shape (dependency-free plain object):
+ *   { name, description?, schema, func, invoke }
+ *   - schema  = JSON Schema from ProtectedTool.inputSchema (or empty object schema)
+ *   - func / invoke = the GUARDED execute (same function reference) — never the raw tool
+ *
+ * Honesty (do not "upgrade" assurance):
+ *   - composition_assurance is passed through EXACTLY as the core reported it
+ *     (COMPOSITION_CALL_POLICY_COMPLETE may still be false; inescapable_runtime may be false).
+ *   - The adapter converts tool shape + binds guarded execute; it does not claim product-level
+ *     inescapability the core does not claim.
+ *
+ * Only-protected-tools (6/D at the adapter surface):
+ *   - `tools` is derived ONLY from the frozen registry's ProtectedTool list.
+ *   - Raw tools never appear in the returned table. The host may still hold a raw
+ *     reference outside this table; that boundary stays the host's responsibility.
+ *
+ * Ergonomics (5–10 lines): pass raw tools + client + operation → LangGraph-ready descriptors.
+ * Mirrors src/adapters/openai.ts and anthropic.ts — only the target tool shape differs.
+ */
+import type { WithCodeRiftsInput, WithCodeRiftsResult, CompositionAssurance, ReceiptThreadHandle } from '../with-coderifts.js';
+import type { ProtectedTool, RegistryCoverageReport } from '../tool-registry.js';
+/**
+ * Framework-agnostic LangChain/LangGraph tool descriptor (no package import).
+ *
+ * Host wiring (illustrative — host supplies the framework packages, e.g.
+ * @langchain/core tools + @langchain/langgraph ToolNode):
+ *   const lcTools = tools.map((d) =>
+ *     hostTool(d.func, { name: d.name, description: d.description, schema: d.schema }));
+ *   // then hostToolNode(lcTools) / hostLlm.bindTools(lcTools)
+ */
+export type LangGraphToolDescriptor = {
+    name: string;
+    description?: string;
+    /** JSON Schema for tool args (LangChain `schema` / StructuredTool args). */
+    schema: Record<string, unknown>;
+    /**
+     * Guarded execute — same as ProtectedTool.execute.
+     * Pass to LangChain `tool(func, …)` or StructuredTool-style runners.
+     */
+    func: (args: unknown) => Promise<unknown>;
+    /**
+     * Alias of `func` for invoke-style APIs (StructuredTool.invoke / ToolNode).
+     * Same guarded execute reference as `func`.
+     */
+    invoke: (args: unknown) => Promise<unknown>;
+};
+/**
+ * Result of withCodeRiftsLangGraph — descriptors + core assurance, unflattened.
+ *
+ * `tools` is the ONLY list intended for the model/runtime tool table. `protected_tools` is the
+ * same guarded list for host inspection — never the raw tools.
+ */
+export type WithCodeRiftsLangGraphResult = {
+    /** LangGraph/LangChain-compatible descriptors — only protected/guarded tools. */
+    tools: LangGraphToolDescriptor[];
+    /**
+     * Guarded ProtectedTool list from withCodeRifts (same tools as `tools`).
+     * Host may use these for dispatch; never raw tools.
+     */
+    protected_tools: ProtectedTool[];
+    /** Untouched registry report — registry's own truth. */
+    registry_report: RegistryCoverageReport;
+    /**
+     * Product-level assurance — deliberately narrower than the registry.
+     * Passed through untouched; may still show inescapable_runtime:false and
+     * residual composition_call_policy_incomplete.
+     */
+    composition_assurance: CompositionAssurance;
+    /** Per-composition receipt cursor — NOT product-truth chain evidence. */
+    receipt_thread: ReceiptThreadHandle;
+    repository?: string;
+};
+/**
+ * Map one ProtectedTool → LangGraph/LangChain tool descriptor.
+ * Binds guarded execute to both `func` and `invoke` (same reference).
+ * Prefer tool.inputSchema when it is a plain object; otherwise empty object schema.
+ */
+export declare function protectedToolToLangGraph(tool: ProtectedTool): LangGraphToolDescriptor;
+/**
+ * Convert a list of ProtectedTool into LangGraph/LangChain descriptors.
+ * Does NOT call the guard — pure map over an already-protected list.
+ */
+export declare function toLangGraphTools(protectedTools: readonly ProtectedTool[]): LangGraphToolDescriptor[];
+/**
+ * Build LangGraph/LangChain-ready guarded tool descriptors from raw tools + client + operation.
+ *
+ * Calls withCodeRifts internally (guard logic stays in the core). Returns:
+ *   - `tools` — plain descriptors { name, description?, schema, func, invoke }
+ *   - `protected_tools` — same guarded tools
+ *   - assurance objects from the core, passed through untouched
+ *
+ * @param input Same shape as withCodeRifts (WithCodeRiftsInput).
+ */
+export declare function withCodeRiftsLangGraph(input: WithCodeRiftsInput): WithCodeRiftsLangGraphResult;
+/**
+ * Shape adapter over an existing WithCodeRiftsResult (composition style).
+ * Prefer withCodeRiftsLangGraph when starting from raw tools.
+ *
+ * Does not re-run the guard; does not invent assurance.
+ */
+export declare function langGraphToolAdapter(result: WithCodeRiftsResult): WithCodeRiftsLangGraphResult;
+//# sourceMappingURL=langgraph.d.ts.map

package/dist/esm/adapters/langgraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.d.ts","sourceRoot":"","sources":["../../../src/adapters/langgraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAEjF;;;;;;;;GAQG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC;;;OAGG;IACH,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1C;;;OAGG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7C,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG;IACzC,iFAAiF;IACjF,KAAK,EAAE,uBAAuB,EAAE,CAAC;IACjC;;;OAGG;IACH,eAAe,EAAE,aAAa,EAAE,CAAC;IACjC,wDAAwD;IACxD,eAAe,EAAE,sBAAsB,CAAC;IACxC;;;;OAIG;IACH,qBAAqB,EAAE,oBAAoB,CAAC;IAC5C,yEAAyE;IACzE,cAAc,EAAE,mBAAmB,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,GAAG,uBAAuB,CAqBrF;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,SAAS,aAAa,EAAE,GAAG,uBAAuB,EAAE,CAEpG;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,4BAA4B,CAG9F;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,GAAG,4BAA4B,CAc9F"}

package/dist/esm/adapters/langgraph.js

@@ -0,0 +1,107 @@
+/**
+ * LangChain / LangGraph tool adapter over withCodeRifts (ID632 slice 3 — same thin
+ * pattern as OpenAI / Anthropic).
+ *
+ * Thin converter only. Guard logic stays in withCodeRifts; this module:
+ *   1. calls withCodeRifts with the same input shape,
+ *   2. maps each ProtectedTool → a framework-agnostic tool descriptor that
+ *      LangChain's tool()/StructuredTool and LangGraph's ToolNode can accept,
+ *   3. returns those descriptors PLUS the untouched assurance objects
+ *      (registry_report, composition_assurance, receipt_thread).
+ *
+ * NO hard dependency on langchain / @langchain/* / langgraph packages. The host
+ * owns the framework import and wires descriptors into tool() / ToolNode /
+ * bind_tools / StateGraph themselves.
+ *
+ * Descriptor shape (dependency-free plain object):
+ *   { name, description?, schema, func, invoke }
+ *   - schema  = JSON Schema from ProtectedTool.inputSchema (or empty object schema)
+ *   - func / invoke = the GUARDED execute (same function reference) — never the raw tool
+ *
+ * Honesty (do not "upgrade" assurance):
+ *   - composition_assurance is passed through EXACTLY as the core reported it
+ *     (COMPOSITION_CALL_POLICY_COMPLETE may still be false; inescapable_runtime may be false).
+ *   - The adapter converts tool shape + binds guarded execute; it does not claim product-level
+ *     inescapability the core does not claim.
+ *
+ * Only-protected-tools (6/D at the adapter surface):
+ *   - `tools` is derived ONLY from the frozen registry's ProtectedTool list.
+ *   - Raw tools never appear in the returned table. The host may still hold a raw
+ *     reference outside this table; that boundary stays the host's responsibility.
+ *
+ * Ergonomics (5–10 lines): pass raw tools + client + operation → LangGraph-ready descriptors.
+ * Mirrors src/adapters/openai.ts and anthropic.ts — only the target tool shape differs.
+ */
+import { withCodeRifts } from '../with-coderifts.js';
+/** Empty JSON Schema object — used when a ProtectedTool has no inputSchema. */
+const EMPTY_SCHEMA = Object.freeze({
+    type: 'object',
+    properties: {},
+});
+/**
+ * Map one ProtectedTool → LangGraph/LangChain tool descriptor.
+ * Binds guarded execute to both `func` and `invoke` (same reference).
+ * Prefer tool.inputSchema when it is a plain object; otherwise empty object schema.
+ */
+export function protectedToolToLangGraph(tool) {
+    const schema = tool.inputSchema != null
+        && typeof tool.inputSchema === 'object'
+        && !Array.isArray(tool.inputSchema)
+        ? tool.inputSchema
+        : { ...EMPTY_SCHEMA };
+    // Guarded execute only — never a raw unwrapped executor.
+    const guarded = (args) => Promise.resolve(tool.execute(args));
+    const out = {
+        name: tool.name,
+        schema,
+        func: guarded,
+        invoke: guarded,
+    };
+    if (tool.description != null && tool.description !== '') {
+        out.description = tool.description;
+    }
+    return out;
+}
+/**
+ * Convert a list of ProtectedTool into LangGraph/LangChain descriptors.
+ * Does NOT call the guard — pure map over an already-protected list.
+ */
+export function toLangGraphTools(protectedTools) {
+    return protectedTools.map(protectedToolToLangGraph);
+}
+/**
+ * Build LangGraph/LangChain-ready guarded tool descriptors from raw tools + client + operation.
+ *
+ * Calls withCodeRifts internally (guard logic stays in the core). Returns:
+ *   - `tools` — plain descriptors { name, description?, schema, func, invoke }
+ *   - `protected_tools` — same guarded tools
+ *   - assurance objects from the core, passed through untouched
+ *
+ * @param input Same shape as withCodeRifts (WithCodeRiftsInput).
+ */
+export function withCodeRiftsLangGraph(input) {
+    const core = withCodeRifts(input);
+    return langGraphToolAdapter(core);
+}
+/**
+ * Shape adapter over an existing WithCodeRiftsResult (composition style).
+ * Prefer withCodeRiftsLangGraph when starting from raw tools.
+ *
+ * Does not re-run the guard; does not invent assurance.
+ */
+export function langGraphToolAdapter(result) {
+    const protected_tools = result.tools;
+    const tools = toLangGraphTools(protected_tools);
+    const out = {
+        tools,
+        protected_tools,
+        registry_report: result.registry_report,
+        composition_assurance: result.composition_assurance,
+        receipt_thread: result.receipt_thread,
+    };
+    if (result.repository !== undefined) {
+        out.repository = result.repository;
+    }
+    return out;
+}
+//# sourceMappingURL=langgraph.js.map

package/dist/esm/adapters/langgraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"langgraph.js","sourceRoot":"","sources":["../../../src/adapters/langgraph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA8DrD,+EAA+E;AAC/E,MAAM,YAAY,GAA4B,MAAM,CAAC,MAAM,CAAC;IAC1D,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE,EAAE;CACf,CAAC,CAAC;AAEH;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CAAC,IAAmB;IAC1D,MAAM,MAAM,GACV,IAAI,CAAC,WAAW,IAAI,IAAI;WACrB,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ;WACpC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC;QACjC,CAAC,CAAE,IAAI,CAAC,WAAuC;QAC/C,CAAC,CAAC,EAAE,GAAG,YAAY,EAAE,CAAC;IAE1B,yDAAyD;IACzD,MAAM,OAAO,GAAG,CAAC,IAAa,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAEvE,MAAM,GAAG,GAA4B;QACnC,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,MAAM;QACN,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,OAAO;KAChB,CAAC;IACF,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,EAAE,EAAE,CAAC;QACxD,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,cAAwC;IACvE,OAAO,cAAc,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB,CAAC,KAAyB;IAC9D,MAAM,IAAI,GAAwB,aAAa,CAAC,KAAK,CAAC,CAAC;IACvD,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC;AACpC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAA2B;IAC9D,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC;IACrC,MAAM,KAAK,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAC;IAChD,MAAM,GAAG,GAAiC;QACxC,KAAK;QACL,eAAe;QACf,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;QACnD,cAAc,EAAE,MAAM,CAAC,cAAc;KACtC,CAAC;IACF,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACpC,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}