@blaxel/langgraph 0.2.49-dev.214 → 0.2.49-dev1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./model.js";
+export * from "./tools.js";
+import "./telemetry.js";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./model.js"), exports);
+__exportStar(require("./tools.js"), exports);
+require("./telemetry.js");

package/dist/model/cohere.d.ts

@@ -0,0 +1,6 @@
+import { FetchFunction } from "cohere-ai/core";
+/**
+ * Creates a custom fetcher for CohereClient that adds dynamic headers
+ * CohereClient's fetcher expects a function that intercepts fetch requests
+ */
+export declare const createCohereFetcher: () => FetchFunction;

package/dist/model/cohere.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCohereFetcher = void 0;
+const core_1 = require("@blaxel/core");
+/**
+ * Creates a custom fetcher for CohereClient that adds dynamic headers
+ * CohereClient's fetcher expects a function that intercepts fetch requests
+ */
+const createCohereFetcher = () => {
+    // Return a function that matches CohereClient's FetchFunction interface
+    const fetcher = async (args) => {
+        await (0, core_1.authenticate)();
+        const dynamicHeaders = core_1.settings.headers;
+        // Extract all fields from args
+        const { url, method, headers: argsHeaders, body, contentType, queryParameters, timeoutMs, withCredentials, abortSignal, requestType, responseType, duplex } = args;
+        // Build URL with query parameters
+        let requestUrl = url;
+        if (queryParameters) {
+            const params = new URLSearchParams();
+            Object.entries(queryParameters).forEach(([key, value]) => {
+                if (Array.isArray(value)) {
+                    value.forEach(v => {
+                        if (typeof v === 'object' && v !== null) {
+                            params.append(key, JSON.stringify(v));
+                        }
+                        else {
+                            params.append(key, String(v));
+                        }
+                    });
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    params.append(key, JSON.stringify(value));
+                }
+                else {
+                    params.append(key, String(value));
+                }
+            });
+            const queryString = params.toString();
+            if (queryString) {
+                requestUrl += (url.includes('?') ? '&' : '?') + queryString;
+            }
+        }
+        // Merge headers and filter out undefined values
+        const mergedHeaders = {
+            ...(argsHeaders || {}),
+            ...dynamicHeaders,
+        };
+        // Add content-type if specified
+        if (contentType) {
+            mergedHeaders['Content-Type'] = contentType;
+        }
+        // Filter out undefined values
+        const headers = Object.entries(mergedHeaders).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        // Prepare body based on requestType
+        let requestBody;
+        if (body !== undefined) {
+            if (requestType === 'json' || !requestType) {
+                requestBody = JSON.stringify(body);
+            }
+            else if (requestType === 'bytes' && body instanceof Uint8Array) {
+                // Create a new ArrayBuffer from the Uint8Array to avoid SharedArrayBuffer issues
+                const arrayBuffer = new ArrayBuffer(body.length);
+                const view = new Uint8Array(arrayBuffer);
+                view.set(body);
+                requestBody = arrayBuffer;
+            }
+            else if (requestType === 'file' && body instanceof Blob) {
+                requestBody = body;
+            }
+            else if (typeof body === 'string') {
+                requestBody = body;
+            }
+            else {
+                requestBody = JSON.stringify(body);
+            }
+        }
+        try {
+            // Create abort controller for timeout
+            const controller = new AbortController();
+            let timeoutId;
+            if (timeoutMs) {
+                timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            }
+            // Merge abort signals
+            const signal = abortSignal
+                ? AbortSignal.any([abortSignal, controller.signal])
+                : controller.signal;
+            // Make the request with merged headers
+            const requestInit = {
+                method: method,
+                headers,
+                body: requestBody,
+                credentials: withCredentials ? 'include' : 'same-origin',
+                signal,
+            };
+            // Add duplex if specified (for streaming)
+            if (duplex) {
+                requestInit.duplex = duplex;
+            }
+            const response = await fetch(requestUrl, requestInit);
+            // Clear timeout
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            // Handle response based on responseType
+            let responseBody;
+            if (response.ok) {
+                if (responseType === 'blob') {
+                    responseBody = await response.blob();
+                }
+                else if (responseType === 'text') {
+                    responseBody = await response.text();
+                }
+                else if (responseType === 'arrayBuffer') {
+                    responseBody = await response.arrayBuffer();
+                }
+                else if (responseType === 'streaming' || responseType === 'sse') {
+                    // For streaming, return the response body stream
+                    responseBody = response.body;
+                }
+                else {
+                    // Default to JSON
+                    responseBody = await response.json();
+                }
+                // Return success response in the format CohereClient expects
+                return {
+                    ok: true,
+                    body: responseBody,
+                    headers: Object.fromEntries(response.headers.entries()),
+                };
+            }
+            else {
+                // Return error response in the format CohereClient expects
+                const errorBody = await response.text();
+                return {
+                    ok: false,
+                    error: {
+                        reason: "status-code",
+                        statusCode: response.status,
+                        body: errorBody,
+                    },
+                };
+            }
+        }
+        catch (error) {
+            // Check if it's a timeout error
+            if (error instanceof Error && error.name === 'AbortError') {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "timeout",
+                    },
+                };
+            }
+            // Return unknown error
+            return {
+                ok: false,
+                error: {
+                    reason: "unknown",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    };
+    return fetcher;
+};
+exports.createCohereFetcher = createCohereFetcher;