@niadra/sdk 0.1.0 → 0.7.0

package/dist/langchain.d.ts

@@ -0,0 +1,102 @@
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import { BaseMessage } from '@langchain/core/messages';
+import { LLMResult } from '@langchain/core/outputs';
+import { Runnable } from '@langchain/core/runnables';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { g as ModelUsage } from './client-DsIxZxZk.js';
+import { S as SessionResolver, a as ProofSource, A as AgentMemoryOption, b as Session } from './shared-Bb5B59Bu.js';
+export { P as Proof, c as attestationProof } from './shared-Bb5B59Bu.js';
+import { Serialized } from '@langchain/core/load/serializable';
+
+/**
+ * Niadra for LangChain.js and LangGraph.js (`@langchain/core` 1.x).
+ *
+ * - `niadraContext(session)` is a runnable for LCEL chains (`niadraContext(convo).pipe(model)`):
+ *   it takes the messages (or `{ messages }`), records the customer's newest message, and returns
+ *   them with the pack as a system message after the leading system messages and the suffix
+ *   appended to the last human message. `withNiadraContext(session, messages)` does the same
+ *   inside a LangGraph node, right before the model call, so nothing lands in the graph's state.
+ * - `NiadraCallbackHandler` records the model's answers with the usage LangChain standardizes
+ *   (`usage_metadata`, prompt cache reads and writes included). Answers that only call tools
+ *   record nothing. With `{ turns: true }` each top-level run (a chain, a graph, an agent, or a
+ *   chat model called alone) is a turn record, with its tool calls (the provider's call ids) and
+ *   its model calls with their tokens; a run inside a turn in progress (`conversation.turn()`)
+ *   records into it. A function wrapped with `tool()` inside a tool takes over its call, which is
+ *   how a replay answers it from the record.
+ * - `niadraTools(session)` is the navigation kit as structured tools bound to the customer.
+ *
+ * Fail-open: when Niadra is slow or down, the messages go to the model as they came.
+ */
+
+interface NiadraContextOptions {
+    /** What your app proved about the user, recorded once before the first context read. */
+    verify?: ProofSource;
+    /** Records the newest human message as the customer's turn. Defaults to `true`. */
+    recordCustomer?: boolean;
+    /** Puts the agent's own notes before the customer's context. Pass the same to `niadraTools`. */
+    agentMemory?: AgentMemoryOption;
+}
+/**
+ * The messages with the context in place: the prefix (the agent's notes and the customer's pack)
+ * after the leading system messages, the suffix at the end of the last human message. Records
+ * the newest human message once. Returns a new array; never throws.
+ */
+declare function withNiadraContext(session: Session, messages: readonly BaseMessage[], options?: NiadraContextOptions): Promise<BaseMessage[]>;
+/**
+ * A runnable that puts the context into the messages, for LCEL: `niadraContext(convo).pipe(model)`.
+ * Takes a list of messages or `{ messages }`. With a function in place of the session, it finds
+ * the session per call; `null` passes the messages through.
+ */
+declare function niadraContext(session: SessionResolver, options?: NiadraContextOptions): Runnable<BaseMessage[] | {
+    messages: BaseMessage[];
+}, BaseMessage[]>;
+interface NiadraCallbackOptions {
+    /** Records each top-level run as a turn, with its tool and model calls. Defaults to `false`. */
+    turns?: boolean;
+}
+/**
+ * Records the model's answers as the agent's turns, with their usage, and with `turns: true` the
+ * turn record of each top-level run. Pass it in `callbacks` of the model or of the whole run; with
+ * a function in place of the session, it finds the session per callback.
+ */
+declare class NiadraCallbackHandler extends BaseCallbackHandler {
+    private readonly session;
+    name: string;
+    private readonly hooks;
+    /** Each nested run's top-level run, whose turn it records into. */
+    private readonly roots;
+    constructor(session: SessionResolver, options?: NiadraCallbackOptions);
+    /** The same handler: the turns it holds open are shared by every run it is passed to. */
+    copy(): this;
+    handleChainStart(_chain: Serialized, _inputs: unknown, runId: string, runType?: string, _tags?: string[], _metadata?: Record<string, unknown>, _runName?: string, parentRunId?: string): void;
+    handleChainEnd(_outputs: unknown, runId: string): void;
+    handleChainError(error: Error, runId: string): void;
+    handleChatModelStart(_llm: Serialized, _messages: BaseMessage[][], runId: string, parentRunId?: string): void;
+    handleToolStart(tool: Serialized, input: string, runId: string, parentRunId?: string, _tags?: string[], _metadata?: Record<string, unknown>, runName?: string, toolCallId?: string): void;
+    handleToolEnd(output: unknown, runId: string): void;
+    handleToolError(error: Error, runId: string): void;
+    handleLLMEnd(output: LLMResult, runId?: string): void;
+    handleLLMError(error: Error, runId: string): void;
+    private started;
+    private ended;
+    private rootOf;
+    private model;
+}
+/** The navigation kit as LangChain structured tools, bound to the session's customer. */
+/** The tool metadata key `recordTools()` sets: a replay answers the tool from the record. */
+declare const RECORDED = "niadra_recorded";
+/**
+ * Your LangChain tools with each call recorded in the turn it runs in, and answered from the record in a replay.
+ * `dryRun` names the tools a replay may run for real when the record has no answer. A tool without a function
+ * of its own (`func`) is refused: wrap what it calls with `tool()`.
+ */
+declare function recordTools(tools: readonly DynamicStructuredTool[], options?: {
+    dryRun?: readonly string[];
+}): DynamicStructuredTool[];
+declare function niadraTools(session: Session, options?: {
+    agentMemory?: AgentMemoryOption;
+}): DynamicStructuredTool[];
+/** An AI message's `usage_metadata` as a `ModelUsage`: input tokens include the cached ones. */
+declare function langchainUsage(message: BaseMessage): ModelUsage | null;
+
+export { AgentMemoryOption, NiadraCallbackHandler, type NiadraCallbackOptions, type NiadraContextOptions, ProofSource, RECORDED, Session, SessionResolver, langchainUsage, niadraContext, niadraTools, recordTools, withNiadraContext };