For Engineers

const { v4: uuidv4 } = require('uuid');

// Adaline constants
const ADX_API_KEY = "my_workspace_api_key";
const ADX_PROMPT_ID = "my_prompt_id";
const ADX_DEPLOYMENT_ENVIRONMENT_ID = "my_deployment_environment_id";
const ADX_BASE_URL = "https://api.adaline.ai";

// OpenAI constants
const OPENAI_API_KEY = "my_openai_api_key";

// Replace variables in prompt with your runtime values
function injectVariables(messages, variables) {
  return messages.map(message => ({
    role: message.role,
    content: message.content.map(c => {
      let text = c.value;
      variables.forEach(v => {
        const placeholder = `{{${v.name}}}`;
        text = text.replaceAll(placeholder, v.value);
      });
      return text;
    }).join(" "),
  }));
}

// Fetch latest deployment from Adaline
async function getLatestDeployment(promptId, deploymentEnvironmentId) {
  const response = await fetch(`${ADX_BASE_URL}/v2/deployments?promptId=${promptId}&deploymentId=latest&deploymentEnvironmentId=${deploymentEnvironmentId}`, {
    headers: {
      Authorization: `Bearer ${ADX_API_KEY}`,
    },
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }

  return response.json();
}

// Send log to Adaline after workflow execution
async function sendLog(projectId, trace, span) {
  const response = await fetch(`${ADX_BASE_URL}/v2/logs/trace`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${ADX_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      projectId,
      trace,
      spans: [span],
    }),
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`API Error: ${error.error}`);
  }

  return response.json();
}

// Sample workflow using OpenAI
async function callOpenAIChatCompletion(model, messages) {
  const spanId = uuidv4();
  const spanStartTime = Date.now();

  const response = await fetch("https://api.openai.com/v1/chat/completions", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${OPENAI_API_KEY}`,
      "Content-Type": "application/json",
      "X-Span-Id": spanId,
    },
    body: JSON.stringify({
      model: model,
      messages: messages,
    }),
  });

  const spanEndTime = Date.now();

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`OpenAI API Error: ${error.error.message}`);
  }

  const data = await response.json();

  return {
    spanId,
    spanStartTime,
    spanEndTime,
    rawResponse: data,
    content: data.choices[0].message.content,
  };
}

// Main function
(async () => {
  try {

    // Start trace
    const traceId = uuidv4();
    const traceStartTime = Date.now();

    // Get latest deployment
    const deployment = await getLatestDeployment(ADX_PROMPT_ID, ADX_DEPLOYMENT_ENVIRONMENT_ID);
    const deploymentId = deployment.id;
    const projectId = deployment.projectId;
    const prompt = deployment.prompt;
    const model = prompt.config.model;
    const provider = prompt.config.providerName;

    // Inject variables into prompt
    const inputVariables = [{ name: "persona", value: "financial analyst" }];
    const messages = injectVariables(prompt.messages, inputVariables);

    // Run sample workflow
    const openAIResult = await callOpenAIChatCompletion(model, messages);

    // End trace
    const traceEndTime = Date.now();

    console.log("========== TRACE INFO ==========");
    console.log("Trace ID:", traceId);
    console.log("Trace Start:", new Date(traceStartTime).toISOString());
    console.log("Trace End:  ", new Date(traceEndTime).toISOString());
    console.log("Trace Duration (ms):", traceEndTime - traceStartTime);

    console.log("\n---- Span: OpenAI API Call ----");
    console.log("Span ID:", openAIResult.spanId);
    console.log("Span Start:", new Date(openAIResult.spanStartTime).toISOString());
    console.log("Span End:  ", new Date(openAIResult.spanEndTime).toISOString());
    console.log("Span Duration (ms):", openAIResult.spanEndTime - openAIResult.spanStartTime);

    console.log("\n✅ OpenAI LLM Response:");
    console.log(openAIResult.content);

    // Construct log payload
    const trace = {
      startedAt: traceStartTime,
      endedAt: traceEndTime,
      name: "test-trace",
      status: "success",
      referenceId: traceId,
      attributes: {
        application: "test-app",
        environment: "test-env"
      },
      tags: ["test-trace-tag"]
    };

    const span = {
      promptId: ADX_PROMPT_ID,
      deploymentId,
      startedAt: openAIResult.spanStartTime,
      endedAt: openAIResult.spanEndTime,
      name: "test-span",
      status: "success",
      referenceId: openAIResult.spanId,
      content: {
        type: "Model",
        provider,
        model,
        input: JSON.stringify({
          config: prompt.config,
          messages: prompt.messages,
          tools: prompt.tools
        }),
        output: JSON.stringify(openAIResult.rawResponse),
        variables: inputVariables.reduce((acc, v) => {
          acc[v.name] = {
            modality: "text",
            value: v.value
          }
          return acc;
        }, {})
      },
      attributes: {
        application: "test-app",
        environment: "test-env"
      },
      tags: ["test-span-tag"]
    };

    // Send trace and span to Adaline
    const logIds = await sendLog(projectId, trace, span);

    // Print log IDs from Adaline
    console.log("\n✅ Log IDs:", logIds);
  } catch (error) {
    console.error("\n❌ Error:", error.message);
  }
})();