@langchain/langgraph-api 0.0.30 → 0.0.32

package/dist/graph/parser/schema/types.mjs

@@ -14,10 +14,8 @@
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import * as ts from "typescript";
 import * as vm from "node:vm";
-import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { createHash } from "node:crypto";
-import dedent from "dedent";
 const REGEX_FILE_NAME_OR_SPACE = /(\bimport\(".*?"\)|".*?")\.| /g;
 const REGEX_TJS_JSDOC = /^-([\w]+)\s+(\S|\S[\s\S]*\S)\s*$/g;
 const REGEX_GROUP_JSDOC = /^[.]?([\w]+)\s+(\S|\S[\s\S]*\S)\s*$/g;
@@ -1496,112 +1494,3 @@ export function buildGenerator(program, args = {}) {
     });
     return new JsonSchemaGenerator(symbols, allSymbols, userSymbols, inheritingTypes, typeChecker, settings);
 }
-export async function extractGraphSchema(id, userPath, exportName) {
-    const filePath = path.resolve(process.cwd(), userPath);
-    const parentPath = path.dirname(filePath);
-    const typePath = path.resolve(parentPath, `__$0${id}.mts`);
-    const importPath = path.relative(parentPath, filePath);
-    try {
-        await fs.writeFile(typePath, dedent `
-        import { ${exportName} as __graph } from "./${importPath}";
-        import type { BaseMessage } from "@langchain/core/messages";
-        import type {
-          StateType,
-          UpdateType,
-          StateDefinition,
-        } from "@langchain/langgraph";
-
-        type Wrap<T> = (a: T) => void;
-        type MatchBaseMessage<T> = T extends BaseMessage ? BaseMessage : never;
-        type MatchBaseMessageArray<T> =
-          T extends Array<infer C>
-            ? Wrap<MatchBaseMessage<C>> extends Wrap<BaseMessage>
-              ? BaseMessage[]
-              : never
-            : never;
-
-        type Defactorify<T> = T extends (...args: any[]) => infer R
-          ? Awaited<R>
-          : Awaited<T>;
-
-        type Inspect<T> = T extends unknown
-          ? {
-              [K in keyof T]: 0 extends 1 & T[K]
-                ? T[K]
-                : Wrap<MatchBaseMessageArray<T[K]>> extends Wrap<BaseMessage[]>
-                  ? BaseMessage[]
-                  : Wrap<MatchBaseMessage<T[K]>> extends Wrap<BaseMessage>
-                    ? BaseMessage
-                    : Inspect<T[K]>;
-            }
-          : never;
-
-        type ReflectCompiled<T> = T extends { RunInput: infer S; RunOutput: infer U }
-          ? { state: S; update: U }
-          : never;
-
-        type Reflect<T> =
-          Defactorify<T> extends infer DT
-            ? DT extends {
-                compile(...args: any[]): infer Compiled;
-              }
-              ? ReflectCompiled<Compiled>
-              : ReflectCompiled<DT>
-            : never;
-
-        type __reflect = Reflect<typeof __graph>;
-        export type __state = Inspect<__reflect["state"]>;
-        export type __update = Inspect<__reflect["update"]>;
-
-        type BuilderReflectCompiled<T> = T extends {
-          builder: {
-            _inputDefinition: infer I extends StateDefinition;
-            _outputDefinition: infer O extends StateDefinition;
-            _configSchema?: infer C extends StateDefinition | undefined;
-          };
-        }
-          ? { input: UpdateType<I>; output: StateType<O>; config: UpdateType<C> }
-          : never;
-
-        type BuilderReflect<T> =
-          Defactorify<T> extends infer DT
-            ? DT extends {
-                compile(...args: any[]): infer Compiled;
-              }
-              ? BuilderReflectCompiled<Compiled>
-              : BuilderReflectCompiled<DT>
-            : never;
-
-        type __builder = BuilderReflect<typeof __graph>;
-        type FilterAny<T> = 0 extends 1 & T ? never : T;
-        export type __input = Inspect<FilterAny<__builder["input"]>>;
-        export type __output = Inspect<FilterAny<__builder["output"]>>;
-        export type __config = Inspect<FilterAny<__builder["config"]>>;
-      `);
-        const program = ts.createProgram([typePath], {
-            noEmit: true,
-            strict: true,
-            allowUnusedLabels: true,
-        });
-        const schema = buildGenerator(program);
-        const trySymbol = (schema, symbol) => {
-            try {
-                return schema?.getSchemaForSymbol(symbol) ?? undefined;
-            }
-            catch (e) {
-                console.error(`Failed to obtain symbol "${symbol}":`, e?.message);
-            }
-            return undefined;
-        };
-        return {
-            state: trySymbol(schema, "__state"),
-            update: trySymbol(schema, "__update"),
-            input: trySymbol(schema, "__input"),
-            output: trySymbol(schema, "__output"),
-            config: trySymbol(schema, "__config"),
-        };
-    }
-    finally {
-        await fs.unlink(typePath);
-    }
-}

package/dist/graph/parser/schema/types.template.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/graph/parser/schema/types.template.mts

@@ -4,14 +4,19 @@ import type {
   UpdateType,
   StateDefinition,
 } from "@langchain/langgraph";
-import type { Graph } from "@langchain/langgraph";
-import type { Pregel } from "@langchain/langgraph/pregel";
 
 // @ts-expect-error
-type AnyPregel = Pregel<any, any>;
+type AnyPregel = {
+  lg_is_pregel: boolean;
+  stream: (...args: any[]) => any;
+  invoke: (...args: any[]) => any;
+};
 
 // @ts-expect-error
-type AnyGraph = Graph<any, any, any, any, any>;
+type AnyGraph = {
+  compiled: boolean;
+  compile: (...args: any[]) => any;
+};
 
 type Wrap<T> = (a: T) => void;
 type MatchBaseMessage<T> = T extends BaseMessage ? BaseMessage : never;

package/dist/http/custom.d.mts

@@ -0,0 +1,6 @@
+import { Hono } from "hono";
+export declare function registerHttp(appPath: string, options: {
+    cwd: string;
+}): Promise<{
+    api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+}>;

package/dist/http/middleware.d.mts

@@ -0,0 +1,11 @@
+import { MiddlewareHandler } from "hono";
+export declare const cors: (cors: {
+    allow_origins?: string[];
+    allow_origin_regex?: string;
+    allow_methods?: string[];
+    allow_headers?: string[];
+    allow_credentials?: boolean;
+    expose_headers?: string[];
+    max_age?: number;
+} | undefined) => MiddlewareHandler;
+export declare const ensureContentType: () => MiddlewareHandler;

package/dist/logging.d.mts

@@ -0,0 +1,7 @@
+import type { MiddlewareHandler } from "hono";
+export declare const logger: import("winston").Logger;
+export declare const logError: (error: unknown, options?: {
+    context?: Record<string, unknown>;
+    prefix?: string;
+}) => void;
+export declare const requestLogger: () => MiddlewareHandler;

package/dist/loopback.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+export declare function getLoopbackFetch(): (url: string, init?: RequestInit) => Promise<Response>;
+export declare const bindLoopbackFetch: (app: Hono) => void;

package/dist/preload.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/queue.d.mts

@@ -0,0 +1 @@
+export declare const queue: () => Promise<never>;