The Open Framework for Building Agents
import { describe, expect, it, vi } from "vitest";
import { createSpanWriter } from "./writer.js";
import type { AgentTelemetry, SpanWriter, PreparedSpan } from "./types.js";
describe("trace engine failure and capture boundary", () => {
it("runs application code exactly once when context fails and preserves application errors", () => {
const writer: SpanWriter = {
reference: { traceId: "1".repeat(32), spanId: "2".repeat(16), traceFlags: 1 },
setAttribute: vi.fn(),
addEvent: vi.fn(),
fail: vi.fn(),
setStatus: vi.fn(),
end: vi.fn(),
};
const telemetry: Pick<AgentTelemetry, "startSpan" | "run" | "suppressed"> = {
startSpan: () => writer,
run() {
throw new Error("context unavailable");
},
suppressed() {
throw new Error("suppression unavailable");
},
};
const engine = createSpanWriter({ telemetry });
const operation = engine.start(
{ type: "tool", operationId: "tool", name: "execute_tool lookup", attributes: {} },
{ emit: true, recordInputs: false, recordOutputs: false },
);
const execute = vi.fn(() => "result");
expect(operation.run(execute)).toBe("result");
expect(execute).toHaveBeenCalledTimes(1);
const error = new Error("application");
telemetry.run = (_operation, callback) => callback();
const fail = vi.fn(() => {
throw error;
});
expect(() => operation.run(fail)).toThrow(error);
expect(fail).toHaveBeenCalledTimes(1);
});
it("filters denied initial and late content and closes each operation once", () => {
const writer: SpanWriter = {
reference: { traceId: "1".repeat(32), spanId: "2".repeat(16), traceFlags: 1 },
setAttribute: vi.fn(),
addEvent: vi.fn(),
fail: vi.fn(),
setStatus: vi.fn(),
end: vi.fn(),
};
const start = vi.fn((_span: PreparedSpan) => writer);
const telemetry: Pick<AgentTelemetry, "startSpan" | "run"> = {
startSpan: start,
run: (_operation, callback) => callback(),
};
const operation = createSpanWriter({ telemetry }).start(
{
type: "tool",
operationId: "tool",
name: "execute_tool lookup",
attributes: { "gen_ai.tool.name": "lookup", "gen_ai.tool.call.arguments": "secret" },
},
{ emit: true, recordInputs: false, recordOutputs: false },
);
expect(start.mock.calls[0]![0].attributes).toEqual({ "gen_ai.tool.name": "lookup" });
operation.setAttribute("gen_ai.tool.call.result", "secret");
operation.addEvent("protocol", { "gen_ai.input.messages": "secret", "rpc.method": "call" });
operation.fail(new TypeError("secret"));
operation.end();
operation.end();
expect(writer.setAttribute).not.toHaveBeenCalled();
expect(writer.addEvent).toHaveBeenCalledWith("protocol", { "rpc.method": "call" }, undefined);
expect(writer.fail).toHaveBeenCalledWith(undefined, "TypeError");
expect(writer.end).toHaveBeenCalledTimes(1);
});
});