Traces and Logs

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

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

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

// Configure client
const modelRegistry = new VercelAIModelRegistry()
  .registerModels(["gpt-4o-mini"], (name) => openai(name));

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

// Load and run prompt with telemetry
const prompt = await client.loadTextPrompt("greeting.prompt.mdx");
const input = await prompt.format({
  props: { name: 'Alice' },
  telemetry: {
    isEnabled: true,
    functionId: "greeting-function",
    metadata: {
      userId: "123",
      environment: "production"
    }
  }
});

const result = await generateText(input);

// Shutdown tracer (only for short-running scripts)
await tracer.shutdown();

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

await trace('user-request-handler', async () => {
  // All spans created here are grouped under this trace
  const prompt = await client.loadTextPrompt('handler.prompt.mdx');
  const input = await prompt.format({
    props: { query: 'What is AgentMark?' },
    telemetry: { isEnabled: true }
  });

  const result = await generateText(input);
  return result;
});

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

await trace('multi-step-workflow', async () => {

  await component('validate-input', async () => {
    // Validation logic
  });

  await component('process-request', async () => {
    // Main processing
    const prompt = await client.loadTextPrompt('process.prompt.mdx');
    // ...
  });

  await component('format-response', async () => {
    // Response formatting
  });
});

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

await trace(
  {
    name: "ai-agent-workflow",
    metadata: {
      "graph.node.id": "orchestrator",
      "graph.node.display_name": "Orchestrator",
      "graph.node.type": "router"
    }
  },
  async () => {

    // Step 1: Process input
    await 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 () => {
        // Process and validate input
      }
    );

    // Step 2: Retrieve context
    await 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
      }
    );

    // Step 3: LLM reasoning (depends on both previous steps)
    await 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 () => {
        const prompt = await client.loadTextPrompt('reason.prompt.mdx');
        // ... reasoning logic
      }
    );
  }
);

// ❌ Bad
telemetry: { functionId: "func1" }

// ✅ Good
telemetry: { functionId: "customer-support-greeting" }

telemetry: {
  isEnabled: true,
  functionId: "search-handler",
  metadata: {
    userId: user.id,
    environment: process.env.NODE_ENV,
    query: searchQuery,
    resultCount: results.length
  }
}

// For short-running scripts (like CLI tools)
await tracer.shutdown();

// For long-running servers, shutdown on process exit
process.on('SIGTERM', async () => {
  await tracer.shutdown();
  process.exit(0);
});