@artemiskit/adapter-langchain 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,133 @@
+# @artemiskit/adapter-langchain
+
+## 0.2.0
+
+### Minor Changes
+
+- ## v0.3.0 - SDK, Guardian Mode & OWASP Compliance
+
+  This major release delivers the full programmatic SDK, runtime protection with Guardian Mode, OWASP LLM Top 10 2025 attack vectors, and agentic framework adapters.
+
+  ### Programmatic SDK (`@artemiskit/sdk`)
+
+  The new SDK package provides a complete programmatic API for LLM evaluation:
+
+  - **ArtemisKit class** with `run()`, `redteam()`, and `stress()` methods
+  - **Jest integration** with custom matchers (`toPassAllCases`, `toHaveSuccessRate`, etc.)
+  - **Vitest integration** with identical matchers
+  - **Event handling** for real-time progress updates
+  - **13 custom matchers** for run, red team, and stress test assertions
+
+  ```typescript
+  import { ArtemisKit } from "@artemiskit/sdk";
+  import { jestMatchers } from "@artemiskit/sdk/jest";
+
+  expect.extend(jestMatchers);
+
+  const kit = new ArtemisKit({ provider: "openai", model: "gpt-4o" });
+  const results = await kit.run({ scenario: "./tests.yaml" });
+  expect(results).toPassAllCases();
+  ```
+
+  ### Guardian Mode (Runtime Protection)
+
+  New Guardian Mode provides runtime protection for AI/LLM applications:
+
+  - **Three operating modes**: `testing`, `guardian`, `hybrid`
+  - **Prompt injection detection** and blocking
+  - **PII detection & redaction** (email, SSN, phone, API keys)
+  - **Action validation** for agent tool/function calls
+  - **Intent classification** with risk assessment
+  - **Circuit breaker** for automatic blocking on repeated violations
+  - **Rate limiting** and **cost limiting**
+  - **Custom policies** via TypeScript or YAML
+
+  ```typescript
+  import { createGuardian } from "@artemiskit/sdk/guardian";
+
+  const guardian = createGuardian({ mode: "guardian", blockOnFailure: true });
+  const protectedClient = guardian.protect(myLLMClient);
+  ```
+
+  ### OWASP LLM Top 10 2025 Attack Vectors
+
+  New red team mutations aligned with OWASP LLM Top 10 2025:
+
+  | Mutation             | OWASP | Description                    |
+  | -------------------- | ----- | ------------------------------ |
+  | `bad-likert-judge`   | LLM01 | Exploit evaluation capability  |
+  | `crescendo`          | LLM01 | Multi-turn gradual escalation  |
+  | `deceptive-delight`  | LLM01 | Positive framing bypass        |
+  | `system-extraction`  | LLM07 | System prompt leakage          |
+  | `output-injection`   | LLM05 | XSS, SQLi in output            |
+  | `excessive-agency`   | LLM06 | Unauthorized action claims     |
+  | `hallucination-trap` | LLM09 | Confident fabrication triggers |
+
+  ```bash
+  akit redteam scenario.yaml --owasp LLM01,LLM05
+  akit redteam scenario.yaml --owasp-full
+  ```
+
+  ### Agentic Framework Adapters
+
+  New adapters for testing agentic AI systems:
+
+  **LangChain Adapter** (`@artemiskit/adapter-langchain`)
+
+  - Test chains, agents, and runnables
+  - Capture intermediate steps and tool usage
+  - Support for LCEL, ReAct agents, RAG chains
+
+  **DeepAgents Adapter** (`@artemiskit/adapter-deepagents`)
+
+  - Test multi-agent systems and workflows
+  - Capture agent traces and inter-agent messages
+  - Support for sequential, parallel, and hierarchical workflows
+
+  ```typescript
+  import { createLangChainAdapter } from "@artemiskit/adapter-langchain";
+  import { createDeepAgentsAdapter } from "@artemiskit/adapter-deepagents";
+
+  const adapter = createLangChainAdapter(myChain, {
+    captureIntermediateSteps: true,
+  });
+  const result = await adapter.generate({ prompt: "Test query" });
+  ```
+
+  ### Supabase Storage Enhancements
+
+  Enhanced cloud storage capabilities:
+
+  - **Analytics tables** for metrics tracking
+  - **Case results table** for granular analysis
+  - **Baseline management** for regression detection
+  - **Trend analysis** queries
+
+  ### Bug Fixes
+
+  - **adapter-openai**: Use `max_completion_tokens` for newer OpenAI models (o1, o3, gpt-4.5)
+  - **redteam**: Resolve TypeScript and flaky test issues in OWASP mutations
+  - **adapters**: Fix TypeScript build errors for agentic adapters
+  - **core**: Add `langchain` and `deepagents` to ProviderType union
+
+  ### Examples
+
+  New comprehensive examples organized by feature:
+
+  - `examples/guardian/` - Guardian Mode examples (testing, guardian, hybrid modes)
+  - `examples/sdk/` - SDK usage examples (Jest, Vitest, events)
+  - `examples/adapters/` - Agentic adapter examples
+  - `examples/owasp/` - OWASP LLM Top 10 test scenarios
+
+  ### Documentation
+
+  - Complete SDK documentation with API reference
+  - Guardian Mode guide with all three modes explained
+  - Agentic adapters documentation (LangChain, DeepAgents)
+  - Test matchers reference for Jest/Vitest
+  - OWASP LLM Top 10 testing scenarios
+
+### Patch Changes
+
+- Updated dependencies
+  - @artemiskit/core@0.3.0

package/README.md

@@ -0,0 +1,151 @@
+# @artemiskit/adapter-langchain
+
+LangChain.js adapter for ArtemisKit - Test and evaluate LangChain chains, agents, and runnables.
+
+## Installation
+
+```bash
+bun add @artemiskit/adapter-langchain
+# or
+npm install @artemiskit/adapter-langchain
+```
+
+## Quick Start
+
+### Testing a Simple Chain
+
+```typescript
+import { createLangChainAdapter } from '@artemiskit/adapter-langchain';
+import { ChatOpenAI } from '@langchain/openai';
+import { StringOutputParser } from '@langchain/core/output_parsers';
+import { ChatPromptTemplate } from '@langchain/core/prompts';
+
+// Create your LangChain chain
+const model = new ChatOpenAI({ model: 'gpt-4' });
+const prompt = ChatPromptTemplate.fromTemplate('Answer concisely: {input}');
+const chain = prompt.pipe(model).pipe(new StringOutputParser());
+
+// Wrap with ArtemisKit adapter
+const adapter = createLangChainAdapter(chain, {
+  name: 'qa-chain',
+  runnableType: 'chain',
+});
+
+// Use in ArtemisKit tests
+const result = await adapter.generate({ prompt: 'What is 2+2?' });
+console.log(result.text); // "4"
+```
+
+### Testing an Agent
+
+```typescript
+import { createLangChainAdapter } from '@artemiskit/adapter-langchain';
+import { AgentExecutor, createReactAgent } from 'langchain/agents';
+import { ChatOpenAI } from '@langchain/openai';
+import { Calculator } from '@langchain/community/tools/calculator';
+
+// Create agent
+const model = new ChatOpenAI({ model: 'gpt-4' });
+const tools = [new Calculator()];
+const agent = createReactAgent({ llm: model, tools, prompt: agentPrompt });
+const agentExecutor = new AgentExecutor({ agent, tools });
+
+// Wrap with ArtemisKit adapter
+const adapter = createLangChainAdapter(agentExecutor, {
+  name: 'calculator-agent',
+  runnableType: 'agent',
+  captureIntermediateSteps: true,
+});
+
+// Use in ArtemisKit tests
+const result = await adapter.generate({ prompt: 'Calculate 25 * 4' });
+console.log(result.text); // "100"
+
+// Access agent execution metadata
+console.log(result.raw.metadata.toolsUsed); // ['calculator']
+console.log(result.raw.metadata.totalToolCalls); // 1
+```
+
+### Testing RAG Chains
+
+```typescript
+import { createLangChainAdapter } from '@artemiskit/adapter-langchain';
+import { ChatOpenAI } from '@langchain/openai';
+import { RetrievalQAChain } from 'langchain/chains';
+
+// Assume vectorstore is already set up
+const retriever = vectorstore.asRetriever();
+const chain = RetrievalQAChain.fromLLM(
+  new ChatOpenAI({ model: 'gpt-4' }),
+  retriever
+);
+
+const adapter = createLangChainAdapter(chain, {
+  name: 'rag-qa',
+  inputKey: 'query',
+  outputKey: 'result',
+});
+
+const result = await adapter.generate({
+  prompt: 'What does the document say about X?',
+});
+```
+
+## Configuration Options
+
+| Option                     | Type                                            | Default     | Description                              |
+| -------------------------- | ----------------------------------------------- | ----------- | ---------------------------------------- |
+| `name`                     | `string`                                        | -           | Identifier for the chain/agent           |
+| `runnableType`             | `'chain' \| 'agent' \| 'llm' \| 'runnable'`     | auto-detect | Type of LangChain runnable               |
+| `captureIntermediateSteps` | `boolean`                                       | `true`      | Capture agent intermediate steps         |
+| `inputKey`                 | `string`                                        | `'input'`   | Custom input key for the runnable        |
+| `outputKey`                | `string`                                        | `'output'`  | Custom output key for the runnable       |
+
+## Supported Runnable Types
+
+The adapter supports all LangChain runnables that implement `invoke()`:
+
+- **Chains**: LCEL chains, RetrievalQA, ConversationalRetrievalQA, etc.
+- **Agents**: ReAct agents, OpenAI Functions agents, Tool-calling agents
+- **LLMs**: Direct ChatOpenAI, ChatAnthropic, etc.
+- **Custom Runnables**: Any object with an `invoke()` method
+
+## Streaming Support
+
+If your runnable supports streaming via `stream()`, the adapter will use it:
+
+```typescript
+for await (const chunk of adapter.stream({ prompt: 'Tell me a story' }, console.log)) {
+  // Process streaming chunks
+}
+```
+
+## ArtemisKit Integration
+
+Use with ArtemisKit scenarios:
+
+```yaml
+# scenario.yaml
+name: langchain-qa-test
+provider: langchain
+scenarios:
+  - name: Basic QA
+    input: 'What is the capital of France?'
+    expected:
+      contains: 'Paris'
+```
+
+```typescript
+// Register adapter in your test setup
+import { adapterRegistry } from '@artemiskit/core';
+import { LangChainAdapter } from '@artemiskit/adapter-langchain';
+
+adapterRegistry.register('langchain', async (config) => {
+  // Your chain/agent setup
+  return new LangChainAdapter(config, myChain);
+});
+```
+
+## License
+
+Apache-2.0

package/dist/client.d.ts

@@ -0,0 +1,73 @@
+/**
+ * LangChain Adapter
+ * Wraps LangChain chains and agents for ArtemisKit testing
+ */
+import type { AdapterConfig, GenerateOptions, GenerateResult, ModelCapabilities, ModelClient } from '@artemiskit/core';
+import type { LangChainAdapterConfig, LangChainRunnable } from './types';
+/**
+ * Adapter for testing LangChain chains and agents with ArtemisKit
+ *
+ * @example
+ * ```typescript
+ * import { LangChainAdapter } from '@artemiskit/adapter-langchain';
+ * import { ChatOpenAI } from '@langchain/openai';
+ * import { StringOutputParser } from '@langchain/core/output_parsers';
+ * import { ChatPromptTemplate } from '@langchain/core/prompts';
+ *
+ * // Create a LangChain chain
+ * const model = new ChatOpenAI({ model: 'gpt-4' });
+ * const prompt = ChatPromptTemplate.fromTemplate('Answer: {input}');
+ * const chain = prompt.pipe(model).pipe(new StringOutputParser());
+ *
+ * // Wrap with ArtemisKit adapter
+ * const adapter = new LangChainAdapter({
+ *   provider: 'langchain',
+ *   runnable: chain,
+ *   runnableType: 'chain',
+ * });
+ *
+ * // Use in ArtemisKit tests
+ * const result = await adapter.generate({ prompt: 'What is 2+2?' });
+ * ```
+ */
+export declare class LangChainAdapter implements ModelClient {
+    private runnable;
+    private config;
+    private runnableType;
+    readonly provider = "langchain";
+    constructor(config: AdapterConfig, runnable: LangChainRunnable);
+    /**
+     * Attempt to detect the type of runnable based on its properties
+     */
+    private detectRunnableType;
+    generate(options: GenerateOptions): Promise<GenerateResult>;
+    stream(options: GenerateOptions, onChunk: (chunk: string) => void): AsyncIterable<string>;
+    capabilities(): Promise<ModelCapabilities>;
+    close(): Promise<void>;
+    /**
+     * Prepare input for the LangChain runnable
+     */
+    private prepareInput;
+    /**
+     * Extract the text output from a LangChain response
+     * Handles various response shapes from different runnable types
+     */
+    private extractOutput;
+    /**
+     * Extract execution metadata from the response
+     */
+    private extractMetadata;
+}
+/**
+ * Factory function to create a LangChain adapter
+ *
+ * @example
+ * ```typescript
+ * const adapter = createLangChainAdapter(myChain, {
+ *   name: 'my-rag-chain',
+ *   runnableType: 'chain',
+ * });
+ * ```
+ */
+export declare function createLangChainAdapter(runnable: LangChainRunnable, options?: Partial<LangChainAdapterConfig>): LangChainAdapter;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,WAAW,EACZ,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EACV,sBAAsB,EAEtB,iBAAiB,EAGlB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,YAAY,CAAwB;IAC5C,QAAQ,CAAC,QAAQ,eAAe;gBAEpB,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,iBAAiB;IAM9D;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAqBpB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;IAmC1D,MAAM,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC;IAqB1F,YAAY,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAW1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;OAEG;IACH,OAAO,CAAC,YAAY;IA6BpB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAgCrB;;OAEG;IACH,OAAO,CAAC,eAAe;CAexB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,GACxC,gBAAgB,CAOlB"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @artemiskit/adapter-langchain
+ *
+ * LangChain.js adapter for ArtemisKit LLM evaluation toolkit.
+ * Enables testing of LangChain chains, agents, and runnables.
+ *
+ * @example
+ * ```typescript
+ * import { createLangChainAdapter } from '@artemiskit/adapter-langchain';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const model = new ChatOpenAI({ model: 'gpt-4' });
+ * const adapter = createLangChainAdapter(model, { name: 'gpt4-direct' });
+ *
+ * // Use with ArtemisKit
+ * const result = await adapter.generate({ prompt: 'Hello!' });
+ * ```
+ */
+export { LangChainAdapter, createLangChainAdapter } from './client';
+export type { LangChainAdapterConfig, LangChainRunnable, LangChainRunnableOutput, LangChainRunnableType, LangChainIntermediateStep, LangChainStreamChunk, LangChainExecutionMetadata, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AACpE,YAAY,EACV,sBAAsB,EACtB,iBAAiB,EACjB,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,170 @@
+// @bun
+// ../../../node_modules/nanoid/index.js
+import { webcrypto as crypto } from "crypto";
+
+// ../../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../../node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid(size = 21) {
+  fillPool(size |= 0);
+  let id = "";
+  for (let i = poolOffset - size;i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id;
+}
+
+// src/client.ts
+class LangChainAdapter {
+  runnable;
+  config;
+  runnableType;
+  provider = "langchain";
+  constructor(config, runnable) {
+    this.config = config;
+    this.runnable = runnable;
+    this.runnableType = this.config.runnableType ?? this.detectRunnableType(runnable);
+  }
+  detectRunnableType(runnable) {
+    const runnableAny = runnable;
+    if (runnableAny.agent || runnableAny.agentExecutor || typeof runnableAny.runAgent === "function") {
+      return "agent";
+    }
+    if (runnableAny.modelName || runnableAny.model || runnableAny._llmType) {
+      return "llm";
+    }
+    return "runnable";
+  }
+  async generate(options) {
+    const startTime = Date.now();
+    const input = this.prepareInput(options);
+    const response = await this.runnable.invoke(input);
+    const latencyMs = Date.now() - startTime;
+    const text = this.extractOutput(response);
+    const metadata = this.extractMetadata(response);
+    return {
+      id: nanoid(),
+      model: this.config.name || `langchain:${this.runnableType}`,
+      text,
+      tokens: {
+        prompt: 0,
+        completion: 0,
+        total: 0
+      },
+      latencyMs,
+      finishReason: "stop",
+      raw: {
+        response,
+        metadata
+      }
+    };
+  }
+  async* stream(options, onChunk) {
+    if (!this.runnable.stream) {
+      const result = await this.generate(options);
+      onChunk(result.text);
+      yield result.text;
+      return;
+    }
+    const input = this.prepareInput(options);
+    const stream = this.runnable.stream(input);
+    for await (const chunk of stream) {
+      const text = chunk.content?.toString() || chunk.text || "";
+      if (text) {
+        onChunk(text);
+        yield text;
+      }
+    }
+  }
+  async capabilities() {
+    return {
+      streaming: typeof this.runnable.stream === "function",
+      functionCalling: this.runnableType === "agent",
+      toolUse: this.runnableType === "agent",
+      maxContext: 128000,
+      vision: false,
+      jsonMode: false
+    };
+  }
+  async close() {}
+  prepareInput(options) {
+    const inputKey = this.config.inputKey ?? "input";
+    if (typeof options.prompt === "string") {
+      return { [inputKey]: options.prompt };
+    }
+    const messages = options.prompt;
+    const lastUserMessage = messages.findLast((m) => m.role === "user");
+    const systemMessage = messages.find((m) => m.role === "system");
+    if (systemMessage) {
+      return {
+        [inputKey]: lastUserMessage?.content || "",
+        system: systemMessage.content,
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        }))
+      };
+    }
+    return { [inputKey]: lastUserMessage?.content || "" };
+  }
+  extractOutput(response) {
+    const outputKey = this.config.outputKey ?? "output";
+    if (typeof response === "string") {
+      return response;
+    }
+    const possibleKeys = [outputKey, "output", "content", "text", "result", "answer"];
+    for (const key of possibleKeys) {
+      const value = response[key];
+      if (typeof value === "string") {
+        return value;
+      }
+      if (value && typeof value === "object" && "content" in value) {
+        return String(value.content);
+      }
+    }
+    if (response.intermediateSteps?.length) {
+      const steps = response.intermediateSteps;
+      const lastStep = steps[steps.length - 1];
+      return lastStep?.observation || JSON.stringify(response);
+    }
+    return JSON.stringify(response);
+  }
+  extractMetadata(response) {
+    const metadata = {
+      runnableType: this.runnableType,
+      name: this.config.name
+    };
+    if (this.config.captureIntermediateSteps !== false && response.intermediateSteps) {
+      metadata.intermediateSteps = response.intermediateSteps;
+      metadata.toolsUsed = [...new Set(response.intermediateSteps.map((s) => s.action.tool))];
+      metadata.totalToolCalls = response.intermediateSteps.length;
+    }
+    return metadata;
+  }
+}
+function createLangChainAdapter(runnable, options) {
+  const config = {
+    provider: "langchain",
+    ...options
+  };
+  return new LangChainAdapter(config, runnable);
+}
+export {
+  createLangChainAdapter,
+  LangChainAdapter
+};

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Types for LangChain adapter
+ */
+import type { BaseAdapterConfig } from '@artemiskit/core';
+/**
+ * Supported LangChain runnable types
+ */
+export type LangChainRunnableType = 'chain' | 'agent' | 'llm' | 'runnable';
+/**
+ * Configuration for LangChain adapter
+ */
+export interface LangChainAdapterConfig extends BaseAdapterConfig {
+    provider: 'langchain';
+    /**
+     * The type of LangChain runnable being wrapped
+     */
+    runnableType?: LangChainRunnableType;
+    /**
+     * Name identifier for the chain/agent (for logging/tracking)
+     */
+    name?: string;
+    /**
+     * Whether to capture intermediate steps from agents
+     * @default true
+     */
+    captureIntermediateSteps?: boolean;
+    /**
+     * Custom input key for the runnable (default: 'input')
+     */
+    inputKey?: string;
+    /**
+     * Custom output key for the runnable (default: 'output')
+     */
+    outputKey?: string;
+}
+/**
+ * Generic interface for LangChain-like runnables
+ * Supports both chains and agents with invoke() method
+ */
+export interface LangChainRunnable {
+    invoke(input: Record<string, unknown> | string, config?: Record<string, unknown>): Promise<LangChainRunnableOutput>;
+    stream?(input: Record<string, unknown> | string, config?: Record<string, unknown>): AsyncIterable<LangChainStreamChunk>;
+}
+/**
+ * Output from a LangChain runnable
+ */
+export interface LangChainRunnableOutput {
+    /** Main text output - can be in various forms */
+    output?: string;
+    content?: string;
+    text?: string;
+    result?: string;
+    /** For agent outputs with intermediate steps */
+    intermediateSteps?: LangChainIntermediateStep[];
+    /** Raw response for other properties */
+    [key: string]: unknown;
+}
+/**
+ * Intermediate step from agent execution
+ */
+export interface LangChainIntermediateStep {
+    action: {
+        tool: string;
+        toolInput: unknown;
+        log?: string;
+    };
+    observation: string;
+}
+/**
+ * Streaming chunk from LangChain
+ */
+export interface LangChainStreamChunk {
+    content?: string;
+    text?: string;
+    [key: string]: unknown;
+}
+/**
+ * Metadata extracted from LangChain execution
+ */
+export interface LangChainExecutionMetadata {
+    runnableType: LangChainRunnableType;
+    name?: string;
+    intermediateSteps?: LangChainIntermediateStep[];
+    toolsUsed?: string[];
+    totalToolCalls?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,iBAAiB;IAC/D,QAAQ,EAAE,WAAW,CAAC;IACtB;;OAEG;IACH,YAAY,CAAC,EAAE,qBAAqB,CAAC;IACrC;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,CACJ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EACvC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACpC,MAAM,CAAC,CACL,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,EACvC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,aAAa,CAAC,oBAAoB,CAAC,CAAC;CACxC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,iBAAiB,CAAC,EAAE,yBAAyB,EAAE,CAAC;IAChD,wCAAwC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,OAAO,CAAC;QACnB,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,YAAY,EAAE,qBAAqB,CAAC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iBAAiB,CAAC,EAAE,yBAAyB,EAAE,CAAC;IAChD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}