@loopman/langchain-sdk 1.7.0 → 1.8.0

package/dist/langgraph/helpers.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Helper functions for LangGraph integration with Loopman
+ */
+import type { LoopmanDecision, LoopmanGuideline } from "./types";
+/**
+ * Configuration for enriching system prompts
+ */
+export interface EnrichSystemPromptOptions {
+    /** Whether to include guidelines (default: true) */
+    includeGuidelines?: boolean;
+    /** Whether to include decision context (default: true) */
+    includeDecisionContext?: boolean;
+    /** Maximum number of historical decisions to show (default: 3) */
+    maxDecisions?: number;
+    /** Custom header for guidelines section */
+    guidelinesHeader?: string;
+    /** Custom header for decision context section */
+    decisionContextHeader?: string;
+}
+/**
+ * Enriches a system prompt with Loopman guidelines and decision context
+ *
+ * This helper function automatically formats and appends validation guidelines
+ * and historical decision context to your agent's system prompt.
+ *
+ * **Works with any state**: This function accepts any state object and only
+ * checks for `guidelines` and `decisionContext` properties. You don't need
+ * to use `LoopmanGraphState` - it works with your custom state too!
+ *
+ * @param basePrompt - The base system prompt to enrich
+ * @param state - Any state object (checks for guidelines and decisionContext)
+ * @param options - Optional configuration for formatting
+ * @returns Enriched system prompt with Loopman context
+ *
+ * @example With LoopmanGraphState
+ * ```typescript
+ * async function agentNode(state: typeof LoopmanGraphState.State) {
+ *   const systemPrompt = enrichSystemPrompt(
+ *     "You are a helpful email assistant.",
+ *     state // Pass entire state, extracts what it needs
+ *   );
+ *
+ *   const response = await model.invoke([
+ *     { role: "system", content: systemPrompt },
+ *     ...messages,
+ *   ]);
+ *
+ *   return { messages: [response] };
+ * }
+ * ```
+ *
+ * @example With custom state
+ * ```typescript
+ * const MyCustomState = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({ ... }),
+ *   myCustomField: Annotation<string>({ ... }),
+ *   guidelines: Annotation<LoopmanGuideline[]>({ ... }), // Optional Loopman field
+ *   decisionContext: Annotation<LoopmanDecision[]>({ ... }), // Optional Loopman field
+ * });
+ *
+ * async function agentNode(state: typeof MyCustomState.State) {
+ *   // Works seamlessly with custom state!
+ *   const systemPrompt = enrichSystemPrompt(
+ *     "You are a helpful assistant.",
+ *     state
+ *   );
+ *
+ *   return { messages: [response] };
+ * }
+ * ```
+ *
+ * @example With custom options
+ * ```typescript
+ * const systemPrompt = enrichSystemPrompt(
+ *   "You are a helpful assistant.",
+ *   state,
+ *   {
+ *     maxDecisions: 5,
+ *     guidelinesHeader: "📋 Company Policies",
+ *     includeDecisionContext: false, // Skip decision history
+ *   }
+ * );
+ * ```
+ */
+export declare function enrichSystemPrompt(basePrompt: string, state: any, // Accept any state object
+options?: EnrichSystemPromptOptions): string;
+/**
+ * Formats guidelines as a structured string for logging or display
+ *
+ * @param guidelines - Array of Loopman guidelines
+ * @returns Formatted string representation of guidelines
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatGuidelines(state.guidelines);
+ * console.log(formatted);
+ * // Output:
+ * // 📋 3 Guideline(s):
+ * //   - [CRITICAL] Never send emails without approval
+ * //   - [MAJOR] Always validate email addresses
+ * //   - [MINOR] Include signature in all emails
+ * ```
+ */
+export declare function formatGuidelines(guidelines: LoopmanGuideline[]): string;
+/**
+ * Formats decision context as a structured string for logging or display
+ *
+ * @param decisions - Array of Loopman decisions
+ * @param maxDecisions - Maximum number of decisions to show (default: all)
+ * @returns Formatted string representation of decision history
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatDecisionContext(state.decisionContext, 3);
+ * console.log(formatted);
+ * // Output:
+ * // 📜 3 Recent Decision(s):
+ * //   - APPROVED by USER: "Looks good"
+ * //   - NEEDS_CHANGES by USER: "Fix the subject line"
+ * //   - APPROVED by USER
+ * ```
+ */
+export declare function formatDecisionContext(decisions: LoopmanDecision[], maxDecisions?: number): string;
+/**
+ * Checks if the state contains any Loopman context (guidelines or decisions)
+ *
+ * Works with any state object - simply checks for the presence of
+ * `guidelines` or `decisionContext` properties.
+ *
+ * @param state - Any state object (checks for guidelines and decisionContext)
+ * @returns True if state has guidelines or decision context
+ *
+ * @example
+ * ```typescript
+ * if (hasLoopmanContext(state)) {
+ *   console.log("Using Loopman context for enhanced decision-making");
+ * }
+ * ```
+ */
+export declare function hasLoopmanContext(state: any): boolean;
+/**
+ * Extracts critical guidelines from a list
+ *
+ * @param guidelines - Array of Loopman guidelines
+ * @returns Array containing only critical severity guidelines
+ *
+ * @example
+ * ```typescript
+ * const criticalGuidelines = getCriticalGuidelines(state.guidelines);
+ * if (criticalGuidelines.length > 0) {
+ *   console.warn(`${criticalGuidelines.length} critical guideline(s) must be followed!`);
+ * }
+ * ```
+ */
+export declare function getCriticalGuidelines(guidelines: LoopmanGuideline[]): LoopmanGuideline[];
+/**
+ * Gets the latest decision from decision context
+ *
+ * @param decisions - Array of Loopman decisions
+ * @returns The most recent decision, or null if empty
+ *
+ * @example
+ * ```typescript
+ * const latestDecision = getLatestDecision(state.decisionContext);
+ * if (latestDecision?.status === "NEEDS_CHANGES") {
+ *   console.log("Previous attempt needs changes:", latestDecision.comment);
+ * }
+ * ```
+ */
+export declare function getLatestDecision(decisions: LoopmanDecision[]): LoopmanDecision | null;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/langgraph/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/langgraph/helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,oDAAoD;IACpD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,0DAA0D;IAC1D,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iDAAiD;IACjD,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,GAAG,EAAE,0BAA0B;AACtC,OAAO,GAAE,yBAA8B,GACtC,MAAM,CAwCR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAUvE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,eAAe,EAAE,EAC5B,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAkBR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAKrD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,gBAAgB,EAAE,GAC7B,gBAAgB,EAAE,CAEpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,eAAe,EAAE,GAC3B,eAAe,GAAG,IAAI,CAKxB"}

package/dist/langgraph/helpers.js

@@ -0,0 +1,216 @@
+/**
+ * Helper functions for LangGraph integration with Loopman
+ */
+/**
+ * Enriches a system prompt with Loopman guidelines and decision context
+ *
+ * This helper function automatically formats and appends validation guidelines
+ * and historical decision context to your agent's system prompt.
+ *
+ * **Works with any state**: This function accepts any state object and only
+ * checks for `guidelines` and `decisionContext` properties. You don't need
+ * to use `LoopmanGraphState` - it works with your custom state too!
+ *
+ * @param basePrompt - The base system prompt to enrich
+ * @param state - Any state object (checks for guidelines and decisionContext)
+ * @param options - Optional configuration for formatting
+ * @returns Enriched system prompt with Loopman context
+ *
+ * @example With LoopmanGraphState
+ * ```typescript
+ * async function agentNode(state: typeof LoopmanGraphState.State) {
+ *   const systemPrompt = enrichSystemPrompt(
+ *     "You are a helpful email assistant.",
+ *     state // Pass entire state, extracts what it needs
+ *   );
+ *
+ *   const response = await model.invoke([
+ *     { role: "system", content: systemPrompt },
+ *     ...messages,
+ *   ]);
+ *
+ *   return { messages: [response] };
+ * }
+ * ```
+ *
+ * @example With custom state
+ * ```typescript
+ * const MyCustomState = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({ ... }),
+ *   myCustomField: Annotation<string>({ ... }),
+ *   guidelines: Annotation<LoopmanGuideline[]>({ ... }), // Optional Loopman field
+ *   decisionContext: Annotation<LoopmanDecision[]>({ ... }), // Optional Loopman field
+ * });
+ *
+ * async function agentNode(state: typeof MyCustomState.State) {
+ *   // Works seamlessly with custom state!
+ *   const systemPrompt = enrichSystemPrompt(
+ *     "You are a helpful assistant.",
+ *     state
+ *   );
+ *
+ *   return { messages: [response] };
+ * }
+ * ```
+ *
+ * @example With custom options
+ * ```typescript
+ * const systemPrompt = enrichSystemPrompt(
+ *   "You are a helpful assistant.",
+ *   state,
+ *   {
+ *     maxDecisions: 5,
+ *     guidelinesHeader: "📋 Company Policies",
+ *     includeDecisionContext: false, // Skip decision history
+ *   }
+ * );
+ * ```
+ */
+export function enrichSystemPrompt(basePrompt, state, // Accept any state object
+options = {}) {
+    const { includeGuidelines = true, includeDecisionContext = true, maxDecisions = 3, guidelinesHeader = "**Guidelines**", decisionContextHeader = "**Previous Decisions**", } = options;
+    let enrichedPrompt = basePrompt;
+    // Add guidelines if available and enabled
+    if (includeGuidelines && state.guidelines && state.guidelines.length > 0) {
+        enrichedPrompt += `\n\n${guidelinesHeader}:\n`;
+        state.guidelines.forEach((g) => {
+            enrichedPrompt += `- [${g.severity.toUpperCase()}] ${g.description}\n`;
+        });
+    }
+    // Add decision context if available and enabled
+    if (includeDecisionContext &&
+        state.decisionContext &&
+        state.decisionContext.length > 0) {
+        enrichedPrompt += `\n\n${decisionContextHeader}:\n`;
+        // Show only the most recent N decisions
+        const recentDecisions = state.decisionContext.slice(-maxDecisions);
+        recentDecisions.forEach((d) => {
+            enrichedPrompt += `- ${d.status} by ${d.userType}`;
+            if (d.comment) {
+                enrichedPrompt += `: "${d.comment}"`;
+            }
+            enrichedPrompt += "\n";
+        });
+    }
+    return enrichedPrompt;
+}
+/**
+ * Formats guidelines as a structured string for logging or display
+ *
+ * @param guidelines - Array of Loopman guidelines
+ * @returns Formatted string representation of guidelines
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatGuidelines(state.guidelines);
+ * console.log(formatted);
+ * // Output:
+ * // 📋 3 Guideline(s):
+ * //   - [CRITICAL] Never send emails without approval
+ * //   - [MAJOR] Always validate email addresses
+ * //   - [MINOR] Include signature in all emails
+ * ```
+ */
+export function formatGuidelines(guidelines) {
+    if (!guidelines || guidelines.length === 0) {
+        return "No guidelines available";
+    }
+    let output = `${guidelines.length} Guideline(s):\n`;
+    guidelines.forEach((g) => {
+        output += `  - [${g.severity.toUpperCase()}] ${g.description}\n`;
+    });
+    return output.trim();
+}
+/**
+ * Formats decision context as a structured string for logging or display
+ *
+ * @param decisions - Array of Loopman decisions
+ * @param maxDecisions - Maximum number of decisions to show (default: all)
+ * @returns Formatted string representation of decision history
+ *
+ * @example
+ * ```typescript
+ * const formatted = formatDecisionContext(state.decisionContext, 3);
+ * console.log(formatted);
+ * // Output:
+ * // 📜 3 Recent Decision(s):
+ * //   - APPROVED by USER: "Looks good"
+ * //   - NEEDS_CHANGES by USER: "Fix the subject line"
+ * //   - APPROVED by USER
+ * ```
+ */
+export function formatDecisionContext(decisions, maxDecisions) {
+    if (!decisions || decisions.length === 0) {
+        return "No decision history available";
+    }
+    const displayDecisions = maxDecisions
+        ? decisions.slice(-maxDecisions)
+        : decisions;
+    let output = `${displayDecisions.length} Recent Decision(s):\n`;
+    displayDecisions.forEach((d) => {
+        output += `  - ${d.status} by ${d.userType}`;
+        if (d.comment) {
+            output += `: "${d.comment}"`;
+        }
+        output += "\n";
+    });
+    return output.trim();
+}
+/**
+ * Checks if the state contains any Loopman context (guidelines or decisions)
+ *
+ * Works with any state object - simply checks for the presence of
+ * `guidelines` or `decisionContext` properties.
+ *
+ * @param state - Any state object (checks for guidelines and decisionContext)
+ * @returns True if state has guidelines or decision context
+ *
+ * @example
+ * ```typescript
+ * if (hasLoopmanContext(state)) {
+ *   console.log("Using Loopman context for enhanced decision-making");
+ * }
+ * ```
+ */
+export function hasLoopmanContext(state) {
+    return ((state.guidelines && state.guidelines.length > 0) ||
+        (state.decisionContext && state.decisionContext.length > 0));
+}
+/**
+ * Extracts critical guidelines from a list
+ *
+ * @param guidelines - Array of Loopman guidelines
+ * @returns Array containing only critical severity guidelines
+ *
+ * @example
+ * ```typescript
+ * const criticalGuidelines = getCriticalGuidelines(state.guidelines);
+ * if (criticalGuidelines.length > 0) {
+ *   console.warn(`${criticalGuidelines.length} critical guideline(s) must be followed!`);
+ * }
+ * ```
+ */
+export function getCriticalGuidelines(guidelines) {
+    return guidelines.filter((g) => g.severity === "critical");
+}
+/**
+ * Gets the latest decision from decision context
+ *
+ * @param decisions - Array of Loopman decisions
+ * @returns The most recent decision, or null if empty
+ *
+ * @example
+ * ```typescript
+ * const latestDecision = getLatestDecision(state.decisionContext);
+ * if (latestDecision?.status === "NEEDS_CHANGES") {
+ *   console.log("Previous attempt needs changes:", latestDecision.comment);
+ * }
+ * ```
+ */
+export function getLatestDecision(decisions) {
+    if (!decisions || decisions.length === 0) {
+        return null;
+    }
+    return decisions[decisions.length - 1];
+}
+//# sourceMappingURL=helpers.js.map

package/dist/langgraph/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/langgraph/helpers.ts"],"names":[],"mappings":"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"}

package/dist/langgraph/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * LangGraph Integration for Loopman
+ *
+ * This module provides LangGraph nodes and utilities for integrating
+ * Human-in-the-Loop validation into your workflows.
+ */
+export { LoopmanGraphState } from "./types";
+export type { LoopmanGuideline, LoopmanDecision } from "./types";
+export { createLoopmanValidationNode } from "./loopman-validation-node";
+export type { LoopmanValidationNodeConfig } from "./loopman-validation-node";
+export { createLoopmanConditionalEdge } from "./loopman-conditional-edge";
+export { createLoopmanContextNode } from "./loopman-context-node";
+export type { LoopmanContextNodeConfig } from "./loopman-context-node";
+export { enrichSystemPrompt, formatGuidelines, formatDecisionContext, hasLoopmanContext, getCriticalGuidelines, getLatestDecision, } from "./helpers";
+export type { EnrichSystemPromptOptions } from "./helpers";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/langgraph/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAGjE,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AACxE,YAAY,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAG7E,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAG1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,YAAY,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAGvE,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC"}

package/dist/langgraph/index.js

@@ -0,0 +1,17 @@
+/**
+ * LangGraph Integration for Loopman
+ *
+ * This module provides LangGraph nodes and utilities for integrating
+ * Human-in-the-Loop validation into your workflows.
+ */
+// Export types and state
+export { LoopmanGraphState } from "./types";
+// Export validation node
+export { createLoopmanValidationNode } from "./loopman-validation-node";
+// Export conditional edge
+export { createLoopmanConditionalEdge } from "./loopman-conditional-edge";
+// Export context node
+export { createLoopmanContextNode } from "./loopman-context-node";
+// Export helper functions
+export { enrichSystemPrompt, formatGuidelines, formatDecisionContext, hasLoopmanContext, getCriticalGuidelines, getLatestDecision, } from "./helpers";
+//# sourceMappingURL=index.js.map

package/dist/langgraph/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/langgraph/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,yBAAyB;AACzB,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG5C,yBAAyB;AACzB,OAAO,EAAE,2BAA2B,EAAE,MAAM,2BAA2B,CAAC;AAGxE,0BAA0B;AAC1B,OAAO,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC;AAE1E,sBAAsB;AACtB,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAGlE,0BAA0B;AAC1B,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,WAAW,CAAC"}

package/dist/langgraph/loopman-conditional-edge.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Loopman Conditional Edge for LangGraph
+ *
+ * This conditional edge routes the workflow based on the Loopman task status
+ * after human validation.
+ */
+/**
+ * Creates a conditional edge function for routing based on Loopman task status
+ *
+ * **Works with any state**: This function only reads `loopmanTaskStatus` from
+ * the state. You can use it with any custom state that includes this field.
+ *
+ * @param options - Optional configuration
+ * @param options.debug - Enable debug logging
+ * @returns Function that routes based on loopmanTaskStatus
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createLoopmanConditionalEdge } from "loopman-langchain-sdk";
+ * import { StateGraph, END } from "@langchain/langgraph";
+ *
+ * const workflow = new StateGraph(LoopmanGraphState)
+ *   .addNode("agent", agentNode)
+ *   .addNode("validation", validationNode)
+ *   .addNode("tools", toolNode)
+ *   .addConditionalEdges(
+ *     "validation",
+ *     createLoopmanConditionalEdge({ debug: true }),
+ *     {
+ *       execute: "tools",     // APPROVED → execute tool
+ *       rejected: END,        // REJECTED → end workflow
+ *       retry: "agent",       // NEEDS_CHANGES → retry with feedback
+ *       timeout: END,         // TIMEOUT → end workflow
+ *       error: END            // ERROR → end workflow
+ *     }
+ *   );
+ * ```
+ *
+ * @example Custom routing
+ * ```typescript
+ * const workflow = new StateGraph(MyState)
+ *   .addConditionalEdges(
+ *     "validation",
+ *     createLoopmanConditionalEdge(),
+ *     {
+ *       execute: "execute_action",
+ *       rejected: "notify_rejection",
+ *       retry: "agent_with_context",
+ *       timeout: "handle_timeout",
+ *       error: "handle_error",
+ *     }
+ *   );
+ * ```
+ */
+export declare function createLoopmanConditionalEdge(options?: {
+    debug?: boolean;
+}): (state: any) => string;
+//# sourceMappingURL=loopman-conditional-edge.d.ts.map

package/dist/langgraph/loopman-conditional-edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopman-conditional-edge.d.ts","sourceRoot":"","sources":["../../src/langgraph/loopman-conditional-edge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,IAChE,OAAO,GAAG,KAAG,MAAM,CA0B5B"}

package/dist/langgraph/loopman-conditional-edge.js

@@ -0,0 +1,77 @@
+/**
+ * Loopman Conditional Edge for LangGraph
+ *
+ * This conditional edge routes the workflow based on the Loopman task status
+ * after human validation.
+ */
+/**
+ * Creates a conditional edge function for routing based on Loopman task status
+ *
+ * **Works with any state**: This function only reads `loopmanTaskStatus` from
+ * the state. You can use it with any custom state that includes this field.
+ *
+ * @param options - Optional configuration
+ * @param options.debug - Enable debug logging
+ * @returns Function that routes based on loopmanTaskStatus
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createLoopmanConditionalEdge } from "loopman-langchain-sdk";
+ * import { StateGraph, END } from "@langchain/langgraph";
+ *
+ * const workflow = new StateGraph(LoopmanGraphState)
+ *   .addNode("agent", agentNode)
+ *   .addNode("validation", validationNode)
+ *   .addNode("tools", toolNode)
+ *   .addConditionalEdges(
+ *     "validation",
+ *     createLoopmanConditionalEdge({ debug: true }),
+ *     {
+ *       execute: "tools",     // APPROVED → execute tool
+ *       rejected: END,        // REJECTED → end workflow
+ *       retry: "agent",       // NEEDS_CHANGES → retry with feedback
+ *       timeout: END,         // TIMEOUT → end workflow
+ *       error: END            // ERROR → end workflow
+ *     }
+ *   );
+ * ```
+ *
+ * @example Custom routing
+ * ```typescript
+ * const workflow = new StateGraph(MyState)
+ *   .addConditionalEdges(
+ *     "validation",
+ *     createLoopmanConditionalEdge(),
+ *     {
+ *       execute: "execute_action",
+ *       rejected: "notify_rejection",
+ *       retry: "agent_with_context",
+ *       timeout: "handle_timeout",
+ *       error: "handle_error",
+ *     }
+ *   );
+ * ```
+ */
+export function createLoopmanConditionalEdge(options) {
+    return (state) => {
+        const { loopmanTaskStatus } = state;
+        void options; // Debug logging intentionally omitted (library is silent by default)
+        switch (loopmanTaskStatus) {
+            case "APPROVED":
+                return "execute"; // Proceed to tool execution
+            case "REJECTED":
+                return "rejected"; // End workflow
+            case "NEEDS_CHANGES":
+                return "retry"; // Loop back to agent for correction
+            case "TIMEOUT":
+                return "timeout"; // Handle timeout case
+            case "PENDING":
+                // Should not happen after polling completes, but handle gracefully
+                return "timeout";
+            case "ERROR":
+            default:
+                return "error"; // Handle errors
+        }
+    };
+}
+//# sourceMappingURL=loopman-conditional-edge.js.map

package/dist/langgraph/loopman-conditional-edge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopman-conditional-edge.js","sourceRoot":"","sources":["../../src/langgraph/loopman-conditional-edge.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,4BAA4B,CAAC,OAA6B;IACxE,OAAO,CAAC,KAAU,EAAU,EAAE;QAC5B,MAAM,EAAE,iBAAiB,EAAE,GAAG,KAAK,CAAC;QACpC,KAAK,OAAO,CAAC,CAAC,qEAAqE;QAEnF,QAAQ,iBAAiB,EAAE,CAAC;YAC1B,KAAK,UAAU;gBACb,OAAO,SAAS,CAAC,CAAC,4BAA4B;YAEhD,KAAK,UAAU;gBACb,OAAO,UAAU,CAAC,CAAC,eAAe;YAEpC,KAAK,eAAe;gBAClB,OAAO,OAAO,CAAC,CAAC,oCAAoC;YAEtD,KAAK,SAAS;gBACZ,OAAO,SAAS,CAAC,CAAC,sBAAsB;YAE1C,KAAK,SAAS;gBACZ,mEAAmE;gBACnE,OAAO,SAAS,CAAC;YAEnB,KAAK,OAAO,CAAC;YACb;gBACE,OAAO,OAAO,CAAC,CAAC,gBAAgB;QACpC,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/langgraph/loopman-context-node.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Loopman Context Enrichment Node for LangGraph
+ *
+ * This node fetches validation guidelines and historical decision context
+ * from Loopman and adds them to the graph state.
+ */
+/**
+ * Configuration for the Loopman context enrichment node
+ */
+export interface LoopmanContextNodeConfig {
+    /** Loopman API key for authentication */
+    apiKey: string;
+    /** Workflow identifier */
+    workflowId: string;
+    /** Execution identifier (auto-generated if not provided) */
+    executionId?: string;
+    /** Category to filter guidelines (optional, use "none" for all) */
+    category?: string;
+    /** Whether to fetch guidelines (default: true) */
+    includeGuidelines?: boolean;
+    /** Whether to fetch decision history (default: true) */
+    includeDecisionHistory?: boolean;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Factory function to create a Loopman context enrichment node
+ *
+ * This node fetches validation guidelines and historical decision context
+ * from Loopman and adds them to the graph state. This enriched context
+ * can then be used by agents to make better-informed decisions.
+ *
+ * **Works with any state**: This node only adds `guidelines` and `decisionContext`
+ * to your state. It doesn't require `LoopmanGraphState` - you can use your own
+ * custom state with any fields you want!
+ *
+ * @example With LoopmanGraphState
+ * ```typescript
+ * import { createLoopmanContextNode, LoopmanGraphState } from "loopman-langchain-sdk";
+ *
+ * const contextNode = createLoopmanContextNode({
+ *   apiKey: process.env.LOOPMAN_API_KEY!,
+ *   workflowId: "my-workflow",
+ *   category: "email", // Optional category filter
+ * });
+ *
+ * const workflow = new StateGraph(LoopmanGraphState)
+ *   .addNode("load_context", contextNode)
+ *   .addNode("agent", agentNode)
+ *   .addEdge(START, "load_context")
+ *   .addEdge("load_context", "agent");
+ * ```
+ *
+ * @example With custom state
+ * ```typescript
+ * const MyCustomState = Annotation.Root({
+ *   messages: Annotation<BaseMessage[]>({ ... }),
+ *   myCustomField: Annotation<string>({ ... }),
+ *   guidelines: Annotation<LoopmanGuideline[]>({ ... }), // Add Loopman fields
+ *   decisionContext: Annotation<LoopmanDecision[]>({ ... }), // to your state
+ * });
+ *
+ * const contextNode = createLoopmanContextNode({
+ *   apiKey: process.env.LOOPMAN_API_KEY!,
+ *   workflowId: "my-workflow",
+ * });
+ *
+ * const workflow = new StateGraph(MyCustomState)
+ *   .addNode("load_context", contextNode) // Works with custom state!
+ *   .addNode("agent", agentNode);
+ * ```
+ */
+export declare function createLoopmanContextNode(config: LoopmanContextNodeConfig): (state: any) => Promise<any>;
+//# sourceMappingURL=loopman-context-node.d.ts.map

package/dist/langgraph/loopman-context-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopman-context-node.d.ts","sourceRoot":"","sources":["../../src/langgraph/loopman-context-node.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,wDAAwD;IACxD,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,IAazD,OAAO,GAAG,KAAG,OAAO,CAAC,GAAG,CAAC,CAoGxC"}