Traces and Logs

import { AgentMarkSDK } from "@agentmark/sdk";
import {
  createAgentMarkClient,
  VercelAIModelRegistry
} from "@agentmark/vercel-ai-v4-adapter";
import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";


const sdk = new AgentMarkSDK({
  apiKey: process.env.AGENTMARK_API_KEY!,
  appId: process.env.AGENTMARK_APP_ID!
});

// Initialize tracing
const tracer = sdk.initTracing();

// Configure agentmark with vercel ai v4 adapter
const modelRegistry = new VercelAIModelRegistry();
modelRegistry.registerModels("gpt-4o-mini", (name: string) => {
    return openai(name);
});

const agentmark = createAgentMarkClient({
  loader: sdk.getFileLoader(),
  modelRegistry,
});

const myPrompt = await agentmark.loadTextPrompt("my-prompt.prompt.mdx");

// Format the prompt with props and telemetry
const vercelInput = await myPrompt.format({
  props,
  telemetry: { 
    isEnabled: true,
    functionId: "my-function",
    metadata: {
      userId: "123",
    }
  } 
});

const result = await generateText(vercelInput);

// Shutdown tracer (only needed for short-running scripts, local testing)
await tracer.shutdown();

import { trace } from "@agentmark/sdk";
...
trace('my-trace', async () => {
  // Your code here
});

import { component } from "@agentmark/sdk";
...
trace('my-trace', async () => {
  component('my-component', async () => {
    // Your code here
  });
});

import { trace, component } from "@agentmark/sdk";

trace(
  {
    name: "ai-agent-workflow",
    metadata: {
      "graph.node.id": "orchestrator",
      "graph.node.display_name": "AI Agent Orchestrator",
      "graph.node.type": "router",
    },
  },
  async () => {
    // Process and validate user input
    component(
      {
        name: "input-processor",
        metadata: {
          "graph.node.id": "input-processor",
          "graph.node.parent_id": "orchestrator",
          "graph.node.display_name": "Input Processor",
          "graph.node.type": "agent",
        },
      },
      async () => {
        // Validate and clean user input, extract intent
        console.log("Processing user input...");
      }
    );

    // Retrieve relevant context from memory/database
    component(
      {
        name: "context-retrieval",
        metadata: {
          "graph.node.id": "context-retrieval", 
          "graph.node.parent_id": "orchestrator",
          "graph.node.display_name": "Context Retrieval",
          "graph.node.type": "retrieval",
        },
      },
      async () => {
        // Fetch relevant context, conversation history, user preferences
        console.log("Retrieving context...");
      }
    );

    // Main LLM reasoning combining input and context
    component(
      {
        name: "llm-reasoning",
        metadata: {
          "graph.node.id": "llm-reasoning",
          "graph.node.parent_ids": JSON.stringify(["input-processor", "context-retrieval"]),
          "graph.node.display_name": "LLM Reasoning",
          "graph.node.type": "llm",
        },
      },
      async () => {
        // Perform main AI reasoning with processed input and retrieved context
        console.log("AI reasoning...");
      }
    );

    // Execute tools if needed based on LLM decision
    component(
      {
        name: "tool-executor",
        metadata: {
          "graph.node.id": "tool-executor",
          "graph.node.parent_id": "llm-reasoning",
          "graph.node.display_name": "Tool Executor",
          "graph.node.type": "tool",
        },
      },
      async () => {
        // Execute external tools (API calls, calculations, etc.)
        console.log("Executing tools...");
      }
    );

    // Format the final response
    component(
      {
        name: "response-formatter",
        metadata: {
          "graph.node.id": "response-formatter",
          "graph.node.parent_ids": JSON.stringify(["llm-reasoning", "tool-executor"]),
          "graph.node.display_name": "Response Formatter",
          "graph.node.type": "agent",
        },
      },
      async () => {
        // Format the response for the user
        console.log("Formatting response...");
      }
    );

    // Store interaction in memory for future reference
    component(
      {
        name: "memory-storage",
        metadata: {
          "graph.node.id": "memory-storage",
          "graph.node.parent_id": "response-formatter",
          "graph.node.display_name": "Memory Storage",
          "graph.node.type": "memory",
        },
      },
      async () => {
        // Store the interaction, learnings, and outcomes
        console.log("Storing in memory...");
      }
    );
  }
);

component({
  name: "multi-parent-node",
  metadata: {
    "graph.node.id": "aggregator",
    "graph.node.parent_ids": JSON.stringify(["node1", "node2", "node3"]),
    "graph.node.display_name": "Data Aggregator",
    "graph.node.type": "router",
  },
}, async () => {
  // This node processes outputs from multiple parent nodes
});