@stigmer/runner 3.38.2 → 3.38.3

package/src/shared/model-registry.ts

@@ -7,7 +7,8 @@
  * model-pricing-data.ts) and uses `costTier` + `harness` fields to
  * dynamically resolve economy-tier models for extraction/summarization,
  * plus `capabilities` catalog metadata for per-model capability lookups
- * (getModelVisionCapability).
+ * (getModelVisionCapability) and the request facts a native row states
+ * (getNativeRequestProfile).
  */
 
 import {
@@ -38,6 +39,46 @@ interface RegistryModel {
    * Consumers gate only on the explicit `false` (see attachment-vision.ts).
    */
   visionCapability?: boolean;
+  /**
+   * The model's output ceiling in tokens, as the row states it. `undefined`
+   * when the row carries none or a value that is not a positive integer;
+   * the caller then keeps its own default.
+   */
+  maxOutputTokens?: number;
+  /** The thinking form the row declares; see {@link NativeThinkingProfile}. */
+  thinking: NativeThinkingProfile;
+}
+
+/**
+ * How a model reasons, as its registry row declares it (the proto's
+ * `ModelCapabilities`):
+ *
+ * - `shape` is `"adaptive"` when the row declares `adaptiveThinking` (depth
+ *   adapts; Anthropic `{type: "adaptive"}`), `"budget"` when it declares only
+ *   `thinking` (a fixed token budget; `{type: "enabled", budget_tokens}`),
+ *   and `"none"` otherwise. Adaptive wins where a row declares both: it is
+ *   the current form, and the budget form is deprecated on models that take
+ *   both.
+ * - `required` is the row's `thinkingRequired`, tri-state: `true` for a
+ *   model that always thinks and refuses to be told not to, `false` for one
+ *   that accepts an explicit `{type: "disabled"}`, `undefined` for a row that
+ *   was never assessed. The absence matters: a runner that read it as
+ *   `false` would send `disabled` to a model that refuses it.
+ */
+export interface NativeThinkingProfile {
+  readonly shape: "budget" | "adaptive" | "none";
+  readonly required: boolean | undefined;
+}
+
+/**
+ * The request facts a native-harness model's registry row states, read by
+ * the native execution turn when it builds its model client. One home for
+ * what the provider needs to be told about a model (the runner never names
+ * models in code); a field is `undefined` when the row does not state it.
+ */
+export interface NativeRequestProfile {
+  readonly maxOutputTokens: number | undefined;
+  readonly thinking: NativeThinkingProfile;
 }
 
 let cache: { models: readonly RegistryModel[]; expiresAt: number } | null = null;
@@ -58,9 +99,28 @@ function parseRegistry(json: unknown): RegistryModel[] {
       harness: (m.harness as string) ?? "native",
       featured: !!m.featured,
       visionCapability: parseVisionCapability(m.capabilities),
+      maxOutputTokens: parsePositiveInteger(m.maxOutputTokens),
+      thinking: parseThinkingProfile(m.capabilities),
     }));
 }
 
+function parsePositiveInteger(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+
+/**
+ * The row's thinking form. A missing or malformed `capabilities` block
+ * declares no shape and leaves `required` unknown, the same tri-state
+ * posture as {@link parseVisionCapability}.
+ */
+function parseThinkingProfile(capabilities: unknown): NativeThinkingProfile {
+  if (!capabilities || typeof capabilities !== "object") return { shape: "none", required: undefined };
+  const flags = capabilities as Record<string, unknown>;
+  const shape = flags.adaptiveThinking === true ? "adaptive" : flags.thinking === true ? "budget" : "none";
+  const required = typeof flags.thinkingRequired === "boolean" ? flags.thinkingRequired : undefined;
+  return { shape, required };
+}
+
 /**
  * Extract `capabilities.vision` preserving the tri-state: a missing or
  * malformed `capabilities` block stays `undefined` (never coerced to false).
@@ -264,6 +324,28 @@ export async function getModelVisionCapability(
   return entry?.visionCapability;
 }
 
+/**
+ * The native-harness row's request facts for a model, matched by registry
+ * `id` or `apiModelId` (the execution config carries the former, the
+ * registry default the latter) and filtered to `harness: native`: ids such
+ * as `claude-sonnet-5` exist on both harnesses, and only the native row
+ * describes the native request. `undefined` when the registry is
+ * unreachable, the name is empty or Auto, or no native row matches — the
+ * caller then sends what it sent before.
+ */
+export async function getNativeRequestProfile(
+  modelName: string,
+): Promise<NativeRequestProfile | undefined> {
+  if (!modelName || modelName === "default") return undefined;
+
+  const registry = await getRegistry();
+  const entry = registry.find(
+    (m) => m.harness === "native" && (m.id === modelName || m.apiModelId === modelName),
+  );
+  if (!entry) return undefined;
+  return { maxOutputTokens: entry.maxOutputTokens, thinking: entry.thinking };
+}
+
 /** Exposed for testing — resets the in-memory cache. */
 export function _resetRegistryCache(): void {
   cache = null;

package/src/shared/thinking-mode.ts

@@ -16,14 +16,26 @@
  * rather than pricing-gated, and the estimate/billing paths need no
  * thinking-specific rates.
  *
- * v1 translates thinking on the Cursor harness only (the explicit
- * `thinking` variant parameter, `execute-cursor/service-tier.ts`). No
- * native wire mapping exists yet — create-time validation refuses ENABLED
- * for native-harness models, mirroring the tier's #361 posture.
+ * Each harness translates the mode in its own dialect: the Cursor harness
+ * as the explicit `thinking` variant parameter
+ * (`execute-cursor/service-tier.ts`), the native harness as Anthropic's
+ * `thinking` request parameter in the form the model's native registry row
+ * declares ({@link toAnthropicThinking}). ENABLED means "the model reasons
+ * before it answers", whichever form the row takes.
+ *
+ * One model family breaks the "always explicit" rule on purpose: a row
+ * that states `thinkingRequired` names a model that always thinks and
+ * refuses `{type: "disabled"}` with a 400. Create-time validation refuses
+ * an explicit DISABLED there, and the runner sends the model's thinking
+ * form whatever the mode, so its reasoning streams as text rather than the
+ * empty blocks the model's own `display` default produces.
  */
 
+import type { ThinkingConfigParam } from "@anthropic-ai/sdk/resources/messages";
 import { ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
+import type { NativeThinkingProfile } from "./model-registry.js";
+
 /**
  * The effective mode after platform-default resolution: never UNSPECIFIED.
  */
@@ -50,3 +62,64 @@ export function thinkingModeLabel(mode: ThinkingMode): string {
       return "unspecified";
   }
 }
+
+/**
+ * The thinking budget sent to a model whose row declares the fixed-budget
+ * form. One platform constant, not a user choice (per-execution budgets are
+ * a later proto change): 16,000 tokens is room for a real plan while
+ * leaving every budget row's output ceiling (64,000 on the smallest) most
+ * of its length for the answer. The provider requires at least 1,024 and
+ * less than `max_tokens`. No interleaved-thinking beta rides with it: the
+ * hosted proxy forwards no `anthropic-beta` header, so these models think
+ * at the start of each model call, not between tool calls.
+ */
+export const BUDGET_THINKING_TOKENS = 16_000;
+
+/**
+ * The native request's `thinking` parameter for an execution's effective
+ * mode on a model's native row, or `undefined` to send none.
+ *
+ * - A row that requires thinking gets its thinking form whatever the mode;
+ *   the model thinks either way, and `display: "summarized"` is what makes
+ *   its reasoning readable (the newest models default to `"omitted"`).
+ * - ENABLED gets the row's form: adaptive with `display: "summarized"`, or
+ *   the fixed budget. A row that declares no form gets nothing; create-time
+ *   validation refuses ENABLED there, so this is the fail-safe.
+ * - DISABLED gets an explicit `{type: "disabled"}` only where the row
+ *   declares a thinking form and states `thinkingRequired: false`. Where the
+ *   flag was never assessed nothing is sent (the request as it was before),
+ *   because sending `disabled` to a model that requires thinking fails every
+ *   turn; a row with no thinking form has no parameter to pin.
+ * - No row (an unreachable registry, an unknown model) sends nothing.
+ */
+export function toAnthropicThinking(
+  mode: EffectiveThinkingMode,
+  profile: NativeThinkingProfile | undefined,
+): ThinkingConfigParam | undefined {
+  if (profile === undefined) return undefined;
+  if (profile.required === true || mode === ThinkingMode.ENABLED) {
+    switch (profile.shape) {
+      case "adaptive":
+        return { type: "adaptive", display: "summarized" };
+      case "budget":
+        return { type: "enabled", budget_tokens: BUDGET_THINKING_TOKENS };
+      case "none":
+        return undefined;
+    }
+  }
+  return profile.required === false && profile.shape !== "none" ? { type: "disabled" } : undefined;
+}
+
+/**
+ * Whether a graph built on this row reasons natively: true exactly when
+ * {@link toAnthropicThinking} asks for thinking. Derived from the same
+ * mapping, never decided separately, so the `think` tool and the structured
+ * output strategy can never disagree with the wire.
+ */
+export function graphThinks(
+  mode: EffectiveThinkingMode,
+  profile: NativeThinkingProfile | undefined,
+): boolean {
+  const thinking = toAnthropicThinking(mode, profile);
+  return thinking !== undefined && thinking.type !== "disabled";
+}