mirror of
https://github.com/agentclientprotocol/claude-agent-acp.git
synced 2026-11-12 20:31:15 +00:00
Compare commits
2 Commits
v0.82.0
...
v0.82.1-pr
| Author | SHA1 | Date | |
|---|---|---|---|
|
49858b5273 | ||
|
|
77ceab0339 |
722
package-lock.json
generated
722
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
14
package.json
14
package.json
@@ -65,16 +65,16 @@
|
||||
"node": ">=22"
|
||||
},
|
||||
"dependencies": {
|
||||
"@agentclientprotocol/sdk": "1.5.0",
|
||||
"@anthropic-ai/claude-agent-sdk": "0.3.280",
|
||||
"diff": "^8.0.3",
|
||||
"@agentclientprotocol/sdk": "1.5.1",
|
||||
"@anthropic-ai/claude-agent-sdk": "0.3.283",
|
||||
"diff": "9.0.0",
|
||||
"zod": "4.6.5"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@anthropic-ai/sdk": "0.127.0",
|
||||
"@anthropic-ai/sdk": "0.128.0",
|
||||
"@eslint/js": "10.0.1",
|
||||
"@tsconfig/node22": "22.0.6",
|
||||
"@types/node": "26.6.2",
|
||||
"@types/node": "26.6.3",
|
||||
"@typescript-eslint/eslint-plugin": "8.70.1",
|
||||
"@typescript-eslint/parser": "8.70.1",
|
||||
"ajv": "8.20.0",
|
||||
@@ -82,9 +82,9 @@
|
||||
"eslint": "10.11.0",
|
||||
"eslint-config-prettier": "10.1.8",
|
||||
"globals": "17.12.0",
|
||||
"prettier": "3.9.8",
|
||||
"prettier": "3.9.9",
|
||||
"ts-node": "10.9.2",
|
||||
"typescript": "6.0.3",
|
||||
"vitest": "5.0.1"
|
||||
"vitest": "5.0.2"
|
||||
}
|
||||
}
|
||||
|
||||
138
src/acp-agent.ts
138
src/acp-agent.ts
@@ -833,6 +833,9 @@ export type Session = {
|
||||
* terminal (e.g. /doctor, /color). ACP clients aren't that terminal, so
|
||||
* these are filtered out of `available_commands_update` payloads. */
|
||||
terminalSlashCommands?: string[];
|
||||
/** Serialized `system`/init `plugin_errors` last logged, so the per-turn
|
||||
* init re-emit logs a plugin load failure once, not every turn. */
|
||||
loggedPluginErrors?: string;
|
||||
/** The long-lived consumer task. Lazily started on the first `prompt()` and
|
||||
* kept alive for the session so between-turn/background messages are still
|
||||
* drained and forwarded. */
|
||||
@@ -928,16 +931,16 @@ export type Session = {
|
||||
* prompts so mid-stream usage_update notifications report a correct `size`
|
||||
* before the turn's first result message arrives. Seeded synchronously at
|
||||
* session creation and on model switches from the per-model cache or the
|
||||
* text heuristic (DEFAULT_CONTEXT_WINDOW when both miss), then confirmed —
|
||||
* and the cache populated — by each result's modelUsage. No extra
|
||||
* `getContextUsage` IPC is on these paths: before the first turn it can add
|
||||
* tens of seconds to both fresh and resumed sessions (see the seeding call
|
||||
* sites and `contextWindowCache`). */
|
||||
* text heuristic (DEFAULT_CONTEXT_WINDOW when both miss), refined by a
|
||||
* background `getContextUsage` when that seed was a guess (see
|
||||
* `refreshContextWindowInBackground`), then confirmed — and the cache
|
||||
* populated — by each result's modelUsage. No awaited IPC is on these
|
||||
* paths (see the seeding call sites and `contextWindowCache`). */
|
||||
contextWindowSize: number;
|
||||
contextUsedTokens?: number;
|
||||
/** Whether `contextWindowSize` came from an authoritative source (the
|
||||
* cross-session cache or a `result.modelUsage`) rather than the text
|
||||
* heuristic / default. Guards the
|
||||
* cross-session cache, a `result.modelUsage`, or the background
|
||||
* `getContextUsage`) rather than the text heuristic / default. Guards the
|
||||
* mid-stream `message_start` heuristic upgrade: an authoritative window that
|
||||
* happens to equal DEFAULT_CONTEXT_WINDOW must not be mistaken for "unseeded"
|
||||
* and clobbered by a "1m" text match. */
|
||||
@@ -4591,6 +4594,20 @@ export class ClaudeAcpAgent {
|
||||
this.logger.error(`Failed to re-advertise slash commands: ${error}`);
|
||||
}
|
||||
}
|
||||
// Plugin load failures (CLI 2.1.283+) have no ACP surface;
|
||||
// log them so a missing plugin isn't silent.
|
||||
if (message.plugin_errors?.length) {
|
||||
const pluginErrors = JSON.stringify(message.plugin_errors);
|
||||
if (pluginErrors !== session.loggedPluginErrors) {
|
||||
session.loggedPluginErrors = pluginErrors;
|
||||
for (const error of message.plugin_errors) {
|
||||
this.logger.error(
|
||||
`Plugin ${error.plugin} failed to load (${error.type})` +
|
||||
`${error.path ? ` from ${error.path}` : ""}: ${error.message}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case "status": {
|
||||
if (message.status === "compacting") {
|
||||
@@ -7983,6 +8000,41 @@ export class ClaudeAcpAgent {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Replace a heuristic context window with `getContextUsage().rawMaxTokens`
|
||||
* without blocking the caller. The text heuristic misses natively-1M models
|
||||
* whose picker rows carry no "1m" token (`sonnet`, and since CLI 2.1.283
|
||||
* `opus`/`default`), which would otherwise report 200k until the first
|
||||
* result's modelUsage. Never awaited: SDK control requests are serialized,
|
||||
* so an awaited call would delay session/new or a model switch (before the
|
||||
* first turn it took ~15s on older CLIs, issues #886/#880; ~0.5s on 2.1.283).
|
||||
* Not written to `contextWindowCache` — that stays keyed to the
|
||||
* `result.modelUsage` spellings — and a result still overwrites it.
|
||||
*/
|
||||
private refreshContextWindowInBackground(sessionId: string, session: Session): void {
|
||||
if (session.contextWindowAuthoritative) return;
|
||||
const { query } = session;
|
||||
const modelId = session.models.currentModelId;
|
||||
const stillCurrent = () =>
|
||||
this.sessions[sessionId] === session &&
|
||||
session.query === query &&
|
||||
session.models.currentModelId === modelId;
|
||||
// A synchronous throw must not fail the caller either.
|
||||
Promise.resolve()
|
||||
.then(() => query.getContextUsage())
|
||||
.then(
|
||||
(usage) => {
|
||||
if (!stillCurrent() || session.contextWindowAuthoritative) return;
|
||||
if (!(usage.rawMaxTokens > 0)) return;
|
||||
session.contextWindowSize = usage.rawMaxTokens;
|
||||
session.contextWindowAuthoritative = true;
|
||||
},
|
||||
(error) => {
|
||||
if (stillCurrent()) this.logger.error("Failed to read the context window:", error);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
private async applyConfigOptionValue(
|
||||
sessionId: string,
|
||||
session: Session,
|
||||
@@ -7997,19 +8049,16 @@ export class ClaudeAcpAgent {
|
||||
// context window for semantic aliases (e.g. `default`) whose ID alone
|
||||
// carries no "1m" token.
|
||||
const newModelInfo = session.modelInfos.find((m) => m.value === value);
|
||||
if (session.models.currentModelId !== value) {
|
||||
// Seed the new model's context window WITHOUT any IPC on the switch
|
||||
// path: cached authoritative value if we've already learned it (from a
|
||||
// prior turn's `result.modelUsage`), else the text heuristic, else the
|
||||
// default. We deliberately do NOT call `getContextUsage` here — before
|
||||
// a fresh session's first prompt turn that control request is not
|
||||
// serviced (~15s stall, issues #886/#880), and (because SDK control
|
||||
// requests are serialized over one channel) it would drag the awaited
|
||||
// `setModel` down with it. The authoritative window arrives on the
|
||||
// first `result.modelUsage` for the model and is cached from there;
|
||||
// until then a switched-to alias that has never run a turn shows the
|
||||
// heuristic/default window, which self-corrects on its first response
|
||||
// (matches pre-0.59.0 behavior).
|
||||
const modelChanged = session.models.currentModelId !== value;
|
||||
if (modelChanged) {
|
||||
// Seed the new model's context window WITHOUT awaited IPC on the
|
||||
// switch path: cached authoritative value if we've already learned it
|
||||
// (from a prior turn's `result.modelUsage`), else the text heuristic,
|
||||
// else the default. SDK control requests are serialized over one
|
||||
// channel, so an awaited `getContextUsage` here would delay the rest
|
||||
// of the switch (issues #886/#880); a guessed seed is instead refined
|
||||
// in the background once the switch is done
|
||||
// (`refreshContextWindowInBackground`).
|
||||
const seeded = immediateContextWindow(session.providerCacheKey, value, newModelInfo);
|
||||
session.contextWindowSize = seeded.size;
|
||||
session.contextWindowAuthoritative = seeded.authoritative;
|
||||
@@ -8151,6 +8200,8 @@ export class ClaudeAcpAgent {
|
||||
if (modeDowngraded) {
|
||||
await this.sessionModes.publishFallbackState(sessionId, session);
|
||||
}
|
||||
// Last, so the switch's own control requests don't queue behind it.
|
||||
if (modelChanged) this.refreshContextWindowInBackground(sessionId, session);
|
||||
} else if (configId === EFFORT_CONFIG_ID) {
|
||||
// Apply first so a rejected control request cannot leave the displayed
|
||||
// value ahead of the SDK flag layer.
|
||||
@@ -8873,10 +8924,12 @@ export class ClaudeAcpAgent {
|
||||
}
|
||||
|
||||
// Apply user's `availableModels` allowlist from settings.json before any
|
||||
// downstream model handling. The SDK only enforces this allowlist in its
|
||||
// own UI, not in `initializationResult.models`, so we filter here to keep
|
||||
// configOptions, the current-model resolver, and the stored modelInfos
|
||||
// consistent with what the user configured.
|
||||
// downstream model handling. `initializationResult.models` is already
|
||||
// policy-filtered by the CLI; we rebuild the picker from the allowlist
|
||||
// so the user's exact spellings (and `modelOverrides` targets) are the
|
||||
// values passed to `setModel`, keeping configOptions, the current-model
|
||||
// resolver, and the stored modelInfos consistent with what the user
|
||||
// configured. Managed `deniedModels` drops entries the CLI would refuse.
|
||||
const settingsAvailableModels = settingsManager.getSettings().availableModels;
|
||||
const settingsModelOverrides = settingsManager.getSettings().modelOverrides;
|
||||
const allowedModels = Array.isArray(settingsAvailableModels)
|
||||
@@ -8884,6 +8937,7 @@ export class ClaudeAcpAgent {
|
||||
initializationResult.models,
|
||||
settingsAvailableModels,
|
||||
settingsModelOverrides,
|
||||
settingsManager.getManagedDeniedModels(),
|
||||
)
|
||||
: initializationResult.models;
|
||||
|
||||
@@ -8987,21 +9041,17 @@ export class ClaudeAcpAgent {
|
||||
if (useRecommendedValue && typeof initialEffort?.currentValue === "string") {
|
||||
await q.applyFlagSettings({ effortLevel: toSdkEffortLevel(initialEffort.currentValue) });
|
||||
}
|
||||
// Seed the context window without extra IPC. The cached authoritative
|
||||
// Seed the context window without awaited IPC. The cached authoritative
|
||||
// window from a prior turn wins (`result.modelUsage`, cross-session),
|
||||
// then the text heuristic, then the default. We deliberately do NOT issue
|
||||
// a getContextUsage call here: before the first prompt turn that control
|
||||
// request can take tens of seconds, on resumed as well as fresh sessions.
|
||||
// The authoritative window arrives on the first `result.modelUsage` and
|
||||
// is cached from there.
|
||||
// then the text heuristic, then the default. A guessed seed is refined
|
||||
// by a background getContextUsage once the session is registered
|
||||
// (`refreshContextWindowInBackground`); the authoritative window then
|
||||
// arrives on the first `result.modelUsage` and is cached from there.
|
||||
//
|
||||
// Text inference alone misses aliases that resolve to extended-context
|
||||
// models with no "1m" token anywhere in their id or description (e.g.
|
||||
// `sonnet` → claude-sonnet-5, natively ~1M): those stream
|
||||
// `usage_update.size: 200000` until the first result's modelUsage corrects
|
||||
// it — but the cache means only the FIRST session to ever run a turn on such
|
||||
// a model eats that window, not every fresh session after a process
|
||||
// restart (issue #596).
|
||||
// `sonnet` → claude-sonnet-5, and `opus`/`default` since CLI 2.1.283,
|
||||
// all natively ~1M) — the background refresh covers those (issue #596).
|
||||
//
|
||||
// The inference fallback is deliberately keyed to the allowlisted entry: a
|
||||
// fallback-resolved sibling's resolvedModel/displayName/description can
|
||||
@@ -9077,6 +9127,7 @@ export class ClaudeAcpAgent {
|
||||
fileChangeReporter,
|
||||
};
|
||||
timing.phase("register");
|
||||
this.refreshContextWindowInBackground(sessionId, this.sessions[sessionId]);
|
||||
|
||||
return {
|
||||
sessionId,
|
||||
@@ -10310,6 +10361,7 @@ export function toAcpNotifications(
|
||||
case "compaction_delta":
|
||||
case "advisor_tool_result":
|
||||
case "fallback":
|
||||
case "mcp_tool_listing":
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -10582,10 +10634,9 @@ function commonPrefixLength(a: string, b: string) {
|
||||
* "claude-opus-4-8[1m]", "Opus 4.7 (1M context)"), so callers pass those too.
|
||||
* This text scan can't catch every model — some resolve to extended-context
|
||||
* models with no "1m" anywhere (e.g. `sonnet` → claude-sonnet-5, natively
|
||||
* ~1M). Such a miss falls back to the default window and is corrected by
|
||||
* `result.modelUsage` (and cached) within one turn. We do NOT consult the
|
||||
* SDK's `getContextUsage` to close that gap: before the first prompt turn it
|
||||
* can take tens of seconds (issues #886/#880, see `contextWindowCache`). */
|
||||
* ~1M). Such a miss falls back to the default window, is refined by the
|
||||
* background `getContextUsage` (`refreshContextWindowInBackground`), and is
|
||||
* corrected by `result.modelUsage` (and cached) within one turn. */
|
||||
function inferContextWindowFromModel(...texts: Array<string | undefined>): number | null {
|
||||
if (texts.some((text) => text != null && /\b1m\b/i.test(text))) return 1_000_000;
|
||||
return null;
|
||||
@@ -10606,11 +10657,10 @@ function inferContextWindowFromModel(...texts: Array<string | undefined>): numbe
|
||||
* verbatim live id (rows without `resolvedModel`) can hit too.
|
||||
*
|
||||
* Populated authoritatively by each `result.modelUsage` a turn confirms (see
|
||||
* the consumer's result handler). We deliberately never populate it from a
|
||||
* fresh session's `getContextUsage`: before that session's first prompt turn
|
||||
* has run the control request is not serviced (it stalls ~15s, and serializes
|
||||
* ahead of an awaited `setModel` — issues #886/#880, regressed in 0.59.0), so
|
||||
* it can neither beat the first `result` nor be issued cheaply before one.
|
||||
* the consumer's result handler). We deliberately never populate it from
|
||||
* `getContextUsage`: its `model` spelling and `rawMaxTokens` can differ from
|
||||
* the `result.modelUsage` key and window (e.g. 967000 vs 1000000 for sonnet),
|
||||
* so it only refines the live session (`refreshContextWindowInBackground`).
|
||||
* Cleared on `logout`: 1M-context entitlement can differ per account/tier, so
|
||||
* windows learned under one login must not seed sessions under the next. */
|
||||
const contextWindowCache = new Map<string, number>();
|
||||
|
||||
@@ -260,6 +260,39 @@ function resolveSettingsModel(
|
||||
return resolveModelPreference(models, settingsModel);
|
||||
}
|
||||
|
||||
const MODEL_FAMILY_ALIASES = new Set(["opus", "sonnet", "haiku", "fable"]);
|
||||
|
||||
/** A model id without the spellings `deniedModels` ignores: provider
|
||||
* prefixes, dates, version suffixes, `-fast` and context hints. */
|
||||
function normalizeDeniedModelId(value: string): string {
|
||||
let id = stripContextHints(value.trim().toLowerCase());
|
||||
const providerPrefix = id.lastIndexOf("anthropic.");
|
||||
if (providerPrefix !== -1) id = id.slice(providerPrefix + "anthropic.".length);
|
||||
return id
|
||||
.replace(/@.*$/, "")
|
||||
.replace(/-v\d+(?::\d+)?$/, "")
|
||||
.replace(/-fast$/, "")
|
||||
.replace(/-\d{8}$/, "");
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether managed `deniedModels` blocks a model id, following the CLI's rules
|
||||
* closely enough for the picker: a family alias blocks the whole family, and a
|
||||
* model id blocks that version in every spelling plus the later minor versions
|
||||
* it prefixes (`claude-opus-5` also blocks `claude-opus-5-5`). The CLI stays
|
||||
* the enforcer; this only keeps the picker from offering a refused row.
|
||||
*/
|
||||
export function isDeniedModel(modelId: string, deniedModels: readonly string[]): boolean {
|
||||
const id = normalizeDeniedModelId(modelId);
|
||||
if (!id) return false;
|
||||
return deniedModels.some((entry) => {
|
||||
const denied = normalizeDeniedModelId(entry);
|
||||
if (!denied) return false;
|
||||
if (MODEL_FAMILY_ALIASES.has(denied)) return id === denied || id.includes(`-${denied}`);
|
||||
return id === denied || id.startsWith(`${denied}-`);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Restrict the SDK's model list to the user's `availableModels` allowlist
|
||||
* (already merged-and-deduped across settings sources by `SettingsManager`).
|
||||
@@ -275,11 +308,14 @@ function resolveSettingsModel(
|
||||
* - `undefined` is handled by the caller (no allowlist applied).
|
||||
* - The Default option is unaffected by `availableModels` — it always remains
|
||||
* available, even when the allowlist is `[]`.
|
||||
* - Managed `deniedModels` wins over the allowlist, so a denied entry is
|
||||
* dropped even though the CLI would otherwise leave it unmatched.
|
||||
*/
|
||||
export function applyAvailableModelsAllowlist(
|
||||
sdkModels: ModelInfo[],
|
||||
allowlist: string[],
|
||||
settingsModelOverrides?: Record<string, string>,
|
||||
deniedModels: readonly string[] = [],
|
||||
): ModelInfo[] {
|
||||
// Default is always preserved per the docs. Synthesize one if the SDK
|
||||
// didn't surface it so downstream code (e.g. `getAvailableModels` picking
|
||||
@@ -310,6 +346,13 @@ export function applyAvailableModelsAllowlist(
|
||||
if (seen.has(effective)) continue;
|
||||
|
||||
const sdkMatch = resolveModelPreference(sdkModelsWithoutDefault, trimmed);
|
||||
if (
|
||||
[trimmed, effective, sdkMatch?.resolvedModel].some(
|
||||
(id) => id != null && isDeniedModel(id, deniedModels),
|
||||
)
|
||||
) {
|
||||
continue;
|
||||
}
|
||||
if (sdkMatch) {
|
||||
result.push({ ...sdkMatch, value: effective });
|
||||
} else {
|
||||
|
||||
@@ -49,6 +49,7 @@ export interface SettingsManagerOptions {
|
||||
export class SettingsManager {
|
||||
private cwd: string;
|
||||
private effective: Settings = {};
|
||||
private managedDeniedModels: string[] = [];
|
||||
private watchers: fs.FSWatcher[] = [];
|
||||
private onChange?: () => void;
|
||||
private logger: { log: (...args: any[]) => void; error: (...args: any[]) => void };
|
||||
@@ -106,9 +107,14 @@ export class SettingsManager {
|
||||
try {
|
||||
const resolved = await resolveSettings({ cwd: this.cwd });
|
||||
this.effective = filterEscalatingDefaultMode(resolved);
|
||||
// The CLI reads `deniedModels` from managed settings only.
|
||||
this.managedDeniedModels = resolved.sources
|
||||
.filter((entry) => entry.source === "managed")
|
||||
.flatMap((entry) => entry.settings.deniedModels ?? []);
|
||||
} catch (error) {
|
||||
this.logger.error("Failed to resolve settings:", error);
|
||||
this.effective = {};
|
||||
this.managedDeniedModels = [];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -171,6 +177,14 @@ export class SettingsManager {
|
||||
return this.effective;
|
||||
}
|
||||
|
||||
/**
|
||||
* `deniedModels` entries from the managed tier, the only tier the CLI
|
||||
* honors them from.
|
||||
*/
|
||||
getManagedDeniedModels(): string[] {
|
||||
return this.managedDeniedModels;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current working directory
|
||||
*/
|
||||
|
||||
@@ -852,26 +852,40 @@ describe("createSession options merging", () => {
|
||||
return (agent as unknown as { sessions: Record<string, any> }).sessions[sessionId];
|
||||
}
|
||||
|
||||
it("does not call getContextUsage during session creation", async () => {
|
||||
// getContextUsage stalls until the session's first prompt turn has run
|
||||
// (it is not serviced pre-turn), so session/new must never call it —
|
||||
it("does not wait for getContextUsage during session creation", async () => {
|
||||
// SDK control requests are serialized and getContextUsage used to stall
|
||||
// until the first prompt turn, so session/new only kicks it off —
|
||||
// awaiting it inline is what regressed session/new latency in 0.59.0.
|
||||
const ctxSpy = vi.fn(async () => ({ rawMaxTokens: 967000 }));
|
||||
const ctxSpy = vi.fn(() => new Promise<never>(() => {}));
|
||||
contextUsageResult = ctxSpy;
|
||||
|
||||
await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
|
||||
const response = await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
|
||||
|
||||
expect(ctxSpy).not.toHaveBeenCalled();
|
||||
expect(ctxSpy).toHaveBeenCalledOnce();
|
||||
expect(sessionFor(response.sessionId).contextWindowSize).toBe(200000);
|
||||
expect(sessionFor(response.sessionId).contextWindowAuthoritative).toBe(false);
|
||||
});
|
||||
|
||||
it("seeds contextWindowSize from text inference, falling back to the default when it misses", async () => {
|
||||
it("refines a guessed window from getContextUsage in the background", async () => {
|
||||
// The mock model ("claude-sonnet-4-6" / "Claude Sonnet" / "Fast") carries
|
||||
// no "1m" token anywhere, so inference misses and the window falls back to
|
||||
// the default; the authoritative value arrives later via result.modelUsage.
|
||||
// no "1m" token anywhere, so inference misses and the seed is the default
|
||||
// until the background getContextUsage answers.
|
||||
contextUsageResult = async () => ({ rawMaxTokens: 967000 });
|
||||
|
||||
const response = await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
|
||||
|
||||
await vi.waitFor(() => expect(sessionFor(response.sessionId).contextWindowSize).toBe(967000));
|
||||
expect(sessionFor(response.sessionId).contextWindowAuthoritative).toBe(true);
|
||||
});
|
||||
|
||||
it("keeps the guessed window when getContextUsage reports a non-positive size", async () => {
|
||||
const ctxSpy = vi.fn(async () => ({ rawMaxTokens: 0 }));
|
||||
contextUsageResult = ctxSpy;
|
||||
|
||||
const response = await agent.newSession({ cwd: process.cwd(), mcpServers: [] });
|
||||
await vi.waitFor(() => expect(ctxSpy).toHaveBeenCalled());
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
|
||||
expect(sessionFor(response.sessionId).contextWindowSize).toBe(200000);
|
||||
expect(sessionFor(response.sessionId).contextWindowAuthoritative).toBe(false);
|
||||
});
|
||||
@@ -918,7 +932,7 @@ describe("createSession options merging", () => {
|
||||
expect(response.configOptions?.find((option) => option.id === "model")?.currentValue).toBe(
|
||||
"haiku",
|
||||
);
|
||||
expect(ctxSpy).not.toHaveBeenCalled();
|
||||
// Kicked off in the background, never awaited: it never answers here.
|
||||
expect(sessionFor("resumed-model-probe").contextWindowAuthoritative).toBe(false);
|
||||
expect(getSessionMessages).toHaveBeenCalledTimes(1);
|
||||
expect(getSessionMessages).toHaveBeenCalledWith("resumed-model-probe");
|
||||
|
||||
@@ -156,7 +156,7 @@ describe("versioned model display names", () => {
|
||||
// Account-dependent model availability requires the same authenticated environment
|
||||
// as the adapter. No prompt is sent: inspect only the SDK initialization response.
|
||||
it.skipIf(!process.env.RUN_INTEGRATION_TESTS)(
|
||||
"the real SDK exposes one named Opus with the expected context suffix",
|
||||
"the real SDK exposes one plain Opus row",
|
||||
async () => {
|
||||
let finishInput!: () => void;
|
||||
const inputGate = new Promise<void>((resolve) => {
|
||||
@@ -178,12 +178,14 @@ it.skipIf(!process.env.RUN_INTEGRATION_TESTS)(
|
||||
/\bopus\b/i.test(`${model.value} ${model.resolvedModel} ${model.displayName}`),
|
||||
);
|
||||
expect(opusModels).toHaveLength(1);
|
||||
// CLI 2.1.283 dropped the "[1m]" / "(1M context)" spelling from the Opus
|
||||
// row: Opus is natively 1M, so the row names the plain model.
|
||||
expect(opusModels[0]).toMatchObject({
|
||||
value: "opus[1m]",
|
||||
displayName: "Opus (1M context)",
|
||||
resolvedModel: expect.stringMatching(/^claude-opus-.*\[1m\]$/),
|
||||
description: expect.stringContaining("1M context"),
|
||||
value: "opus",
|
||||
displayName: "Opus",
|
||||
resolvedModel: expect.stringMatching(/^claude-opus-[\d-]+$/),
|
||||
});
|
||||
expect(opusModels[0].description).not.toMatch(/\b1m\b/i);
|
||||
} finally {
|
||||
clearTimeout(timeout);
|
||||
finishInput();
|
||||
|
||||
@@ -5,6 +5,7 @@ import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
|
||||
import {
|
||||
resolveModelPreference,
|
||||
applyAvailableModelsAllowlist,
|
||||
isDeniedModel,
|
||||
matchResumedModel,
|
||||
} from "../session-model.js";
|
||||
import { settingsEffortForModel } from "../session-effort.js";
|
||||
@@ -234,6 +235,49 @@ describe("applyAvailableModelsAllowlist - modelOverrides", () => {
|
||||
});
|
||||
});
|
||||
|
||||
describe("applyAvailableModelsAllowlist - managed deniedModels", () => {
|
||||
it("drops an allowlisted model that deniedModels blocks, keeping Default", () => {
|
||||
const result = applyAvailableModelsAllowlist(
|
||||
LIVE_SHAPED_MODELS,
|
||||
["claude-sonnet-5", "claude-opus-5-5"],
|
||||
undefined,
|
||||
["claude-opus-5"],
|
||||
);
|
||||
expect(result.map((m) => m.value)).toEqual(["default", "claude-sonnet-5"]);
|
||||
});
|
||||
|
||||
it("checks an alias entry against the row it resolves to", () => {
|
||||
const result = applyAvailableModelsAllowlist(LIVE_SHAPED_MODELS, ["sonnet"], undefined, [
|
||||
"claude-sonnet-5",
|
||||
]);
|
||||
expect(result.map((m) => m.value)).toEqual(["default"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("isDeniedModel", () => {
|
||||
it("blocks every spelling of a denied version and its later minors", () => {
|
||||
const denied = ["claude-opus-5"];
|
||||
expect(isDeniedModel("claude-opus-5", denied)).toBe(true);
|
||||
expect(isDeniedModel("claude-opus-5-20260101", denied)).toBe(true);
|
||||
expect(isDeniedModel("claude-opus-5[1m]", denied)).toBe(true);
|
||||
expect(isDeniedModel("us.anthropic.claude-opus-5-v1:0", denied)).toBe(true);
|
||||
expect(isDeniedModel("claude-opus-5-5", denied)).toBe(true);
|
||||
expect(isDeniedModel("claude-opus-4-8", denied)).toBe(false);
|
||||
});
|
||||
|
||||
it("blocks only that version when the entry names a minor", () => {
|
||||
expect(isDeniedModel("claude-opus-5", ["claude-opus-5-5"])).toBe(false);
|
||||
expect(isDeniedModel("claude-opus-5-5-fast", ["claude-opus-5-5"])).toBe(true);
|
||||
});
|
||||
|
||||
it("blocks a whole family for a family alias and ignores settings-dependent aliases", () => {
|
||||
expect(isDeniedModel("claude-haiku-4-5-20251001", ["haiku"])).toBe(true);
|
||||
expect(isDeniedModel("haiku", ["haiku"])).toBe(true);
|
||||
expect(isDeniedModel("claude-sonnet-5", ["haiku"])).toBe(false);
|
||||
expect(isDeniedModel("claude-opus-5", ["default", "best", "opusplan"])).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
// Runs against the real SDK (no mocks) so the fixture above is flagged the
|
||||
// moment the SDK's actual model list shape drifts from it. Requires a usable
|
||||
// ANTHROPIC_API_KEY, hence opt-in via RUN_INTEGRATION_TESTS.
|
||||
|
||||
@@ -1155,13 +1155,11 @@ describe("session config options", () => {
|
||||
return (agent as unknown as { sessions: Record<string, any> }).sessions[SESSION_ID];
|
||||
}
|
||||
|
||||
it("sets the window from text inference on model switch, without any getContextUsage IPC", async () => {
|
||||
// getContextUsage stalls until the session's first prompt turn, so the
|
||||
// switch path must never call it; the window is seeded from the text
|
||||
// heuristic (here via the new model's resolvedModel) and later confirmed
|
||||
// by result.modelUsage.
|
||||
it("seeds the window from text inference on model switch", async () => {
|
||||
// The window is seeded synchronously from the text heuristic (here via
|
||||
// the new model's resolvedModel); the background refresh never answers.
|
||||
const session = getSession();
|
||||
session.query.getContextUsage = vi.fn(async () => ({ rawMaxTokens: 967000 }));
|
||||
session.query.getContextUsage = vi.fn(() => new Promise<never>(() => {}));
|
||||
session.modelInfos = session.modelInfos.map((m: ModelInfo) =>
|
||||
m.value === "claude-sonnet-4-6" ? { ...m, resolvedModel: "claude-sonnet-5[1m]" } : m,
|
||||
);
|
||||
@@ -1172,15 +1170,17 @@ describe("session config options", () => {
|
||||
value: "claude-sonnet-4-6",
|
||||
});
|
||||
|
||||
expect(session.query.getContextUsage).not.toHaveBeenCalled();
|
||||
expect(session.contextWindowSize).toBe(1_000_000);
|
||||
expect(session.contextWindowAuthoritative).toBe(false);
|
||||
});
|
||||
|
||||
it("falls back to the default window when inference misses, without any getContextUsage IPC", async () => {
|
||||
it("falls back to the default window when inference misses, then refines it in the background", async () => {
|
||||
const session = getSession();
|
||||
session.contextWindowSize = 1_000_000;
|
||||
// Present but must NOT be called; the switch never consults it.
|
||||
session.query.getContextUsage = vi.fn(async () => ({ rawMaxTokens: 967000 }));
|
||||
let answer!: (usage: { rawMaxTokens: number }) => void;
|
||||
session.query.getContextUsage = vi.fn(
|
||||
() => new Promise<{ rawMaxTokens: number }>((resolve) => (answer = resolve)),
|
||||
);
|
||||
// claude-sonnet-4-6 carries no "1m" token in its id, resolvedModel,
|
||||
// displayName, or description, so inference misses → default window.
|
||||
|
||||
@@ -1190,22 +1190,40 @@ describe("session config options", () => {
|
||||
value: "claude-sonnet-4-6",
|
||||
});
|
||||
|
||||
expect(session.query.getContextUsage).not.toHaveBeenCalled();
|
||||
// The switch resolved without waiting for getContextUsage.
|
||||
expect(session.query.getContextUsage).toHaveBeenCalledOnce();
|
||||
expect(session.contextWindowSize).toBe(200000);
|
||||
|
||||
answer({ rawMaxTokens: 967000 });
|
||||
await vi.waitFor(() => expect(session.contextWindowSize).toBe(967000));
|
||||
expect(session.contextWindowAuthoritative).toBe(true);
|
||||
});
|
||||
|
||||
it("does not call getContextUsage even when switching to a fresh model", async () => {
|
||||
it("drops a background answer that arrives after another switch", async () => {
|
||||
const session = getSession();
|
||||
const spy = vi.fn(async () => ({ rawMaxTokens: 967000 }));
|
||||
session.query.getContextUsage = spy;
|
||||
let answer!: (usage: { rawMaxTokens: number }) => void;
|
||||
session.query.getContextUsage = vi.fn(
|
||||
() => new Promise<{ rawMaxTokens: number }>((resolve) => (answer = resolve)),
|
||||
);
|
||||
|
||||
await agent.setSessionConfigOption({
|
||||
sessionId: SESSION_ID,
|
||||
configId: "model",
|
||||
value: "claude-sonnet-4-6",
|
||||
});
|
||||
const staleAnswer = answer;
|
||||
await agent.setSessionConfigOption({
|
||||
sessionId: SESSION_ID,
|
||||
configId: "model",
|
||||
value: "claude-opus-4-5",
|
||||
});
|
||||
const windowAfterSecondSwitch = session.contextWindowSize;
|
||||
|
||||
expect(spy).not.toHaveBeenCalled();
|
||||
staleAnswer({ rawMaxTokens: 967000 });
|
||||
await new Promise((resolve) => setImmediate(resolve));
|
||||
|
||||
expect(session.contextWindowSize).toBe(windowAfterSecondSwitch);
|
||||
expect(session.contextWindowAuthoritative).toBe(false);
|
||||
});
|
||||
|
||||
it("keeps the learned window when re-asserting the current model", async () => {
|
||||
|
||||
Reference in New Issue
Block a user