@friskai/frisk-js 0.1.0

package/README.md

@@ -0,0 +1,316 @@
+# frisk_js - JavaScript/TypeScript Bindings for FriskAI Policy Engine
+
+JavaScript and TypeScript bindings for the FriskAI policy engine, available in two flavors:
+
+1. **Node-native N-API bindings** (recommended for Node.js) - Full-featured with OpenTelemetry and PolicyManager
+2. **WebAssembly bindings** - Lightweight for browser environments
+
+## Features
+
+### N-API Bindings (Node.js)
+- 🚀 **Native Performance**: Compiled to native code via Rust N-API
+- 🔄 **Full Feature Parity**: Matches Python SDK functionality
+- 📊 **OpenTelemetry Integration**: Built-in observability
+- 🔄 **Auto Policy Refresh**: Automatic policy synchronization
+- 🔒 **Singleton Pattern**: Process-wide handle management
+- 🛡️ **Field Redaction**: Privacy-preserving data handling
+- 📘 **TypeScript Support**: Full type definitions with JSDoc documentation
+
+### WASM Bindings (Browser/Universal)
+- 🌐 **Universal**: Works in browser and Node.js environments
+- 🔒 **Deterministic**: Consistent policy evaluation across all platforms
+- 📦 **Zero Dependencies**: No external runtime dependencies
+
+## Installation
+
+### N-API (Node.js)
+
+```bash
+# Build from source
+cd crates/frisk_js
+napi build --no-default-features --features napi --platform
+
+# The .node file will be created in the current directory
+```
+
+### WASM (Browser)
+
+```bash
+cd crates/frisk_js
+wasm-pack build --target bundler --out-dir pkg
+```
+
+## Usage
+
+### N-API (Node.js) - JavaScript
+
+```javascript
+const { FriskHandle, redactDictionary } = require('./frisk-js.linux-x64-gnu.node');
+
+// Create singleton handle (automatically starts policy refresh)
+const handle = new FriskHandle(
+  process.env.FRISK_TOKEN,
+  'https://api.frisk.ai',
+  'http://otel-collector:4317'
+);
+
+// Process a tool call
+const result = handle.process(
+  'tool_name',
+  JSON.stringify({ action: 'allowed' }),  // tool args
+  JSON.stringify({ user: 'john' }),       // agent state
+  'call-id-123',                          // tool call ID
+  {                                       // options
+    redact_tool_args: true,
+    redact_agent_state: ['password', 'token']
+  },
+  {                                       // OpenTelemetry trace context
+    traceparent: '00-...'
+  }
+);
+
+console.log(result);
+// { decision: 'allow', rules_matched_count: 1, reason: '...' }
+
+// Update token if needed
+handle.updateAuthToken(newToken);
+
+// Redact sensitive data
+const redacted = redactDictionary(
+  JSON.stringify({ secret: "value", public: "data" }),
+  ['secret']  // or true for all fields
+);
+console.log(redacted.redacted);
+console.log(redacted.matched_paths);
+```
+
+### N-API (Node.js) - TypeScript
+
+Full TypeScript support with comprehensive type definitions:
+
+```typescript
+import { 
+  FriskHandle, 
+  redactDictionary,
+  ProcessToolCallResult,
+  ProcessToolCallOptions,
+  TraceContextCarrier 
+} from '@friskai/frisk-js';
+
+// Create handle with full type checking
+const handle = new FriskHandle(
+  process.env.FRISK_TOKEN!,
+  'https://api.frisk.ai',
+  'http://otel-collector:4317'
+);
+
+// Process with typed options
+const options: ProcessToolCallOptions = {
+  redact_tool_args: ['password', 'api_key'],
+  redact_agent_state: true
+};
+
+const traceContext: TraceContextCarrier = {
+  traceparent: '00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01'
+};
+
+const result: ProcessToolCallResult = handle.process(
+  'send_email',
+  JSON.stringify({ recipient: 'user@example.com' }),
+  JSON.stringify({ user_id: 123 }),
+  'call-abc-123',
+  options,
+  traceContext
+);
+
+// TypeScript knows the exact shape of result
+if (result.decision === 'allow') {
+  console.log(`Allowed: ${result.reason}`);
+} else {
+  console.log(`Denied: ${result.reason}`);
+}
+```
+
+**TypeScript Features:**
+- ✅ Full IntelliSense support in your IDE
+- ✅ Compile-time type checking
+- ✅ Comprehensive JSDoc documentation
+- ✅ Type-safe APIs for all methods
+- ✅ Example code in `examples/typescript/`
+
+See [examples/typescript/README.md](./examples/typescript/README.md) for a complete TypeScript example.
+
+### WASM (Browser)
+
+```javascript
+import { JsPolicyEngine } from '@frisk/policy-engine';
+
+// Define your policies
+const policies = [
+  {
+    id: "policy-1",
+    current_version_id: "v1",
+    status: "ACTIVE",
+    policy: {
+      tool_name: "send_email",
+      rule: {
+        action: "allow",
+        when: {
+          source: "args",
+          matches: {
+            key: "recipient",
+            op: "eq",
+            value: "admin@example.com"
+          }
+        }
+      }
+    }
+  }
+];
+
+// Create engine instance
+const engine = new JsPolicyEngine(policies);
+
+// Evaluate a tool call
+const result = engine.evaluateToolCall(
+  "send_email",
+  { recipient: "admin@example.com", subject: "Test" },
+  { user: "john" },
+  "company-123"
+);
+
+console.log(result);
+// Output: { decision: "allow", rules_matched_count: 1, reason: "..." }
+```
+
+### TypeScript Example
+
+```typescript
+import { JsPolicyEngine } from '@frisk/policy-engine';
+
+interface EvaluationResult {
+  decision: 'allow' | 'deny';
+  rules_matched_count: number;
+  reason: string;
+}
+
+const engine = new JsPolicyEngine(policies);
+const result: EvaluationResult = engine.evaluateToolCall(
+  "send_email",
+  { recipient: "user@example.com" },
+  {},
+  "company-123"
+);
+```
+
+## API Reference
+
+### `JsPolicyEngine`
+
+#### Constructor
+
+```typescript
+new JsPolicyEngine(policies_json: object | string)
+```
+
+Creates a new policy engine instance with the given policies.
+
+**Parameters:**
+- `policies_json`: Policy definitions as an object or JSON string
+
+**Throws:**
+- Error if policies JSON is invalid
+- Error if policies cannot be deserialized
+
+#### `evaluateToolCall`
+
+```typescript
+evaluateToolCall(
+  tool_name: string,
+  tool_args: object,
+  agent_state: object,
+  company_id: string
+): EvaluationResult
+```
+
+Evaluates a tool call against the loaded policies.
+
+**Parameters:**
+- `tool_name`: Name of the tool being called
+- `tool_args`: Arguments passed to the tool (as JSON object or string)
+- `agent_state`: Current agent state (as JSON object or string)
+- `company_id`: Company identifier
+
+**Returns:**
+- `EvaluationResult` object containing:
+  - `decision`: "allow" or "deny"
+  - `rules_matched_count`: Number of rules that matched
+  - `reason`: Human-readable reason for the decision
+
+**Throws:**
+- Error if arguments cannot be parsed as JSON
+- Error if result cannot be serialized
+
+## Policy Format
+
+Policies should follow this structure:
+
+```json
+{
+  "id": "unique-policy-id",
+  "current_version_id": "version-id",
+  "status": "ACTIVE",
+  "policy": {
+    "tool_name": "tool_name_to_match",
+    "rule": {
+      "action": "allow" | "deny" | "modify",
+      "when": {
+        "source": "args" | "state",
+        "matches": {
+          "key": "field_name",
+          "op": "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "in" | "contains" | "regex",
+          "value": "expected_value"
+        }
+      }
+    }
+  }
+}
+```
+
+## Browser Support
+
+Modern browsers with WebAssembly support:
+- Chrome/Edge 57+
+- Firefox 52+
+- Safari 11+
+
+## Node.js Support
+
+Node.js 12+ with WebAssembly support
+
+## Building from Source
+
+```bash
+# Install wasm-pack
+cargo install wasm-pack
+
+# Build the package
+cd crates/frisk_js
+wasm-pack build --target bundler --out-dir pkg
+
+# The generated package will be in the pkg/ directory
+```
+
+## Bundle Size
+
+- Uncompressed: ~1.5 MB
+- Gzipped: ~500 KB
+- Brotli: ~450 KB (estimated)
+
+## License
+
+See the root repository LICENSE file.
+
+## Contributing
+
+Contributions are welcome! Please see the main repository for contribution guidelines.

package/dist/adapters/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @friskai/frisk-js Adapters
+ *
+ * Framework adapters for integrating Frisk with popular AI/LLM frameworks.
+ */
+export { FRISK_SESSION_ID_KEY, FriskCallbackHandler, FriskLangchain, type FriskLangchainInitParams, FriskToolMiddleware, type FriskToolMiddlewareOptions, } from './langchain';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,cAAc,EACd,KAAK,wBAAwB,EAC7B,mBAAmB,EACnB,KAAK,0BAA0B,GAChC,MAAM,aAAa,CAAA"}

package/dist/adapters/langchain/frisk-callback-handler.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @friskai/frisk-js FriskCallbackHandler
+ *
+ * LangChain callback handler for Frisk session tracing.
+ * Handles chain lifecycle events to manage tracing spans.
+ */
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import type { Serialized } from '@langchain/core/load/serializable';
+import type { ChainValues } from '@langchain/core/utils/types';
+import type { FriskLangchain } from './frisk-langchain';
+/**
+ * FriskCallbackHandler - LangChain callback handler for Frisk tracing
+ *
+ * This handler integrates with LangChain's callback system to automatically
+ * manage tracing spans for Frisk sessions. It initializes tracing when a
+ * root chain starts and ends tracing when the root chain completes.
+ *
+ * @example
+ * ```typescript
+ * import { FriskLangchain } from '@friskai/frisk-js';
+ *
+ * const frisk = new FriskLangchain({ apiKey: process.env.FRISK_API_KEY });
+ * await frisk.init();
+ *
+ * const sessionId = frisk.createSession();
+ * const callbackHandler = frisk.callbackHandler(sessionId);
+ *
+ * // Use with LangChain
+ * const result = await agent.invoke(
+ *   { input: 'Hello' },
+ *   { callbacks: [callbackHandler] }
+ * );
+ * ```
+ */
+export declare class FriskCallbackHandler extends BaseCallbackHandler {
+    name: string;
+    private _frisk;
+    private _sessionId;
+    private _friskSession;
+    constructor(frisk: FriskLangchain, sessionId: string);
+    /**
+     * Called at the start of a Chain run.
+     * Initializes tracing for root chains (those without a parent).
+     *
+     * NOTE: The official documentation and source code types state that `parentRunId` is the 8th argument to this method, but this isn't true.
+     * In practice, `parentRunId` is the 4th argument. This may be a documentation bug or an issue with the types, but we need to use the correct argument position to get the parent run ID.
+     */
+    handleChainStart(_chain: Serialized, inputs: ChainValues, runId: string, parentRunId?: string): void;
+    /**
+     * Called at the end of a Chain run.
+     * Ends tracing when the root chain completes.
+     */
+    handleChainEnd(_outputs: ChainValues, runId: string): void;
+}
+//# sourceMappingURL=frisk-callback-handler.d.ts.map

package/dist/adapters/langchain/frisk-callback-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frisk-callback-handler.d.ts","sourceRoot":"","sources":["../../../src/adapters/langchain/frisk-callback-handler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAI9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,oBAAqB,SAAQ,mBAAmB;IAC3D,IAAI,SAAyB;IAE7B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,aAAa,CAAc;gBAEvB,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM;IAmBpD;;;;;;OAMG;IACH,gBAAgB,CACd,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,GACnB,IAAI;IAOP;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAM3D"}

package/dist/adapters/langchain/frisk-langchain.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @friskai/frisk-js LangChain Integration
+ *
+ * FriskLangchain class that extends Frisk with LangChain-specific functionality.
+ */
+import { StateSchema } from '@langchain/langgraph';
+import { Frisk } from '../../core/frisk';
+import type { FriskInitParams } from '../../core/types';
+import { type LangChainToolCall } from '../../framework-adapter';
+import { FriskCallbackHandler } from './frisk-callback-handler';
+import type { LangchainTool } from './langchain-framework-adapter/langchain-framework-adapter';
+/**
+ * LangChain-specific Frisk init params (without frameworkAdapter since it's preset)
+ */
+export type FriskLangchainInitParams = Omit<FriskInitParams<LangChainToolCall, LangchainTool>, 'frameworkAdapter'>;
+/**
+ * FriskLangchain - Frisk SDK configured for LangChain integration
+ *
+ * Extends the base Frisk class with LangChain-specific functionality.
+ * Automatically configures the LangchainFrameworkAdapter.
+ *
+ * @example
+ * ```typescript
+ * import { FriskLangchain } from '@friskai/frisk-js';
+ *
+ * const frisk = new FriskLangchain({
+ *   apiKey: process.env.FRISK_API_KEY,
+ *   options: {
+ *     redactToolArgs: ['password'],
+ *   },
+ * });
+ *
+ * await frisk.init();
+ *
+ * // Wrap tools with policy enforcement
+ * const wrappedTools = frisk.wrapTools(myTools);
+ *
+ * // Evaluate a tool call
+ * const result = frisk.evaluateToolCall(
+ *   'send_email',
+ *   { recipient: 'user@example.com' },
+ *   { userId: 123 }
+ * );
+ * ```
+ */
+export declare class FriskLangchain extends Frisk<LangChainToolCall, LangchainTool> {
+    constructor(params?: FriskLangchainInitParams);
+    /**
+     * Create a callback handler for a session
+     *
+     * The callback handler integrates with LangChain's callback system to
+     * automatically manage tracing spans for the session.
+     *
+     * @param sessionId - The session ID to create a callback handler for
+     * @returns A FriskCallbackHandler instance
+     *
+     * @example
+     * ```typescript
+     * const sessionId = frisk.createSession();
+     * const callbackHandler = frisk.callbackHandler(sessionId);
+     *
+     * const result = await agent.invoke(
+     *   { input: 'Hello' },
+     *   { callbacks: [callbackHandler] }
+     * );
+     * ```
+     */
+    callbackHandler(sessionId: string): FriskCallbackHandler;
+    toolMiddleware(agentStateSchema: StateSchema<any>): import("langchain").AgentMiddleware<any, any, unknown, readonly (import("@langchain/core/tools").ClientTool | import("@langchain/core/tools").ServerTool)[]>;
+}
+//# sourceMappingURL=frisk-langchain.d.ts.map

package/dist/adapters/langchain/frisk-langchain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frisk-langchain.d.ts","sourceRoot":"","sources":["../../../src/adapters/langchain/frisk-langchain.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAElD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,EACL,KAAK,iBAAiB,EAEvB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2DAA2D,CAAA;AAE9F;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,IAAI,CACzC,eAAe,CAAC,iBAAiB,EAAE,aAAa,CAAC,EACjD,kBAAkB,CACnB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,cAAe,SAAQ,KAAK,CAAC,iBAAiB,EAAE,aAAa,CAAC;gBAC7D,MAAM,CAAC,EAAE,wBAAwB;IAO7C;;;;;;;;;;;;;;;;;;;OAmBG;IACI,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,oBAAoB;IAIxD,cAAc,CAAC,gBAAgB,EAAE,WAAW,CAAC,GAAG,CAAC;CAqBzD"}

package/dist/adapters/langchain/frisk-tool-middleware.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @friskai/frisk-js FriskToolMiddleware
+ *
+ * Middleware for intercepting and evaluating LangChain tool calls
+ * against Frisk policies before execution.
+ */
+import { Command } from '@langchain/langgraph';
+import { ToolCallHandler, ToolCallRequest, ToolMessage } from 'langchain';
+import { FriskSDKLogOptions } from '../../logging';
+import { FriskLangchain } from './frisk-langchain';
+import { FriskContext } from './types';
+/**
+ * Options for creating a Frisk tool middleware
+ */
+export interface FriskToolMiddlewareOptions {
+    logging?: FriskSDKLogOptions;
+}
+/**
+ * FriskToolMiddleware - Middleware for LangChain tool call interception
+ *
+ * This middleware wraps LangChain tools with policy enforcement.
+ * When a tool is called, it first evaluates the call against Frisk policies.
+ * If the policy denies the call, a denial message is returned instead of
+ * executing the tool.
+ *
+ * @example
+ * ```typescript
+ * import { FriskLangchain } from '@friskai/frisk-js';
+ *
+ * const frisk = new FriskLangchain({ apiKey: process.env.FRISK_API_KEY });
+ * await frisk.init();
+ *
+ * const session = frisk.createSession();
+ * const middleware = session.toolMiddleware();
+ *
+ * // Wrap tools with policy enforcement
+ * const wrappedTools = middleware.wrapTools(tools);
+ *
+ * // Use wrapped tools with LangGraph agent
+ * const agent = createReactAgent({
+ *   llm,
+ *   tools: wrappedTools,
+ * });
+ *
+ * // Invoke with the session ID in configurable
+ * await agent.invoke(
+ *   { messages: [new HumanMessage("Hello")] },
+ *   { configurable: { frisk_session_id: session.sessionId } }
+ * );
+ * ```
+ */
+export declare class FriskToolMiddleware<TState extends Record<string, unknown> = Record<string, unknown>, TContext extends FriskContext = FriskContext> {
+    private _frisk;
+    private logger;
+    name: string;
+    constructor(frisk: FriskLangchain, options?: FriskToolMiddlewareOptions);
+    /**
+     * Get the Frisk instance
+     */
+    get frisk(): FriskLangchain;
+    wrapToolCall(request: ToolCallRequest<TState, TContext>, handler: ToolCallHandler<TState, TContext>): Promise<ToolMessage | Command>;
+    /**
+     * Get the Frisk session from the RunnableConfig
+     */
+    private getFriskSessionFromRuntime;
+    private blockOrExecuteToolCall;
+}
+//# sourceMappingURL=frisk-tool-middleware.d.ts.map

package/dist/adapters/langchain/frisk-tool-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frisk-tool-middleware.d.ts","sourceRoot":"","sources":["../../../src/adapters/langchain/frisk-tool-middleware.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAC9C,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAUzE,OAAO,EAAE,kBAAkB,EAAa,MAAM,eAAe,CAAA;AAE7D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAClD,OAAO,EAEL,YAAY,EAEb,MAAM,SAAS,CAAA;AAEhB;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,kBAAkB,CAAA;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,mBAAmB,CAC9B,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,QAAQ,SAAS,YAAY,GAAG,YAAY;IAG5C,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAW;IAElB,IAAI,SAAwB;gBACvB,KAAK,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,0BAA0B;IAOvE;;OAEG;IACH,IAAI,KAAK,IAAI,cAAc,CAE1B;IAEY,YAAY,CACvB,OAAO,EAAE,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC1C,OAAO,EAAE,eAAe,CAAC,MAAM,EAAE,QAAQ,CAAC,GACzC,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC;IAiCjC;;OAEG;IACH,OAAO,CAAC,0BAA0B;YAyBpB,sBAAsB;CAgBrC"}

package/dist/adapters/langchain/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @friskai/frisk-js LangChain Adapter
+ *
+ * Exports for LangChain integration.
+ */
+export { FriskCallbackHandler } from './frisk-callback-handler';
+export { FriskLangchain, type FriskLangchainInitParams, } from './frisk-langchain';
+export { FriskToolMiddleware, type FriskToolMiddlewareOptions, } from './frisk-tool-middleware';
+export { FRISK_SESSION_ID_KEY } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/langchain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/langchain/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EACL,cAAc,EACd,KAAK,wBAAwB,GAC9B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EACL,mBAAmB,EACnB,KAAK,0BAA0B,GAChC,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA"}

package/dist/adapters/langchain/langchain-framework-adapter/langchain-framework-adapter.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @friskai/frisk-js LangChain Framework Adapter
+ *
+ * Framework adapter for LangChain integration.
+ * Handles LangChain-specific tool calls, serialization, and tool wrapping.
+ */
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { ZodObject } from 'zod/v4';
+import type { FrameworkAdapter, ToolCallInfo } from '../../../framework-adapter/framework-adapter';
+import type { RedactedDictionary, RedactedSerializedObject, RedactOption } from '../../../utils/redact';
+/**
+ * LangChain ToolCall type
+ * Represents a tool call from LangChain messages
+ */
+export interface LangChainToolCall {
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+    type?: string;
+}
+export interface LangchainTool {
+}
+/**
+ * LangChain framework adapter
+ *
+ * Provides LangChain-specific implementation of the FrameworkAdapter interface.
+ * Handles ToolCall objects, message serialization, and tool wrapping.
+ *
+ * @example
+ * ```typescript
+ * import { LangchainFrameworkAdapter } from '@friskai/frisk-js';
+ *
+ * const adapter = new LangchainFrameworkAdapter();
+ *
+ * // Extract tool call info from a LangChain ToolCall
+ * const toolCallInfo = adapter.getToolCallInfo(toolCall);
+ *
+ * // Serialize agent state with redaction
+ * const serialized = adapter.serializeAgentState(state, {
+ *   redact: ['password', 'api_key'],
+ * });
+ * ```
+ */
+export declare class LangchainFrameworkAdapter implements FrameworkAdapter<LangChainToolCall, LangchainTool> {
+    /**
+     * Serialize tool arguments to JSON with optional redaction
+     */
+    serializeToolArgs(toolArgs: Record<string, unknown> | null | undefined, options?: {
+        redact?: RedactOption;
+    }): RedactedSerializedObject;
+    /**
+     * Serialize agent state to JSON with optional redaction
+     *
+     * Automatically excludes the 'messages' key from serialization
+     * as it typically contains large message arrays.
+     */
+    serializeAgentState(agentState: Record<string, unknown> | null | undefined, options?: {
+        redact?: RedactOption;
+    }): RedactedSerializedObject;
+    /**
+     * Convert tool arguments to dictionary with optional redaction
+     */
+    toolArgsToDict(toolArgs: Record<string, unknown>, options?: {
+        redact?: RedactOption;
+    }): RedactedDictionary;
+    /**
+     * Convert agent state to dictionary with optional redaction
+     *
+     * Automatically combines the provided redact option with EXCLUDED_STATE_KEYS
+     */
+    agentStateToDict(agentState: Record<string, unknown>, options?: {
+        redact?: RedactOption;
+    }): RedactedDictionary;
+    /**
+     * Extract tool call information from a LangChain ToolCall
+     */
+    getToolCallInfo(toolCall: LangChainToolCall): ToolCallInfo;
+    /**
+     * Get the tool call ID or generate one if not present
+     */
+    private getOrCreateToolCallId;
+    /**
+     * Get the tool name from a ToolCall
+     */
+    private getToolName;
+    /**
+     * Extract the user query from agent state
+     *
+     * Looks for the last human message in the messages array
+     */
+    getUserQuery(agentState: Record<string, unknown>): string | null;
+    /**
+     * Wrap tools with additional functionality
+     *
+     * Note: For Frisk policy enforcement, use FriskLangChain.wrapTools() instead.
+     * This method provides basic tool wrapping without policy checks.
+     */
+    wrapTools(tools: Iterable<DynamicStructuredTool<ZodObject>>): DynamicStructuredTool[];
+    /**
+     * Wrap a single tool
+     *
+     * This is a passthrough by default. Override in subclasses for custom wrapping.
+     */
+    wrapTool(originalTool: DynamicStructuredTool<ZodObject>): DynamicStructuredTool;
+}
+//# sourceMappingURL=langchain-framework-adapter.d.ts.map

package/dist/adapters/langchain/langchain-framework-adapter/langchain-framework-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain-framework-adapter.d.ts","sourceRoot":"","sources":["../../../../src/adapters/langchain/langchain-framework-adapter/langchain-framework-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAClC,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACb,MAAM,8CAA8C,CAAA;AACrD,OAAO,KAAK,EACV,kBAAkB,EAClB,wBAAwB,EACxB,YAAY,EACb,MAAM,uBAAuB,CAAA;AAO9B;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,aAAa;CAE7B;AAQD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,yBACX,YAAW,gBAAgB,CAAC,iBAAiB,EAAE,aAAa,CAAC;IAE7D;;OAEG;IACH,iBAAiB,CACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EACpD,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,GAClC,wBAAwB;IAY3B;;;;;OAKG;IACH,mBAAmB,CACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EACtD,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,GAClC,wBAAwB;IAY3B;;OAEG;IACH,cAAc,CACZ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,GAClC,kBAAkB;IAIrB;;;;OAIG;IACH,gBAAgB,CACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,YAAY,CAAA;KAAE,GAClC,kBAAkB;IAQrB;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,iBAAiB,GAAG,YAAY;IAQ1D;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAU7B;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;;;OAIG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IA6BhE;;;;;OAKG;IACH,SAAS,CACP,KAAK,EAAE,QAAQ,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,GAChD,qBAAqB,EAAE;IAI1B;;;;OAIG;IACI,QAAQ,CACb,YAAY,EAAE,qBAAqB,CAAC,SAAS,CAAC,GAC7C,qBAAqB;CAKzB"}

package/dist/adapters/langchain/langchain-framework-adapter/wrapToolWithLlmReasoning.d.ts

@@ -0,0 +1,4 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { ZodObject } from 'zod/v4';
+export declare function wrapToolWithLlmReasoning(tool: DynamicStructuredTool<ZodObject>): any;
+//# sourceMappingURL=wrapToolWithLlmReasoning.d.ts.map

package/dist/adapters/langchain/langchain-framework-adapter/wrapToolWithLlmReasoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapToolWithLlmReasoning.d.ts","sourceRoot":"","sources":["../../../../src/adapters/langchain/langchain-framework-adapter/wrapToolWithLlmReasoning.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAG7D,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAKlC,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,qBAAqB,CAAC,SAAS,CAAC,GACrC,GAAG,CAsCL"}