message: string;

  model_name?: string;

  reasoning_content?: string;

  metrics?: { prompt_tokens?: number; completion_tokens?: number };

  llm_call_count?: number;

  tool_calls?: ReadonlyArray<{

    tool_call_id: string;

    function_name: string;

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

}

/**

 * The trajectory's totals.

 *

 * Summed from what the sources reported and omitted when nothing did: a

 * `total_prompt_tokens` of 0 on a session that never measured any would be a

 * measurement, and this has none to give.

 */

const sumMetrics = (

  entries: ReadonlyArray<CoderEntry>,

): { total_prompt_tokens?: number; total_completion_tokens?: number } => {

  const measured = entries.filter((entry) => entry.metrics !== undefined);

  if (measured.length === 0) return {};

  return {

    total_prompt_tokens: measured.reduce((sum, entry) => sum + (entry.metrics?.promptTokens ?? 0), 0),

    total_completion_tokens: measured.reduce(

      (sum, entry) => sum + (entry.metrics?.completionTokens ?? 0),

      0,

    ),

  };

};

export interface ExportedTrajectory {

  /** Where the file was written. */

  readonly path: string;

  }

};

/** A step's metrics, present only when the source reported any. */

const metricsOf = (entry: CoderEntry): Partial<AtifStep> => {

  const metrics = entry.metrics;

  if (metrics === undefined) return {};

  const figures = {

    ...(metrics.promptTokens === undefined ? {} : { prompt_tokens: metrics.promptTokens }),

    ...(metrics.completionTokens === undefined

      ? {}

      : { completion_tokens: metrics.completionTokens }),

  };

  return {

    ...(Object.keys(figures).length === 0 ? {} : { metrics: figures }),

    ...(metrics.calls === undefined ? {} : { llm_call_count: metrics.calls }),

  };

};

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

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

  const steps: AtifStep[] = [];

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

    if (entry.role === "reasoning") {

      pendingReasoning = pendingReasoning === undefined ? entry.text : `${pendingReasoning}\n${entry.text}`;

      pendingReasoning =

        pendingReasoning === undefined ? entry.text : `${pendingReasoning}\n${entry.text}`;

      continue;

    }

        observation: {

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

        },

        ...metricsOf(entry),

      });

      pendingReasoning = undefined;

      continue;

        message: entry.text,

        model_name: model,

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

        ...metricsOf(entry),

      });

      pendingReasoning = undefined;

    }

        : { tool_definitions: options.toolDefinitions }),

    },

    steps,

    final_metrics: { total_steps: steps.length },

    final_metrics: {

      ...sumMetrics(snapshot.entries),

      total_steps: steps.length,

    },

    extra: {

      exporter: "openagents.coder.atif_export.v1",

      exported_at: at.toISOString(),

    return `Ollama ${this.modelName}`;

  }

  /**

   * The identifier, as against `model`, which is the label a status line shows.

   *

   * A record has to name the model a reader could run again. "Ollama qwen3.8"

   * is for a narrow bar; `qwen3.8:27b-mtp-q8_0` is the thing itself.

   */

  get modelId(): string {

    return this.modelName;

  }

  constructor(options: OllamaOptions) {

    this.client = new Ollama({ host: options.host ?? DEFAULT_HOST });

    this.modelName = options.model;

    // A turn is a loop, not a single call: the model may answer, or it may ask

    // for tools and then answer once it has seen what they returned. The

    // ceiling is what stops a model that only ever delegates.

    let promptTokens = 0;

    let completionTokens = 0;

    let llmCalls = 0;

    for (let step = 0; step < MAX_TOOL_STEPS; step += 1) {

      if (signal.aborted) return;

          const toolCalls = chunk.message.tool_calls;

          if (Array.isArray(toolCalls)) calls.push(...toolCalls);

          if (chunk.done) break;

          if (chunk.done) {

            // The counts ride on the final chunk of each round, so they are

            // summed across the rounds a turn took rather than reported from

            // the last one.

            promptTokens += chunk.prompt_eval_count ?? 0;

            completionTokens += chunk.eval_count ?? 0;

            llmCalls += 1;

            break;

          }

        }

      } finally {

        signal.removeEventListener("abort", onAbort);

        ...(calls.length === 0 ? {} : { tool_calls: calls }),

      });

      if (calls.length === 0) return;

      if (calls.length === 0) {

        yield { type: "usage", promptTokens, completionTokens, calls: llmCalls };

        return;

      }

      for (const call of calls) {

        if (signal.aborted) return;

      type: "text",

      value: `\n\nStopped after ${String(MAX_TOOL_STEPS)} rounds of tool calls without an answer.`,

    };

    yield { type: "usage", promptTokens, completionTokens, calls: llmCalls };

  }

  /**

      /** Arguments as JSON source, pretty-printed when the server printed it. */

      readonly arguments: string;

    }

  | {

      /**

       * What the turn cost, reported once at the end of it.

       *

       * A turn may take several LLM calls -- a model that asks for tools and

       * then answers -- so this is their total, with the count, rather than the

       * last call's figures presented as the turn's.

       */

      readonly type: "usage";

      readonly promptTokens?: number | undefined;

      readonly completionTokens?: number | undefined;

      readonly calls?: number | undefined;

    }

  | {

      readonly type: "tool_result";

      readonly callId: string;

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

}

/** What a turn cost, on the entry that closed it. */

export interface CoderMetrics {

  readonly promptTokens?: number | undefined;

  readonly completionTokens?: number | undefined;

  /** How many LLM calls the figures aggregate. */

  readonly calls?: number | undefined;

}

/** One entry in the transcript. */

export interface CoderEntry {

  readonly role: "you" | "assistant" | "notice" | "tool" | "reasoning";

  settled: boolean;

  /** Present on a `tool` entry only. */

  readonly tool?: CoderToolCall;

  /** Set on the entry a turn ended on, when the source reported the cost. */

  metrics?: CoderMetrics;

}

/** Everything a renderer needs. No renderer reads anything else. */

export interface ReplySource {

  /** The label the status line shows for the reply source. */

  readonly model: string;

  /**

   * The model's identifier, when it differs from the label above.

   *

   * `model` is written for a narrow status bar. A record has to name something

   * a reader could run again, so an export prefers this and falls back to the

   * label when a source has only one name for itself.

   */

  readonly modelId?: string | undefined;

  /**

   * What this source may still spend, already formatted for the status line,

   * or undefined for a source that meters nothing. Read on every snapshot, so

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      try {

        const written = exportTrajectory(this.snapshot(), {

          model: this.source.model,

          model: this.source.modelId ?? this.source.model,

          toolDefinitions: this.source.toolDefinitions?.(),

          version: VERSION,

        });

              status: "running",

            },

          });

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

          // Onto the entry the turn ended on, which is the step a reader of the

          // trajectory would attribute the cost to. `calls` says how many LLM

          // calls it aggregates, so a turn that used tools is not read as one.

          const closing = text ?? reasoning ?? this.entries.at(-1);

          if (closing !== undefined) {

            closing.metrics = {

              promptTokens: chunk.promptTokens,

              completionTokens: chunk.completionTokens,

              calls: chunk.calls,

            };

          }

        } else {

          this.applyToolResult(chunk);

        }

    expect(document["steps"]).toHaveLength(1);

  });

  it("records what a turn cost, and how many calls that was", () => {

    const { document } = write([

      entry({ role: "you", text: "ask" }),

      entry({

        role: "assistant",

        text: "answer",

        metrics: { promptTokens: 2334, completionTokens: 114, calls: 2 },

      }),

    ]);

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

    expect(steps[1]).toMatchObject({

      metrics: { prompt_tokens: 2334, completion_tokens: 114 },

      // A turn that asked for a tool and then answered is two calls, not one.

      llm_call_count: 2,

    });

    expect(document["final_metrics"]).toMatchObject({

      total_prompt_tokens: 2334,

      total_completion_tokens: 114,

      total_steps: 2,

    });

  });

  it("reports no totals rather than zero when nothing measured any", () => {

    const { document } = write([entry({ role: "assistant", text: "answer" })]);

    // A total of 0 on a session that never measured would be a measurement.

    expect(document["final_metrics"]).toEqual({ total_steps: 1 });

  });

  it("writes one file per export, named so they sort by time", () => {

    const { directory } = write([entry({ role: "you", text: "one" })]);

    const chunks = await collect(source, "hi");

    expect(chunks).toEqual([

    // Every turn closes with what it cost, so the text chunks are read apart

    // from the usage chunk that trails them.

    expect(chunks.filter((piece) => piece.type !== "usage")).toEqual([

      { type: "reasoning", value: "weighing it" },

      { type: "text", value: "Hello" },

    ]);

    expect(chunks.at(-1)).toMatchObject({ type: "usage" });

    expect(stub.requests[0]).not.toHaveProperty("tools");

  });

});

    // The call and its result share an id, which is how a renderer pairs them.

    expect(result).toMatchObject({ callId: (call as { callId: string }).callId });

    // The turn continued rather than ending on the tool result.

    expect(chunks.at(-1)).toEqual({ type: "text", value: "They said PONG." });

    const spoken = chunks.filter((piece) => piece.type !== "usage");

    expect(spoken.at(-1)).toEqual({ type: "text", value: "They said PONG." });

    // The tool was declared, and the second round carried the exchange back.

    expect(stub.requests[0]).toHaveProperty("tools");

    expect(messages.at(-1)).toMatchObject({ content: "child 1 said PONG", tool_name: "delegate" });

  });

  it("reports the turn's cost, summed over the rounds it took", async () => {

    const calls: Record<string, unknown>[] = [];

    const { source } = sourceWith([

      [

        chunk({

          content: "",

          tool_calls: [{ function: { name: "delegate", arguments: { prompt: "go" } } }],

        }),

        { message: {}, done: true, prompt_eval_count: 100, eval_count: 10 },

      ],

      [{ message: { content: "done" }, done: true, prompt_eval_count: 200, eval_count: 20 }],

    ] as never);

    source.useTools([delegate(calls)]);

    const chunks = await collect(source, "delegate this");

    // Two LLM calls in one turn: the counts are their total, not the last

    // round's presented as the turn's.

    expect(chunks.at(-1)).toEqual({

      type: "usage",

      promptTokens: 300,

      completionTokens: 30,

      calls: 2,

    });

  });

  it("reports a tool that throws instead of ending the turn", async () => {

    const { source } = sourceWith([CALLING, [chunk({ content: "It failed." }, true)]]);

    source.useTools([

      error: "the fleet is full",

      output: "the fleet is full",

    });

    expect(chunks.at(-1)).toEqual({ type: "text", value: "It failed." });

    expect(chunks.filter((piece) => piece.type !== "usage").at(-1)).toEqual({

      type: "text",

      value: "It failed.",

    });

  });

  it("tells the model when it asks for a tool the session does not have", async () => {

    // Six rounds, then a sentence saying why it stopped.

    expect(stub.chat).toHaveBeenCalledTimes(6);

    expect(chunks.at(-1)).toMatchObject({ type: "text" });

    expect((chunks.at(-1) as { value: string }).value).toContain("Stopped after 6 rounds");

    const spoken = chunks.filter((piece) => piece.type !== "usage");

    expect(spoken.at(-1)).toMatchObject({ type: "text" });

    expect((spoken.at(-1) as { value: string }).value).toContain("Stopped after 6 rounds");

  });

});

    if (written !== undefined) rmSync(written, { force: true });

  });

});

describe("a turn's cost", () => {

  it("lands on the entry the turn ended on", async () => {

    const session = new CoderSession(

      source([

        { type: "text", value: "answer" },

        { type: "usage", promptTokens: 12, completionTokens: 34, calls: 2 },

      ]),

      "repo",

      "main",

    );

    await session.submit("go");

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

    expect(assistant?.metrics).toEqual({ promptTokens: 12, completionTokens: 34, calls: 2 });

  });

});