applyEmbeddedAttemptToolsAllow,

mergeForcedEmbeddedAttemptToolsAllow,

resolveEmbeddedAttemptToolConstructionPlan,

shouldBuildCoreCodingToolsForAllowlist,

shouldCreateBundleLspRuntimeForAttempt,

shouldCreateBundleMcpRuntimeForAttempt,

} from "./attempt-tool-construction-plan.js";

it("keeps plugin-only allowlists on the shared tool policy path", () => {

const tools = [{ name: "memory_search" }, { name: "plugin_extra" }];

expect(shouldBuildCoreCodingToolsForAllowlist(["memory_search"])).toBe(false);

expect(resolveEmbeddedAttemptToolConstructionPlan({ toolsAllow: ["memory_search"] }))

.toHaveProperty("includeCoreTools", false);

expect(

applyEmbeddedAttemptToolsAllow(tools, ["memory_search"]).map((tool) => tool.name),

).toEqual(["memory_search"]);

const tools = [{ name: "exec" }, { name: "read" }, { name: "message" }];

expect(applyEmbeddedAttemptToolsAllow(tools, []).map((tool) => tool.name)).toStrictEqual([]);

expect(shouldBuildCoreCodingToolsForAllowlist([])).toBe(false);

expect(resolveEmbeddedAttemptToolConstructionPlan({ toolsAllow: [] })).toHaveProperty(

"includeCoreTools",

false,

);

});

});

};

}

/** Returns whether the allowlist requires any built-in coding/OpenClaw tools. */

export function shouldBuildCoreCodingToolsForAllowlist(toolsAllow?: string[]): boolean {

return resolveEmbeddedAttemptToolConstructionPlan({ toolsAllow }).includeCoreTools;

}

/**

* Decides whether the bundled MCP runtime is needed for this attempt. Bundle

* runtime creation follows explicit bundle/plugin allowlist names rather than

import {

createUsageAccumulator,

mergeUsageIntoAccumulator,

resolveLastCallUsage,

toLastCallUsage,

toNormalizedUsage,

} from "./usage-accumulator.js";

});

});

describe("resolveLastCallUsage", () => {

it("prefers raw assistant usage when present", () => {

// Raw assistant usage is the provider's final-call truth; the accumulator

// is only a fallback when that snapshot is absent or unusable.

const acc = createUsageAccumulator();

mergeUsageIntoAccumulator(acc, {

input: 150,

output: 40,

cacheRead: 84_000,

cacheWrite: 0,

total: 84_190,

});

expect(

resolveLastCallUsage(

{

inputTokens: 99,

outputTokens: 12,

completion_tokens_details: { reasoning_tokens: 8 },

cache_read_input_tokens: 456,

cache_creation_input_tokens: 3,

totalTokens: 570,

},

acc,

),

).toEqual({

input: 99,

output: 12,

reasoningTokens: 8,

cacheRead: 456,

cacheWrite: 3,

total: 570,

});

});

it("falls back to the accumulator when assistant usage is missing", () => {

const acc = createAccumulatorWithUsage(FINAL_USAGE);

expect(resolveLastCallUsage(undefined, acc)).toEqual({

input: 150,

output: 40,

reasoningTokens: 7,

cacheRead: 84_000,

cacheWrite: undefined,

total: 84_190,

});

});

it("falls back when assistant usage exists but is unusable", () => {

const acc = createAccumulatorWithUsage(FINAL_USAGE);

expect(resolveLastCallUsage({ responseId: "abc" } as never, acc)).toEqual({

input: 150,

output: 40,

reasoningTokens: 7,

cacheRead: 84_000,

cacheWrite: undefined,

total: 84_190,

});

});

it("keeps an explicit zero-usage raw snapshot instead of falling back", () => {

const acc = createAccumulatorWithUsage(FINAL_USAGE);

expect(

resolveLastCallUsage(

{

input: 0,

output: 0,

cacheRead: 0,

cacheWrite: 0,

total: 0,

},

acc,

),

).toEqual({

input: 0,

output: 0,

cacheRead: 0,

cacheWrite: 0,

total: 0,

});

});

});

});

/**

* Accumulates and normalizes per-call token usage across embedded runs.

*/

import { normalizeUsage, type NormalizedUsage, type UsageLike } from "../usage.js";

import type { NormalizedUsage } from "../usage.js";

export type UsageAccumulator = {

input: number;

total: usage.lastTotal || undefined,

};

};

export const resolveLastCallUsage = (

rawUsage: UsageLike | null | undefined,

usageAccumulator: UsageAccumulator,

): NormalizedUsage | undefined => normalizeUsage(rawUsage) ?? toLastCallUsage(usageAccumulator);