describeLoad,

  isRefusal,

  loadPluginFromManifest,

  pluginIdentity,

  pluginTool,

  type LoadedPlugin,

} from "./coder-plugins.js";

      declareTools();

      const loadPlugin = (manifestPath: string): string => {

        const outcome = loadPluginFromManifest(resolvePath(process.cwd(), manifestPath));

        if (!isRefusal(outcome)) {

          // Reloading a name replaces it: a demo iterates on one plugin, and

          // two tools with one name would be a declaration the model cannot

          // tell apart.

          const at = plugins.findIndex((held) => held.manifest.name === outcome.manifest.name);

          if (at >= 0) plugins.splice(at, 1);

          plugins.push(outcome);

          declareTools();

        const manifestFile = resolvePath(process.cwd(), manifestPath);

        const outcome = loadPluginFromManifest(manifestFile);

        const described = describeLoad(outcome);

        // The load is recorded both ways on purpose: the notice the interface

        // shows stays interface chatter, and the typed occurrence on the

        // session is what `/export` writes as a `source: "system"` step — a

        // capability-surface change with the full digest, ordered among the

        // turns. Refusals are recorded too; a trajectory that omits the load

        // that failed cannot explain the session that follows it.

        if (isRefusal(outcome)) {

          session.recordPluginEvent({

            message: described,

            event: "plugin_load_refused",

            code: outcome.code,

            plugin: { manifestPath: manifestFile },

          });

          return described;

        }

        return describeLoad(outcome);

        // Reloading a name replaces it: a demo iterates on one plugin, and

        // two tools with one name would be a declaration the model cannot

        // tell apart.

        const at = plugins.findIndex((held) => held.manifest.name === outcome.manifest.name);

        if (at >= 0) plugins.splice(at, 1);

        plugins.push(outcome);

        declareTools();

        const identity = pluginIdentity(outcome);

        session.recordPluginEvent({

          message: described,

          event: "plugin_loaded",

          plugin: {

            name: identity.name,

            version: identity.version,

            artifactDigest: identity.artifactDigest,

            bytes: identity.bytes,

            abi: identity.abi,

            timeoutMs: identity.timeoutMs,

            capabilities: identity.capabilities,

            manifestPath: manifestFile,

            toolName: identity.toolName,

          },

        });

        return described;

      };

      // Delegation is off rather than quietly running children on the

 * Notices are the interface talking to the reader, not the model, so they are

 * not steps -- they are recorded under `extra` where a reader can still see

 * them without a consumer mistaking them for turns.

 *

 * Plugin loads are the exception that proves the rule: the notice stays a

 * notice, but the act itself changed what the agent could do, so it also

 * exports as a `source: "system"` step carrying the typed record -- which

 * plugin, which exact artifact, what bounds -- in its observation's `extra`.

 */

import { spawnSync } from "node:child_process";

import { homedir } from "node:os";

import { join } from "node:path";

import type { CoderEntry, CoderSnapshot } from "./coder-session.js";

import type { CoderEntry, CoderPluginEvent, CoderSnapshot } from "./coder-session.js";

const SCHEMA_VERSION = "ATIF-v1.7";

    tool_call_id: string;

    function_name: string;

    arguments: Record<string, unknown>;

    /** Per-call metadata the format leaves open. Plugin provenance goes here. */

    extra?: Record<string, unknown>;

  }>;

  observation?: { results: ReadonlyArray<{ source_call_id: string; content: string }> };

  observation?: {

    results: ReadonlyArray<{

      /** Null for a system-initiated operation, which no tool call sourced. */

      source_call_id: string | null;

      content: string;

      /** Result-level metadata the format leaves open. */

      extra?: Record<string, unknown>;

    }>;

  };

}

/**

  };

};

/**

 * The typed half of a plugin lifecycle step, in the shape ATIF's `extra`

 * fields carry it.

 *

 * The digest is written whole. The notices truncate it for a human eye;

 * anything a machine reads gets the full `sha256:<hex>`, because a truncated

 * digest identifies nothing.

 */

const pluginEventExtra = (event: CoderPluginEvent): Record<string, unknown> => {

  const plugin = event.plugin;

  return {

    event: event.event,

    ...(event.code === undefined ? {} : { code: event.code }),

    plugin: {

      ...(plugin.name === undefined ? {} : { name: plugin.name }),

      ...(plugin.version === undefined ? {} : { version: plugin.version }),

      ...(plugin.artifactDigest === undefined ? {} : { artifact_digest: plugin.artifactDigest }),

      ...(plugin.bytes === undefined ? {} : { bytes: plugin.bytes }),

      ...(plugin.abi === undefined ? {} : { abi: plugin.abi }),

      ...(plugin.timeoutMs === undefined ? {} : { timeout_ms: plugin.timeoutMs }),

      ...(plugin.capabilities === undefined ? {} : { capabilities: plugin.capabilities }),

      manifest_path: plugin.manifestPath,

      ...(plugin.toolName === undefined ? {} : { tool_name: plugin.toolName }),

    },

  };

};

/** Fold the transcript into ATIF steps. */

const stepsOf = (entries: ReadonlyArray<CoderEntry>, model: string): ReadonlyArray<AtifStep> => {

const stepsOf = (

  entries: ReadonlyArray<CoderEntry>,

  pluginEvents: ReadonlyArray<CoderPluginEvent>,

  model: string,

): ReadonlyArray<AtifStep> => {

  const steps: AtifStep[] = [];

  /** Reasoning arrives before the turn it belongs to and attaches to it. */

  let pendingReasoning: string | undefined;

  /** The next plugin event still waiting for its place among the turns. */

  let nextEvent = 0;

  // A plugin load is a system-initiated capability change, and ATIF v1.5+

  // gives it a home: a `source: "system"` step whose observation carries the

  // typed record. It lands where it happened — between the turns on either

  // side of it — so a consumer replaying the steps sees the capability appear

  // before the call that used it.

  const emitEventsThrough = (at: number) => {

    while (nextEvent < pluginEvents.length) {

      const event = pluginEvents[nextEvent];

      if (event === undefined || event.at > at) break;

      steps.push({

        step_id: steps.length + 1,

        timestamp: new Date(event.at).toISOString(),

        source: "system",

        message: event.message,

        observation: {

          results: [

            { source_call_id: null, content: event.message, extra: pluginEventExtra(event) },

          ],

        },

      });

      nextEvent += 1;

    }

  };

  for (const entry of entries) {

    emitEventsThrough(entry.at);

    const timestamp = new Date(entry.at).toISOString();

    if (entry.role === "notice") continue;

    }

    if (entry.role === "tool" && entry.tool !== undefined) {

      const { callId, name, arguments: args, output, error } = entry.tool;

      const { callId, name, arguments: args, output, error, plugin } = entry.tool;

      steps.push({

        step_id: steps.length + 1,

        timestamp,

        model_name: model,

        ...(pendingReasoning === undefined ? {} : { reasoning_content: pendingReasoning }),

        tool_calls: [

          { tool_call_id: callId, function_name: name, arguments: argumentsOf(args) },

          {

            tool_call_id: callId,

            function_name: name,

            arguments: argumentsOf(args),

            // A plugin-backed call names the exact artifact that answered it,

            // digest whole, so a trace feeds usage attribution the same way a

            // thread's `tool.ran` event does.

            ...(plugin === undefined

              ? {}

              : {

                  extra: {

                    plugin: {

                      name: plugin.name,

                      version: plugin.version,

                      artifact_digest: plugin.artifactDigest,

                    },

                  },

                }),

          },

        ],

        observation: {

          results: [{ source_call_id: callId, content: error ?? output ?? "" }],

    }

  }

  // A load after the last turn still happened in this session.

  emitEventsThrough(Number.POSITIVE_INFINITY);

  return steps;

};

): ExportedTrajectory {

  const at = options.now ?? new Date();

  const directory = options.directory ?? join(homedir(), ".openagents", "exports");

  const steps = stepsOf(snapshot.entries, options.model);

  const steps = stepsOf(snapshot.entries, snapshot.pluginEvents ?? [], options.model);

  const document = {

    schema_version: SCHEMA_VERSION,

  };

}

/**

 * The loaded plugin's identity, for provenance records.

 *

 * Everything a receipt or a trajectory needs to say which exact artifact ran:

 * the digest here is the full `sha256:<hex>` the host verified, never the

 * truncated form the prose notices show.

 */

export interface PluginIdentity {

  readonly name: string;

  readonly version: string;

  /** The verified digest, full `sha256:<hex>`. */

  readonly artifactDigest: string;

  /** The artifact's size in bytes. */

  readonly bytes: number;

  readonly abi: { readonly entry: string; readonly alloc: string };

  readonly timeoutMs: number;

  readonly capabilities: {

    readonly mounts: ReadonlyArray<unknown>;

    readonly hosts: ReadonlyArray<unknown>;

  };

  /** The tool the plugin materializes, which is the manifest's name. */

  readonly toolName: string;

}

/** Read a loaded plugin's identity, as a provenance record understands it. */

export function pluginIdentity(plugin: LoadedPlugin): PluginIdentity {

  const { manifest } = plugin;

  return {

    name: manifest.name,

    version: manifest.version,

    artifactDigest: plugin.digest,

    bytes: plugin.wasm.length,

    abi: { entry: manifest.abi.entry, alloc: manifest.abi.alloc },

    timeoutMs: manifest.capabilities.timeout_ms,

    capabilities: {

      mounts: manifest.capabilities.mounts,

      hosts: manifest.capabilities.hosts,

    },

    toolName: manifest.name,

  };

}

/** What `/plugin load` reports, for a notice or a plain line. */

export function describeLoad(outcome: LoadedPlugin | PluginRefusal): string {

  if (isRefusal(outcome)) {

  output: string | undefined;

  error: string | undefined;

  status: "running" | "succeeded" | "failed";

  /**

   * Which plugin backed this call, when one did.

   *

   * Stamped when the call entry is opened, not looked up at export: a plugin

   * reloaded mid-session changes what later calls ran, and a call must carry

   * the identity of the artifact that actually answered it.

   */

  readonly plugin?: CoderPluginProvenance;

}

/**

 * The identity a plugin-backed tool call carries.

 *

 * The digest is the full `sha256:<hex>` the host verified. Prose may truncate

 * it; anything machine-read carries the whole thing.

 */

export interface CoderPluginProvenance {

  readonly name: string;

  readonly version: string;

  readonly artifactDigest: string;

}

/**

 * A plugin lifecycle occurrence: a `/plugin load` that succeeded or refused.

 *

 * Not a transcript entry. The notice a load produces is the interface talking

 * to the reader and stays a notice; this is the typed record of the same act,

 * kept on the side so `/export` can write it as a `source: "system"` step — a

 * capability-surface change a trajectory consumer can machine-read — without

 * any renderer having to learn a new entry kind.

 */

export interface CoderPluginEvent {

  /** When it happened, in epoch milliseconds, for ordering among the turns. */

  readonly at: number;

  /** The human notice, exactly as the interface showed it. */

  readonly message: string;

  readonly event: "plugin_loaded" | "plugin_load_refused";

  /** The refusal code, on refusals. */

  readonly code?: string | undefined;

  readonly plugin: {

    readonly name?: string | undefined;

    readonly version?: string | undefined;

    /** Full `sha256:<hex>`, never truncated. */

    readonly artifactDigest?: string | undefined;

    readonly bytes?: number | undefined;

    readonly abi?: { readonly entry: string; readonly alloc: string } | undefined;

    readonly timeoutMs?: number | undefined;

    readonly capabilities?:

      | { readonly mounts: ReadonlyArray<unknown>; readonly hosts: ReadonlyArray<unknown> }

      | undefined;

    /** Always known: the path the load was asked for, even when it refused. */

    readonly manifestPath: string;

    readonly toolName?: string | undefined;

  };

}

/**

   * then no renderer draws a fleet at all.

   */

  readonly tasks: ReadonlyArray<CoderTask>;

  /**

   * Plugin loads and refusals, oldest first.

   *

   * A side-channel rather than transcript entries: renderers ignore it, and

   * `/export` merges it into the steps by timestamp. Optional so a snapshot

   * built by hand — a test fixture above all — does not have to say "no

   * plugins" to be a snapshot.

   */

  readonly pluginEvents?: ReadonlyArray<CoderPluginEvent>;

}

/** What the session needs in order to delegate. Absent means it cannot. */

   * replayed history, so the first new turn must not pay for it again.

   */

  private restored = false;

  /** Plugin loads and refusals, in the order they happened. */

  private readonly pluginEvents: CoderPluginEvent[] = [];

  /**

   * Which plugin currently backs each tool name, so a tool entry can be

   * stamped with its provenance the moment the call arrives.

   */

  private readonly pluginTools = new Map<string, CoderPluginProvenance>();

  constructor(

    private readonly source: ReplySource,

      turns: this.turnCount,

      budget: this.source.budget,

      tasks: this.delegation?.registry.list() ?? [],

      pluginEvents: this.pluginEvents.map((event) => ({

        ...event,

        plugin: { ...event.plugin },

      })),

    };

  }

  /**

   * Record a plugin load or refusal as a typed occurrence.

   *

   * The caller keeps showing its notice however it does — this is the record,

   * not the display. A successful load also registers the tool it declared,

   * so every later call of that tool carries the plugin's identity; loading a

   * name again re-registers it, because the calls after a reload ran the new

   * artifact.

   */

  recordPluginEvent(event: Omit<CoderPluginEvent, "at">): void {

    this.pluginEvents.push({ at: Date.now(), ...event });

    const { toolName, name, version, artifactDigest } = event.plugin;

    if (

      event.event === "plugin_loaded" &&

      toolName !== undefined &&

      name !== undefined &&

      version !== undefined &&

      artifactDigest !== undefined

    ) {

      this.pluginTools.set(toolName, { name, version, artifactDigest });

    }

    this.emit();

  }

  /** Whether `/delegate` does anything, which is what the interface reads. */

  get canDelegate(): boolean {

    return this.delegation !== undefined;

          settle(reasoning);

          text = undefined;

          reasoning = undefined;

          // A call to a plugin-backed tool carries the plugin's identity from

          // the moment it opens, so the record says which artifact answered

          // even if the plugin is reloaded before the export.

          const provenance = this.pluginTools.get(chunk.name);

          this.entries.push({

            role: "tool",

            text: chunk.name,

              output: undefined,

              error: undefined,

              status: "running",

              ...(provenance === undefined ? {} : { plugin: provenance }),

            },

          });

        } else if (chunk.type === "usage") {

import { describe, expect, it } from "vitest";

import { exportTrajectory } from "../src/coder-export.js";

import type { CoderEntry, CoderSnapshot } from "../src/coder-session.js";

import type { CoderEntry, CoderPluginEvent, CoderSnapshot } from "../src/coder-session.js";

const AT = Date.parse("2026-08-24T14:00:00.000Z");

  ...partial,

});

const snapshot = (entries: ReadonlyArray<CoderEntry>): CoderSnapshot =>

const snapshot = (

  entries: ReadonlyArray<CoderEntry>,

  pluginEvents?: ReadonlyArray<CoderPluginEvent>,

): CoderSnapshot =>

  ({

    entries,

    repository: "openagents.com",

    turns: 1,

    running: false,

    tasks: [],

    ...(pluginEvents === undefined ? {} : { pluginEvents }),

  }) as unknown as CoderSnapshot;

const write = (entries: ReadonlyArray<CoderEntry>) => {

const write = (

  entries: ReadonlyArray<CoderEntry>,

  pluginEvents?: ReadonlyArray<CoderPluginEvent>,

) => {

  const directory = mkdtempSync(join(tmpdir(), "coder-export-"));

  const result = exportTrajectory(snapshot(entries), {

  const result = exportTrajectory(snapshot(entries, pluginEvents), {

    model: "Ollama qwen",

    version: "0.3.5",

    now: new Date(AT),

  };

};

/** A full digest, as the host verifies it: `sha256:` and 64 hex characters. */

const FULL_DIGEST = `sha256:${"7c724f993da2".padEnd(64, "0")}`;

describe("exporting a conversation as ATIF", () => {

  it("writes the envelope the rest of the system reads", () => {

    const { document, result } = write([entry({ role: "you", text: "hello" })]);

    expect(name).toMatch(/^2026-08-24T14-00-00-000Z-openagents\.com-atif\.json$/);

  });

});

describe("plugin provenance in the export", () => {

  const refusedLoad: CoderPluginEvent = {

    at: AT + 1_000,

    message: "Plugin not loaded (digest_mismatch): the artifact is not the one described",

    event: "plugin_load_refused",

    code: "digest_mismatch",

    plugin: { manifestPath: "/work/demo/plugin.json" },

  };

  const successfulLoad: CoderPluginEvent = {

    at: AT + 2_000,

    message: "Loaded plugin `word_stats` v0.1.0 — digest verified (sha256:7c724f993da2…).",

    event: "plugin_loaded",

    plugin: {

      name: "word_stats",

      version: "0.1.0",

      artifactDigest: FULL_DIGEST,

      bytes: 18_432,

      abi: { entry: "handle_packet", alloc: "packet_alloc" },

      timeoutMs: 2_000,

      capabilities: { mounts: [], hosts: [] },

      manifestPath: "/work/demo/plugin.json",

      toolName: "word_stats",

    },

  };

  const pluginCall = entry({

    role: "tool",

    text: "word_stats",

    at: AT + 4_000,

    tool: {

      callId: "call-p1",

      name: "word_stats",

      arguments: '{"text":"one two"}',

      output: '{"ok":{"words":2}}',

      error: undefined,

      status: "succeeded",

      plugin: { name: "word_stats", version: "0.1.0", artifactDigest: FULL_DIGEST },

    },

  });

  const plainCall = entry({

    role: "tool",

    text: "shell",

    at: AT + 5_000,

    tool: {

      callId: "call-s1",

      name: "shell",

      arguments: '{"command":"ls"}',

      output: "README.md",

      error: undefined,

      status: "succeeded",

    },

  });

  const fixture = () =>

    write(

      [

        entry({ role: "you", text: "load it", at: AT }),

        entry({ role: "notice", text: "Loaded plugin `word_stats` v0.1.0.", at: AT + 2_500 }),

        entry({ role: "you", text: "count the words", at: AT + 3_000 }),

        pluginCall,

        plainCall,

      ],

      [refusedLoad, successfulLoad],

    );

  it("writes loads and refusals as system steps, in order among the turns", () => {

    const { document } = fixture();

    const steps = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    expect(steps.map((step) => step["source"])).toEqual([

      "user",

      "system",

      "system",

      "user",

      "agent",

      "agent",

    ]);

    expect(steps.map((step) => step["step_id"])).toEqual([1, 2, 3, 4, 5, 6]);

    expect(steps[1]).toMatchObject({ message: refusedLoad.message });

    expect(steps[2]).toMatchObject({ message: successfulLoad.message });

  });

  it("types the refusal on the system step's observation", () => {

    const { document } = fixture();

    const steps = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    expect(steps[1]).toMatchObject({

      observation: {

        results: [

          {

            source_call_id: null,

            content: refusedLoad.message,

            extra: {

              event: "plugin_load_refused",

              code: "digest_mismatch",

              plugin: { manifest_path: "/work/demo/plugin.json" },

            },

          },

        ],

      },

    });

  });

  it("types the load, with the full digest, on the system step's observation", () => {

    const { document } = fixture();

    const steps = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    const loadStep = steps[2] as Record<string, unknown>;

    const observation = loadStep["observation"] as Record<string, unknown>;

    const [result] = observation["results"] as ReadonlyArray<Record<string, unknown>>;

    expect(result).toMatchObject({

      source_call_id: null,

      extra: {

        event: "plugin_loaded",

        plugin: {

          name: "word_stats",

          version: "0.1.0",

          artifact_digest: FULL_DIGEST,

          bytes: 18_432,

          abi: { entry: "handle_packet", alloc: "packet_alloc" },

          timeout_ms: 2_000,

          capabilities: { mounts: [], hosts: [] },

          manifest_path: "/work/demo/plugin.json",

          tool_name: "word_stats",

        },

      },

    });

    // The prose may truncate the digest; the machine-read record never does.

    const extra = result?.["extra"] as { plugin: { artifact_digest: string } };

    expect(extra.plugin.artifact_digest).toMatch(/^sha256:[0-9a-f]{64}$/);

  });

  it("stamps a plugin-backed call with its provenance, and no other call", () => {

    const { document } = fixture();

    const steps = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    const [pluginStep, plainStep] = steps.slice(4);

    expect(pluginStep).toMatchObject({

      tool_calls: [

        {

          tool_call_id: "call-p1",

          function_name: "word_stats",

          extra: {

            plugin: { name: "word_stats", version: "0.1.0", artifact_digest: FULL_DIGEST },

          },

        },

      ],

    });

    const [plainToolCall] = (plainStep as Record<string, unknown>)["tool_calls"] as ReadonlyArray<

      Record<string, unknown>

    >;

    expect(plainToolCall?.["extra"]).toBeUndefined();

  });

  it("keeps interface chatter in extra.notices, unchanged", () => {

    const { document } = fixture();

    expect((document["extra"] as Record<string, unknown>)["notices"]).toEqual([

      expect.objectContaining({ text: "Loaded plugin `word_stats` v0.1.0." }),

    ]);

  });

  it("counts system steps in the totals", () => {

    const { document } = fixture();

    expect(document["final_metrics"]).toMatchObject({ total_steps: 6 });

  });

  it("writes a load after the last turn, rather than dropping it", () => {

    const { document } = write([entry({ role: "you", text: "ask", at: AT })], [successfulLoad]);

    const steps = document["steps"] as ReadonlyArray<Record<string, unknown>>;

    expect(steps.map((step) => step["source"])).toEqual(["user", "system"]);

  });

});

    expect(session.snapshot().entries).toHaveLength(2);

  });

});

describe("plugin occurrences", () => {

  const digest = `sha256:${"ab".repeat(32)}`;

  const loaded = {

    message: "Loaded plugin `word_stats` v0.1.0.",

    event: "plugin_loaded" as const,

    plugin: {

      name: "word_stats",

      version: "0.1.0",

      artifactDigest: digest,

      bytes: 1024,

      abi: { entry: "handle_packet", alloc: "packet_alloc" },

      timeoutMs: 2000,

      capabilities: { mounts: [], hosts: [] },

      manifestPath: "/work/demo/plugin.json",

      toolName: "word_stats",

    },

  };

  it("records loads and refusals on the snapshot, not the transcript", () => {

    const session = new CoderSession(scripted(["a"]), "repo", "main");

    session.recordPluginEvent({

      message: "Plugin not loaded (digest_mismatch): wrong artifact.",

      event: "plugin_load_refused",

      code: "digest_mismatch",

      plugin: { manifestPath: "/work/demo/plugin.json" },

    });

    session.recordPluginEvent(loaded);

    const { entries, pluginEvents } = session.snapshot();

    // A renderer draws entries; the occurrences are the export's to read.

    expect(entries).toHaveLength(0);

    expect(pluginEvents?.map((event) => event.event)).toEqual([

      "plugin_load_refused",

      "plugin_loaded",

    ]);

    expect(pluginEvents?.[1]?.plugin.artifactDigest).toBe(digest);

    expect(pluginEvents?.[0]?.at).toBeGreaterThan(0);

  });

  it("stamps a call of the loaded tool with the plugin's identity", async () => {

    const session = new CoderSession(

      source([

        { type: "tool_call", callId: "c1", name: "word_stats", arguments: "{}" },

        { type: "tool_result", callId: "c1", output: "{}", error: undefined },

        { type: "tool_call", callId: "c2", name: "shell", arguments: "{}" },

        { type: "tool_result", callId: "c2", output: "", error: undefined },

      ]),

      "repo",

      "main",

    );

    session.recordPluginEvent(loaded);

    await session.submit("count");

    const tools = session.snapshot().entries.filter((entry) => entry.role === "tool");

    expect(tools[0]?.tool?.plugin).toEqual({

      name: "word_stats",

      version: "0.1.0",

      artifactDigest: digest,

    });

    // A tool no plugin backs carries no provenance to mistake for some.

    expect(tools[1]?.tool?.plugin).toBeUndefined();

  });

  it("does not register a tool from a refused load", async () => {

    const session = new CoderSession(

      source([

        { type: "tool_call", callId: "c1", name: "word_stats", arguments: "{}" },

        { type: "tool_result", callId: "c1", output: "{}", error: undefined },

      ]),

      "repo",

      "main",

    );

    session.recordPluginEvent({

      message: "Plugin not loaded (manifest_unreadable): no such file.",

      event: "plugin_load_refused",

      code: "manifest_unreadable",

      plugin: { manifestPath: "/work/demo/plugin.json" },

    });

    await session.submit("count");

    const tool = session.snapshot().entries.find((entry) => entry.role === "tool");

    expect(tool?.tool?.plugin).toBeUndefined();

  });

});