wtagent 0.2.1 → 0.3.0

package/src/cli/render-events.js

@@ -8,6 +8,8 @@
 // A single Renderer instance is shared across every turn of a conversation so
 // spinner state and per-tool timing survive between the model's replies.
 
+import { t } from "./i18n.js";
+
 const DIM = "\x1b[2m";
 const BOLD = "\x1b[1m";
 const CYAN = "\x1b[36m";
@@ -109,7 +111,7 @@ export class Renderer {
     }
     this.spinner = {
       kind: "processing",
-      label: "processing request",
+      label: t("renderer.processing"),
       start: Date.now(),
       bytes: 0,
     };
@@ -119,7 +121,7 @@ export class Renderer {
   beginRunning(name) {
     this.spinner = {
       kind: "running",
-      label: `running ${name}`,
+      label: t("renderer.running", { tool: name }),
       start: Date.now(),
       bytes: 0,
     };
@@ -235,7 +237,7 @@ export class Renderer {
   answer(message) {
     this.stopSpinner();
     this.println("");
-    this.println(`${GREEN}${BOLD}⏺ assistant${RESET}`);
+    this.println(`${GREEN}${BOLD}⏺ ${t("renderer.assistant")}${RESET}`);
     for (const line of String(message ?? "").split(/\r?\n/)) {
       this.println(line);
     }
@@ -260,36 +262,25 @@ export class Renderer {
           break;
         }
         this.lifecycleShown.add(type);
-        this.status("Chrome started.");
+        this.status(t("renderer.chromeStarted"));
         break;
       case "browser.auth_required":
         this.stopSpinner();
-        this.println(`${YELLOW}Log in to ${this.providerLabel} in the opened Chrome window…${RESET}`);
+        this.println(
+          `${YELLOW}${t("renderer.loginRequired", { provider: this.providerLabel })}${RESET}`,
+        );
         break;
       case "browser.authenticated":
-        this.println(`${GREEN}${this.providerLabel} login detected.${RESET}`);
-        break;
-      case "conversation.mode_selected": {
-        const { requested, status, selectedLabel } = payload;
-        if (status === "select" || status === "already") {
-          this.status(`Mode: ${selectedLabel ?? requested}.`);
-        } else if (status === "fallback") {
-          this.note(`Mode: ${requested} unavailable; using ${selectedLabel}.`);
-        } else {
-          this.note(`Mode: could not select ${requested}; continuing on current mode.`);
-        }
+        this.println(
+          `${GREEN}${t("renderer.loginDetected", { provider: this.providerLabel })}${RESET}`,
+        );
         break;
-      }
       case "conversation.started":
         if (this.lifecycleShown.has(type)) {
           break;
         }
         this.lifecycleShown.add(type);
-        if (payload.mode) {
-          this.status(`Conversation ready (${payload.mode}).`);
-        } else {
-          this.status("Conversation ready (current mode).");
-        }
+        this.status(t("renderer.conversationReady"));
         break;
       case "model.message_sent":
         this.beginProcessing();
@@ -305,18 +296,29 @@ export class Renderer {
         this.stopSpinner();
         this.note(
           payload.deadRequest
-            ? `no reply from ${this.providerLabel}; asking it to continue (${payload.retry}/${payload.maxRetries})`
+            ? t("renderer.noReply", {
+              provider: this.providerLabel,
+              retry: payload.retry,
+              maxRetries: payload.maxRetries,
+            })
             : payload.generationFailed
-              ? `${this.providerLabel} generation failed (server error); asking it to retry (${payload.retry}/${payload.maxRetries})`
-              : `empty ${this.providerLabel} response; asking it to continue (${payload.retry}/${payload.maxRetries})`,
+              ? t("renderer.generationFailed", {
+                provider: this.providerLabel,
+                retry: payload.retry,
+                maxRetries: payload.maxRetries,
+              })
+              : t("renderer.emptyResponse", {
+                provider: this.providerLabel,
+                retry: payload.retry,
+                maxRetries: payload.maxRetries,
+              }),
         );
         break;
       case "model.limit_reached":
         this.stopSpinner();
-        this.note(
-          `${this.providerLabel} usage limit reached. Wait for the limit to reset, `
-            + "try a different mode on resume, or change plans.",
-        );
+        this.note(t("renderer.limitReached", {
+          provider: this.providerLabel,
+        }));
         break;
       case "model.progress":
         this.stopSpinner();
@@ -329,7 +331,7 @@ export class Renderer {
         break;
       case "protocol.plain_answer":
         this.stopSpinner();
-        this.note("The model answered without the XML protocol; showing the reply as the final answer.");
+        this.note(t("renderer.plainAnswer"));
         break;
       case "tool.proposed":
         this.stopSpinner();
@@ -361,21 +363,25 @@ export class Renderer {
         this.stopSpinner();
         if (!payload.id || !this.handled.has(payload.id)) {
           if (payload.id) this.handled.add(payload.id);
-          this.println(`${this.#hdr()} ${DIM}↺ reused prior result for ${payload.name}${RESET}`);
+          this.println(
+            `${this.#hdr()} ${DIM}↺ ${t("renderer.reused", { tool: payload.name })}${RESET}`,
+          );
         }
         break;
       case "tool.reused_unknown":
         this.stopSpinner();
         if (!payload.id || !this.handled.has(payload.id)) {
           if (payload.id) this.handled.add(payload.id);
-          this.println(`${this.#hdr()} ${YELLOW}↺ reused (completion unknown) for ${payload.name}${RESET}`);
+          this.println(
+            `${this.#hdr()} ${YELLOW}↺ ${t("renderer.reusedUnknown", { tool: payload.name })}${RESET}`,
+          );
         }
         break;
       case "tool.conflict":
         this.stopSpinner();
         if (!payload.id || !this.handled.has(payload.id)) {
           if (payload.id) this.handled.add(payload.id);
-          this.note(`conflicting reuse for ${payload.name}`);
+          this.note(t("renderer.conflictingReuse", { tool: payload.name }));
         }
         break;
       case "run.completed":
@@ -383,12 +389,16 @@ export class Renderer {
         break;
       case "run.interrupted":
         this.stopSpinner();
-        this.println(`${YELLOW}Run interrupted: ${truncate(payload.message, 160)}${RESET}`);
+        this.println(`${YELLOW}${t("renderer.interrupted", {
+          message: truncate(payload.message, 160),
+        })}${RESET}`);
         break;
       case "run.recovery_required":
         this.stopSpinner();
         this.println(
-          `${YELLOW}${truncate(payload.message, 180)} The session and Chrome window remain open.${RESET}`,
+          `${YELLOW}${t("renderer.recoveryOpen", {
+            message: truncate(payload.message, 180),
+          })}${RESET}`,
         );
         break;
       case "tool.result_sent":

package/src/cli/self-update.js

@@ -6,12 +6,14 @@ import { getPackageName, getPackageVersion } from "../shared/package-info.js";
 export const UPDATE_CHECK_TIMEOUT_MS = NETWORK_TIMEOUT_MS;
 export const UPDATE_COMMAND_TIMEOUT_MS = 10_000;
 export const INSTALL_TIMEOUT_MS = 120_000;
-export const MANUAL_INSTALL_COMMAND = "npm install -g wtagent@latest";
+export const OFFICIAL_NPM_REGISTRY = "https://registry.npmjs.org/";
+export const MANUAL_INSTALL_COMMAND =
+  `npm install -g wtagent@latest --registry=${OFFICIAL_NPM_REGISTRY}`;
 
 const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
 
 export function npmRegistryLatestUrl(name = getPackageName()) {
-  return `https://registry.npmjs.org/${encodeURIComponent(name)}/latest`;
+  return `${OFFICIAL_NPM_REGISTRY}${encodeURIComponent(name)}/latest`;
 }
 
 export function parseVersion(value) {
@@ -76,7 +78,12 @@ export async function installLatest({
   timeoutMs = INSTALL_TIMEOUT_MS,
   stdio = "inherit",
 } = {}) {
-  const plan = planCommandImpl("npm", ["install", "-g", "wtagent@latest"]);
+  const plan = planCommandImpl("npm", [
+    "install",
+    "-g",
+    "wtagent@latest",
+    `--registry=${OFFICIAL_NPM_REGISTRY}`,
+  ]);
   return await new Promise((resolve) => {
     let settled = false;
     let timer;

package/src/runtime/agent-runtime.js

@@ -19,11 +19,7 @@ import {
   toolResultOutput,
   userMessage,
 } from "../session/canonical-transcript.js";
-import {
-  DEFAULT_LIMITS,
-  PRO_MODEL_TURN_TIMEOUT_MS,
-  isProMode,
-} from "../shared/limits.js";
+import { DEFAULT_LIMITS } from "../shared/limits.js";
 import { utf8ByteLength } from "../shared/text-budget.js";
 import {
   BrowserAdapterError,
@@ -148,6 +144,7 @@ export class AgentRuntime {
     session,
     approval,
     onEvent,
+    postAuthSetup = null,
     limits = DEFAULT_LIMITS,
   }) {
     this.adapter = adapter;
@@ -156,6 +153,7 @@ export class AgentRuntime {
     this.session = session;
     this.approval = approval;
     this.onEvent = onEvent;
+    this.postAuthSetup = postAuthSetup;
     this.limits = limits;
   }
 
@@ -239,12 +237,10 @@ export class AgentRuntime {
     instruction = null,
     files = [],
     inPlaceRecovery = false,
-    mode = null,
   } = {}) {
     const {
       task,
       projectRoot,
-      mode: sessionMode,
     } = this.session.state;
     const previousConversationUrl = this.session.state.conversationUrl;
     await this.session.recoverInterruptedSideEffects();
@@ -300,58 +296,25 @@ export class AgentRuntime {
           : null,
       },
     );
-    // A fresh run uses the mode stored at session creation; a resume applies
-    // an explicit mode override (--mode or the interactive choice) when given,
-    // and otherwise keeps the mode the conversation is already on.
-    const requestedMode = mode ?? sessionMode;
-    // The actual mode may differ from the requested one (Pro limited, fallback,
-    // or switcher not found), so report what was really selected.
-    let activeMode = resume
-      ? (this.session.state.activeMode ?? null)
-      : null;
-    const selectRequested = Boolean(
-      requestedMode && (!resume || mode != null),
-    );
-    if (selectRequested) {
-      const modeResult = await this.adapter.selectMode(requestedMode);
-      if (modeResult) {
-        await this.emit("conversation.mode_selected", {
-          requested: requestedMode,
-          status: modeResult.status,
-          selectedLabel: modeResult.selectedLabel ?? null,
-          attempts: modeResult.attempts ?? 0,
-          reason: modeResult.reason ?? null,
-        });
-        if (modeResult.status === "select" || modeResult.status === "already") {
-          activeMode = modeResult.selectedLabel ?? requestedMode;
-        } else if (modeResult.status === "fallback") {
-          activeMode = modeResult.selectedLabel ?? requestedMode;
-        } else {
-          // Pro not selected and no known fallback label — the real mode is
-          // whatever ChatGPT already had, which we cannot name reliably.
-          activeMode = null;
-        }
-      }
+
+    // Optional setup after authentication and the target conversation are
+    // ready, but before the first message is sent. Interactive CLI runs use
+    // this to let the user choose a model directly on the provider website.
+    // WTAgent never names, selects, or overrides a provider-specific model.
+    // Resumes skip this setup so an existing conversation is not interrupted.
+    if (!resume && this.postAuthSetup) {
+      await this.postAuthSetup({ adapter: this.adapter });
     }
-    // ChatGPT Pro can think considerably longer before the first token;
-    // every other provider/mode uses the default. An explicit
-    // --model-turn-timeout-ms always wins (resolveLimits marks it). The
-    // active mode may differ from the requested one (Pro limited, fallback),
-    // so prefer the mode the conversation is actually on.
-    const modelTurnTimeoutMs = !this.limits.modelTurnTimeoutExplicit
-      && (isProMode(activeMode) || isProMode(requestedMode))
-      ? PRO_MODEL_TURN_TIMEOUT_MS
-      : this.limits.modelTurnTimeoutMs;
+
+    const modelTurnTimeoutMs = this.limits.modelTurnTimeoutMs;
 
     await this.session.update({
       phase: "running",
       conversationUrl: await this.adapter.getConversationUrl(),
-      activeMode,
+      activeMode: null,
     });
     await this.emit("conversation.started", {
       url: this.session.state.conversationUrl,
-      mode: activeMode,
-      requestedMode,
     });
 
     let initialMessage;

package/src/shared/limits.js

@@ -19,15 +19,8 @@ export const DEFAULT_LIMITS = Object.freeze({
   maxSearchResults: 200,
 });
 
-// ChatGPT Pro plans can legitimately think longer than the default before the
-// first token (see the runtime's mode-aware timeout selection).
-export const PRO_MODEL_TURN_TIMEOUT_MS = 16 * 60_000;
-
-// The CLI's --model-turn-timeout-ms always wins over the mode-aware default.
-export function isProMode(mode) {
-  return String(mode ?? "") === "Pro";
-}
-
+// Model response timing is provider/model agnostic. Users who need a longer
+// window can override it explicitly with --model-turn-timeout-ms.
 export function resolveLimits({ modelTurnTimeoutMs } = {}) {
   if (modelTurnTimeoutMs == null || modelTurnTimeoutMs === "") {
     return DEFAULT_LIMITS;

package/src/browser/mode-selection.js

@@ -1,214 +0,0 @@
-// Language-independent model/mode selection logic for the ChatGPT web picker.
-//
-// Prefer language-independent option slugs derived from data-testid / data-* /
-// id. Current ChatGPT menus sometimes omit every such attribute, including on
-// the Pro item, so an exact normalized label match is kept as a conservative
-// fallback. We never use fuzzy label matching.
-//
-// This module is pure and DOM-free so it can be unit-tested without a browser.
-// The adapter supplies a small "port" of async DOM operations to
-// `runModeSelection`; all the retry / fallback policy lives here.
-
-export function slugTokens(slug) {
-  return String(slug ?? "").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
-}
-
-export function normalizeToken(value) {
-  return String(value ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "");
-}
-
-// Does the option's stable slug encode the requested mode token?
-// `token` is a normalized (separator-free) string, e.g. "pro" or "extrahigh".
-// Short tokens (< 4 chars, e.g. "pro") require an exact whole-segment match so
-// "pro" does not match "provider". Longer tokens also allow a substring match
-// against the separator-free slug, so a multi-word mode like "Extra high"
-// (-> "extrahigh") matches a hyphenated slug like "o3-extra-high".
-export function slugMatchesToken(slug, token) {
-  if (!token) {
-    return false;
-  }
-  const tokens = slugTokens(slug);
-  if (tokens.includes(token)) {
-    return true;
-  }
-  if (token.length >= 4) {
-    const joined = tokens.join("");
-    return joined.includes(token) || tokens.some((candidate) => candidate.includes(token));
-  }
-  return false;
-}
-
-export function labelMatchesToken(label, token) {
-  return String(label ?? "")
-    .split(/\r?\n/)
-    .some((line) => normalizeToken(line) === token);
-}
-
-// Given the enumerated menu options and the requested mode, decide what to do.
-// options: [{ index, slug, label, disabled, selected }] in DOM order.
-// Returns { status, targetIndex, selectedLabel, reason }.
-//   status "select"              -> requested mode is available; click it.
-//   status "already"             -> requested mode is already selected.
-//   status "fallback"            -> requested mode is limited/disabled; click
-//                                   the option immediately before it.
-//   status "unavailable"         -> requested mode is not present in the menu.
-//   status "unavailable_disabled"-> requested mode is disabled and the previous
-//                                   option is not selectable either.
-export function chooseModeOption(options, requested) {
-  const token = normalizeToken(requested);
-  let proIndex = options.findIndex(
-    (option) => slugMatchesToken(option.slug, token),
-  );
-  if (proIndex === -1) {
-    proIndex = options.findIndex(
-      (option) => labelMatchesToken(option.label, token),
-    );
-  }
-
-  if (proIndex === -1) {
-    return {
-      status: "unavailable",
-      targetIndex: null,
-      selectedLabel: null,
-      reason: `"${requested}" is not in the model menu.`,
-    };
-  }
-
-  const pro = options[proIndex];
-  if (pro.selected) {
-    return {
-      status: "already",
-      targetIndex: null,
-      selectedLabel: pro.label || requested,
-      reason: `Already using ${requested}.`,
-    };
-  }
-  if (!pro.disabled) {
-    return {
-      status: "select",
-      targetIndex: proIndex,
-      selectedLabel: pro.label || requested,
-      reason: `Selecting ${requested}.`,
-    };
-  }
-
-  // Pro is present but limited. Fall back to the option immediately before it.
-  const previous = options[proIndex - 1];
-  if (previous && !previous.disabled) {
-    return {
-      status: "fallback",
-      targetIndex: proIndex - 1,
-      selectedLabel: previous.label || `option ${proIndex}`,
-      reason: `${requested} is limited; selecting the previous option `
-        + `"${previous.label || proIndex - 1}" instead.`,
-    };
-  }
-
-  return {
-    status: "unavailable_disabled",
-    targetIndex: null,
-    selectedLabel: null,
-    reason: previous
-      ? `${requested} is limited and the previous option is also unavailable.`
-      : `${requested} is limited and has no previous option to fall back to.`,
-  };
-}
-
-// Orchestrates selection against a DOM "port". Never throws for mode issues:
-// it always resolves to a structured result the runtime can surface to the CLI,
-// so a limited/absent Pro degrades gracefully instead of aborting the run.
-//
-// port: {
-//   alreadyOnMode(requested) -> bool,
-//   hasSwitcher()            -> bool,
-//   openMenu(requested)      -> void,
-//   readOptions()            -> [{index, slug, label, disabled, selected}],
-//   clickOption(index)       -> bool (click landed),
-//   waitSelected(requested)  -> bool (picker reflects the requested mode),
-//   waitClosed()             -> bool (menu closed after click),
-//   closeMenu()              -> void,
-//   writeDiagnostics(label)  -> void,
-// }
-export async function runModeSelection(port, requested, { maxAttempts = 2 } = {}) {
-  if (!requested) {
-    return { status: "skipped", requested, attempts: 0, reason: "No mode requested." };
-  }
-
-  if (await port.alreadyOnMode(requested)) {
-    return {
-      status: "already",
-      requested,
-      selectedLabel: requested,
-      attempts: 0,
-      reason: `Already using ${requested}.`,
-    };
-  }
-
-  if (!await port.hasSwitcher()) {
-    await port.writeDiagnostics("mode-switcher-not-found");
-    return {
-      status: "switcher_not_found",
-      requested,
-      attempts: 0,
-      reason: "Model switcher was not found.",
-    };
-  }
-
-  let lastReason = "";
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    await port.openMenu(requested);
-    const options = await port.readOptions();
-
-    // The Radix menu populates asynchronously; an empty read is a race, retry.
-    if (!options || options.length === 0) {
-      lastReason = "Model menu did not populate in time.";
-      await port.closeMenu();
-      continue;
-    }
-
-    const choice = chooseModeOption(options, requested);
-
-    if (choice.status === "already") {
-      await port.closeMenu();
-      return { ...choice, requested, attempts: attempt };
-    }
-
-    if (choice.status === "select" || choice.status === "fallback") {
-      const clicked = await port.clickOption(choice.targetIndex);
-      const expectedMode = choice.status === "fallback"
-        ? choice.selectedLabel
-        : requested;
-      const selected = clicked && (
-        typeof port.waitSelected === "function"
-          ? await port.waitSelected(expectedMode)
-          : await port.waitClosed()
-      );
-      if (selected) {
-        return { ...choice, requested, attempts: attempt };
-      }
-      lastReason = "The option click did not change the selected mode.";
-      await port.closeMenu();
-      continue;
-    }
-
-    await port.closeMenu();
-
-    // A genuinely absent Pro might still be populating on the first pass, so
-    // retry once; a disabled Pro will not change, so report immediately.
-    if (choice.status === "unavailable" && attempt < maxAttempts) {
-      lastReason = choice.reason;
-      continue;
-    }
-
-    await port.writeDiagnostics(`mode-${requested}-${choice.status}`);
-    return { ...choice, requested, attempts: attempt };
-  }
-
-  await port.writeDiagnostics(`mode-${requested}-unresolved`);
-  return {
-    status: "unresolved",
-    requested,
-    attempts: maxAttempts,
-    reason: lastReason || `Could not select ${requested}.`,
-  };
-}

package/src/cli/mode-choice.js

@@ -1,25 +0,0 @@
-export const CHATGPT_MODE_CHOICES = Object.freeze([
-  Object.freeze({
-    name: "Pro — select Pro for this conversation",
-    value: "pro",
-  }),
-  Object.freeze({
-    name: "Current — keep the current ChatGPT setting",
-    value: "current",
-  }),
-]);
-
-export function normalizeConfiguredMode(value) {
-  const configured = String(value ?? "").trim();
-  if (/^current$/i.test(configured)) {
-    return null;
-  }
-  if (/^pro$/i.test(configured)) {
-    return "Pro";
-  }
-  throw new Error('ChatGPT mode must be either "Pro" or "Current".');
-}
-
-export function modeFromPromptChoice(choice) {
-  return choice === "pro" ? "Pro" : null;
-}