MCP Tools Reference

await callTool("pml:search_tools", {
  query: "read and parse JSON files",
  limit: 5,
  include_related: true,
});

await callTool("pml:search_capabilities", {
  intent: "parse JSON from API and store in database",
  include_suggestions: true,
});

{
  workflow: {
    tasks: [
      {
        id: string,           // Unique task identifier
        tool: string,         // Tool name (serverId:toolName)
        arguments: object,    // Tool arguments
        dependsOn?: string[] // IDs of dependent tasks
      }
    ]
  }
}

await callTool("pml:execute_dag", {
  intent: "Read config.json and create a memory entity with its content",
});

await callTool("pml:execute_dag", {
  workflow: {
    tasks: [
      { id: "t1", tool: "filesystem:read_file", arguments: { path: "config.json" } },
      { id: "t2", tool: "filesystem:read_file", arguments: { path: "package.json" } },
      {
        id: "t3",
        tool: "memory:create_entities",
        arguments: { entities: [{ name: "config", content: "$t1.result" }] },
        dependsOn: ["t1"],
      },
    ],
  },
});
// t1 and t2 execute in parallel, t3 waits for t1

await callTool("pml:execute_code", {
  code: `
    const items = context.data;
    const filtered = items.filter(x => x.active);
    return {
      total: filtered.length,
      summary: filtered.slice(0, 5)
    };
  `,
  context: { data: largeDataset },
});

await callTool("pml:execute_code", {
  intent: "Analyze GitHub commits",
  code: `
    // 'github' injected automatically thanks to intent
    const commits = await github.listCommits({ limit: 100 });
    return commits.filter(c => c.author === "alice").length;
  `,
});

await callTool("pml:continue", {
  workflow_id: "wf_abc123",
  reason: "Layer 1 validated, continue",
});

await callTool("pml:abort", {
  workflow_id: "wf_abc123",
  reason: "Error detected in layer 1 results",
});

// After discovering unexpected XML files
await callTool("pml:replan", {
  workflow_id: "wf_abc123",
  new_requirement: "Parse discovered XML files",
  available_context: {
    discovered_files: ["config.xml", "data.xml"],
  },
});

await callTool("pml:approval_response", {
  workflow_id: "wf_abc123",
  checkpoint_id: "cp_xyz789",
  approved: true,
  feedback: "Operation validated, proceed with deployment",
});

// File reading via filesystem server
await callTool("filesystem:read_file", { path: "/path/to/file.txt" });

// GitHub issue creation
await callTool("github:create_issue", {
  repo: "owner/repo",
  title: "Bug report",
  body: "Description...",
});

// Memory search
await callTool("memory:search_nodes", { query: "configuration" });

interface DAGStructure {
  tasks: DAGTask[];
}

interface DAGTask {
  id: string; // Unique identifier
  tool: string; // "serverId:toolName"
  type?: "mcp_tool" | "code_execution";
  arguments: Record<string, unknown>;
  dependsOn?: string[]; // Dependency IDs (camelCase, not snake_case)
  code?: string; // For type: "code_execution"
}

interface TaskResult {
  taskId: string;
  status: "success" | "error" | "skipped";
  result?: unknown;
  error?: string;
  duration_ms: number;
}

type WorkflowStatus =
  | "running" // Currently executing
  | "paused" // Waiting for validation/approval
  | "complete" // Completed successfully
  | "aborted" // Stopped by user
  | "error"; // Failed

// 1. Discover relevant tools
const tools = await callTool("pml:search_tools", {
  query: "read files and analyze project structure",
  include_related: true,
});

// 2. Execute a DAG workflow
const result = await callTool("pml:execute_dag", {
  intent: "Read all TypeScript files in src/ and count lines",
});

// 3. Post-process with sandbox
const analysis = await callTool("pml:execute_code", {
  code: `
    const files = context.files;
    return {
      totalFiles: files.length,
      totalLines: files.reduce((sum, f) => sum + f.lines, 0),
      avgLinesPerFile: Math.round(files.reduce((sum, f) => sum + f.lines, 0) / files.length)
    };
  `,
  context: { files: result.results },
});

// 1. Start with per-layer validation
const workflow = await callTool("pml:execute_dag", {
  intent: "Deploy new version to production",
  per_layer_validation: true,
});

// 2. Examine layer results
console.log(workflow.layer_results);

// 3. Approve and continue
await callTool("pml:continue", {
  workflow_id: workflow.workflow_id,
  reason: "Tests passed, approved for deployment",
});