openloops 0.1.9 → 0.1.11

package/dist/chunk-XRJFNASX.mjs

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+export {
+  __decorateClass
+};

package/dist/common/clients/index.d.ts

@@ -0,0 +1,3 @@
+export * from './llm-client';
+export * from './sentry-client';
+export * from './serper-client';

package/dist/common/clients/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clients_exports = {};
+module.exports = __toCommonJS(clients_exports);
+__reExport(clients_exports, require("./llm-client"), module.exports);
+__reExport(clients_exports, require("./sentry-client"), module.exports);
+__reExport(clients_exports, require("./serper-client"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./llm-client"),
+  ...require("./sentry-client"),
+  ...require("./serper-client")
+});

package/dist/common/clients/index.mjs

@@ -0,0 +1,3 @@
+export * from "./llm-client";
+export * from "./sentry-client";
+export * from "./serper-client";

package/dist/common/clients/llm-client.d.ts

@@ -0,0 +1,30 @@
+import 'reflect-metadata';
+import type { KnownProvider, Message, AssistantMessage } from '@mariozechner/pi-ai';
+import { CurrentUser } from '../../services/app/core/index.js';
+export declare class LLMClient {
+    private readonly logger;
+    private readonly langfuse;
+    constructor();
+    complete(params: LLMCompletionParams): Promise<AssistantMessage>;
+    private postResponse;
+    private formatContentForLog;
+    private formatMessagesForLog;
+}
+export interface LLMCompletionParams {
+    taskName: string;
+    sessionId: string;
+    answerId: string;
+    currentUser?: CurrentUser;
+    systemPrompt?: string;
+    messages: Message[];
+    provider?: KnownProvider;
+    modelName?: string;
+    temperature?: number;
+}
+export interface LLMPostResponseParams {
+    taskName: string;
+    sessionId: string;
+    answerId: string;
+    currentUser?: CurrentUser;
+    response: AssistantMessage;
+}

package/dist/common/clients/llm-client.js

@@ -0,0 +1,159 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var llm_client_exports = {};
+__export(llm_client_exports, {
+  LLMClient: () => LLMClient
+});
+module.exports = __toCommonJS(llm_client_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_tsyringe = require("tsyringe");
+var import_langfuse = require("langfuse");
+var import_secret_manager = require("../utils/secret-manager.js");
+var import_logger = require("../logger/index.js");
+var import_helpers = require("../helpers/index.js");
+var import_create_llmcall = require("../../services/agent/modules/llmcalls/lambdas/create-llmcall/index.js");
+class LLMClient {
+  logger = new import_logger.Logger();
+  langfuse;
+  constructor() {
+    process.env.OPENAI_API_KEY = import_secret_manager.secretManager.get("OPENAI_API_KEY");
+    this.langfuse = new import_langfuse.Langfuse({
+      publicKey: import_secret_manager.secretManager.get("LANGFUSE_PUBLIC_KEY"),
+      secretKey: import_secret_manager.secretManager.get("LANGFUSE_SECRET_KEY"),
+      baseUrl: process.env.LANGFUSE_BASE_URL
+    });
+  }
+  async complete(params) {
+    const { getModel, complete } = await import("@mariozechner/pi-ai");
+    const {
+      taskName,
+      sessionId,
+      answerId,
+      currentUser,
+      systemPrompt,
+      messages,
+      provider = "openai",
+      modelName = "gpt-4o-mini",
+      temperature = 0.7
+    } = params ?? {};
+    const model = getModel(provider, modelName);
+    const context = {
+      systemPrompt,
+      messages
+    };
+    this.logger.debug({
+      taskName,
+      context: {
+        ...context,
+        messages: this.formatMessagesForLog(messages)
+      }
+    }, "[LLM Service] context");
+    const trace = this.langfuse.trace({
+      sessionId,
+      name: taskName,
+      userId: currentUser?.userId,
+      metadata: {
+        taskName,
+        email: currentUser?.email,
+        sessionId
+      }
+    });
+    const generation = trace.generation({
+      name: "llm-completion",
+      model: modelName,
+      modelParameters: { temperature, provider },
+      input: context
+    });
+    try {
+      const response = await complete(model, context, {
+        temperature
+      });
+      generation.end({
+        output: response,
+        usage: response.usage ? {
+          promptTokens: response.usage.input,
+          completionTokens: response.usage.output,
+          totalTokens: response.usage.totalTokens
+        } : void 0
+      });
+      await this.langfuse.flushAsync();
+      this.logger.debug({
+        taskName,
+        response: {
+          ...response,
+          content: this.formatContentForLog(response?.content)
+        }
+      }, "[LLM Service] Response");
+      await this.postResponse({ taskName, sessionId, answerId, currentUser, response });
+      return response;
+    } catch (error) {
+      generation.end({
+        level: "ERROR",
+        statusMessage: error.message
+      });
+      await this.langfuse.flushAsync();
+      throw error;
+    }
+  }
+  async postResponse(params) {
+    const { taskName, sessionId, answerId, currentUser, response } = params ?? {};
+    const createLLMCallUseCase = import_tsyringe.container.resolve(import_create_llmcall.CreateLLMCallUseCase);
+    await createLLMCallUseCase.execute({
+      payload: {
+        taskName,
+        sessionId,
+        answerId,
+        response,
+        costInUsd: response?.usage?.cost?.total
+      },
+      currentUser
+    });
+  }
+  formatContentForLog(records) {
+    return records?.map((record) => {
+      const text = record?.text;
+      const extracted = (0, import_helpers.extractJSON)(text);
+      const isJson = Object.keys(extracted).length > 0;
+      return {
+        ...record,
+        text: isJson ? extracted : text
+      };
+    });
+  }
+  formatMessagesForLog(messages) {
+    return messages.map((message) => ({
+      ...message,
+      content: this.formatContentForLog(message?.content) ?? message?.content
+    }));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LLMClient
+});

package/dist/common/clients/llm-client.mjs

@@ -0,0 +1,126 @@
+import "../../chunk-XRJFNASX.mjs";
+import "reflect-metadata";
+import { container } from "tsyringe";
+import { Langfuse } from "langfuse";
+import { secretManager } from "../utils/secret-manager.js";
+import { Logger } from "../logger/index.js";
+import { extractJSON } from "../helpers/index.js";
+import { CreateLLMCallUseCase } from "../../services/agent/modules/llmcalls/lambdas/create-llmcall/index.js";
+class LLMClient {
+  logger = new Logger();
+  langfuse;
+  constructor() {
+    process.env.OPENAI_API_KEY = secretManager.get("OPENAI_API_KEY");
+    this.langfuse = new Langfuse({
+      publicKey: secretManager.get("LANGFUSE_PUBLIC_KEY"),
+      secretKey: secretManager.get("LANGFUSE_SECRET_KEY"),
+      baseUrl: process.env.LANGFUSE_BASE_URL
+    });
+  }
+  async complete(params) {
+    const { getModel, complete } = await import("@mariozechner/pi-ai");
+    const {
+      taskName,
+      sessionId,
+      answerId,
+      currentUser,
+      systemPrompt,
+      messages,
+      provider = "openai",
+      modelName = "gpt-4o-mini",
+      temperature = 0.7
+    } = params ?? {};
+    const model = getModel(provider, modelName);
+    const context = {
+      systemPrompt,
+      messages
+    };
+    this.logger.debug({
+      taskName,
+      context: {
+        ...context,
+        messages: this.formatMessagesForLog(messages)
+      }
+    }, "[LLM Service] context");
+    const trace = this.langfuse.trace({
+      sessionId,
+      name: taskName,
+      userId: currentUser?.userId,
+      metadata: {
+        taskName,
+        email: currentUser?.email,
+        sessionId
+      }
+    });
+    const generation = trace.generation({
+      name: "llm-completion",
+      model: modelName,
+      modelParameters: { temperature, provider },
+      input: context
+    });
+    try {
+      const response = await complete(model, context, {
+        temperature
+      });
+      generation.end({
+        output: response,
+        usage: response.usage ? {
+          promptTokens: response.usage.input,
+          completionTokens: response.usage.output,
+          totalTokens: response.usage.totalTokens
+        } : void 0
+      });
+      await this.langfuse.flushAsync();
+      this.logger.debug({
+        taskName,
+        response: {
+          ...response,
+          content: this.formatContentForLog(response?.content)
+        }
+      }, "[LLM Service] Response");
+      await this.postResponse({ taskName, sessionId, answerId, currentUser, response });
+      return response;
+    } catch (error) {
+      generation.end({
+        level: "ERROR",
+        statusMessage: error.message
+      });
+      await this.langfuse.flushAsync();
+      throw error;
+    }
+  }
+  async postResponse(params) {
+    const { taskName, sessionId, answerId, currentUser, response } = params ?? {};
+    const createLLMCallUseCase = container.resolve(CreateLLMCallUseCase);
+    await createLLMCallUseCase.execute({
+      payload: {
+        taskName,
+        sessionId,
+        answerId,
+        response,
+        costInUsd: response?.usage?.cost?.total
+      },
+      currentUser
+    });
+  }
+  formatContentForLog(records) {
+    return records?.map((record) => {
+      const text = record?.text;
+      const extracted = extractJSON(text);
+      const isJson = Object.keys(extracted).length > 0;
+      return {
+        ...record,
+        text: isJson ? extracted : text
+      };
+    });
+  }
+  formatMessagesForLog(messages) {
+    return messages.map((message) => ({
+      ...message,
+      content: this.formatContentForLog(message?.content) ?? message?.content
+    }));
+  }
+}
+export {
+  LLMClient
+};

package/dist/common/clients/sentry-client.d.ts

@@ -0,0 +1,10 @@
+export declare class SentryClient {
+    private static instance;
+    private readonly enabled;
+    static getInstance(): SentryClient;
+    private constructor();
+    captureError(error: unknown, contextData?: Record<string, any>): Promise<void>;
+    setUser(userId: string): void;
+    private resolveDsn;
+}
+export declare const sentryClient: SentryClient;

package/dist/common/clients/sentry-client.js

@@ -0,0 +1,87 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sentry_client_exports = {};
+__export(sentry_client_exports, {
+  SentryClient: () => SentryClient,
+  sentryClient: () => sentryClient
+});
+module.exports = __toCommonJS(sentry_client_exports);
+var Sentry = __toESM(require("@sentry/node"));
+var import_logger = require("../logger");
+var import_secret_manager = require("../utils/secret-manager.js");
+class SentryClient {
+  static instance;
+  enabled;
+  static getInstance() {
+    if (!SentryClient.instance) {
+      SentryClient.instance = new SentryClient();
+    }
+    return SentryClient.instance;
+  }
+  constructor() {
+    const dsn = this.resolveDsn();
+    this.enabled = !!dsn;
+    if (!dsn) {
+      import_logger.logger.warn("[Sentry Client] Sentry DSN is not configured. Skipping error reporting.");
+      return;
+    }
+    Sentry.init({ dsn, environment: process.env.NODE_ENV || "production", tracesSampleRate: 0 });
+    import_logger.logger.debug("[Sentry Client] Sentry client initialized");
+  }
+  async captureError(error, contextData) {
+    if (!this.enabled) return;
+    Sentry.withScope((scope) => {
+      if (contextData) scope.setExtras(contextData);
+      Sentry.captureException(error);
+    });
+    try {
+      await Sentry.flush(2e3);
+      import_logger.logger.debug("[Sentry Client] Error reported to Sentry successfully");
+    } catch (e) {
+      import_logger.logger.error(e, "[Sentry Client] Failed to flush Sentry events");
+    }
+  }
+  setUser(userId) {
+    if (!this.enabled) return;
+    Sentry.setUser({ id: userId });
+  }
+  resolveDsn() {
+    try {
+      return import_secret_manager.secretManager.get("SENTRY_DSN");
+    } catch {
+      return void 0;
+    }
+  }
+}
+const sentryClient = SentryClient.getInstance();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SentryClient,
+  sentryClient
+});

package/dist/common/clients/sentry-client.mjs

@@ -0,0 +1,53 @@
+import "../../chunk-XRJFNASX.mjs";
+import * as Sentry from "@sentry/node";
+import { logger } from "../logger";
+import { secretManager } from "../utils/secret-manager.js";
+class SentryClient {
+  static instance;
+  enabled;
+  static getInstance() {
+    if (!SentryClient.instance) {
+      SentryClient.instance = new SentryClient();
+    }
+    return SentryClient.instance;
+  }
+  constructor() {
+    const dsn = this.resolveDsn();
+    this.enabled = !!dsn;
+    if (!dsn) {
+      logger.warn("[Sentry Client] Sentry DSN is not configured. Skipping error reporting.");
+      return;
+    }
+    Sentry.init({ dsn, environment: process.env.NODE_ENV || "production", tracesSampleRate: 0 });
+    logger.debug("[Sentry Client] Sentry client initialized");
+  }
+  async captureError(error, contextData) {
+    if (!this.enabled) return;
+    Sentry.withScope((scope) => {
+      if (contextData) scope.setExtras(contextData);
+      Sentry.captureException(error);
+    });
+    try {
+      await Sentry.flush(2e3);
+      logger.debug("[Sentry Client] Error reported to Sentry successfully");
+    } catch (e) {
+      logger.error(e, "[Sentry Client] Failed to flush Sentry events");
+    }
+  }
+  setUser(userId) {
+    if (!this.enabled) return;
+    Sentry.setUser({ id: userId });
+  }
+  resolveDsn() {
+    try {
+      return secretManager.get("SENTRY_DSN");
+    } catch {
+      return void 0;
+    }
+  }
+}
+const sentryClient = SentryClient.getInstance();
+export {
+  SentryClient,
+  sentryClient
+};

package/dist/common/clients/serper-client.d.ts

@@ -0,0 +1,66 @@
+export declare class SerperClient {
+    private readonly logger;
+    searchOnGoogle(params: SerperSearchParams): Promise<SerperSearchResponse | undefined>;
+}
+export interface SerperSearchParams {
+    query: string;
+    type?: 'search' | 'news';
+    page?: number;
+    num?: number;
+    countryCode?: string;
+    languageCode?: string;
+}
+export interface SerperOrganicResult {
+    title: string;
+    link: string;
+    snippet: string;
+    position: number;
+    sitelinks?: Array<{
+        title: string;
+        link: string;
+    }>;
+    date?: string;
+    attributes?: Record<string, string>;
+}
+export interface SerperAnswerBox {
+    title?: string;
+    answer?: string;
+    snippet?: string;
+    source?: string;
+    sourceLink?: string;
+    temperature?: string;
+    unit?: string;
+    weather?: string;
+    humidity?: string;
+    wind?: string;
+}
+export interface SerperKnowledgeGraph {
+    title: string;
+    type?: string;
+    website?: string;
+    imageUrl?: string;
+    description?: string;
+    descriptionSource?: string;
+    descriptionLink?: string;
+    attributes?: Record<string, string>;
+}
+export interface SerperRelatedSearch {
+    query: string;
+}
+export interface SerperSearchResponse {
+    searchParameters: {
+        q: string;
+        gl?: string;
+        hl?: string;
+        type: string;
+        engine: string;
+        num?: number;
+        page?: number;
+    };
+    news?: SerperOrganicResult[];
+    organic?: SerperOrganicResult[];
+    answerBox?: SerperAnswerBox;
+    knowledgeGraph?: SerperKnowledgeGraph;
+    relatedSearches?: SerperRelatedSearch[];
+    credits?: number;
+}

package/dist/common/clients/serper-client.js

@@ -0,0 +1,74 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var serper_client_exports = {};
+__export(serper_client_exports, {
+  SerperClient: () => SerperClient
+});
+module.exports = __toCommonJS(serper_client_exports);
+var import_axios = __toESM(require("axios"));
+var import_logger = require("../logger/index.js");
+var import_secret_manager = require("../utils/secret-manager.js");
+class SerperClient {
+  logger = new import_logger.Logger();
+  async searchOnGoogle(params) {
+    const { query, type, page, num, countryCode, languageCode } = params;
+    const apiKey = import_secret_manager.secretManager.get("SERPER_API_KEY");
+    const inputData = {
+      q: query,
+      type,
+      page,
+      num,
+      ...countryCode ? { gl: countryCode } : {},
+      ...languageCode ? { hl: languageCode } : {},
+      engine: "google"
+    };
+    const config = {
+      method: "post",
+      maxBodyLength: Infinity,
+      url: "https://google.serper.dev/search",
+      headers: {
+        "X-API-KEY": apiKey,
+        "Content-Type": "application/json"
+      },
+      data: inputData
+    };
+    try {
+      this.logger.debug({ ...inputData }, "[Serper Client] Searching on internet...");
+      const { data } = await import_axios.default.request(config);
+      this.logger.debug({ ...data }, "[Serper Client] Search results");
+      return data;
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SerperClient
+});