@worktango/ai-assistant 0.0.133 → 1.0.135

package/build/express.d.ts

@@ -1,2 +0,0 @@
-export { setupAiAssistantRoutes } from "./src/backend/express";
-export * from "./backendTypes";

package/build/express.js

@@ -1,21 +0,0 @@
-"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 });
-exports.setupAiAssistantRoutes = void 0;
-var express_1 = require("./src/backend/express");
-Object.defineProperty(exports, "setupAiAssistantRoutes", { enumerable: true, get: function () { return express_1.setupAiAssistantRoutes; } });
-__exportStar(require("./backendTypes"), exports);
-//# sourceMappingURL=express.js.map

package/build/react.d.ts

@@ -1,4 +0,0 @@
-export * from "./src/frontend/reactComponent";
-export * as config from "./src/frontend/config";
-export * as tools from "./src/frontend/tools/llm-tools";
-export * from "./sharedTypes";

package/build/react.js

@@ -1,44 +0,0 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-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);
-};
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tools = exports.config = void 0;
-__exportStar(require("./src/frontend/reactComponent"), exports);
-exports.config = __importStar(require("./src/frontend/config"));
-exports.tools = __importStar(require("./src/frontend/tools/llm-tools"));
-__exportStar(require("./sharedTypes"), exports);
-//# sourceMappingURL=react.js.map

package/build/src/backend/express.d.ts

@@ -1,63 +0,0 @@
-import type { Express, RequestHandler } from "express";
-import type { RestEndpointCallbacks, GraphQLOperationCallbacks } from "./types";
-/**
- * Note: the inline TypeScript documentation for the below is in `../../express.d.ts`.
- * This is optimized for external use, so we don't want to duplicate the docs here.
- */
-export declare function setupAiAssistantRoutes(args: {
-    app: Express;
-    getBearerToken: (headers: Record<string, undefined | string | string[]>) => Promise<string>;
-    targetHost: string;
-    targetPort?: number;
-    targetProtocol?: string;
-    route?: string;
-    logger?: Pick<typeof console, "log" | "error" | "debug">;
-    preflightMiddlewares?: RequestHandler[];
-    getTargetPath: (path: string) => string;
-    followRedirects?: boolean;
-    /**
-     * Optional callbacks to invoke after successful REST endpoint responses (status 200 only).
-     * Provides access to both request and response data with full type safety.
-     *
-     * @example
-     * ```typescript
-     * onRestEndpointSuccess: {
-     *   '/api/api-ai-assistant/v1/chat': async ({ request, response }) => {
-     *     console.log('Chat completed successfully');
-     *     // response is typed as ChatResponse
-     *     console.log('Model response:', response.role, response.parts);
-     *   },
-     *   '/api/api-ai-assistant/v1/tts': async ({ request, response }) => {
-     *     // response is typed as TTSResponse
-     *     console.log('Speech synthesis:', response.synthesis);
-     *   },
-     * }
-     * ```
-     */
-    onRestEndpointSuccess?: RestEndpointCallbacks;
-    /**
-     * Optional callbacks to invoke after successful GraphQL operation responses (status 200 only).
-     * Keys must match the GraphQL operation names (PascalCase), not field names.
-     * Provides access to both request and response data with full type safety.
-     *
-     * @example
-     * ```typescript
-     * onGraphQLOperationSuccess: {
-     *   AppendMessageToConversation: async ({ request, response }) => {
-     *     // Extract the conversation ID from the typed response
-     *     const conversationId = response.data?.appendMessage?.conversation?.id;
-     *     if (conversationId) {
-     *       // Store in localStorage, update UI state, trigger analytics, etc.
-     *       localStorage.setItem('lastConversationId', conversationId);
-     *       console.log('New conversation created:', conversationId);
-     *     }
-     *   },
-     *   GetAllConversations: async ({ request, response }) => {
-     *     const conversations = response.data?.getConversations;
-     *     console.log(`Loaded ${conversations?.length ?? 0} conversations`);
-     *   },
-     * }
-     * ```
-     */
-    onGraphQLOperationSuccess?: GraphQLOperationCallbacks;
-}): void;

package/build/src/backend/express.js

@@ -1,366 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setupAiAssistantRoutes = setupAiAssistantRoutes;
-const http_proxy_middleware_1 = require("http-proxy-middleware");
-const helpers_1 = require("@kazoohr/helpers");
-/**
- * Note: the inline TypeScript documentation for the below is in `../../express.d.ts`.
- * This is optimized for external use, so we don't want to duplicate the docs here.
- */
-function setupAiAssistantRoutes(args) {
-    const logger = (0, helpers_1.coalesce)(args.logger, console);
-    const routePath = args.route ?? "/ai-assistant";
-    const port = args.targetPort ?? 80;
-    const protocol = args.targetProtocol ?? "http";
-    // This initial middleware mutates the request headers for the proxy request
-    // so that we can add the bearer token to the request. We need this separate
-    // because the proxy middleware callbacks cannot be async.
-    const bearerTokenMiddleware = (req, res, next) => {
-        args
-            .getBearerToken(req.headers)
-            .then((bearerToken) => {
-            getRequestWithNewAuthHeader(req).newAuthHeader = `Bearer ${bearerToken}`;
-            next();
-        })
-            .catch((error) => {
-            logger.error("Error getting bearer token:", error);
-            next(error);
-        });
-    };
-    const proxyOptions = {
-        target: `${protocol}://${args.targetHost}:${port}`,
-        changeOrigin: true,
-        followRedirects: args.followRedirects ?? true,
-        secure: protocol === "https",
-        pathRewrite: (path, req) => {
-            // Since we use express, we know that req.originalUrl is available
-            const expressRequest = req; // eslint-disable-line @typescript-eslint/consistent-type-assertions
-            return args.getTargetPath(expressRequest.originalUrl || path);
-        },
-        on: {
-            proxyReq: (proxyReq, req) => {
-                const newAuthHeader = getRequestWithNewAuthHeader(req).newAuthHeader;
-                if (newAuthHeader) {
-                    proxyReq.setHeader("Authorization", newAuthHeader);
-                }
-                (0, http_proxy_middleware_1.fixRequestBody)(proxyReq, req);
-            },
-            proxyRes: (proxyRes, req, res) => {
-                if (proxyRes.statusCode !== 200) {
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    const originalUrl = req
-                        .originalUrl;
-                    logger.error(`[setupAiAssistantRoutes] Proxy error ${proxyRes.statusCode}: ${originalUrl}`);
-                }
-                // istanbul ignore else - noop, normal request
-                if (req.headers.accept === "text/event-stream") {
-                    res.writeHead(res.statusCode, {
-                        "Content-Type": "text/event-stream",
-                        "Cache-Control": "no-transform",
-                        Connection: "keep-alive",
-                    });
-                }
-                // Handle callbacks for successful responses
-                if (proxyRes.statusCode === 200 &&
-                    (args.onRestEndpointSuccess || args.onGraphQLOperationSuccess)) {
-                    handleSuccessCallback({
-                        proxyRes,
-                        req,
-                        logger,
-                        onRestEndpointSuccess: args.onRestEndpointSuccess,
-                        onGraphQLOperationSuccess: args.onGraphQLOperationSuccess,
-                    });
-                }
-            },
-            error: (err, req, res) => {
-                logger.error("[setupAiAssistantRoutes] Proxy error:", err);
-                if ("headersSent" in res && !res.headersSent) {
-                    res.statusCode = 502;
-                    res.write("Bad Gateway");
-                    res.end();
-                }
-            },
-        },
-    };
-    logger.debug("[setupAiAssistantRoutes] Setting up AI Assistant proxy:", proxyOptions);
-    const proxy = (0, http_proxy_middleware_1.createProxyMiddleware)(proxyOptions);
-    args.app.use(routePath, ...(0, helpers_1.coalesce)(args.preflightMiddlewares, []), bearerTokenMiddleware, proxy);
-}
-/**
- * This function gets around needing to add new global types that are only
- * needed for this one function.
- */
-function getRequestWithNewAuthHeader(req) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return req;
-}
-/**
- * Handles success callbacks by buffering the response and invoking the
- * appropriate callback based on the request type
- */
-function handleSuccessCallback(args) {
-    const { proxyRes, req, logger, onRestEndpointSuccess, onGraphQLOperationSuccess, } = args;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const expressRequest = req;
-    const targetPath = expressRequest.path || expressRequest.url || "";
-    const requestBody = expressRequest.body;
-    // Buffer the response data
-    const chunks = [];
-    proxyRes.on("data", (chunk) => {
-        chunks.push(chunk);
-    });
-    proxyRes.on("end", () => {
-        processBufferedResponse({
-            chunks,
-            requestBody,
-            targetPath,
-            expressRequest,
-            logger,
-            onRestEndpointSuccess,
-            onGraphQLOperationSuccess,
-        });
-    });
-}
-/**
- * Processes the buffered response and routes to appropriate callbacks
- */
-function processBufferedResponse(args) {
-    const { chunks, requestBody, targetPath, expressRequest, logger, onRestEndpointSuccess, onGraphQLOperationSuccess, } = args;
-    try {
-        const responseBody = Buffer.concat(chunks).toString("utf8");
-        // Skip callback if response is empty
-        if (!responseBody) {
-            return;
-        }
-        const parsedResponse = tryParseJSON(responseBody, logger);
-        if (!parsedResponse) {
-            return;
-        }
-        routeCallback({
-            requestBody,
-            parsedResponse,
-            targetPath,
-            expressRequest,
-            logger,
-            onRestEndpointSuccess,
-            onGraphQLOperationSuccess,
-        });
-    }
-    catch (error) {
-        // Don't let callback errors break the proxy
-        logger.error("[setupAiAssistantRoutes] Error in success callback:", error);
-    }
-}
-/**
- * Routes the parsed response to the appropriate callback handler
- */
-function routeCallback(args) {
-    const { requestBody, parsedResponse, targetPath, expressRequest, logger, onRestEndpointSuccess, onGraphQLOperationSuccess, } = args;
-    const isGraphQLRequest = isGraphQLRequestBody(requestBody);
-    if (isGraphQLRequest && onGraphQLOperationSuccess) {
-        handleGraphQLCallback({
-            requestBody,
-            parsedResponse,
-            expressRequest,
-            onGraphQLOperationSuccess,
-            logger,
-        });
-    }
-    else if (!isGraphQLRequest && onRestEndpointSuccess) {
-        handleRestCallback({
-            targetPath,
-            requestBody,
-            parsedResponse,
-            expressRequest,
-            onRestEndpointSuccess,
-            logger,
-        });
-    }
-}
-/**
- * Attempts to parse JSON response body
- */
-function tryParseJSON(responseBody, logger) {
-    try {
-        return JSON.parse(responseBody);
-    }
-    catch (error) {
-        // If it's not JSON (e.g., streaming response), skip callback
-        logger.debug("[setupAiAssistantRoutes] Response is not JSON, skipping callback");
-        return undefined;
-    }
-}
-/**
- * Checks if an object has GraphQL operation fields
- */
-function hasGraphQLFields(item) {
-    return (typeof item === "object" &&
-        item !== null &&
-        ("operationName" in item || "query" in item));
-}
-/**
- * Checks if request body indicates a GraphQL request
- */
-function isGraphQLRequestBody(requestBody) {
-    // Handle single GraphQL operation
-    if (!Array.isArray(requestBody)) {
-        return hasGraphQLFields(requestBody);
-    }
-    // Handle batched GraphQL operations
-    if (requestBody.length > 0) {
-        return hasGraphQLFields(requestBody[0]);
-    }
-    return false;
-}
-/**
- * Handles GraphQL operation callbacks
- */
-function handleGraphQLCallback(args) {
-    const { requestBody, parsedResponse, expressRequest, onGraphQLOperationSuccess, logger, } = args;
-    // Handle batched GraphQL requests
-    if (Array.isArray(requestBody)) {
-        handleBatchedGraphQLCallbacks({
-            requestBodies: requestBody,
-            parsedResponse,
-            expressRequest,
-            onGraphQLOperationSuccess,
-            logger,
-        });
-        return;
-    }
-    // Handle single GraphQL request
-    const operationName = extractGraphQLOperationName(requestBody, logger);
-    if (!operationName) {
-        return;
-    }
-    const callback = onGraphQLOperationSuccess[operationName];
-    if (callback) {
-        invokeGraphQLCallback({
-            callback,
-            requestBody,
-            parsedResponse,
-            expressRequest,
-            operationName,
-            logger,
-        });
-    }
-}
-/**
- * Handles batched GraphQL operation callbacks
- */
-function handleBatchedGraphQLCallbacks(args) {
-    const { requestBodies, parsedResponse, expressRequest, onGraphQLOperationSuccess, logger, } = args;
-    // Response should also be an array for batched requests
-    const responses = Array.isArray(parsedResponse)
-        ? parsedResponse
-        : [parsedResponse];
-    // Process each operation in the batch
-    requestBodies.forEach((requestBody, index) => {
-        const operationName = extractGraphQLOperationName(requestBody, logger);
-        if (!operationName) {
-            return;
-        }
-        const callback = onGraphQLOperationSuccess[operationName];
-        if (!callback) {
-            return;
-        }
-        // Match the request with its corresponding response
-        const response = responses[index] || parsedResponse;
-        invokeGraphQLCallback({
-            callback,
-            requestBody,
-            parsedResponse: response,
-            expressRequest,
-            operationName,
-            logger,
-        });
-    });
-}
-/**
- * Extracts the GraphQL operation name from request body
- */
-function extractGraphQLOperationName(requestBody, logger) {
-    if (typeof requestBody !== "object" || requestBody === null) {
-        return undefined;
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const body = requestBody;
-    // First, check if operationName is explicitly provided
-    if (body.operationName) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return body.operationName;
-    }
-    // Try to extract from query string
-    if (body.query) {
-        const match = body.query.match(/(?:query|mutation)\s+(\w+)/);
-        if (match) {
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            return match[1];
-        }
-    }
-    logger.debug("[setupAiAssistantRoutes] Could not determine GraphQL operation name");
-    return undefined;
-}
-/**
- * Invokes a GraphQL callback with the provided context
- * Type assertion is necessary because callbacks have specific request/response types
- * but we're working with unknown at runtime
- */
-function invokeGraphQLCallback(args) {
-    const { callback, requestBody, parsedResponse, expressRequest, operationName, logger, } = args;
-    const context = {
-        request: {
-            path: expressRequest.path || expressRequest.url || "",
-            method: expressRequest.method || "POST",
-            body: requestBody,
-        },
-        response: parsedResponse,
-    };
-    // Type assertion needed: callback expects specific CallbackContext types,
-    // but we can only provide CallbackContext<unknown, unknown> at runtime
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const typedCallback = callback;
-    Promise.resolve(typedCallback(context)).catch((error) => {
-        logger.error(`[setupAiAssistantRoutes] Error in GraphQL callback for ${operationName}:`, error);
-    });
-}
-/**
- * Handles REST endpoint callbacks
- */
-function handleRestCallback(args) {
-    const { targetPath, requestBody, parsedResponse, expressRequest, onRestEndpointSuccess, logger, } = args;
-    const matchingPath = findMatchingRestEndpoint(targetPath, onRestEndpointSuccess);
-    if (!matchingPath) {
-        return;
-    }
-    const callback = onRestEndpointSuccess[matchingPath];
-    if (callback) {
-        // Empty string fallback for path is unreachable since targetPath and expressRequest.path come from same source
-        /* istanbul ignore next */
-        const requestPath = expressRequest.path || expressRequest.url || "";
-        const context = {
-            request: {
-                path: requestPath,
-                method: expressRequest.method || "POST",
-                body: requestBody,
-            },
-            response: parsedResponse,
-        };
-        // Type assertion needed: callback expects specific CallbackContext types,
-        // but we can only provide CallbackContext<unknown, unknown> at runtime
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const typedCallback = callback;
-        Promise.resolve(typedCallback(context)).catch((error) => {
-            logger.error(`[setupAiAssistantRoutes] Error in REST callback for ${matchingPath}:`, error);
-        });
-    }
-}
-/**
- * Finds a matching REST endpoint path from the callbacks
- */
-function findMatchingRestEndpoint(targetPath, callbacks) {
-    const match = Object.keys(callbacks).find((path) => targetPath.includes(path));
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return match;
-}
-//# sourceMappingURL=express.js.map