dsh-model 0.0.1 → 0.15.0

package/dist/bridge/workbuddy/loopback.js

@@ -0,0 +1,52 @@
+// Ported from dsh-workbuddy-connect v0.7.1 (commit 390582e04da4e8e8bf746d71997440e4b716ec47),
+// https://github.com/corrinehu/dsh-workbuddy-connect — MIT License, Copyright (c) 2026 Corrine Hu.
+// See LICENSE.dsh-workbuddy-connect in this directory. Changes: imports adapted to dsh-model (./_compat.js).
+/**
+ * Shared loopback gates for the plugin's local HTTP surfaces: the loopback
+ * shim and the same-origin web-status route. Both are only ever meant to be
+ * addressed through the machine's loopback interface.
+ *
+ * @module dsh-workbuddy-connect/loopback
+ */
+/** Loopback hostnames a local plugin surface may be addressed by. */
+export const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]']);
+/** Strip the optional :port from a Host header value, IPv6-bracket aware. */
+export function hostnameOfHost(host) {
+    let hostname = host.trim().toLowerCase();
+    if (hostname.startsWith('[')) {
+        const end = hostname.indexOf(']');
+        return end === -1 ? hostname : hostname.slice(0, end + 1);
+    }
+    // Only `name:port` with a single colon is a port; anything with more colons
+    // is an (unbracketed) IPv6 literal and must not be truncated.
+    const colon = hostname.lastIndexOf(':');
+    if (colon !== -1 && !hostname.slice(0, colon).includes(':') && /^\d+$/.test(hostname.slice(colon + 1))) {
+        hostname = hostname.slice(0, colon);
+    }
+    return hostname;
+}
+/**
+ * The request's Host header must name the loopback interface. A DNS-rebinding
+ * page (attacker domain re-resolved to 127.0.0.1) sends its own domain in
+ * Host, so this check drops those before any routing happens.
+ */
+export function hostIsLoopback(host) {
+    if (host === undefined || host.trim() === '')
+        return false;
+    return LOOPBACK_HOSTS.has(hostnameOfHost(host));
+}
+/**
+ * A browser-sent Origin (present header) must be loopback. Non-browser
+ * clients (the plugin's own fetch calls) send no Origin at all and pass.
+ */
+export function originIsLoopback(origin) {
+    if (origin === undefined || origin.trim() === '')
+        return true;
+    try {
+        const { hostname } = new URL(origin);
+        return LOOPBACK_HOSTS.has(hostname) || hostname === '::1';
+    }
+    catch {
+        return false;
+    }
+}

package/dist/bridge/workbuddy/probe.js

@@ -0,0 +1,153 @@
+// Ported from dsh-workbuddy-connect v0.7.1 (commit 390582e04da4e8e8bf746d71997440e4b716ec47),
+// https://github.com/corrinehu/dsh-workbuddy-connect — MIT License, Copyright (c) 2026 Corrine Hu.
+// See LICENSE.dsh-workbuddy-connect in this directory. Changes: imports adapted to dsh-model (./_compat.js).
+/**
+ * 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
+ */
+import { randomBytes } from 'node:crypto';
+/**
+ * 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.
+ */
+export const PROBE_EFFORT_CANDIDATES = ['low', 'medium', 'high', 'xhigh', 'max'];
+/** Prompt body used by every probe request; carries nothing user-specific. */
+export const PROBE_PROMPT = 'ping';
+/** Output ceiling for a probe request; the answer itself is never read. */
+export const PROBE_MAX_TOKENS = 1;
+/** Per-request ceiling so one hung probe cannot stall the queue. */
+export const PROBE_REQUEST_TIMEOUT_MS = 30_000;
+/** Default sentinel: unmistakably non-canonical, different on every call. */
+export function randomSentinel() {
+    return `probe_sentinel_${randomBytes(12).toString('hex')}`;
+}
+/**
+ * The upstream's "this effort value is not supported" codes, per region, as
+ * measured on each live endpoint. The sets are kept separate so a code only
+ * ever widens detection for the endpoint it was measured on.
+ *
+ * - `invalid_reasoning_effort` — the China endpoint, measured 2026-09-11
+ *   (plan §4.2). Also kept for `global` as a fallback spelling.
+ * - `model_param_invalid` — the global endpoint, measured 2026-10-01. A
+ *   non-canonical value is answered `400` / `11133` with this code, which names
+ *   no field (`extError.param` is empty), instead of one that names the effort.
+ *   It is generic enough to be readable here only because the baseline step has
+ *   already proved the *same* request without `reasoning_effort` succeeds,
+ *   leaving the sentinel as the only difference between the two attempts. A
+ *   sibling code in the same `11133` envelope that names another parameter
+ *   (`integer_below_min_value`, the `max_tokens` floor) and a body carrying no
+ *   `extError` at all (`11102`, unknown model) are therefore not mistaken for
+ *   it, and neither is a level-sweep answer. It is *not* added to `cn`: that
+ *   endpoint was measured answering the specific code, and reading a generic
+ *   code there would widen attribution beyond what was observed.
+ *
+ * Neither is treated as a permanent protocol promise: anything unrecognized
+ * still degrades to `unknown` rather than to a capability conclusion.
+ */
+const INVALID_EFFORT_CODES = {
+    cn: new Set(['invalid_reasoning_effort']),
+    global: new Set(['invalid_reasoning_effort', 'model_param_invalid']),
+};
+/** Whether an attempt is an attributable rejection of the effort value. */
+function isEffortRejection(attempt, region) {
+    const codes = INVALID_EFFORT_CODES[region];
+    return attempt.status === 400 && attempt.errorCode !== undefined && codes.has(attempt.errorCode);
+}
+/** 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 === undefined ? '' : ` (${attempt.errorCode})`;
+    const detail = attempt.detail === undefined ? '' : `: ${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}. `options.region` selects which
+ * endpoint's rejection vocabulary is read; it defaults to `cn`, which is also
+ * the production default for the China app.
+ */
+export async function probeModel(options) {
+    const sentinel = options.sentinel ?? randomSentinel;
+    const candidates = options.candidates ?? PROBE_EFFORT_CANDIDATES;
+    const timeoutMs = options.timeoutMs ?? PROBE_REQUEST_TIMEOUT_MS;
+    const region = options.region ?? 'cn';
+    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);
+        }
+    };
+    // 1. Baseline: proves the request path itself is sound. Without this a 400
+    //    on the sentinel could just as well be an unrelated request problem.
+    const baseline = await attempt(undefined);
+    if (!isAcceptance(baseline)) {
+        return { validation: 'unknown', efforts: [], requests, reason: unknownReason('baseline', baseline) };
+    }
+    // 2. Sentinel: the only step that can distinguish "validates the field" from
+    //    "accepts anything".
+    const probe = sentinel();
+    const sentinelAttempt = await attempt(probe);
+    if (isAcceptance(sentinelAttempt)) {
+        // The upstream took a value that cannot exist. Any per-level acceptance
+        // would be equally meaningless, so stop here rather than spend more
+        // requests producing false positives.
+        return { validation: 'non-validating', efforts: [], requests };
+    }
+    if (!isEffortRejection(sentinelAttempt, region)) {
+        return { validation: 'unknown', efforts: [], requests, reason: unknownReason('sentinel', sentinelAttempt) };
+    }
+    // 3. Levels: meaningful only because the sentinel was refused.
+    const accepted = [];
+    for (const effort of candidates) {
+        const levelAttempt = await attempt(effort);
+        if (isAcceptance(levelAttempt)) {
+            accepted.push(effort);
+            continue;
+        }
+        if (isEffortRejection(levelAttempt, region))
+            continue;
+        // A non-decisive answer mid-sweep: the partial list is not a finding, so
+        // report the whole run as unknown rather than under-claiming a model.
+        return {
+            validation: 'unknown',
+            efforts: [],
+            requests,
+            reason: unknownReason(`level ${effort}`, levelAttempt),
+        };
+    }
+    return { validation: 'validating', efforts: accepted, requests };
+}

package/dist/bridge/workbuddy/status-paths.js

@@ -0,0 +1,49 @@
+// Ported from dsh-workbuddy-connect v0.7.1 (commit 390582e04da4e8e8bf746d71997440e4b716ec47),
+// https://github.com/corrinehu/dsh-workbuddy-connect — MIT License, Copyright (c) 2026 Corrine Hu.
+// See LICENSE.dsh-workbuddy-connect in this directory. Changes: imports adapted to dsh-model (./_compat.js).
+/** Node-free constants and types shared by the Host and browser halves. */
+/** Plugin-owned status endpoint consumed by its browser half. */
+export const WORKBUDDY_STATUS_PATH = '/plugins/dsh-workbuddy-connect/status';
+/**
+ * Plugin-owned probe control endpoint.
+ *
+ * Separate from the status route because it accepts writes: the status route's
+ * loopback Host/Origin guard protects against a DNS-rebinding *page*, which is
+ * not the same as authorizing a state-changing action. This route therefore
+ * also requires the in-process key the browser half receives with the status
+ * document.
+ */
+export const WORKBUDDY_PROBE_PATH = '/plugins/dsh-workbuddy-connect/probe';
+/**
+ * The international (WorkBuddy AI) variant's own pair of routes.
+ *
+ * Kept as separate constants rather than a computed suffix so both halves
+ * reference literal strings: the browser bundle and the host bundle are built
+ * independently, and a shared expression is one build-config drift away from
+ * the desk asking a route the host never mounted.
+ */
+export const WORKBUDDY_AI_STATUS_PATH = '/plugins/dsh-workbuddy-connect/ai/status';
+export const WORKBUDDY_AI_PROBE_PATH = '/plugins/dsh-workbuddy-connect/ai/probe';
+/**
+ * Same-origin route backing the browser's update reminder.
+ *
+ * Read-only like the status route, so the same loopback Host/Origin gate
+ * applies; it answers public npm/GitHub metadata only and never token
+ * material.
+ */
+export const WORKBUDDY_UPDATE_PATH = '/plugins/dsh-workbuddy-connect/update';
+/** Every reason code, for validation without trusting a wire value. */
+const SIGNED_OUT_REASON_CODES = [
+    'no-credential',
+    'credential-region-mismatch',
+    'encrypted-credential-unreadable',
+    'electron-binary-not-found',
+    'electron-binary-ambiguous',
+    'electron-binary-unavailable',
+    'electron-path-invalid',
+    'electron-discovery-incomplete',
+];
+/** Whether a value is one of the closed set of signed-out reason codes. */
+export function isWorkBuddySignedOutReasonCode(value) {
+    return typeof value === 'string' && SIGNED_OUT_REASON_CODES.includes(value);
+}