import { Ollama } from "ollama";

import type { Message as OllamaMessage, Tool as OllamaTool, ToolCall as OllamaToolCall } from "ollama";

import { declaredDescription } from "./coder-tool-families.js";

import { merge } from "./coder-merge.js";

import type { ReplyChunk, ReplySource } from "./coder-session.js";

import { LOCAL_LANE, systemPrompt } from "./coder-system.js";

  toolDefinitions(): ReadonlyArray<Record<string, unknown>> {

    return this.tools.map((tool) => ({

      type: "function",

      function: { name: tool.name, description: tool.description, parameters: tool.parameters },

      function: {

        name: tool.name,

        // The local family's emphasis is the lane's economics — free tokens,

        // slow generation — so it applies whatever weights answer.

        description: declaredDescription(tool, "local"),

        parameters: tool.parameters,

      },

    }));

  }

                type: "function",

                function: {

                  name: tool.name,

                  description: tool.description,

                  description: declaredDescription(tool, "local"),

                  // The client's type for a schema is narrower than JSON

                  // Schema. The server takes the schema as written.

                  parameters: tool.parameters as NonNullable<OllamaTool["function"]["parameters"]>,

/** The lane sentence for a session answering from a model on this machine. */

export const LOCAL_LANE =

  "You answer from a model running locally on this machine through Ollama.";

  "You answer from a model running locally on this machine through Ollama. Tokens here cost " +

  "nothing, but generation is slow: prefer a few composite tool calls over many small ones, " +

  "keep narration brief, and verify in one final pass rather than several.";

/** The lane sentence for a session answering through the account's thread. */

export const THREAD_LANE =

  "You answer through the OpenAgents inference proxy, on a thread opened for this session.";

  "You answer through the OpenAgents inference proxy, on a thread opened for this session. " +

  "Every round of tool calls re-sends the whole conversation to a metered model, so batch " +

  "independent commands into one call and keep large dumps out of the transcript.";

import { Redacted } from "effect";

import type { ChildGrant } from "./coder-child-gateway.js";

import { declaredDescription, toolFamilyOf } from "./coder-tool-families.js";

import { merge } from "./coder-merge.js";

import type { ReplyChunk, ReplySource } from "./coder-session.js";

import type { CoderTool } from "./coder-tools.js";

   */

  /** The tools as declared, in the shape ATIF records them. */

  toolDefinitions(): ReadonlyArray<Record<string, unknown>> {

    const family = toolFamilyOf(this.model);

    return this.tools.map((tool) => ({

      type: "function",

      function: { name: tool.name, description: tool.description, parameters: tool.parameters },

      function: {

        name: tool.name,

        description: declaredDescription(tool, family),

        parameters: tool.parameters,

      },

    }));

  }

          ...(this.tools.length === 0 || this.mustAnswer

            ? {}

            : {

                // Declarations resolve per model family: the base says what

                // a tool is, and a family override adds the emphasis that

                // family has measurably needed (coder-tool-families.ts).

                tools: this.tools.map((tool) => ({

                  type: "function",

                  function: {

                    name: tool.name,

                    description: tool.description,

                    description: declaredDescription(tool, toolFamilyOf(this.model)),

                    parameters: tool.parameters,

                  },

                })),

/**

 * Per-model-family tool declaration overrides.

 *

 * The first graded Gym runs measured a model-family habit, not a capability

 * gap: on the same task, gemini-3.7-flash issued fifteen single-command tool

 * rounds where gpt-5.6-luna issued six composite ones, and spent three times

 * the input tokens replaying the growing transcript

 * (`openagents.com` docs/terminalbench/2026-08-24-fix-git-run-analysis.md).

 * Saying "batch" once in the system prompt was not enough for every family.

 *

 * Gemini CLI's own harness answers the same problem inside the declarations:

 * a base declaration per tool plus per-model-family description overrides,

 * resolved at request time (`gemini-cli`

 * packages/core/src/tools/definitions/resolver.ts). This is that pattern,

 * kept as data: a family is a name derived from the model or lane, and an

 * override is an extra sentence appended to a tool's base description. The

 * base descriptions stay the single source of what a tool is; a family

 * override only adds the emphasis that family has measurably needed.

 */

import type { CoderTool } from "./coder-tools.js";

/** The families with distinct declared emphasis. `default` adds nothing. */

export type ToolFamily = "default" | "gemini" | "local";

/**

 * The family for a model name, by prefix.

 *

 * The local lane passes `"local"` explicitly rather than relying on model

 * names, because what distinguishes it is the lane's economics — free

 * tokens, slow generation — not which weights answer.

 */

export const toolFamilyOf = (model: string | undefined): ToolFamily => {

  if (model === undefined) return "default";

  const normalized = model.toLowerCase();

  if (normalized.startsWith("gemini")) return "gemini";

  if (normalized.startsWith("ollama:")) return "local";

  return "default";

};

/**

 * Extra emphasis per family and tool, appended to the base description.

 *

 * Measured, not speculative: an override earns its place with a Gym delta on

 * the same suite, and the analysis document above records why each exists.

 */

const emphasis: Partial<Record<ToolFamily, Partial<Record<string, string>>>> = {

  gemini: {

    shell:

      " IMPORTANT: batch independent commands into ONE call joined with && — " +

      "each separate call replays the whole conversation to the model, so ten " +

      "one-line calls cost several times what one composite call costs. Never " +

      "run one small inspection per call.",

  },

  local: {

    shell:

      " This session's model generates slowly on this machine: prefer a few " +

      "composite calls over many small ones, and keep verification to one " +

      "final pass.",

  },

};

/** A tool's description as declared to this family's model. */

export const declaredDescription = (tool: CoderTool, family: ToolFamily): string => {

  const extra = emphasis[family]?.[tool.name];

  return extra === undefined ? tool.description : tool.description + extra;

};

      "output. Both output streams come back together with the exit code. There is no terminal, " +

      "so a command that would prompt gets end-of-file instead of waiting; pass a flag that " +

      "answers the prompt. A few commands that cannot be undone are refused, such as erasing a " +

      "root or a home directory, reformatting a disk, or halting the machine.",

      "root or a home directory, reformatting a disk, or halting the machine. Work economically: " +

      "batch independent commands into one call with && instead of one call each — every call " +

      "replays the conversation so far. Use quiet flags and `git --no-pager`; prefer `--stat` " +

      "before `-p`, and dump a full patch only for the file you are actually deciding about.",

    parameters: {

      type: "object",

      properties: {

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

import {

  CHILD_LANE_ALIASES,

  CHILD_MODELS,

  childLaneName,

  resolveChildLane,

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

import { declaredDescription, toolFamilyOf } from "../src/coder-tool-families.js";

import type { CoderTool } from "../src/coder-tools.js";

const tool = (name: string): CoderTool => ({

  name,

  description: "Base description.",

  parameters: { type: "object", properties: {} },

  run: async () => "",

});

describe("toolFamilyOf", () => {

  it("names the gemini family by model prefix", () => {

    expect(toolFamilyOf("gemini-3.7-flash")).toBe("gemini");

    expect(toolFamilyOf("gemini-3.5-flash")).toBe("gemini");

  });

  it("names the local family by the ollama model shape", () => {

    expect(toolFamilyOf("ollama:qwen3.8:27b-mtp-q8_0")).toBe("local");

  });

  it("defaults everything else, including absence", () => {

    expect(toolFamilyOf("gpt-5.6-luna")).toBe("default");

    expect(toolFamilyOf("ox-alpha")).toBe("default");

    expect(toolFamilyOf(undefined)).toBe("default");

  });

});

describe("declaredDescription", () => {

  it("adds batching emphasis to shell for the gemini family", () => {

    const declared = declaredDescription(tool("shell"), "gemini");

    expect(declared.startsWith("Base description.")).toBe(true);

    expect(declared).toContain("batch independent commands into ONE call");

  });

  it("adds the latency emphasis to shell for the local family", () => {

    expect(declaredDescription(tool("shell"), "local")).toContain("generates slowly");

  });

  it("leaves the default family and unlisted tools at the base", () => {

    expect(declaredDescription(tool("shell"), "default")).toBe("Base description.");

    expect(declaredDescription(tool("skill"), "gemini")).toBe("Base description.");

  });

});