bareloop 0.40.0 → 0.42.0

package/types/thinking.d.ts

@@ -0,0 +1,90 @@
+/**
+ * What bare-agent knows about switching this model's thinking. A missing kind, a non-function `impl`, or a throw all read
+ * `'unverified'` — never a guess in either direction.
+ * @param {string} shape an API shape id (src/providershapes.js)
+ * @param {string} model
+ * @param {{ baseUrl?: string|null, impl?: Function }} [o] `impl` is a test seam; production uses bare-agent's own
+ * @returns {true|false|'unverified'}
+ */
+export function thinkingSupport(shape: string, model: string, { baseUrl, impl }?: {
+    baseUrl?: string | null;
+    impl?: Function;
+}): true | false | "unverified";
+/**
+ * The per-call options for one support answer and one tick (`true` = "Thinking on"). The table (PANEL-BUILD.md P8, ruling Q1):
+ *   tick on : true -> on | false -> {} (the box is greyed, cannot be on) | 'unverified' -> on
+ *   tick off: true -> off | false -> {} (the model thinks as it would) | 'unverified' -> off (bare-agent decides; plain request on failure)
+ * @param {true|false|'unverified'} support
+ * @param {boolean} tick
+ * @returns {{ thinkingMode: 'on'|'off' } | {}}
+ */
+export function thinkingOptions(support: true | false | "unverified", tick: boolean): {
+    thinkingMode: "on" | "off";
+} | {};
+/**
+ * Throw unless `mode` is one of {@link THINKING_MODES} — an operator-param guard, so a typo never silently means a mode.
+ * @param {unknown} mode
+ * @returns {'on'|'off'}
+ */
+export function assertThinkingMode(mode: unknown): "on" | "off";
+/**
+ * The API shape of a constructed bare-agent provider (the three client classes only); `null` for a test double or a clipipe.
+ * @param {any} provider
+ * @returns {string|null}
+ */
+export function shapeOfProvider(provider: any): string | null;
+/**
+ * The per-call options every DRAFTING and JUDGING model call on this provider instance carries for this mode. A provider that is
+ * not one of the three client classes (a test double, a clipipe) is never sent the switch.
+ * @param {any} provider a constructed bare-agent provider
+ * @param {unknown} [mode] 'on' | 'off' (default 'off')
+ * @returns {{ thinkingMode: 'on'|'off' } | {}}
+ */
+export function thinkingCallOptions(provider: any, mode?: unknown): {
+    thinkingMode: "on" | "off";
+} | {};
+/**
+ * What the drafting calls will carry for a model the caller has only NAMED (shape, model id, Base URL) — no key, no network. The
+ * first drafting row is shown from this, before the key is read.
+ * @param {{providerName: string, model: string, baseUrl?: string|null}} o
+ * @param {unknown} [mode] 'on' | 'off'
+ * @returns {{ support: true|false|'unverified', mode: 'on'|'off', options: {thinkingMode?: 'on'|'off'} }}
+ */
+export function thinkingPlanFor({ providerName, model, baseUrl }: {
+    providerName: string;
+    model: string;
+    baseUrl?: string | null;
+}, mode?: unknown): {
+    support: true | false | "unverified";
+    mode: "on" | "off";
+    options: {
+        thinkingMode?: "on" | "off";
+    };
+};
+/**
+ * The server's answer for one Model-menu line: whether the "Thinking on" box can change and the words under it. `false` greys and
+ * unticks the box (the note reads {@link THINKING_FIXED_SAY}); `'unverified'` leaves it enabled with no note.
+ * @param {string} shape @param {string} model @param {string|null|undefined} baseUrl
+ * @returns {{ support: true|false|'unverified', canChange: boolean, say: string }}
+ */
+export function thinkingForLine(shape: string, model: string, baseUrl: string | null | undefined): {
+    support: true | false | "unverified";
+    canChange: boolean;
+    say: string;
+};
+/**
+ * The first drafting row's words — code-owned, ALWAYS starting "thinking on" or "thinking off". `status` is bare-agent's own
+ * `thinkingStatus` for a call that has run ('applied' | 'unsupported' | 'ignored' | 'unknown'); undefined = before any call, read from
+ * the plan (`support`, `mode`).
+ * @param {{ mode: 'on'|'off', support?: true|false|'unverified', status?: string }} s
+ * @returns {string}
+ */
+export function thinkingRowText({ mode, support, status }: {
+    mode: "on" | "off";
+    support?: true | false | "unverified";
+    status?: string;
+}): string;
+/** The words under a greyed "Thinking on" box (the server's `thinking.canChange` decides; the page decides nothing). */
+export const THINKING_FIXED_SAY: "can't change this for this model";
+/** The enumerated operator knob a drafting call is built with: 'on' | 'off' (the tick, spelled as a word). */
+export const THINKING_MODES: readonly string[];

package/types/userrun.d.ts

@@ -61,6 +61,17 @@ export type Deps = {
      */
     provider?: any;
     providerFor?: ((tier: string) => any) | undefined;
+    /**
+     * PART 1c - a test seam: how a web input is read at run start (production: barebrowse)
+     */
+    fetchUrl?: ((url: string) => Promise<{
+        ok: true;
+        text: string;
+        url: string;
+    } | {
+        ok: false;
+        error: string;
+    }>) | undefined;
     judgeProvider?: any;
     /**
      * F196 — a test seam for `appendRun`'s
@@ -136,9 +147,13 @@ export type RunOpts = {
      */
     into?: string | undefined;
     /**
-     * the raw `--model` tier name (`sonnet`/`haiku`), or null for the default
+     * the raw `--model <id>` (a model id of a ticked Settings line), or null
      */
     model?: string | null | undefined;
+    /**
+     * the raw `--provider <KEY>` (a key's env name), or null
+     */
+    providerKey?: string | null | undefined;
     /**
      * the raw `--read-shim` arm name, or null for the default
      */
@@ -205,6 +220,7 @@ export type RunCtx = {
      */
     into?: string | undefined;
     model: string | null;
+    providerKey: string | null;
     readShim: string | null;
     scout: string | null;
     draftSpentUsd: string | null;