@poncho-ai/harness 0.2.0

package/src/telemetry.ts

@@ -0,0 +1,108 @@
+import type { AgentEvent } from "@poncho-ai/sdk";
+
+export interface TelemetryConfig {
+  enabled?: boolean;
+  otlp?: string;
+  latitude?: {
+    apiKey?: string;
+    projectId?: string | number;
+    path?: string;
+    documentPath?: string;
+  };
+  handler?: (event: AgentEvent) => Promise<void> | void;
+}
+
+export class TelemetryEmitter {
+  private readonly config: TelemetryConfig | undefined;
+
+  constructor(config?: TelemetryConfig) {
+    this.config = config;
+  }
+
+  async emit(event: AgentEvent): Promise<void> {
+    if (this.config?.enabled === false) {
+      return;
+    }
+    if (this.config?.handler) {
+      await this.config.handler(event);
+      return;
+    }
+    if (this.config?.otlp) {
+      await this.sendOtlp(event);
+    }
+    if (this.config?.latitude?.apiKey) {
+      await this.sendLatitude(event);
+    }
+    // Default behavior in local dev: print concise structured logs.
+    process.stdout.write(`[event] ${event.type} ${JSON.stringify(event)}\n`);
+  }
+
+  private async sendOtlp(event: AgentEvent): Promise<void> {
+    const endpoint = this.config?.otlp;
+    if (!endpoint) {
+      return;
+    }
+    try {
+      await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          resourceLogs: [
+            {
+              scopeLogs: [
+                {
+                  logRecords: [
+                    {
+                      timeUnixNano: String(Date.now() * 1_000_000),
+                      severityText: "INFO",
+                      body: { stringValue: event.type },
+                      attributes: [
+                        {
+                          key: "event.payload",
+                          value: { stringValue: JSON.stringify(event) },
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        }),
+      });
+    } catch {
+      // Ignore telemetry delivery failures.
+    }
+  }
+
+  private async sendLatitude(event: AgentEvent): Promise<void> {
+    const apiKey = this.config?.latitude?.apiKey;
+    if (!apiKey) {
+      return;
+    }
+    const projectId =
+      this.config?.latitude?.projectId ?? process.env.LATITUDE_PROJECT_ID;
+    const path = this.config?.latitude?.path ?? process.env.LATITUDE_PATH;
+    const documentPath =
+      this.config?.latitude?.documentPath ?? process.env.LATITUDE_DOCUMENT_PATH;
+    try {
+      await fetch("https://api.latitude.so/v1/telemetry/events", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          type: event.type,
+          payload: event,
+          timestamp: Date.now(),
+          projectId,
+          path,
+          documentPath,
+        }),
+      });
+    } catch {
+      // Ignore telemetry delivery failures.
+    }
+  }
+}

package/src/tool-dispatcher.ts

@@ -0,0 +1,69 @@
+import type { ToolContext, ToolDefinition } from "@poncho-ai/sdk";
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+}
+
+export interface ToolExecutionResult {
+  callId: string;
+  tool: string;
+  output?: unknown;
+  error?: string;
+}
+
+export class ToolDispatcher {
+  private readonly tools = new Map<string, ToolDefinition>();
+
+  register(tool: ToolDefinition): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  registerMany(tools: ToolDefinition[]): void {
+    for (const tool of tools) {
+      this.register(tool);
+    }
+  }
+
+  list(): ToolDefinition[] {
+    return [...this.tools.values()];
+  }
+
+  get(name: string): ToolDefinition | undefined {
+    return this.tools.get(name);
+  }
+
+  async execute(call: ToolCall, context: ToolContext): Promise<ToolExecutionResult> {
+    const definition = this.tools.get(call.name);
+    if (!definition) {
+      return {
+        callId: call.id,
+        tool: call.name,
+        error: `Tool not found: ${call.name}`,
+      };
+    }
+
+    try {
+      const output = await definition.handler(call.input, context);
+      return {
+        callId: call.id,
+        tool: call.name,
+        output,
+      };
+    } catch (error) {
+      return {
+        callId: call.id,
+        tool: call.name,
+        error: error instanceof Error ? error.message : "Unknown tool error",
+      };
+    }
+  }
+
+  async executeBatch(
+    calls: ToolCall[],
+    context: ToolContext,
+  ): Promise<ToolExecutionResult[]> {
+    return Promise.all(calls.map(async (call) => this.execute(call, context)));
+  }
+}

package/test/agent-parser.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { parseAgentMarkdown, renderAgentPrompt } from "../src/agent-parser.js";
+
+describe("agent parser", () => {
+  it("parses frontmatter and body", () => {
+    const parsed = parseAgentMarkdown(`---
+name: test-agent
+description: test description
+model:
+  provider: anthropic
+  name: claude-opus-4-5
+---
+
+# Hello
+Working dir: {{runtime.workingDir}}
+`);
+
+    expect(parsed.frontmatter.name).toBe("test-agent");
+    expect(parsed.frontmatter.description).toBe("test description");
+    expect(parsed.body).toContain("# Hello");
+  });
+
+  it("renders mustache runtime and parameter context", () => {
+    const parsed = parseAgentMarkdown(`---
+name: test-agent
+---
+
+Project: {{parameters.project}}
+Env: {{runtime.environment}}
+`);
+    const prompt = renderAgentPrompt(parsed, {
+      parameters: { project: "poncho" },
+      runtime: { environment: "development", workingDir: "/tmp/work" },
+    });
+
+    expect(prompt).toContain("Project: poncho");
+    expect(prompt).toContain("Env: development");
+  });
+});