@aliou/pi-neuralwatt 0.16.2 → 0.17.0

package/extensions/provider/api/anthropic-messages.ts

@@ -1,12 +1,12 @@
 import type { StreamOptions } from "@earendil-works/pi-ai";
 import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import { configuredApiBaseUrl } from "../../../src/config/loader";
 import {
-  NEURALWATT_BASE_URL,
   NEURALWATT_PROVIDER_ID,
   NEURALWATT_REQUEST_HEADERS,
 } from "../constants";
 import { buildAnthropicThinkingLevelMap } from "../models/build";
-import type { NeuralwattModel } from "../models/catalog";
+import type { NeuralwattChatModel } from "../models/catalog";
 import type { AnyStreamSimple } from "../stream-simple";
 import type { NeuralwattApiHandler } from "./types";
 
@@ -61,7 +61,7 @@ function toMessagesBaseUrl(baseUrl: string): string {
   return baseUrl.replace(/\/v1\/?$/, "");
 }
 
-function stampAnthropicModels(models: NeuralwattModel[]) {
+function stampAnthropicModels(models: NeuralwattChatModel[]) {
   return models.map((model) => {
     const { reasoningContract, ...compiled } = model;
     // No retained contract: the identity map is the alias-free special case.
@@ -77,7 +77,7 @@ function stampAnthropicModels(models: NeuralwattModel[]) {
       ...compiled,
       api: "anthropic-messages" as const,
       provider: NEURALWATT_PROVIDER_ID,
-      baseUrl: toMessagesBaseUrl(model.baseUrl ?? NEURALWATT_BASE_URL),
+      baseUrl: toMessagesBaseUrl(model.baseUrl ?? configuredApiBaseUrl()),
       headers: NEURALWATT_REQUEST_HEADERS,
       compat: {
         forceAdaptiveThinking: true,
@@ -105,10 +105,10 @@ export function createAnthropicMessagesApi(options?: {
     stream: (model, context, streamOptions) =>
       stream(model, context, withReasoning(streamOptions) as never),
     streamSimple: (model, context, simpleOptions) =>
-      (options?.streamSimple ?? streamSimple)(
+      ((options?.streamSimple ?? streamSimple) as AnyStreamSimple)(
         model,
         context,
-        withReasoning(simpleOptions) as never,
+        withReasoning(simpleOptions),
       ),
   };
 }

package/extensions/provider/api/openai-completions.ts

@@ -1,11 +1,11 @@
 import type { StreamOptions } from "@earendil-works/pi-ai";
 import { stream, streamSimple } from "@earendil-works/pi-ai/compat";
+import { configuredApiBaseUrl } from "../../../src/config/loader";
 import {
-  NEURALWATT_BASE_URL,
   NEURALWATT_PROVIDER_ID,
   NEURALWATT_REQUEST_HEADERS,
 } from "../constants";
-import type { NeuralwattModel } from "../models/catalog";
+import type { NeuralwattChatModel } from "../models/catalog";
 import type { AnyStreamSimple } from "../stream-simple";
 import type { NeuralwattApiHandler } from "./types";
 
@@ -60,24 +60,24 @@ export function createOpenAiCompletionsApi(options?: {
   });
 
   return {
-    stampModels: (models: NeuralwattModel[]) =>
+    stampModels: (models: NeuralwattChatModel[]) =>
       models.map((model) => {
         const { reasoningContract: _reasoningContract, ...compiled } = model;
         return {
           ...compiled,
           api: "openai-completions" as const,
           provider: NEURALWATT_PROVIDER_ID,
-          baseUrl: model.baseUrl ?? NEURALWATT_BASE_URL,
+          baseUrl: model.baseUrl ?? configuredApiBaseUrl(),
           headers: NEURALWATT_REQUEST_HEADERS,
         };
       }),
     stream: (model, context, streamOptions) =>
       stream(model, context, withReasoningReplay(streamOptions) as never),
     streamSimple: (model, context, simpleOptions) =>
-      (options?.streamSimple ?? streamSimple)(
+      ((options?.streamSimple ?? streamSimple) as AnyStreamSimple)(
         model,
         context,
-        withReasoningReplay(simpleOptions) as never,
+        withReasoningReplay(simpleOptions),
       ),
   };
 }

package/extensions/provider/api/system-one.ts

@@ -0,0 +1,242 @@
+import type {
+  ClassifierAnswer,
+  ClassifierApi,
+  ClassifierContext,
+  ClassifierFunction,
+  ClassifierModel,
+  ClassifierOptions,
+  ClassifierResult,
+} from "@earendil-works/pi-ai";
+import { calculateCost } from "@earendil-works/pi-ai";
+import type { Static } from "typebox";
+import { Type } from "typebox";
+import { Check, Parse, ParseError } from "typebox/value";
+import { configuredApiBaseUrl } from "../../../src/config/loader";
+import {
+  NEURALWATT_PROVIDER_ID,
+  NEURALWATT_REQUEST_HEADERS,
+} from "../constants";
+import {
+  NEURALWATT_SYSTEM_ONE_API,
+  type NeuralwattClassifierModel,
+} from "../models/build";
+
+const UsageSchema = Type.Object({
+  input_tokens: Type.Integer({ minimum: 0 }),
+  output_tokens: Type.Integer({ minimum: 0 }),
+});
+const AnswerSchemas = {
+  choice: Type.Object({
+    type: Type.Literal("choice"),
+    choice: Type.String(),
+    probabilities: Type.Record(Type.String(), Type.Number()),
+    confidence: Type.Number(),
+  }),
+  score: Type.Object({
+    type: Type.Literal("score"),
+    score: Type.Number(),
+    confidence: Type.Number(),
+  }),
+  bool: Type.Object({ type: Type.Literal("noul"), noul: Type.Number() }),
+};
+const ErrorSchema = Type.Union([
+  Type.Object({
+    error: Type.Object({
+      message: Type.String(),
+      type: Type.String(),
+      code: Type.String(),
+    }),
+  }),
+  Type.Object({ detail: Type.String() }),
+]);
+
+function responseSchema(context: ClassifierContext) {
+  return Type.Object({
+    answers: Type.Object(
+      Object.fromEntries(
+        Object.entries(context.questions).map(([id, question]) => [
+          id,
+          AnswerSchemas[question.type],
+        ]),
+      ),
+    ),
+    usage: Type.Optional(UsageSchema),
+  });
+}
+
+type SystemOneResponse = Static<ReturnType<typeof responseSchema>>;
+
+function mapAnswer(
+  value: SystemOneResponse["answers"][string],
+): ClassifierAnswer {
+  if (value.type === "noul") return { type: "bool", probability: value.noul };
+  if (value.type === "score")
+    return { type: "score", score: value.score, confidence: value.confidence };
+  return {
+    type: "choice",
+    choice: value.choice,
+    probabilities: value.probabilities,
+    confidence: value.confidence,
+  };
+}
+
+function mapUsage(
+  model: ClassifierModel<ClassifierApi>,
+  value: SystemOneResponse["usage"],
+): ClassifierResult["usage"] {
+  if (!value) return undefined;
+  const { input_tokens: input, output_tokens: output } = value;
+  const usage = {
+    input,
+    output,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: input + output,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+  };
+  calculateCost(model, usage);
+  return usage;
+}
+
+function billedUsageOnInvalidResponse(
+  model: ClassifierModel<ClassifierApi>,
+  error: ParseError,
+) {
+  const usage = (error.cause.value as { usage?: unknown } | null)?.usage;
+  return Check(UsageSchema, usage) ? mapUsage(model, usage) : undefined;
+}
+
+function formatRequest(
+  model: ClassifierModel<ClassifierApi>,
+  context: ClassifierContext,
+) {
+  return {
+    model: model.id,
+    state: context.state,
+    questions: Object.fromEntries(
+      Object.entries(context.questions).map(([id, question]) => [
+        id,
+        question.type === "bool" ? { ...question, type: "noul" } : question,
+      ]),
+    ),
+  };
+}
+
+function requestHeaders(
+  model: ClassifierModel<ClassifierApi>,
+  options: ClassifierOptions,
+) {
+  const headers = new Headers({
+    authorization: `Bearer ${options.apiKey || "-"}`,
+    "content-type": "application/json",
+  });
+  const overrides = [model.headers, options.headers].flatMap((source) =>
+    Object.entries(source ?? {}),
+  );
+  for (const [name, value] of overrides) {
+    if (value === null) headers.delete(name);
+    else headers.set(name, value);
+  }
+  return Object.fromEntries(headers);
+}
+
+function requestSignal({ signal, timeoutMs }: ClassifierOptions) {
+  if (timeoutMs === undefined) return signal;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+async function request(
+  model: ClassifierModel<ClassifierApi>,
+  context: ClassifierContext,
+  options: ClassifierOptions,
+) {
+  if (model.api !== NEURALWATT_SYSTEM_ONE_API) {
+    throw new Error(`Unsupported classifier API: ${model.api}`);
+  }
+
+  if (context.images?.length) {
+    throw new Error("Neuralwatt classifier does not support image input");
+  }
+
+  options.signal?.throwIfAborted();
+
+  const rawPayload = formatRequest(model, context);
+  const payload = (await options.onPayload?.(rawPayload, model)) ?? rawPayload;
+
+  const url = new URL("systemone", `${model.baseUrl.replace(/\/+$/u, "")}/`);
+
+  const requestFetch = options.fetch ?? globalThis.fetch;
+
+  const response = await requestFetch(url, {
+    method: "POST",
+    headers: requestHeaders(model, options),
+    body: JSON.stringify(payload),
+    signal: requestSignal(options),
+  });
+
+  await options.onResponse?.(
+    { status: response.status, headers: Object.fromEntries(response.headers) },
+    model,
+  );
+
+  const body: unknown = await response.json();
+  if (!response.ok) {
+    const failure = Parse(ErrorSchema, body);
+    const message = "error" in failure ? failure.error.message : failure.detail;
+    throw new Error(
+      `Neuralwatt System One API returned ${response.status}: ${message}`,
+    );
+  }
+
+  return Parse(responseSchema(context), body);
+}
+
+export const classify: ClassifierFunction = async (
+  model,
+  context,
+  options = {},
+) => {
+  const result: ClassifierResult = {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    answers: {},
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+  try {
+    const body = await request(model, context, options);
+    result.usage = mapUsage(model, body.usage);
+    result.answers = Object.fromEntries(
+      Object.keys(context.questions).map((id) => [
+        id,
+        mapAnswer(body.answers[id]),
+      ]),
+    );
+  } catch (error) {
+    result.stopReason = options.signal?.aborted ? "aborted" : "error";
+    if (error instanceof ParseError) {
+      result.usage = billedUsageOnInvalidResponse(model, error);
+      result.errorMessage = error.cause.errors
+        .map(({ instancePath, message }) => `${instancePath}: ${message}`)
+        .join("; ");
+      return result;
+    }
+    result.errorMessage =
+      error instanceof Error ? error.message : String(error);
+  }
+  return result;
+};
+
+export function stampClassifierModels(
+  models: NeuralwattClassifierModel[],
+): ClassifierModel<ClassifierApi>[] {
+  return models.map((model) => ({
+    ...model,
+    api: NEURALWATT_SYSTEM_ONE_API,
+    provider: NEURALWATT_PROVIDER_ID,
+    baseUrl: model.baseUrl ?? configuredApiBaseUrl(),
+    headers: NEURALWATT_REQUEST_HEADERS,
+  }));
+}

package/extensions/provider/api/types.ts

@@ -1,24 +1,24 @@
 import type {
   Api,
   AssistantMessageEventStream,
-  Context,
   Model,
   SimpleStreamOptions,
   StreamOptions,
+  TranscriptContext,
 } from "@earendil-works/pi-ai";
-import type { NeuralwattModel } from "../models/catalog";
+import type { NeuralwattChatModel } from "../models/catalog";
 
-/** One Neuralwatt API surface: model stamping plus submission plumbing. */
+/** One Neuralwatt API surface: model stamping plus chat submission plumbing. */
 export interface NeuralwattApiHandler {
-  stampModels(models: NeuralwattModel[]): Model<Api>[];
+  stampModels(models: NeuralwattChatModel[]): Model<Api>[];
   stream(
     model: Model<Api>,
-    context: Context,
+    context: TranscriptContext,
     options?: StreamOptions,
   ): AssistantMessageEventStream;
   streamSimple(
     model: Model<Api>,
-    context: Context,
+    context: TranscriptContext,
     options?: SimpleStreamOptions,
   ): AssistantMessageEventStream;
 }

package/extensions/provider/commands/settings/api-base-url-editor.ts

@@ -0,0 +1,129 @@
+import type { Component, SettingsListTheme } from "@earendil-works/pi-tui";
+import {
+  Input,
+  Key,
+  matchesKey,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+
+export interface ApiBaseUrlEditorOptions {
+  initial: string;
+  defaultBaseUrl: string;
+  theme: SettingsListTheme;
+  requestRender: () => void;
+  onSubmit: (value: string) => void;
+  onCancel: () => void;
+}
+
+type Status =
+  | { kind: "idle" }
+  | { kind: "validating"; url: string }
+  | { kind: "error"; message: string };
+
+export function normalizeApiBaseUrlInput(value: string): string {
+  return value.trim().replace(/\/+$/u, "");
+}
+
+export async function checkApiBase(
+  base: string,
+  timeoutMs = 8_000,
+): Promise<string | null> {
+  try {
+    const response = await fetch(`${base}/models`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    return response.ok ? null : `HTTP ${response.status} from ${base}/models`;
+  } catch (error) {
+    return error instanceof Error && error.name === "TimeoutError"
+      ? `Timed out reaching ${base}/models`
+      : `Could not reach ${base}/models`;
+  }
+}
+
+export class ApiBaseUrlEditor implements Component {
+  private readonly input = new Input();
+  private readonly defaultBaseUrl: string;
+  private readonly theme: SettingsListTheme;
+  private readonly requestRender: () => void;
+  private readonly onSubmit: (value: string) => void;
+  private readonly onCancel: () => void;
+  private status: Status = { kind: "idle" };
+
+  constructor(options: ApiBaseUrlEditorOptions) {
+    this.defaultBaseUrl = options.defaultBaseUrl;
+    this.theme = options.theme;
+    this.requestRender = options.requestRender;
+    this.onSubmit = options.onSubmit;
+    this.onCancel = options.onCancel;
+    this.input.setValue(options.initial);
+    this.input.onSubmit = (value) => void this.submit(value);
+    this.input.onEscape = () => this.onCancel();
+  }
+
+  private async submit(raw: string): Promise<void> {
+    const base = normalizeApiBaseUrlInput(raw);
+    if (base) {
+      this.status = { kind: "validating", url: `${base}/models` };
+      this.requestRender();
+      const error = await checkApiBase(base);
+      if (error) {
+        this.status = { kind: "error", message: error };
+        this.requestRender();
+        return;
+      }
+    }
+    this.onSubmit(base);
+  }
+
+  invalidate(): void {}
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.escape)) {
+      this.onCancel();
+      return;
+    }
+    if (this.status.kind === "validating") return;
+    this.status = { kind: "idle" };
+    this.input.handleInput(data);
+  }
+
+  render(width: number): string[] {
+    const lines: string[] = [];
+    lines.push(
+      truncateToWidth(this.theme.label("API base URL", true), width, "", true),
+    );
+    lines.push(...this.input.render(width));
+    if (this.status.kind === "validating") {
+      lines.push(
+        truncateToWidth(
+          this.theme.description(`Validating ${this.status.url} …`),
+          width,
+          "",
+          true,
+        ),
+      );
+    } else if (this.status.kind === "error") {
+      lines.push(
+        truncateToWidth(
+          this.theme.value(this.status.message, true),
+          width,
+          "",
+          true,
+        ),
+      );
+    } else {
+      lines.push(
+        truncateToWidth(
+          this.theme.description(
+            `Enter to save · empty = direct upstream (${this.defaultBaseUrl})`,
+          ),
+          width,
+          "",
+          true,
+        ),
+      );
+    }
+    return lines;
+  }
+}

package/extensions/provider/commands/settings/index.ts

@@ -14,6 +14,7 @@ import {
   NEURALWATT_CONFIG_UPDATED_EVENT,
   type NeuralwattFeatureId,
 } from "../../../../src/events";
+import { ApiBaseUrlEditor } from "./api-base-url-editor";
 
 export interface RegisterNeuralwattSettingsOptions {
   getLoadedFeatures: () => Set<NeuralwattFeatureId>;
@@ -62,15 +63,16 @@ export function registerNeuralwattSettings(
   options: RegisterNeuralwattSettingsOptions,
 ): void {
   const { getLoadedFeatures } = options;
-  // The provider stamps `provider.api` at extension load; a saved change only
-  // reaches it after `/reload`.
+  // The provider stamps `provider.api` and assembles against the configured
+  // base at extension load; a saved change only reaches it after `/reload`.
   let pendingApi: NeuralwattApi | undefined;
+  let pendingApiBaseUrl: string | undefined;
 
   registerSettingsCommand<NeuralwattConfig, ResolvedNeuralwattConfig>(pi, {
     commandName: "neuralwatt:settings",
     title: "Neuralwatt Settings",
     configStore: configLoader,
-    buildSections: (tabConfig, resolved): SettingsSection[] => {
+    buildSections: (tabConfig, resolved, buildCtx): SettingsSection[] => {
       const loaded = getLoadedFeatures();
       return [
         {
@@ -80,10 +82,41 @@ export function registerNeuralwattSettings(
               id: "api",
               label: "API",
               description:
-                "Serve models via the OpenAI-compatible chat/completions endpoint or the Anthropic-compatible /v1/messages endpoint",
+                "Serve models via the OpenAI completions endpoint or the Anthropic endpoint",
               currentValue: tabConfig?.provider?.api ?? resolved.provider.api,
               values: ["openai-completions", "anthropic-messages"],
             },
+            {
+              id: "apiBaseUrl",
+              label: "API base URL",
+              description:
+                "Base URL for API requests; empty uses the default upstream",
+              currentValue: tabConfig?.provider?.apiBaseUrl || "(not set)",
+              submenu: (current, submenuDone, submenuCtx) => {
+                const display = (value: string) => value || "(not set)";
+                return new ApiBaseUrlEditor({
+                  initial: current === "(not set)" ? "" : current,
+                  defaultBaseUrl: resolved.provider.apiBaseUrl,
+                  theme: buildCtx.theme,
+                  requestRender: submenuCtx.requestRender,
+                  onSubmit: (value) => {
+                    const updated = structuredClone(
+                      tabConfig ?? {},
+                    ) as NeuralwattConfig;
+                    updated.provider = { ...updated.provider };
+                    if (value) {
+                      updated.provider.apiBaseUrl = value;
+                    } else {
+                      delete updated.provider.apiBaseUrl;
+                    }
+                    buildCtx.setDraft(updated);
+                    pendingApiBaseUrl = value;
+                    submenuDone(display(value));
+                  },
+                  onCancel: () => submenuDone(display(current)),
+                });
+              },
+            },
           ],
         },
         {
@@ -165,9 +198,12 @@ export function registerNeuralwattSettings(
     },
     onSave: async (ctx) => {
       emitConfigUpdated(pi);
-      if (pendingApi === undefined) return;
+      if (pendingApi === undefined && pendingApiBaseUrl === undefined) {
+        return;
+      }
       pendingApi = undefined;
-      ctx.ui.notify("Run /reload to apply the new API", "info");
+      pendingApiBaseUrl = undefined;
+      ctx.ui.notify("Run /reload to apply the new provider settings", "info");
     },
   });
 }

package/extensions/provider/index.ts

@@ -30,7 +30,10 @@ import {
   parseRateLimitHeaders,
 } from "./rate-limit-error";
 import { updateQuotasFromSseComment } from "./sse-quotas";
-import { wrapNeuralwattStreamSimple } from "./stream-simple";
+import {
+  type NeuralwattStreamCallbacks,
+  wrapNeuralwattStreamSimple,
+} from "./stream-simple";
 
 const HEADER_EMIT_THROTTLE_MS = 5_000;
 
@@ -42,7 +45,7 @@ function emitConfigUpdated(pi: ExtensionAPI): void {
 
 function registerNeuralwattProvider(
   pi: ExtensionAPI,
-  onSseQuota: (line: string) => void,
+  streamCallbacks: NeuralwattStreamCallbacks,
 ): void {
   const staticModels = buildNeuralwattProviderModels();
 
@@ -51,7 +54,7 @@ function registerNeuralwattProvider(
   const streamSimple = baseStreamSimple
     ? (wrapNeuralwattStreamSimple(
         baseStreamSimple as never,
-        onSseQuota,
+        streamCallbacks,
       ) as never)
     : undefined;
 
@@ -60,7 +63,7 @@ function registerNeuralwattProvider(
   const messagesStreamSimple = messagesBaseStreamSimple
     ? (wrapNeuralwattStreamSimple(
         messagesBaseStreamSimple as never,
-        onSseQuota,
+        streamCallbacks,
       ) as never)
     : undefined;
 
@@ -101,7 +104,17 @@ export default async function (pi: ExtensionAPI) {
     emitQuotas(quotas, "sse");
   };
 
-  registerNeuralwattProvider(pi, handleSseQuota);
+  // Rate-limit info captured by the per-request fetch wrapper from the most
+  // recent 429 response. Used in message_end to rewrite the generic error
+  // text with actionable details from Neuralwatt's response headers.
+  let pendingRateLimitInfo: NeuralwattRateLimitInfo | undefined;
+
+  registerNeuralwattProvider(pi, {
+    onSseQuota: handleSseQuota,
+    onRateLimit: (info) => {
+      pendingRateLimitInfo = info;
+    },
+  });
 
   const loadedFeatures = new Set<NeuralwattFeatureId>();
 
@@ -125,10 +138,6 @@ export default async function (pi: ExtensionAPI) {
     pi.events.emit(NEURALWATT_QUOTAS_UPDATED_EVENT, { quotas, source });
   }
 
-  // Stored rate-limit info from the most recent 429 response.
-  // Used in message_end to rewrite the generic error text with
-  // actionable details from Neuralwatt's response headers.
-  let pendingRateLimitInfo: NeuralwattRateLimitInfo | undefined;
   let currentModelRegistry: ModelRegistry | undefined;
 
   pi.on("message_end", (event, ctx) => {
@@ -148,14 +157,14 @@ export default async function (pi: ExtensionAPI) {
       return { message };
     }
 
-    // Fallback for 429s where no layer-specific headers were captured. The
-    // streamSimple wrap (wrapNeuralwattStreamSimple) already formats a
-    // detailed message via formatRateLimitError when it captures headers;
-    // detect that case by the `"429 rate limit:"` prefix it emits and leave
-    // it untouched. This branch only fires for genuinely headerless 429s
-    // (e.g. anonymous playground limits, or a 429 from infra in front of
-    // Neuralwatt), since after_provider_response cannot observe 429s — the
-    // OpenAI SDK throws before Pi's onResponse hook runs.
+    // Fallback for 429s where no layer-specific headers were captured (the
+    // fetch wrapper reported `undefined` via onRateLimit, or the 429 came
+    // from infra in front of Neuralwatt). The `"429 rate limit:"` prefix
+    // guard skips messages the first branch already rewrote. On the
+    // openai-completions surface after_provider_response cannot observe
+    // 429s — the OpenAI SDK throws before Pi's onResponse hook runs — so
+    // this is the only repair path there; on anthropic-messages
+    // after_provider_response also feeds pendingRateLimitInfo directly.
     if (
       event.message.role === "assistant" &&
       event.message.stopReason === "error" &&