@code-yeongyu/senpi 2026.10.18 → 2026.10.19

package/dist/utils/wsl.d.ts

@@ -1,3 +1,3 @@
-/** Windows Subsystem for Linux, where Windows executables are reachable through interop. */
-export declare function isWSL(env?: NodeJS.ProcessEnv): boolean;
+/** Windows Subsystem for Linux, where Windows executables are reachable through interop. Linux-only by contract: callers on other platforms must guard with a platform check (as keybindings and the footer provider do), because `WSLENV` can also be set on native Windows. */
+export declare function isWSL(env?: NodeJS.ProcessEnv, procVersionPath?: string): boolean;
 //# sourceMappingURL=wsl.d.ts.map

package/dist/utils/wsl.js

@@ -1,11 +1,11 @@
 import { readFileSync } from "node:fs";
-/** Windows Subsystem for Linux, where Windows executables are reachable through interop. */
-export function isWSL(env = process.env) {
-    if (env.WSL_DISTRO_NAME || env.WSLENV) {
+/** Windows Subsystem for Linux, where Windows executables are reachable through interop. Linux-only by contract: callers on other platforms must guard with a platform check (as keybindings and the footer provider do), because `WSLENV` can also be set on native Windows. */
+export function isWSL(env = process.env, procVersionPath = "/proc/version") {
+    if (env.WSL_DISTRO_NAME || env.WSL_INTEROP || env.WSLENV) {
         return true;
     }
     try {
-        const release = readFileSync("/proc/version", "utf-8");
+        const release = readFileSync(procVersionPath, "utf-8");
         return /microsoft|wsl/i.test(release);
     }
     catch {

package/docs/providers.md

@@ -137,6 +137,7 @@ The `anthropic-subscription` provider routes LLM calls through the official [Cla
 - Run `/login anthropic-subscription` to sign in with your Claude Pro/Max subscription (PKCE, same OAuth client as the Claude Code CLI). An existing Anthropic OAuth credential is offered as an import.
 - Multiple accounts: each `/login anthropic-subscription` adds another named account. `CLAUDE_CODE_OAUTH_TOKEN` (and `_2`..`_N`) are honored as read-only env accounts. `/claude-account` lists, adds, removes, and pins accounts; `--claude-account <name>` pins one for the session; `anthropicSubscriptionProvider.pinnedAccount` pins one in settings.
 - Session affinity: one senpi session sticks to one account (rendezvous hashing), which keeps Anthropic's prompt cache warm - accounts never rotate mid-session except on automatic failover. Rate limits and auth errors block the account (with cooldown) and retry on the next account, before any visible output; once output has started, the error surfaces instead of replaying.
+- To stop instead of spending another account's allowance, set `anthropicSubscriptionProvider.accountFallback: false`. On managed lanes (`oauth-slots` and `config-dir`), only the explicitly pinned account, otherwise the resident session's account, otherwise the deterministic affinity winner may serve the request. A blocked selected account is not skipped on later requests. Same-account transient retries and credential refresh still work; an explicit account pin can select a different account. The default is `true`. This is independent of `retry.modelFallback` / `--no-model-fallback`; disable model fallback too if you do not want a different model or provider to serve the failed turn. The ambient lane has no managed-account fallback.
 - Default lane: **ambient** - with no `tokenInjection` setting the provider inherits the environment like the upstream extension (Claude Code CLI login or `ANTHROPIC_API_KEY`). Managed lanes (`oauth-slots`, `config-dir`) are opt-in via one settings line until the live subscription spike proves a managed default.
 - Ambient lane is explicit opt-in: a Claude Code CLI login on the host is not consent to spend that subscription, so the ambient lane is gated by `anthropicSubscriptionProvider.enabled` (default `false`, env override `SENPI_CLAUDE_SDK_OAUTH_ENABLED`). Before this gate existed, a logged-in Claude Code CLI made the provider available with no senpi-side action. An explicit senpi-side login is itself an opt-in: stored OAuth accounts in `auth.json` and `CLAUDE_CODE_OAUTH_TOKEN` / `CLAUDE_CODE_OAUTH_TOKEN_<n>` env accounts keep the provider available with the flag unset. Only the host-CLI-derived ambient lane requires the flag.
 - Settings (`anthropicSubscriptionProvider`):
@@ -154,6 +155,7 @@ The `anthropic-subscription` provider routes LLM calls through the official [Cla
   | `SENPI_CLAUDE_SDK_OAUTH_TOKEN_INJECTION` | `oauth-slots` \| `config-dir` \| `ambient` |
   | `SENPI_CLAUDE_SDK_OAUTH_SETTING_SOURCES` | Overrides `settingSources` |
   | `SENPI_CLAUDE_SDK_OAUTH_PINNED_ACCOUNT` | Overrides `pinnedAccount` |
+  | `SENPI_CLAUDE_SDK_OAUTH_ACCOUNT_FALLBACK` | `0` / `false` disables managed-account fallback; `1` / `true` enables it |
   | `SENPI_CLAUDE_SDK_OAUTH_COMPACTION_OWNER` | Overrides `compactionOwner` (`senpi` \| `sdk`) |
 
   Every `SENPI_*` variable is stripped from the Claude Code subprocess environment on all three lanes; other inherited variables are preserved.

package/docs/rpc.md

@@ -466,6 +466,10 @@ are what this decision encodes; the other two are what a client must not undo el
   that window, while its process is alive, the ensure fails with `HostEnsureRefusedError { reason: "host_stalled" }`
   and sends no signal, starts no generation beside it and leaves its registration untouched - a stalled host is still
   serving its sessions.
+  When no registration names the endpoint at all, yet something still accepts connections at the public path and did
+  not answer `get_protocol_info`, the ensure fails with `HostEnsureRefusedError { reason: "endpoint_occupied" }` (exit 3)
+  and leaves that process and its entry alone: a start there could only lose the bind and exit without a reason. An
+  entry nobody listens behind is still free and is replaced by the start.
 - **I2 - compatibility is protocol version + capabilities, never semver equality.** An ordinal that cannot be
   compared (a build without git metadata, a host that reports none) is EQUAL, and since a handoff requires
   STRICTLY greater, such a pair attaches instead of upgrading.
@@ -1832,6 +1836,8 @@ no longer lists it and the handle answers `unknown_session`.
   `session_released` entry on disk or in memory, and a later release can be retried. A teardown that fails
   after it claimed the session leaves it closing.
 
+A release with `reason: "move"` (and a `moveId`) seals the session for a move to another device: its `session_released` entry records `move_id`, `target` and `session_id`, and from then on any write to the file is refused with `session_moved_away` until that same move is reclaimed. A later `takeover` release, or any ownership entry for another move, is refused too. A `move` without `moveId` is refused with `invalid_release_reason`.
+
 ### Host self-observation (event-loop stalls and memory pressure)
 
 Every in-process session shares the host's event loop, so a session that blocks it freezes every other session and the
@@ -2050,7 +2056,7 @@ names a valid preset.
 | `close_session` | `sessionId` | `{}` | Refused with `unknown_session` when the requesting connection never attached to that handle (a close releases the CALLER's attachment, and `list_sessions` publishes every handle). Otherwise aborts active work, awaits agent idle + settled persistence for up to the host grace window (default 10s), then quarantines any worker that has not exited without releasing its path reservation; its response is the LAST record tagged with that handle for the first closer — no events after (test-pinned). An admitted concurrent close joins the same teardown and receives its own successful response; output saturation rejects admission with the bounded close-overflow/resync notice described above. |
 | `list_sessions` | `include_workers?` (default false) | `{ sessions: [{ sessionId, durableSessionId, sessionPath, cwd, name, status, attachments, kind, context? }] }` | Includes `opening`/`closing` entries. Internally quarantined workers remain externally `closing` until exit. `attachments` is the session's live client attachment count; `0` on an `open` row is a retained session with no client attached. Every row carries `kind`. Rows with `kind: "worker"` are omitted unless `include_workers: true`, and `context` is published ONLY on that listing — a default listing carries no `context` at all. |
 | `detach_connection` | - | `{ deferred: string[] }` | Multi-session hosts that advertise `detach_connection`. Meant as the connection's last request: the host releases every session attachment this connection holds and answers only after that, so another connection's next `list_sessions` no longer counts it. `deferred` names the sessions that still count it (see `#### detach_connection`). Closing the socket afterwards releases nothing more. `senpi host session` sends it before closing, bounded at 5 s; on a host without the capability, or after a request timed out or the connection was lost, it relies on the release at socket close. |
-| `release_session` | `sessionId`, `reason: "takeover"`, `interrupt?`, `force?` | `{ released: true, session_path, attachments }` | Hands the session to a runtime outside this host. See "Handing a session over (`release_session`)" below. |
+| `release_session` | `sessionId`, `reason: "takeover" \| "move"`, `moveId?` (required for `move`), `target?`, `interrupt?`, `force?` | `{ released: true, session_path, attachments }` | Hands the session to a runtime outside this host. See "Handing a session over (`release_session`)" below. |
 | `wake` | `sessionId`, `delivery_ids?` | `{ admitted: [{ delivery_id, kind }] }` | Runs the session's registered inbox drain once. See "Waking a host session (`wake`)" below. |
 | `warm` | `cwd?`, `kind?`, `context?` (as on `open_session`; `cwd` MUST be absolute) | `{ state: "warmed" \| "already_warm" \| "unsupported" }` | Loads what the next matching `open_session` needs without opening a session; never listed, never an attachment, idempotent per profile. See "Warming a host" above. Advertised as the `warm` capability by in-process hosts only. |
 | every existing command | + `sessionId` (REQUIRED in multi mode) | unchanged | Routed to that session. |
@@ -2528,6 +2534,18 @@ For both commands, `status` is `removed` / `edited`, or `already_delivered` (the
 {"type": "response", "command": "edit_queued_message", "success": true, "data": {"queuedId": "q_4", "status": "conflict", "currentRevision": 2, "reason": "conflict", "action": "read the input's current text and revision from get_state or queue_update, then retry with that expectedRevision if the change still applies"}}
 ```
 
+#### get_pending_inputs
+
+What the engine holds for every pending input, and the outcome of each id a client sent, read in one consistent step (senpi#3549). `inputs` lists every input still queued, sending or failed, each as a projection: `clientMessageId`, `state` (`queued`, `edited`, `sending`, `failed`), `text`, `requestedMode`, `revision`, `statusCode`, `statusText`, `actions` and `pendingDecoration`. `knownClientMessageIds` (at most 64 non-empty ids of at most 256 characters) asks for an outcome per id: `admitted` with its projection, including `delivered` and `removed`, or `not_admitted`. Absence from `inputs` is never an outcome; read the id's outcome instead.
+
+The answer is consistent through `throughCursor`. To follow changes without a gap, subscribe first, apply the snapshot, then apply only `pending_input_update` events whose `cursor` is later. Each event carries every input one committed change touched, under that change's single `cursor`, with the same `lifetimeId`. A different `lifetimeId` means the session reopened: read the snapshot again.
+
+```json
+{"type": "get_pending_inputs", "knownClientMessageIds": ["c-7"]}
+{"type": "response", "command": "get_pending_inputs", "success": true, "data": {"lifetimeId": "5b0c…", "throughCursor": 4, "inputs": [{"clientMessageId": "c-7", "state": "queued", "text": "also run the tests", "requestedMode": "followUp", "revision": 1, "statusCode": "queued_follow_up", "statusText": "Queued - sent after this turn", "actions": ["edit", "remove", "copy"], "pendingDecoration": true, "supersededVersions": []}], "outcomes": [{"clientMessageId": "c-7", "status": "admitted", "projection": {"clientMessageId": "c-7", "state": "queued"}}]}}
+{"type": "pending_input_update", "lifetimeId": "5b0c…", "cursor": 5, "changes": [{"clientMessageId": "c-7", "state": "sending"}]}
+```
+
 #### clear_queue
 
 Remove queued steering and follow-up messages and return their text.
@@ -2787,7 +2805,7 @@ List all configured models, refreshing credential availability on each request s
 {"type": "get_available_models"}
 ```
 
-Response contains an array of full [Model](#model) objects with supported thinking levels. Each row also carries `supportsAssistantPrefill`: whether the model accepts a request ending with an assistant message, given the session's current thinking level. It is `false` for every model today, so clients continue an edited answer with `continue_from_leaf`:
+Response contains an array of full [Model](#model) objects with supported thinking levels. A row's `serviceTier` and `upstreamModelId` are the values the session resolves for that model, including ones declared only in `models.json` or by an extension provider, so a `-fast` priority alias names its base model there and a client can tell a child opened on the base model is the alias it asked for. Each row also carries `supportsAssistantPrefill`: whether the model accepts a request ending with an assistant message, given the session's current thinking level. It is `false` for every model today, so clients continue an edited answer with `continue_from_leaf`:
 ```json
 {
   "type": "response",

package/docs/settings.md

@@ -415,6 +415,7 @@ When unset, senpi leaves provider payloads unchanged. This setting currently app
 | Setting | Type | Default | Description |
 |---------|------|---------|-------------|
 | `anthropicSubscriptionProvider.enabled` | boolean | `false` | Enable the ambient (host-CLI-derived) lane of `anthropic-subscription`. Env override: `SENPI_CLAUDE_SDK_OAUTH_ENABLED`. Explicit senpi-side logins (stored OAuth accounts in `auth.json`, `CLAUDE_CODE_OAUTH_TOKEN` / `CLAUDE_CODE_OAUTH_TOKEN_<n>` env accounts) keep the provider available with this unset |
+| `anthropicSubscriptionProvider.accountFallback` | boolean | `true` | Allow automatic switching between managed Claude accounts. `false` surfaces failure instead of using another account, including when the selected account is already blocked. Same-account retries and refresh remain enabled. Independent of `retry.modelFallback`. Env override: `SENPI_CLAUDE_SDK_OAUTH_ACCOUNT_FALLBACK` |
 | `cursorCliOauthProvider.enabled` | boolean | `false` | Enable the `cursor-cli-oauth` fallback lane and automatic native credential bootstrap. Env override: `SENPI_CURSOR_CLI_OAUTH_ENABLED` |
 | `providers.<id>.maxConcurrency` | number | unlimited | Cap the streaming requests senpi keeps in flight against one provider, keyed by registry provider id (`anthropic`, `openai`, ...). `0`, a negative value, a fraction, or an absent key all mean unlimited |
 

package/docs/terminal-setup.md

@@ -95,6 +95,8 @@ If you already have a `config.keys` table, add the entry to it.
 
 On WSL, WezTerm may require a visible hardware cursor for IME candidate window positioning. If CJK IME candidates do not follow the text cursor, set `PI_HARDWARE_CURSOR=1` before running senpi or set `showHardwareCursor` to `true` in settings.
 
+On Windows, inline images need WezTerm 20250208-160106 or newer, which today means a [nightly build](https://wezterm.org/install/windows.html). WezTerm runs the shell through the ConPTY it bundles, and the ConPTY in older builds (including the 20240203 stable release) drops Kitty graphics before WezTerm sees them. On those builds senpi shows the image placeholder with a hint to update instead of leaving a blank gap. Running senpi through `wezterm ssh` also bypasses ConPTY.
+
 ## Alacritty
 
 Alacritty usually works out of the box for `Shift+Enter`. On macOS, `Option+Enter` may arrive as plain `Enter`. To use `Option+Enter` for pi follow-up queueing, add to `~/.config/alacritty/alacritty.toml`:

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.18",
+	"version": "2026.10.19",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -29,6 +29,10 @@
 			"types": "./dist/client/index.d.ts",
 			"import": "./dist/client/index.js"
 		},
+		"./pending-input": {
+			"types": "./dist/core/pending-input-public.d.ts",
+			"import": "./dist/core/pending-input-public.js"
+		},
 		"./prompt-presets": {
 			"types": "./dist/core/extensions/builtin/prompt-preset/public.d.ts",
 			"import": "./dist/core/extensions/builtin/prompt-preset/public.js"
@@ -60,9 +64,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.18",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.18",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.18",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.19",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.19",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.19",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
@@ -81,8 +85,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.296",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.18",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.18",
+		"@code-yeongyu/senpi-codemode": "2026.10.19",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.19",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",

package/dist/bundle/chunks/chunk-COJK5FDH.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{getProviderEnvValue}from"./chunk-5ROMKDLK.js";import{appendAssistantMessageDiagnostic}from"./chunk-DMI55M2N.js";function isObject(value){return typeof value=="object"&&value!==null}function hasMessagesArray(value){return isObject(value)&&Array.isArray(value.messages)}function isContentBlockParam(value){return isObject(value)&&typeof value.type=="string"}function isToolUseBlock(block){return block.type==="tool_use"&&"id"in block&&typeof block.id=="string"}function isToolResultBlock(block){return block.type==="tool_result"}var SYNTHETIC_OUTPUT="Tool output unavailable (interrupted before result)";function cloneWith(block,patch){return{...block,...patch}}function isMessageWithArrayContent(value,role){if(!isObject(value)||value.role!==role||!Array.isArray(value.content))return!1;for(let block of value.content)if(!isContentBlockParam(block))return!1;return!0}function isUserMessageWithStringContent(value){return isObject(value)&&value.role==="user"&&typeof value.content=="string"}function dedupeAssistantToolUses(message,usedIds){let content=[],expectedIds=[],remapQueues=new Map,changed=!1;for(let block of message.content){if(!isToolUseBlock(block)||block.id.length===0){content.push(block);continue}let finalId=block.id;if(usedIds.has(finalId)){let suffix=2;for(;usedIds.has(`${block.id}__dedup${suffix}`);)suffix+=1;finalId=`${block.id}__dedup${suffix}`,changed=!0}usedIds.add(finalId),expectedIds.push(finalId);let queue=remapQueues.get(block.id);queue===void 0?remapQueues.set(block.id,[finalId]):queue.push(finalId),content.push(finalId===block.id?block:cloneWith(block,{id:finalId}))}return changed?{message:{...message,content},changed:!0,expectedIds,remapQueues}:{message,changed:!1,expectedIds,remapQueues}}function syntheticToolResult(toolUseId){return{type:"tool_result",tool_use_id:toolUseId,content:SYNTHETIC_OUTPUT,is_error:!0}}function sameBlocks(left,right){return left.length===right.length&&left.every((block,index)=>block===right[index])}function repairFollowingUserMessage(message,expectedIds,remapQueues){let expected=new Set(expectedIds),found=new Set,results=[],ordinary=[];for(let block of message.content){if(!isToolResultBlock(block)){ordinary.push(block);continue}let rawId=block.tool_use_id,id=rawId;if(typeof rawId=="string"){let queue=remapQueues.get(rawId);queue!==void 0&&queue.length>0&&(id=queue.shift())}typeof id!="string"||!expected.has(id)||found.has(id)||(found.add(id),results.push(id===rawId?block:cloneWith(block,{tool_use_id:id})))}for(let id of expectedIds)found.has(id)||results.push(syntheticToolResult(id));let content=[...results,...ordinary];return sameBlocks(content,message.content)?{message,changed:!1}:{message:{...message,content},changed:!0}}function removeOrphanResults(message){let content=message.content.filter(block=>!isToolResultBlock(block));return content.length===message.content.length?{message,changed:!1}:content.length===0?{changed:!0}:{message:{...message,content},changed:!0}}function sanitizeAnthropicToolPairs(payload){if(!hasMessagesArray(payload))return payload;let changed=!1,usedToolUseIds=new Set,sanitizedMessages=[];for(let index=0;index<payload.messages.length;index++){let unknownMessage=payload.messages[index];if(isMessageWithArrayContent(unknownMessage,"assistant")){let deduped=dedupeAssistantToolUses(unknownMessage,usedToolUseIds);sanitizedMessages.push(deduped.message),changed||=deduped.changed;let expectedIds=deduped.expectedIds;if(expectedIds.length===0)continue;let nextMessage=payload.messages[index+1];if(isMessageWithArrayContent(nextMessage,"user")){let repaired=repairFollowingUserMessage(nextMessage,expectedIds,deduped.remapQueues);sanitizedMessages.push(repaired.message),changed||=repaired.changed,index++;continue}if(isUserMessageWithStringContent(nextMessage)){sanitizedMessages.push({...nextMessage,content:[...expectedIds.map(syntheticToolResult),{type:"text",text:nextMessage.content}]}),changed=!0,index++;continue}sanitizedMessages.push({role:"user",content:expectedIds.map(syntheticToolResult)}),changed=!0;continue}if(isMessageWithArrayContent(unknownMessage,"user")){let repaired=removeOrphanResults(unknownMessage);repaired.message&&sanitizedMessages.push(repaired.message),changed||=repaired.changed;continue}sanitizedMessages.push(unknownMessage)}return changed?{...payload,messages:sanitizedMessages}:payload}var __rewriteRelativeImportExtension=function(path,preserveJsx){return typeof path=="string"&&/^\.\.?\//.test(path)?path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i,function(m,tsx,d,ext,cm){return tsx?preserveJsx?".jsx":".js":d&&(!ext||!cm)?m:d+ext+"."+cm.toLowerCase()+"js"}):path},_existsSync=null,_homedir=null,_join=null,dynamicImport=specifier=>import(__rewriteRelativeImportExtension(specifier)),NODE_FS_SPECIFIER="node:fs",NODE_OS_SPECIFIER="node:os",NODE_PATH_SPECIFIER="node:path";typeof process<"u"&&(process.versions?.node||process.versions?.bun)&&(dynamicImport(NODE_FS_SPECIFIER).then(m=>{_existsSync=m.existsSync}),dynamicImport(NODE_OS_SPECIFIER).then(m=>{_homedir=m.homedir}),dynamicImport(NODE_PATH_SPECIFIER).then(m=>{_join=m.join}));var ANTHROPIC_AUTH_TOKEN_ENV="ANTHROPIC_AUTH_TOKEN",ANTHROPIC_OAUTH_TOKEN_ENV="ANTHROPIC_OAUTH_TOKEN",ANTHROPIC_API_KEY_ENV="ANTHROPIC_API_KEY",ANTHROPIC_FEDERATION_RULE_ID_ENV="ANTHROPIC_FEDERATION_RULE_ID",ANTHROPIC_ORGANIZATION_ID_ENV="ANTHROPIC_ORGANIZATION_ID",ANTHROPIC_SERVICE_ACCOUNT_ID_ENV="ANTHROPIC_SERVICE_ACCOUNT_ID",ANTHROPIC_IDENTITY_TOKEN_FILE_ENV="ANTHROPIC_IDENTITY_TOKEN_FILE",ANTHROPIC_WORKSPACE_ID_ENV="ANTHROPIC_WORKSPACE_ID",cachedVertexAdcCredentialsExists=null;function hasVertexAdcCredentials(env){let explicitCredentialsPath=env?.GOOGLE_APPLICATION_CREDENTIALS;if(explicitCredentialsPath)return _existsSync?_existsSync(explicitCredentialsPath):!1;if(cachedVertexAdcCredentialsExists===null){if(!_existsSync||!_homedir||!_join)return typeof process<"u"&&(process.versions?.node||process.versions?.bun)||(cachedVertexAdcCredentialsExists=!1),!1;let gacPath=getProviderEnvValue("GOOGLE_APPLICATION_CREDENTIALS",env);gacPath?cachedVertexAdcCredentialsExists=_existsSync(gacPath):cachedVertexAdcCredentialsExists=_existsSync(_join(_homedir(),".config","gcloud","application_default_credentials.json"))}return cachedVertexAdcCredentialsExists}var API_KEY_ENV_VARS={"alibaba-token-plan":"ALIBABA_TOKEN_PLAN_API_KEY","ant-ling":"ANT_LING_API_KEY","qwen-token-plan":"QWEN_TOKEN_PLAN_API_KEY","qwen-token-plan-cn":"QWEN_TOKEN_PLAN_CN_API_KEY","qwen-token-plan-individual":"QWEN_TOKEN_PLAN_API_KEY",openai:"OPENAI_API_KEY",ollama:"OLLAMA_API_KEY","azure-openai-responses":"AZURE_OPENAI_API_KEY",nvidia:"NVIDIA_API_KEY",deepseek:"DEEPSEEK_API_KEY",google:"GEMINI_API_KEY","google-vertex":"GOOGLE_CLOUD_API_KEY",groq:"GROQ_API_KEY",cerebras:"CEREBRAS_API_KEY",venice:"VENICE_API_KEY",xai:"XAI_API_KEY",typesafe:"TYPESAFE_API_KEY",radius:"RADIUS_API_KEY",openrouter:"OPENROUTER_API_KEY","vercel-ai-gateway":"AI_GATEWAY_API_KEY",opengateway:"OPENGATEWAY_API_KEY",zai:"ZAI_API_KEY","zai-coding-cn":"ZAI_CODING_CN_API_KEY",mistral:"MISTRAL_API_KEY",minimax:"MINIMAX_API_KEY","minimax-cn":"MINIMAX_CN_API_KEY",moonshotai:"MOONSHOT_API_KEY","moonshotai-cn":"MOONSHOT_API_KEY",huggingface:"HF_TOKEN",fireworks:"FIREWORKS_API_KEY",together:"TOGETHER_API_KEY",baseten:"BASETEN_API_KEY",bai:"BAI_API_KEY",opencode:"OPENCODE_API_KEY","opencode-go":"OPENCODE_API_KEY","kimi-coding":"KIMI_API_KEY",meta:"META_API_KEY","cloudflare-workers-ai":"CLOUDFLARE_API_KEY","cloudflare-ai-gateway":"CLOUDFLARE_API_KEY",xiaomi:"XIAOMI_API_KEY","xiaomi-token-plan-cn":"XIAOMI_TOKEN_PLAN_CN_API_KEY","xiaomi-token-plan-ams":"XIAOMI_TOKEN_PLAN_AMS_API_KEY","xiaomi-token-plan-sgp":"XIAOMI_TOKEN_PLAN_SGP_API_KEY"},VERTEX_ADC_ENV_NAMES=["GOOGLE_APPLICATION_CREDENTIALS","GOOGLE_CLOUD_PROJECT","GCLOUD_PROJECT","GOOGLE_CLOUD_LOCATION"],BEDROCK_CREDENTIAL_ENV_NAMES=["AWS_PROFILE","AWS_ACCESS_KEY_ID","AWS_SECRET_ACCESS_KEY","AWS_BEARER_TOKEN_BEDROCK","AWS_CONTAINER_CREDENTIALS_RELATIVE_URI","AWS_CONTAINER_CREDENTIALS_FULL_URI","AWS_WEB_IDENTITY_TOKEN_FILE"];function apiKeyEnvProviders(){return["github-copilot","anthropic",...Object.keys(API_KEY_ENV_VARS)]}function providerCredentialEnvNames(){let names=new Set([...VERTEX_ADC_ENV_NAMES,...BEDROCK_CREDENTIAL_ENV_NAMES]);for(let provider of apiKeyEnvProviders())for(let name of getApiKeyEnvVars(provider)??[])names.add(name);return[...names]}function getApiKeyEnvVars(provider){if(provider==="github-copilot")return["COPILOT_GITHUB_TOKEN"];if(provider==="anthropic")return[ANTHROPIC_AUTH_TOKEN_ENV,ANTHROPIC_OAUTH_TOKEN_ENV,ANTHROPIC_API_KEY_ENV];let envVar=API_KEY_ENV_VARS[provider];return envVar?[envVar]:void 0}function findEnvKeys(provider,env){let envVars=getApiKeyEnvVars(provider);if(!envVars)return;let found=envVars.filter(envVar=>!!getProviderEnvValue(envVar,env));return found.length>0?found:void 0}function getEnvApiKey(provider,env){let envKeys=findEnvKeys(provider,env);if(envKeys?.[0]){let apiKeyEnv=provider==="anthropic"?envKeys.find(key=>key!==ANTHROPIC_AUTH_TOKEN_ENV):envKeys[0];if(apiKeyEnv)return getProviderEnvValue(apiKeyEnv,env)}if(provider==="google-vertex"){let hasCredentials=hasVertexAdcCredentials(env),hasProject=!!(getProviderEnvValue("GOOGLE_CLOUD_PROJECT",env)||getProviderEnvValue("GCLOUD_PROJECT",env)),hasLocation=!!getProviderEnvValue("GOOGLE_CLOUD_LOCATION",env);if(hasCredentials&&hasProject&&hasLocation)return"<authenticated>"}if(provider==="amazon-bedrock"&&(getProviderEnvValue("AWS_PROFILE",env)||getProviderEnvValue("AWS_ACCESS_KEY_ID",env)&&getProviderEnvValue("AWS_SECRET_ACCESS_KEY",env)||getProviderEnvValue("AWS_BEARER_TOKEN_BEDROCK",env)||getProviderEnvValue("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",env)||getProviderEnvValue("AWS_CONTAINER_CREDENTIALS_FULL_URI",env)||getProviderEnvValue("AWS_WEB_IDENTITY_TOKEN_FILE",env)))return"<authenticated>"}var SERVER_FALLBACK_ABORTED_DIAGNOSTIC="server_fallback_aborted",BILLING_INCOMPLETE_DIAGNOSTIC="billing_incomplete_after_client_abort";function isRecord(value){return typeof value=="object"&&value!==null&&!Array.isArray(value)}function readModel(value){if(isRecord(value))return typeof value.model=="string"&&value.model.length>0?value.model:void 0}function parseServerFallbackReceipt(block){if(!isRecord(block)||block.type!=="fallback")return;let from=readModel(block.from),to=readModel(block.to);return from!==void 0&&to!==void 0?{from,to}:void 0}function parseStickyFallbackReceipt(usage,requestedModel,servedModel){if(!(!isRecord(usage)||!Array.isArray(usage.iterations)))for(let index=usage.iterations.length-1;index>=0;index--){let entry=usage.iterations[index];if(!isRecord(entry)||entry.type!=="fallback_message")continue;let to=(typeof entry.model=="string"&&entry.model.length>0?entry.model:void 0)??servedModel;return to!==void 0?{from:requestedModel,to}:void 0}}function serverFallbackRefusalExplanation(receipt){return`Server-side fallback (${receipt.from} -> ${receipt.to}) aborted by client policy`}function applyServerFallbackContinuation(message,model,receipt){for(let[index,block]of message.content.entries())block.type==="toolCall"&&(message.content[index]={type:"providerNative",subtype:"discarded_tool_call",raw:block});message.model=receipt.to;let fallback=model.compat?.allowedFallbackModels?.find(candidate=>typeof candidate!="string"&&candidate.provider===model.provider&&candidate.model===receipt.to);return{...model,id:receipt.to,cost:fallback&&typeof fallback!="string"?fallback.cost:model.cost}}function applyServerFallbackAbort(message,receipt){let explanation=serverFallbackRefusalExplanation(receipt);message.content=[],message.stopReason="error",message.stopDetails={type:"refusal",explanation},message.errorMessage=explanation,appendAssistantMessageDiagnostic(message,{type:SERVER_FALLBACK_ABORTED_DIAGNOSTIC,timestamp:Date.now(),details:{from:receipt.from,to:receipt.to}}),appendAssistantMessageDiagnostic(message,{type:BILLING_INCOMPLETE_DIAGNOSTIC,timestamp:Date.now(),details:{reason:"per-attempt usage does not arrive after a client abort"}})}export{sanitizeAnthropicToolPairs,ANTHROPIC_AUTH_TOKEN_ENV,ANTHROPIC_OAUTH_TOKEN_ENV,ANTHROPIC_API_KEY_ENV,ANTHROPIC_FEDERATION_RULE_ID_ENV,ANTHROPIC_ORGANIZATION_ID_ENV,ANTHROPIC_SERVICE_ACCOUNT_ID_ENV,ANTHROPIC_IDENTITY_TOKEN_FILE_ENV,ANTHROPIC_WORKSPACE_ID_ENV,apiKeyEnvProviders,providerCredentialEnvNames,getApiKeyEnvVars,findEnvKeys,getEnvApiKey,SERVER_FALLBACK_ABORTED_DIAGNOSTIC,BILLING_INCOMPLETE_DIAGNOSTIC,parseServerFallbackReceipt,parseStickyFallbackReceipt,serverFallbackRefusalExplanation,applyServerFallbackContinuation,applyServerFallbackAbort};