@endlessriver/optimaiz/dist/index.js

Client SDK for interacting with the Optimaiz logging & trace system.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.OptimaizClient = void 0;
const crypto_1 = __importDefault(require("crypto"));
const DEFAULT_BASE_URL = "https://www.optimaiz.io";
class OptimaizClient {
    constructor(config) {
        this.config = config;
    }
    async post(path, body) {
        const res = await fetch(`${DEFAULT_BASE_URL}${path}`, {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: `Bearer ${this.config.token}`,
            },
            body: JSON.stringify({ ...body }),
        });
        if (!res.ok) {
            const errorText = await res.text();
            throw new Error(`Optimaiz API Error: ${res.status} - ${errorText}`);
        }
        return res.json();
    }
    async startTrace(data) {
        return this.post("/api/v1/interactions/start", data);
    }
    async appendResponse(data) {
        return this.post("/api/v1/interactions/append", data);
    }
    async finalizeTrace(traceId) {
        return this.post("/api/v1/interactions/finalize", { traceId });
    }
    async logError(traceId, error) {
        return this.post("/api/v1/interactions/error", { traceId, error });
    }
    async sendFeedback(traceId, feedback) {
        return this.post("/api/v1/interactions/feedback", { traceId, feedback });
    }
    composePrompts(templates, variables) {
        const prompts = [];
        const promptTemplates = [];
        for (const { role, content, type = "text" } of templates) {
            const resolved = Object.entries(variables).reduce((acc, [k, v]) => acc.replace(`{${k}}`, v), content);
            prompts.push({ type, role, value: resolved });
            promptTemplates.push({ type, role, value: content });
        }
        return { prompts, promptTemplates, promptVariables: variables };
    }
    async wrapLLMCall({ traceId = crypto_1.default.randomUUID(), agentId, flowId, threadId, sessionId, userId, promptTemplate, promptVariables, provider, model, modelParams, metadata, tags, call, }) {
        try {
            await this.startTrace({
                traceId,
                agentId,
                flowId,
                threadId,
                sessionId,
                userId,
                promptTemplate,
                promptVariables,
                provider,
                model,
                modelParams,
                metadata,
                tags,
            });
        }
        catch (err) {
            console.warn("[Optimaiz] Failed to start trace", err);
        }
        try {
            const response = await call();
            try {
                await this.appendResponse({ traceId, rawResponse: response, provider, model });
            }
            catch (err) {
                console.warn("[Optimaiz] Failed to append response", err);
            }
            try {
                await this.finalizeTrace(traceId);
            }
            catch (err) {
                console.warn("[Optimaiz] Failed to finalize trace", err);
            }
            return { response, traceId };
        }
        catch (err) {
            await this.logError(traceId, {
                message: err.message,
                code: err.code || "unknown_error",
                details: err.stack || err,
            });
            console.error("[Optimaiz] Error in wrapLLMCall", err);
            throw err;
        }
    }
    generatePromptFromTools({ toolInfo, toolInput, }) {
        const fn = toolInfo.find(f => f.name === toolInput.name);
        if (!fn)
            throw new Error(`Tool ${toolInput.name} not found in toolInfo`);
        // Normalize parameters
        let properties = {};
        const params = fn.parameters;
        if (params?.type === "object" && params?.properties) {
            properties = params.properties;
        }
        else if ("properties" in params) {
            properties = params.properties;
        }
        else {
            console.warn("Tool parameters not in expected format:", params);
        }
        const argKeys = Object.keys(toolInput.arguments || {});
        const promptText = [
            `Use the tool: {toolName}.`,
            fn.description ? `Tool Description: {description}.` : "",
            ...argKeys.map(key => `${key}: {${key}}${properties[key]?.description ? `  // ${properties[key].description}` : ""}`),
        ]
            .filter(Boolean)
            .join("\n");
        const promptTemplate = [
            {
                role: "user",
                type: "text",
                value: promptText,
            },
        ];
        const promptVariables = {
            toolName: fn.name,
            description: fn.description || "",
            ...Object.fromEntries(argKeys.map(k => [k, String(toolInput.arguments[k])])),
        };
        return { promptTemplate, promptVariables };
    }
    async call(data) {
        data.traceId = data.traceId || crypto_1.default.randomUUID();
        try {
            const { data: response, error } = await this.post("/api/v1/call", data);
            return { data: response, error };
        }
        catch (err) {
            await this.logError(data.traceId, {
                message: err.message,
                code: err.code || "unknown_error",
                details: err.stack || err,
            });
            return { data: null, error: err.message };
        }
    }
}
exports.OptimaizClient = OptimaizClient;