@axiastudio/aioc 0.1.0-alpha.0

package/dist/tests/regression/handoff-policy-trace.regression.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHandoffPolicyTraceRegressionTests = runHandoffPolicyTraceRegressionTests;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const index_1 = require("../../index");
+const handoff_name_1 = require("../support/handoff-name");
+const scripted_provider_1 = require("../support/scripted-provider");
+async function runHandoffPolicyTraceRegressionTests() {
+    const target = new index_1.Agent({
+        name: "TargetAgent",
+        model: "fake-model",
+    });
+    const source = new index_1.Agent({
+        name: "SourceAgent",
+        model: "fake-model",
+        handoffs: [target],
+    });
+    const handoffName = (0, handoff_name_1.toHandoffToolName)(target.name);
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            {
+                type: "tool_call",
+                callId: "handoff-call-1",
+                name: handoffName,
+                arguments: "{}",
+            },
+        ],
+    ]));
+    const denyEvents = [];
+    const denyLogger = {
+        log(event) {
+            denyEvents.push(event);
+        },
+    };
+    await strict_1.default.rejects(() => (0, index_1.run)(source, "hello", {
+        logger: denyLogger,
+    }), (error) => {
+        strict_1.default.ok(error instanceof index_1.HandoffPolicyDeniedError);
+        strict_1.default.equal(error.result.policyResult.reason, "policy_not_configured");
+        return true;
+    });
+    const denyPolicyEvent = denyEvents.find((event) => event.type === "handoff_policy_evaluated");
+    strict_1.default.ok(denyPolicyEvent);
+    strict_1.default.equal(denyPolicyEvent.handoffName, handoffName);
+    strict_1.default.equal(denyPolicyEvent.callId, "handoff-call-1");
+    strict_1.default.equal(denyPolicyEvent.toAgent, "TargetAgent");
+    strict_1.default.equal(denyPolicyEvent.decision, "deny");
+    strict_1.default.equal(denyPolicyEvent.reason, "policy_not_configured");
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            {
+                type: "tool_call",
+                callId: "handoff-call-2",
+                name: handoffName,
+                arguments: "{}",
+            },
+        ],
+        [{ type: "completed", message: "handled by target" }],
+    ]));
+    const allowEvents = [];
+    const allowLogger = {
+        log(event) {
+            allowEvents.push(event);
+        },
+    };
+    const handoffPolicy = () => ({
+        decision: "allow",
+        reason: "allow_transition",
+        policyVersion: "v2",
+        metadata: {
+            gate: "strict",
+        },
+    });
+    const result = await (0, index_1.run)(source, "hello", {
+        logger: allowLogger,
+        policies: {
+            handoffPolicy,
+        },
+    });
+    strict_1.default.equal(result.finalOutput, "handled by target");
+    strict_1.default.equal(result.lastAgent.name, "TargetAgent");
+    const allowPolicyEvent = allowEvents.find((event) => event.type === "handoff_policy_evaluated");
+    strict_1.default.ok(allowPolicyEvent);
+    strict_1.default.equal(allowPolicyEvent.callId, "handoff-call-2");
+    strict_1.default.equal(allowPolicyEvent.decision, "allow");
+    strict_1.default.equal(allowPolicyEvent.reason, "allow_transition");
+    strict_1.default.equal(allowPolicyEvent.policyVersion, "v2");
+    strict_1.default.equal(allowPolicyEvent.metadata?.gate, "strict");
+}

package/dist/tests/regression/handoff-transition.regression.d.ts

@@ -0,0 +1,2 @@
+export declare function runHandoffTransitionRegressionTests(): Promise<void>;
+//# sourceMappingURL=handoff-transition.regression.d.ts.map

package/dist/tests/regression/handoff-transition.regression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-transition.regression.d.ts","sourceRoot":"","sources":["../../../src/tests/regression/handoff-transition.regression.ts"],"names":[],"mappings":"AAWA,wBAAsB,mCAAmC,IAAI,OAAO,CAAC,IAAI,CAAC,CAmEzE"}

package/dist/tests/regression/handoff-transition.regression.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHandoffTransitionRegressionTests = runHandoffTransitionRegressionTests;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const index_1 = require("../../index");
+const handoff_name_1 = require("../support/handoff-name");
+const scripted_provider_1 = require("../support/scripted-provider");
+async function runHandoffTransitionRegressionTests() {
+    const targetAgent = new index_1.Agent({
+        name: "Target Agent",
+        model: "fake-model",
+    });
+    const sourceAgent = new index_1.Agent({
+        name: "Source Agent",
+        model: "fake-model",
+        handoffs: [targetAgent],
+    });
+    const handoffToolName = (0, handoff_name_1.toHandoffToolName)(targetAgent.name);
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            {
+                type: "tool_call",
+                callId: "handoff-call-1",
+                name: handoffToolName,
+                arguments: "{}",
+            },
+        ],
+        [{ type: "completed", message: "Done from target." }],
+    ]));
+    const events = [];
+    const logger = {
+        log(event) {
+            events.push(event);
+        },
+    };
+    const result = await (0, index_1.run)(sourceAgent, "hello", {
+        logger,
+        policies: {
+            handoffPolicy: () => ({
+                decision: "allow",
+                reason: "allow_transition",
+                policyVersion: "v1",
+            }),
+        },
+    });
+    strict_1.default.equal(result.finalOutput, "Done from target.");
+    strict_1.default.equal(result.lastAgent.name, "Target Agent");
+    const activatedAgents = events
+        .filter((event) => event.type === "agent_activated")
+        .map((event) => event.agent);
+    strict_1.default.deepEqual(activatedAgents, ["Source Agent", "Target Agent"]);
+    const handoffPolicyEvent = events.find((event) => event.type === "handoff_policy_evaluated");
+    strict_1.default.ok(handoffPolicyEvent);
+    strict_1.default.equal(handoffPolicyEvent.handoffName, handoffToolName);
+    strict_1.default.equal(handoffPolicyEvent.callId, "handoff-call-1");
+    strict_1.default.equal(handoffPolicyEvent.decision, "allow");
+    strict_1.default.equal(handoffPolicyEvent.reason, "allow_transition");
+    strict_1.default.equal(handoffPolicyEvent.policyVersion, "v1");
+}

package/dist/tests/regression/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tests/regression/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tests/regression/index.ts"],"names":[],"mappings":""}

package/dist/tests/regression/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const handoff_transition_regression_1 = require("./handoff-transition.regression");
+const policy_default_deny_regression_1 = require("./policy-default-deny.regression");
+async function main() {
+    await (0, policy_default_deny_regression_1.runPolicyDefaultDenyRegressionTests)();
+    await (0, handoff_transition_regression_1.runHandoffTransitionRegressionTests)();
+    process.stdout.write("Regression tests passed.\n");
+}
+main().catch((error) => {
+    const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/dist/tests/regression/policy-default-deny.regression.d.ts

@@ -0,0 +1,2 @@
+export declare function runPolicyDefaultDenyRegressionTests(): Promise<void>;
+//# sourceMappingURL=policy-default-deny.regression.d.ts.map

package/dist/tests/regression/policy-default-deny.regression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy-default-deny.regression.d.ts","sourceRoot":"","sources":["../../../src/tests/regression/policy-default-deny.regression.ts"],"names":[],"mappings":"AAaA,wBAAsB,mCAAmC,IAAI,OAAO,CAAC,IAAI,CAAC,CAwHzE"}

package/dist/tests/regression/policy-default-deny.regression.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPolicyDefaultDenyRegressionTests = runPolicyDefaultDenyRegressionTests;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const zod_1 = require("zod");
+const index_1 = require("../../index");
+const scripted_provider_1 = require("../support/scripted-provider");
+async function runPolicyDefaultDenyRegressionTests() {
+    let executions = 0;
+    const ping = (0, index_1.tool)({
+        name: "ping",
+        description: "Ping tool",
+        parameters: zod_1.z.object({}),
+        execute: () => {
+            executions += 1;
+            return { ok: true };
+        },
+    });
+    const agent = new index_1.Agent({
+        name: "Policy regression agent",
+        model: "fake-model",
+        tools: [ping],
+    });
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            {
+                type: "tool_call",
+                callId: "call-1",
+                name: "ping",
+                arguments: "{}",
+            },
+        ],
+    ]));
+    const events = [];
+    const logger = {
+        log(event) {
+            events.push(event);
+        },
+    };
+    await strict_1.default.rejects(() => (0, index_1.run)(agent, "hello", {
+        logger,
+    }), (error) => {
+        strict_1.default.ok(error instanceof index_1.ToolCallPolicyDeniedError);
+        strict_1.default.equal(error.result.policyResult.reason, "policy_not_configured");
+        return true;
+    });
+    strict_1.default.equal(executions, 0);
+    const eventTypes = events.map((event) => event.type);
+    strict_1.default.deepEqual(eventTypes, [
+        "run_started",
+        "agent_activated",
+        "turn_started",
+        "tool_call_started",
+        "tool_policy_evaluated",
+        "tool_call_failed",
+        "run_failed",
+    ]);
+    const policyEvent = events.find((event) => event.type === "tool_policy_evaluated");
+    strict_1.default.ok(policyEvent);
+    strict_1.default.equal(policyEvent.toolName, "ping");
+    strict_1.default.equal(policyEvent.callId, "call-1");
+    strict_1.default.equal(policyEvent.decision, "deny");
+    strict_1.default.equal(policyEvent.reason, "policy_not_configured");
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            {
+                type: "tool_call",
+                callId: "call-2",
+                name: "ping",
+                arguments: "{}",
+            },
+        ],
+        [{ type: "completed", message: "done" }],
+    ]));
+    const allowEvents = [];
+    const allowLogger = {
+        log(event) {
+            allowEvents.push(event);
+        },
+    };
+    const allowResult = await (0, index_1.run)(agent, "hello", {
+        logger: allowLogger,
+        policies: {
+            toolPolicy: () => ({
+                decision: "allow",
+                reason: "allow_ping",
+                policyVersion: "v1",
+                metadata: {
+                    gate: "strict",
+                },
+            }),
+        },
+    });
+    strict_1.default.equal(allowResult.finalOutput, "done");
+    strict_1.default.equal(executions, 1);
+    const allowPolicyEvent = allowEvents.find((event) => event.type === "tool_policy_evaluated");
+    strict_1.default.ok(allowPolicyEvent);
+    strict_1.default.equal(allowPolicyEvent.callId, "call-2");
+    strict_1.default.equal(allowPolicyEvent.decision, "allow");
+    strict_1.default.equal(allowPolicyEvent.reason, "allow_ping");
+    strict_1.default.equal(allowPolicyEvent.policyVersion, "v1");
+    strict_1.default.equal(allowPolicyEvent.metadata?.gate, "strict");
+}

package/dist/tests/support/handoff-name.d.ts

@@ -0,0 +1,2 @@
+export declare function toHandoffToolName(agentName: string): string;
+//# sourceMappingURL=handoff-name.d.ts.map

package/dist/tests/support/handoff-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-name.d.ts","sourceRoot":"","sources":["../../../src/tests/support/handoff-name.ts"],"names":[],"mappings":"AASA,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3D"}

package/dist/tests/support/handoff-name.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHandoffToolName = toHandoffToolName;
+function sanitizeToolSegment(input) {
+    const sanitized = input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return sanitized || "agent";
+}
+function toHandoffToolName(agentName) {
+    return `handoff_to_${sanitizeToolSegment(agentName)}`;
+}

package/dist/tests/support/scripted-provider.d.ts

@@ -0,0 +1,8 @@
+import type { ModelProvider, ProviderEvent, ProviderRequest } from "../../providers/base";
+export declare class ScriptedProvider implements ModelProvider {
+    private readonly turns;
+    private index;
+    constructor(turns: ProviderEvent[][]);
+    stream<TContext = unknown>(_request: ProviderRequest<TContext>): AsyncIterable<ProviderEvent>;
+}
+//# sourceMappingURL=scripted-provider.d.ts.map

package/dist/tests/support/scripted-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripted-provider.d.ts","sourceRoot":"","sources":["../../../src/tests/support/scripted-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAE9B,qBAAa,gBAAiB,YAAW,aAAa;IACpD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,KAAK,CAAK;gBAEN,KAAK,EAAE,aAAa,EAAE,EAAE;IAI7B,MAAM,CAAC,QAAQ,GAAG,OAAO,EAC9B,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC,GAClC,aAAa,CAAC,aAAa,CAAC;CAShC"}

package/dist/tests/support/scripted-provider.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScriptedProvider = void 0;
+class ScriptedProvider {
+    turns;
+    index = 0;
+    constructor(turns) {
+        this.turns = turns;
+    }
+    async *stream(_request) {
+        void _request;
+        const events = this.turns[this.index] ?? [];
+        this.index += 1;
+        for (const event of events) {
+            yield event;
+        }
+    }
+}
+exports.ScriptedProvider = ScriptedProvider;

package/dist/tests/unit/guardrail.unit.d.ts

@@ -0,0 +1,2 @@
+export declare function runGuardrailUnitTests(): Promise<void>;
+//# sourceMappingURL=guardrail.unit.d.ts.map

package/dist/tests/unit/guardrail.unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guardrail.unit.d.ts","sourceRoot":"","sources":["../../../src/tests/unit/guardrail.unit.ts"],"names":[],"mappings":"AAkBA,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CA2C3D"}

package/dist/tests/unit/guardrail.unit.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGuardrailUnitTests = runGuardrailUnitTests;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const index_1 = require("../../index");
+const scripted_provider_1 = require("../support/scripted-provider");
+const outputGuardrail = (0, index_1.defineOutputGuardrail)({
+    name: "block_unsafe_output",
+    execute: ({ outputText }) => ({
+        tripwireTriggered: outputText.toLowerCase().includes("unsafe"),
+        reason: "Output contains forbidden token 'unsafe'.",
+    }),
+});
+async function runGuardrailUnitTests() {
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            { type: "delta", delta: "Safe " },
+            { type: "delta", delta: "output." },
+            { type: "completed", message: "Safe output." },
+        ],
+    ]));
+    const passAgent = new index_1.Agent({
+        name: "Guardrail pass agent",
+        model: "fake-model",
+        outputGuardrails: [outputGuardrail],
+    });
+    const passResult = await (0, index_1.run)(passAgent, "hello");
+    strict_1.default.equal(passResult.finalOutput, "Safe output.");
+    (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+        [
+            { type: "delta", delta: "unsafe output" },
+            { type: "completed", message: "unsafe output" },
+        ],
+    ]));
+    const failAgent = new index_1.Agent({
+        name: "Guardrail fail agent",
+        model: "fake-model",
+        outputGuardrails: [outputGuardrail],
+    });
+    await strict_1.default.rejects(() => (0, index_1.run)(failAgent, "hello"), (error) => {
+        strict_1.default.ok(error instanceof index_1.OutputGuardrailTripwireTriggered);
+        strict_1.default.equal(error.result.guardrail, "block_unsafe_output");
+        return true;
+    });
+}

package/dist/tests/unit/handoff.unit.d.ts

@@ -0,0 +1,2 @@
+export declare function runHandoffUnitTests(): Promise<void>;
+//# sourceMappingURL=handoff.unit.d.ts.map

package/dist/tests/unit/handoff.unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff.unit.d.ts","sourceRoot":"","sources":["../../../src/tests/unit/handoff.unit.ts"],"names":[],"mappings":"AAmDA,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAmMzD"}

package/dist/tests/unit/handoff.unit.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runHandoffUnitTests = runHandoffUnitTests;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const zod_1 = require("zod");
+const index_1 = require("../../index");
+const handoff_name_1 = require("../support/handoff-name");
+const scripted_provider_1 = require("../support/scripted-provider");
+function createAgents() {
+    const targetAgent = new index_1.Agent({
+        name: "Target Agent",
+        model: "fake-model",
+    });
+    const sourceAgent = new index_1.Agent({
+        name: "Source Agent",
+        model: "fake-model",
+        handoffs: [targetAgent],
+    });
+    return {
+        sourceAgent,
+        targetAgent,
+        handoffToolName: (0, handoff_name_1.toHandoffToolName)(targetAgent.name),
+    };
+}
+function createHandoffTurns(handoffToolName) {
+    return [
+        [
+            {
+                type: "tool_call",
+                callId: "handoff-call-1",
+                name: handoffToolName,
+                arguments: JSON.stringify({ reason: "route" }),
+            },
+        ],
+        [{ type: "completed", message: "Handled by target." }],
+    ];
+}
+async function runHandoffUnitTests() {
+    {
+        const { sourceAgent, handoffToolName } = createAgents();
+        const allowHandoffPolicy = () => ({
+            decision: "allow",
+            reason: "allow_transition",
+        });
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider(createHandoffTurns(handoffToolName)));
+        const result = await (0, index_1.run)(sourceAgent, "hello", {
+            policies: {
+                handoffPolicy: allowHandoffPolicy,
+            },
+        });
+        strict_1.default.equal(result.finalOutput, "Handled by target.");
+        strict_1.default.equal(result.lastAgent.name, "Target Agent");
+    }
+    {
+        const { sourceAgent, handoffToolName } = createAgents();
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider(createHandoffTurns(handoffToolName)));
+        await strict_1.default.rejects(() => (0, index_1.run)(sourceAgent, "hello"), (error) => {
+            strict_1.default.ok(error instanceof index_1.HandoffPolicyDeniedError);
+            strict_1.default.equal(error.result.policyResult.reason, "policy_not_configured");
+            return true;
+        });
+    }
+    {
+        const { sourceAgent, handoffToolName } = createAgents();
+        const denyHandoffPolicy = () => ({
+            decision: "deny",
+            reason: "target_not_allowlisted",
+        });
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider(createHandoffTurns(handoffToolName)));
+        await strict_1.default.rejects(() => (0, index_1.run)(sourceAgent, "hello", {
+            policies: {
+                handoffPolicy: denyHandoffPolicy,
+            },
+        }), (error) => {
+            strict_1.default.ok(error instanceof index_1.HandoffPolicyDeniedError);
+            strict_1.default.equal(error.result.policyResult.reason, "target_not_allowlisted");
+            return true;
+        });
+    }
+    {
+        const { sourceAgent, handoffToolName } = createAgents();
+        const softDenyHandoffPolicy = () => (0, index_1.deny)("target_not_allowlisted", {
+            publicReason: "Escalation not permitted for this request.",
+            denyMode: "tool_result",
+        });
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider(createHandoffTurns(handoffToolName)));
+        const result = await (0, index_1.run)(sourceAgent, "hello", {
+            policies: {
+                handoffPolicy: softDenyHandoffPolicy,
+            },
+        });
+        strict_1.default.equal(result.finalOutput, "Handled by target.");
+        strict_1.default.equal(result.lastAgent.name, "Source Agent");
+        const toolOutputItem = result.history.find((item) => item.type === "tool_call_output_item");
+        strict_1.default.deepEqual(toolOutputItem?.output, {
+            status: "denied",
+            code: "target_not_allowlisted",
+            publicReason: "Escalation not permitted for this request.",
+            data: null,
+        });
+    }
+    {
+        const { sourceAgent, handoffToolName } = createAgents();
+        const failingHandoffPolicy = () => {
+            throw new Error("policy failed");
+        };
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider(createHandoffTurns(handoffToolName)));
+        await strict_1.default.rejects(() => (0, index_1.run)(sourceAgent, "hello", {
+            policies: {
+                handoffPolicy: failingHandoffPolicy,
+            },
+        }), (error) => {
+            strict_1.default.ok(error instanceof index_1.HandoffPolicyDeniedError);
+            strict_1.default.equal(error.result.policyResult.reason, "policy_error");
+            return true;
+        });
+    }
+    {
+        const { sourceAgent, handoffToolName } = createAgents();
+        const invalidHandoffPolicy = (() => ({
+            decision: "allow",
+        }));
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider(createHandoffTurns(handoffToolName)));
+        await strict_1.default.rejects(() => (0, index_1.run)(sourceAgent, "hello", {
+            policies: {
+                handoffPolicy: invalidHandoffPolicy,
+            },
+        }), (error) => {
+            strict_1.default.ok(error instanceof index_1.HandoffPolicyDeniedError);
+            strict_1.default.equal(error.result.policyResult.reason, "invalid_policy_result");
+            return true;
+        });
+    }
+    {
+        const targetAgent = new index_1.Agent({
+            name: "Target Agent",
+            model: "fake-model",
+        });
+        const collidingTool = (0, index_1.tool)({
+            name: (0, handoff_name_1.toHandoffToolName)(targetAgent.name),
+            description: "Colliding tool name",
+            parameters: zod_1.z.object({}),
+            execute: () => ({ ok: true }),
+        });
+        const sourceAgent = new index_1.Agent({
+            name: "Source Agent",
+            model: "fake-model",
+            tools: [collidingTool],
+            handoffs: [targetAgent],
+        });
+        const reservedHandoffName = (0, handoff_name_1.toHandoffToolName)(targetAgent.name);
+        const suffixedHandoffName = `${reservedHandoffName}_2`;
+        (0, index_1.setDefaultProvider)(new scripted_provider_1.ScriptedProvider([
+            [
+                {
+                    type: "tool_call",
+                    callId: "handoff-call-2",
+                    name: suffixedHandoffName,
+                    arguments: "{}",
+                },
+            ],
+            [{ type: "completed", message: "Handled by target with suffix." }],
+        ]));
+        const result = await (0, index_1.run)(sourceAgent, "hello", {
+            policies: {
+                handoffPolicy: () => ({
+                    decision: "allow",
+                    reason: "allow_transition",
+                }),
+            },
+        });
+        strict_1.default.equal(result.finalOutput, "Handled by target with suffix.");
+        strict_1.default.equal(result.lastAgent.name, "Target Agent");
+    }
+}

package/dist/tests/unit/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/tests/unit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tests/unit/index.ts"],"names":[],"mappings":""}

package/dist/tests/unit/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const handoff_unit_1 = require("./handoff.unit");
+const guardrail_unit_1 = require("./guardrail.unit");
+const logger_unit_1 = require("./logger.unit");
+const policy_unit_1 = require("./policy.unit");
+const provider_setup_unit_1 = require("./provider-setup.unit");
+const run_record_unit_1 = require("./run-record.unit");
+const run_unit_1 = require("./run.unit");
+async function main() {
+    await (0, run_unit_1.runRunUnitTests)();
+    await (0, run_record_unit_1.runRunRecordUnitTests)();
+    await (0, logger_unit_1.runLoggerUnitTests)();
+    await (0, provider_setup_unit_1.runProviderSetupUnitTests)();
+    await (0, policy_unit_1.runPolicyUnitTests)();
+    await (0, handoff_unit_1.runHandoffUnitTests)();
+    await (0, guardrail_unit_1.runGuardrailUnitTests)();
+    process.stdout.write("Unit tests passed.\n");
+}
+main().catch((error) => {
+    const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+});

package/dist/tests/unit/logger.unit.d.ts

@@ -0,0 +1,2 @@
+export declare function runLoggerUnitTests(): Promise<void>;
+//# sourceMappingURL=logger.unit.d.ts.map

package/dist/tests/unit/logger.unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.unit.d.ts","sourceRoot":"","sources":["../../../src/tests/unit/logger.unit.ts"],"names":[],"mappings":"AAeA,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CA0DxD"}