dsh-workbuddy-connect 0.3.2 → 0.4.0

package/lib/{host-heartbeat-BSsKUoB8.js → host-heartbeat-0UAWqWac.js}

@@ -3,6 +3,7 @@ import { homedir, release } from "node:os";
 import { basename, join } from "node:path";
 import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
+import { randomBytes } from "node:crypto";
 import { execFileSync } from "node:child_process";
 //#region src/auth.ts
 /**
@@ -572,7 +573,7 @@ const FALLBACK_WORKBUDDY_MODELS = [
 			supportedEfforts: [
 				"low",
 				"high",
-				"xhigh"
+				"max"
 			],
 			defaultEffort: "high",
 			canDisableThinking: true
@@ -618,6 +619,137 @@ var WorkBuddyCatalog = class {
 	}
 };
 //#endregion
+//#region src/probe.ts
+/**
+* The reasoning-effort probe: decide whether a model's `reasoning_effort`
+* parameter is actually validated, and if so which canonical values it accepts.
+*
+* Implements `docs/reasoning-effort-probe-plan.md` §4. The order matters and is
+* not an optimization:
+*
+* 1. **Baseline** (no `reasoning_effort`) proves the model, credential, and
+*    request shape work at all, so a later rejection can be attributed.
+* 2. **Sentinel** (a fresh random, impossible-to-collide value) answers the one
+*    question a per-level sweep cannot: does the upstream validate the field?
+*    A model that accepts the sentinel answers 200 to *everything*, so its
+*    per-level results would be uniformly false positives.
+* 3. **Levels**, only after the sentinel was refused.
+*
+* The result is an observation, never a capability claim. Even a fully
+* successful sweep means "the upstream accepted these spellings", not "these
+* spellings change how the model thinks".
+*
+* @module dsh-workbuddy-connect/probe
+*/
+/**
+* The canonical values a probe tests, in a fixed order.
+*
+* `minimal` is absent: it appears in no upstream vocabulary. `off` is absent
+* by policy — disabling thinking is a separate capability the upstream must
+* declare through `canDisableThinking`, never something probing may infer.
+*/
+const PROBE_EFFORT_CANDIDATES = [
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+/** Prompt body used by every probe request; carries nothing user-specific. */
+const PROBE_PROMPT = "ping";
+/** Default sentinel: unmistakably non-canonical, different on every call. */
+function randomSentinel() {
+	return `probe_sentinel_${randomBytes(12).toString("hex")}`;
+}
+/**
+* The upstream's "this effort value is not supported" code, measured
+* 2026-09-11 (plan §4.2). It is *not* treated as a permanent protocol promise:
+* anything unrecognized degrades to `unknown` rather than to a capability
+* conclusion.
+*/
+const INVALID_EFFORT_CODE = "invalid_reasoning_effort";
+/** Whether an attempt is an attributable rejection of the effort value. */
+function isEffortRejection(attempt) {
+	return attempt.status === 400 && attempt.errorCode === INVALID_EFFORT_CODE;
+}
+/** Whether an attempt shows the upstream accepted the request and streamed. */
+function isAcceptance(attempt) {
+	return attempt.status === 200 && attempt.streamed;
+}
+/** Why an attempt ended in `unknown`, phrased for a log line. */
+function unknownReason(stage, attempt) {
+	const code = attempt.errorCode === void 0 ? "" : ` (${attempt.errorCode})`;
+	const detail = attempt.detail === void 0 ? "" : `: ${attempt.detail}`;
+	return `${stage} status ${attempt.status}${code}${detail}`;
+}
+/**
+* Probe one model.
+*
+* `options.candidates` exists so tests can shorten the sweep; production always
+* uses {@link PROBE_EFFORT_CANDIDATES}.
+*/
+async function probeModel(options) {
+	const sentinel = options.sentinel ?? randomSentinel;
+	const candidates = options.candidates ?? PROBE_EFFORT_CANDIDATES;
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	let requests = 0;
+	const attempt = async (effort) => {
+		requests += 1;
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			return await options.send(effort, controller.signal);
+		} catch (error) {
+			return {
+				status: 0,
+				streamed: false,
+				detail: `transport error: ${String(error)}`
+			};
+		} finally {
+			clearTimeout(timer);
+		}
+	};
+	const baseline = await attempt(void 0);
+	if (!isAcceptance(baseline)) return {
+		validation: "unknown",
+		efforts: [],
+		requests,
+		reason: unknownReason("baseline", baseline)
+	};
+	const sentinelAttempt = await attempt(sentinel());
+	if (isAcceptance(sentinelAttempt)) return {
+		validation: "non-validating",
+		efforts: [],
+		requests
+	};
+	if (!isEffortRejection(sentinelAttempt)) return {
+		validation: "unknown",
+		efforts: [],
+		requests,
+		reason: unknownReason("sentinel", sentinelAttempt)
+	};
+	const accepted = [];
+	for (const effort of candidates) {
+		const levelAttempt = await attempt(effort);
+		if (isAcceptance(levelAttempt)) {
+			accepted.push(effort);
+			continue;
+		}
+		if (isEffortRejection(levelAttempt)) continue;
+		return {
+			validation: "unknown",
+			efforts: [],
+			requests,
+			reason: unknownReason(`level ${effort}`, levelAttempt)
+		};
+	}
+	return {
+		validation: "validating",
+		efforts: accepted,
+		requests
+	};
+}
+//#endregion
 //#region src/upstream.ts
 const CN_CHAT_BASE = "https://copilot.tencent.com";
 const CN_BILLING_BASE = "https://www.codebuddy.cn";
@@ -1049,10 +1181,107 @@ var WorkBuddyUpstreamClient = class {
 			accounts
 		};
 	}
+	/**
+	* One probe request: a real streaming chat call carrying the effort under
+	* test.
+	*
+	* Shares `chatHeaders` with the normal chat path on purpose — the plan
+	* forbids probing through anything but the plugin's own credential handling,
+	* so a result describes what a real message would experience.
+	*
+	* The caller aborts as soon as a parseable event arrives; the body is never
+	* assembled into an answer. `reasoning_effort` is omitted entirely (rather
+	* than sent empty) when `effort` is undefined, so the baseline case is a
+	* genuinely bare request.
+	*/
+	async probeEffort(credential, model, effort, signal) {
+		const payload = {
+			model,
+			stream: true,
+			messages: [{
+				role: "user",
+				content: PROBE_PROMPT
+			}],
+			max_tokens: 1
+		};
+		if (effort !== void 0) payload["reasoning_effort"] = effort;
+		let response;
+		try {
+			response = await fetch(`${chatBase(credential)}/v2/chat/completions`, {
+				method: "POST",
+				headers: {
+					...chatHeaders(credential),
+					"Authorization": `Bearer ${credential.accessToken}`
+				},
+				body: JSON.stringify(payload),
+				signal
+			});
+		} catch (error) {
+			return {
+				status: 0,
+				streamed: false,
+				detail: `transport error: ${String(error)}`
+			};
+		}
+		if (!response.ok) {
+			const text = (await response.text()).slice(0, ERROR_BODY_LIMIT);
+			return {
+				status: response.status,
+				streamed: false,
+				...errorCodeOf(text)
+			};
+		}
+		const streamed = await readFirstEvent(response);
+		return {
+			status: response.status,
+			streamed
+		};
+	}
 };
+/** Pull `extError.code` out of an upstream error body, if it is shaped that way. */
+function errorCodeOf(text) {
+	try {
+		const parsed = JSON.parse(text);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+			const extError = parsed["extError"];
+			if (typeof extError === "object" && extError !== null && !Array.isArray(extError)) {
+				const code = extError["code"];
+				if (typeof code === "string") return {
+					errorCode: code,
+					detail: code
+				};
+			}
+		}
+	} catch {}
+	return { detail: text.slice(0, 200) };
+}
+/**
+* Consume just enough of a streaming response to know it really streams.
+*
+* Returns true on the first chunk containing a data line. Cancels the body
+* afterwards; a stream that ends or errors before that counts as not streamed,
+* because an empty 200 is not evidence the effort was accepted.
+*/
+async function readFirstEvent(response) {
+	const body = response.body;
+	if (body === null) return false;
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) return false;
+			if (decoder.decode(value, { stream: true }).includes("data:")) return true;
+		}
+	} catch {
+		return false;
+	} finally {
+		await reader.cancel().catch(() => {});
+	}
+}
 //#endregion
 //#region src/version.ts
-const WORKBUDDY_CONNECT_VERSION = "0.3.2";
+const WORKBUDDY_CONNECT_VERSION = "0.4.0";
 //#endregion
 //#region src/host-heartbeat.ts
 /**
@@ -1195,4 +1424,4 @@ function isHeartbeatProcessAlive(heartbeat) {
 	return startAtMs <= heartbeat.registeredAt;
 }
 //#endregion
-export { workbuddyOwnAuthPath as S, WORKBUDDY_AUTH_FILE_ENV as _, readHostHeartbeat as a, defaultDesktopAuthPath as b, WORKBUDDY_CONNECT_VERSION as c, normalizeCredits as d, prepareChatBody as f, WORKBUDDY_AUTH_FILENAME as g, WorkBuddyCatalog as h, processStartTimeMs as i, WorkBuddyUpstreamClient as l, FALLBACK_WORKBUDDY_MODELS as m, clearHostHeartbeat as n, workbuddyHostHeartbeatPath as o, regionOf as p, isHeartbeatProcessAlive as r, writeHostHeartbeat as s, WORKBUDDY_HOST_HEARTBEAT_FILENAME as t, classifyUpstreamError as u, WorkBuddyCredentialStore as v, parseWorkBuddyAuth as x, defaultDesktopAuthCandidates as y };
+export { defaultDesktopAuthPath as C, defaultDesktopAuthCandidates as S, workbuddyOwnAuthPath as T, FALLBACK_WORKBUDDY_MODELS as _, readHostHeartbeat as a, WORKBUDDY_AUTH_FILE_ENV as b, WORKBUDDY_CONNECT_VERSION as c, normalizeCredits as d, prepareChatBody as f, randomSentinel as g, probeModel as h, processStartTimeMs as i, WorkBuddyUpstreamClient as l, PROBE_EFFORT_CANDIDATES as m, clearHostHeartbeat as n, workbuddyHostHeartbeatPath as o, regionOf as p, isHeartbeatProcessAlive as r, writeHostHeartbeat as s, WORKBUDDY_HOST_HEARTBEAT_FILENAME as t, classifyUpstreamError as u, WorkBuddyCatalog as v, parseWorkBuddyAuth as w, WorkBuddyCredentialStore as x, WORKBUDDY_AUTH_FILENAME as y };

package/lib/index.d.ts

@@ -1,8 +1,66 @@
 import z from "@deepseek-ai/schemastery";
+import "@earendil-works/pi-ai";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
 import { Context } from "@deepseek-ai/cordis";
 import { SettingsNamespace } from "@deepseek-ai/dsh-settings";
 import { AttachmentStore } from "@deepseek-ai/dsh-attachment";
+//#region src/probe.d.ts
+/**
+ * The canonical values a probe tests, in a fixed order.
+ *
+ * `minimal` is absent: it appears in no upstream vocabulary. `off` is absent
+ * by policy — disabling thinking is a separate capability the upstream must
+ * declare through `canDisableThinking`, never something probing may infer.
+ */
+declare const PROBE_EFFORT_CANDIDATES: readonly WorkBuddyEffort[];
+/** Sentinel generator; injectable so tests get deterministic values. */
+type SentinelFactory = () => string;
+/** Default sentinel: unmistakably non-canonical, different on every call. */
+declare function randomSentinel(): string;
+/**
+ * One response as the probe sees it, split into the only distinctions the
+ * attribution rule needs.
+ */
+interface ProbeAttempt {
+  /** HTTP status, or 0 for a transport failure. */
+  status: number;
+  /** True when a parseable SSE event arrived. */
+  streamed: boolean;
+  /** `extError.code` from a JSON error body, when present. */
+  errorCode?: string;
+  /** Free-form detail for logs; never shown as a capability claim. */
+  detail?: string;
+}
+/** How one attempt is performed; the caller owns credentials and HTTP. */
+type ProbeSender = (effort: string | undefined, signal: AbortSignal) => Promise<ProbeAttempt>;
+/** The outcome of probing one model. */
+type ProbeOutcome = {
+  validation: 'validating';
+  efforts: readonly WorkBuddyEffort[];
+  requests: number;
+} | {
+  validation: 'non-validating';
+  efforts: readonly [];
+  requests: number;
+} | {
+  validation: 'unknown';
+  efforts: readonly [];
+  requests: number;
+  reason: string;
+};
+/**
+ * Probe one model.
+ *
+ * `options.candidates` exists so tests can shorten the sweep; production always
+ * uses {@link PROBE_EFFORT_CANDIDATES}.
+ */
+declare function probeModel(options: {
+  send: ProbeSender;
+  sentinel?: SentinelFactory;
+  candidates?: readonly WorkBuddyEffort[];
+  timeoutMs?: number;
+}): Promise<ProbeOutcome>;
+//#endregion
 //#region src/upstream.d.ts
 /** WorkBuddy region selected by the credential's login domain. */
 type WorkBuddyRegion = 'cn' | 'global';
@@ -137,6 +195,20 @@ declare class WorkBuddyUpstreamClient {
   fetchModels(credential: WorkBuddyCredential): Promise<readonly WorkBuddyUpstreamModel[]>;
   /** POST the billing endpoint for the aggregated remaining credit. */
   fetchCredits(credential: WorkBuddyCredential): Promise<WorkBuddyCredits>;
+  /**
+   * One probe request: a real streaming chat call carrying the effort under
+   * test.
+   *
+   * Shares `chatHeaders` with the normal chat path on purpose — the plan
+   * forbids probing through anything but the plugin's own credential handling,
+   * so a result describes what a real message would experience.
+   *
+   * The caller aborts as soon as a parseable event arrives; the body is never
+   * assembled into an answer. `reasoning_effort` is omitted entirely (rather
+   * than sent empty) when `effort` is undefined, so the baseline case is a
+   * genuinely bare request.
+   */
+  probeEffort(credential: WorkBuddyCredential, model: string, effort: string | undefined, signal: AbortSignal): Promise<ProbeAttempt>;
 }
 //#endregion
 //#region src/auth.d.ts
@@ -277,6 +349,93 @@ declare class WorkBuddyCatalog {
   set(models: readonly WorkBuddyModelInfo[]): void;
 }
 //#endregion
+//#region src/probe-store.d.ts
+/** Basename of the probe record inside the Harness home. */
+declare const WORKBUDDY_PROBE_FILENAME = ".workbuddy-probe.json";
+/**
+ * Whether the model's effort parameter is actually validated.
+ *
+ * - `validating`: the upstream rejected an unknown sentinel value, so a
+ *   per-level answer is meaningful.
+ * - `non-validating`: the upstream accepted the sentinel, so it ignores or
+ *   loosely coerces the parameter and no per-level answer can be trusted.
+ * - `unknown`: baseline or sentinel failed for an unrelated reason (auth,
+ *   rate limit, transport, ambiguous error body). Not a negative claim.
+ */
+type WorkBuddyProbeValidation = 'validating' | 'non-validating' | 'unknown';
+/** One model's recorded observation. */
+interface WorkBuddyProbeRecord {
+  /** Fingerprint of the catalog row this observation was made against. */
+  fingerprint: string;
+  validation: WorkBuddyProbeValidation;
+  /** Efforts verified as accepted; only ever non-empty for `validating`. */
+  efforts: readonly WorkBuddyEffort[];
+  /** When the probe ran, epoch milliseconds. */
+  probedAtMs: number;
+  /** Plugin version that produced the record. */
+  pluginVersion: string;
+}
+/** Plugin-owned probe record path inside the Harness home. */
+declare function workbuddyProbePath(): string;
+/**
+ * Fingerprint the catalog fields a probe depends on.
+ *
+ * Deliberately excludes display-only fields (`name`, `billing`, `contextWindow`)
+ * so a rename or a promo badge does not throw away a valid observation, and
+ * deliberately includes the whole reasoning object so any change to the
+ * declared shape re-probes.
+ */
+declare function fingerprintModel(info: WorkBuddyModelInfo): string;
+/** Options for {@link WorkBuddyProbeStore}. */
+interface WorkBuddyProbeStoreOptions {
+  /** Explicit state-file path, overriding the `$DSH_HOME` default. */
+  path?: string;
+  /** Observation lifetime; defaults to 14 days. */
+  ttlMs?: number;
+  /** Plugin version stamped into new records. */
+  pluginVersion: string;
+  /** Clock injection for tests. */
+  now?: () => number;
+}
+/**
+ * The plugin's probe records: read once, written atomically, never trusted
+ * across a fingerprint change or past the TTL.
+ */
+declare class WorkBuddyProbeStore {
+  private readonly path;
+  private readonly ttlMs;
+  private readonly pluginVersion;
+  private readonly now;
+  private records;
+  constructor(options: WorkBuddyProbeStoreOptions | string);
+  /** Resolved state-file path, for the CLI and tests. */
+  filePath(): string;
+  private load;
+  /**
+   * The usable record for a model, or `undefined` when there is none, it is
+   * expired, or it was taken against a different catalog row.
+   */
+  get(modelId: string, fingerprint: string): WorkBuddyProbeRecord | undefined;
+  /**
+   * Store one observation. Only a decisive answer (`validating` /
+   * `non-validating`) replaces an existing decisive record: a transient
+   * `unknown` must not erase knowledge the user already paid for.
+   */
+  set(modelId: string, record: WorkBuddyProbeRecord): void;
+  /** Drop every record; used by the card's explicit "clear" action. */
+  clear(): void;
+  /** Every record currently held, for status display. */
+  all(): Readonly<Record<string, WorkBuddyProbeRecord>>;
+  /** Build a record stamped with this store's clock and version. */
+  record(fingerprint: string, validation: WorkBuddyProbeValidation, efforts: readonly WorkBuddyEffort[]): WorkBuddyProbeRecord;
+  /**
+   * Write through a temporary file and rename, so a crash mid-write cannot
+   * leave a half-parsed document that reads as "no records" and silently drops
+   * every observation.
+   */
+  private persist;
+}
+//#endregion
 //#region src/shim.d.ts
 /** Minimal logger surface the plugin context already provides. */
 interface ShimLogger {
@@ -324,6 +483,11 @@ interface WorkBuddyAdapterOptions {
   catalog: WorkBuddyCatalog;
   /** Resolve the durable attachment service at request time, when present. */
   resolveAttachments?: () => AttachmentStore | undefined;
+  /**
+   * Look up a local probe observation for a model. Consulted only for rows the
+   * upstream left undeclared; absent means declared-set-only behavior.
+   */
+  observe?: (modelId: string) => WorkBuddyProbeRecord | undefined;
 }
 /** What {@link createWorkBuddyAdapter} hands back. */
 interface WorkBuddyAdapter {
@@ -345,6 +509,59 @@ interface WorkBuddyAdapter {
  */
 declare function createWorkBuddyAdapter(options: WorkBuddyAdapterOptions): WorkBuddyAdapter;
 //#endregion
+//#region src/probe-service.d.ts
+/** What the caller learns about a completed probe. */
+type WorkBuddyProbeStatus = {
+  state: 'ok';
+  validation: WorkBuddyProbeRecord['validation'];
+  efforts: readonly string[];
+  requests: number;
+} | {
+  state: 'unavailable';
+  reason: string;
+};
+/** Options for {@link WorkBuddyProbeService}. */
+interface WorkBuddyProbeServiceOptions {
+  store: WorkBuddyProbeStore;
+  catalog: WorkBuddyCatalog;
+  credentials: WorkBuddyCredentialStore;
+  client: WorkBuddyUpstreamClient;
+  /** Whether probing is permitted at all; consulted before every sweep. */
+  consent: () => boolean;
+  sentinel?: SentinelFactory;
+  /** Injectable for tests; defaults to the live upstream sender. */
+  send?: (modelId: string) => ProbeSender;
+}
+/**
+ * Serial probe runner. One instance is shared by the manual API and any
+ * future automatic trigger, so the two can never overlap.
+ */
+declare class WorkBuddyProbeService {
+  private readonly options;
+  private queue;
+  private readonly pending;
+  private running;
+  constructor(options: WorkBuddyProbeServiceOptions);
+  /** Whether a sweep is in flight right now. */
+  isRunning(): boolean;
+  /**
+   * The record the adapter may use for this model, or `undefined`.
+   *
+   * Applies the plan's precedence (§5): a declared set always wins, so a model
+   * that declares `supportedEfforts` is never answered from an observation.
+   */
+  recordFor(modelId: string): WorkBuddyProbeRecord | undefined;
+  /**
+   * Probe one model, serially.
+   *
+   * The authenticated manual route supplies one-request consent after UI
+   * confirmation. Other callers must pass the configured consent gate.
+   * Manual consent never changes the automatic-probing configuration.
+   * Explicit requests bypass historical results, but share an ongoing run.
+   */
+  probe(modelId: string, manualConsent?: boolean): Promise<WorkBuddyProbeStatus>;
+}
+//#endregion
 //#region src/host-heartbeat.d.ts
 /**
  * Host-side heartbeat: a small JSON file written under `$DSH_HOME` once the
@@ -432,6 +649,12 @@ declare const WORKBUDDY_SETTINGS_NS: SettingsNamespace;
 interface Config {
   /** Explicit WorkBuddy desktop auth-file path, overriding env and platform defaults. */
   authFile?: string;
+  /**
+   * Whether the user has authorized sending probe requests about reasoning
+   * efforts. Off by default: a probe spends real credit, so nothing is sent
+   * until the user explicitly agrees.
+   */
+  probeConsent?: boolean;
 }
 declare const Config: z<Config>;
 /**
@@ -442,4 +665,4 @@ declare const Config: z<Config>;
  */
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { Config, FALLBACK_WORKBUDDY_MODELS, type UpstreamErrorKind, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_PROVIDER, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, type WorkBuddyAdapter, type WorkBuddyAuthStatus, WorkBuddyCatalog, type WorkBuddyChatResult, type WorkBuddyCredential, WorkBuddyCredentialStore, type WorkBuddyCredits, type WorkBuddyEffort, type WorkBuddyHostHeartbeat, type WorkBuddyModelBilling, type WorkBuddyModelInfo, type WorkBuddyModelReasoning, type WorkBuddyRefreshOutcome, type WorkBuddyShim, WorkBuddyUpstreamClient, type WorkBuddyUpstreamModel, apply, classifyUpstreamError, clearHostHeartbeat, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthPath, inject, isHeartbeatProcessAlive, name, normalizeCredits, parseWorkBuddyAuth, prepareChatBody, processStartTimeMs, readHostHeartbeat, regionOf, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath };
+export { Config, FALLBACK_WORKBUDDY_MODELS, PROBE_EFFORT_CANDIDATES, type ProbeAttempt, type ProbeOutcome, type ProbeSender, type UpstreamErrorKind, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_PROBE_FILENAME, WORKBUDDY_PROVIDER, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, type WorkBuddyAdapter, type WorkBuddyAuthStatus, WorkBuddyCatalog, type WorkBuddyChatResult, type WorkBuddyCredential, WorkBuddyCredentialStore, type WorkBuddyCredits, type WorkBuddyEffort, type WorkBuddyHostHeartbeat, type WorkBuddyModelBilling, type WorkBuddyModelInfo, type WorkBuddyModelReasoning, type WorkBuddyProbeRecord, WorkBuddyProbeService, type WorkBuddyProbeStatus, WorkBuddyProbeStore, type WorkBuddyProbeValidation, type WorkBuddyRefreshOutcome, type WorkBuddyShim, WorkBuddyUpstreamClient, type WorkBuddyUpstreamModel, apply, classifyUpstreamError, clearHostHeartbeat, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthPath, fingerprintModel, inject, isHeartbeatProcessAlive, name, normalizeCredits, parseWorkBuddyAuth, prepareChatBody, probeModel, processStartTimeMs, randomSentinel, readHostHeartbeat, regionOf, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, workbuddyProbePath };