shariq-pi-extensions 0.1.0

package/extensions/copy-all/index.ts

@@ -0,0 +1,72 @@
+import {
+  copyToClipboard,
+  type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+
+export function textFromMessageContent(content: unknown): string {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => {
+      if (!block || typeof block !== "object" || !("type" in block)) return "";
+      if (
+        block.type === "text" &&
+        "text" in block &&
+        typeof block.text === "string"
+      ) {
+        return block.text;
+      }
+      if (block.type === "image") return "[image]";
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+}
+
+export function formatConversation(
+  messages: ReadonlyArray<{ role?: unknown; content?: unknown }>,
+): string {
+  return messages
+    .filter(
+      (message) => message.role === "user" || message.role === "assistant",
+    )
+    .map((message) => ({
+      role: String(message.role).toUpperCase(),
+      text: textFromMessageContent(message.content),
+    }))
+    .filter((message) => message.text)
+    .map((message) => `${message.role}:\n${message.text}`)
+    .join("\n\n---\n\n");
+}
+
+export default function copyAllExtension(pi: ExtensionAPI) {
+  pi.registerCommand("copy-all", {
+    description: "Copy visible user and assistant text from the current branch",
+    handler: async (_args, ctx) => {
+      await ctx.waitForIdle();
+      const messages = ctx.sessionManager
+        .getBranch()
+        .filter((entry) => entry.type === "message")
+        .map((entry) => entry.message);
+      const visibleMessages = messages.filter(
+        (message) => message.role === "user" || message.role === "assistant",
+      );
+      const transcript = formatConversation(visibleMessages);
+      if (!transcript) {
+        ctx.ui.notify("No user or assistant messages to copy", "info");
+        return;
+      }
+      try {
+        await copyToClipboard(transcript);
+      } catch (error) {
+        ctx.ui.notify(
+          `Could not copy the conversation: ${error instanceof Error ? error.message : String(error)}`,
+          "error",
+        );
+        return;
+      }
+      ctx.ui.notify(`Copied ${visibleMessages.length} branch messages`, "info");
+    },
+  });
+}

package/extensions/factory-provider/API_KEYS.md

@@ -0,0 +1,17 @@
+# Factory API keys
+
+Factory API keys are an authentication method of the single `factory` provider; they are not a separate provider or duplicate model catalog.
+
+Configure rotating keys in:
+
+```text
+<agent-dir>/factory/api-keys.json
+```
+
+Then run `/login factory` and select **Factory API keys — use configured keys**. Pi stores a non-secret selector while the extension keeps keys in the permission-restricted JSON file. Rotation filters keys through the selected model pool's monthly → weekly → 5-hour availability waterfall, chooses the least recently used eligible key, and applies error-specific cooldown/failover behavior.
+
+Alternatively choose Pi's top-level **Use an API key** authentication method to store one key through normal credential storage.
+
+Use `/logout` to remove the active Factory authentication selection. The configured key file is intentionally not deleted by logout.
+
+Open `/factory` to inspect every account, its Standard/Core usage, and rotation status. For a smoke test, use the current `factory/kimi-k3` model.

package/extensions/factory-provider/AUTH.md

@@ -0,0 +1,15 @@
+# Factory authentication
+
+Provider ID: `factory`
+
+Use one login entry for every authentication method:
+
+```text
+/login factory
+```
+
+Choose Pi's **Use a subscription** path for account import, browser/device login, or the configured rotating-key selector. Choose Pi's native **Use an API key** path to enter one key directly. The chosen credential is stored under `factory`, so it appears once in `/logout`.
+
+OAuth account credentials refresh through WorkOS. Configured API-key mode stores only a non-secret selector in Pi auth; actual keys remain in the permission-restricted `<agent-dir>/factory/api-keys.json`. Direct API-key mode stores the key through Pi's normal credential storage.
+
+To switch methods, run `/login factory` again. To disable the selected method, use `/logout` and choose Factory.

package/extensions/factory-provider/README.md

@@ -0,0 +1,90 @@
+# Unified Factory provider for Pi
+
+This package module exposes exactly one Pi provider:
+
+```text
+factory/<model-id>
+```
+
+## Requirements and installation
+
+Use Pi 0.83.0 or newer. Factory access requires either a Factory account or API key. The deterministic catalog and fallback client identity track Droid CLI 0.200.0; an installed Droid CLI can refresh machine-local version and model metadata but is not bundled with this extension.
+
+Install it through the private suite package, then restart Pi or run `/reload` and authenticate with `/login factory`. Verify installation without making a model request:
+
+```bash
+pi --list-models factory
+```
+
+When replacing an existing installation, preserve machine-local credential state. Never copy, overwrite, or share Pi auth storage, `~/.factory/`, or the Factory API-key file. Caches and `node_modules` are not portable installation artifacts.
+
+## Authentication
+
+Run:
+
+```text
+/login factory
+```
+
+Pi's single Factory login entry offers **Use a subscription** or **Use an API key**. Subscription login then offers:
+
+1. Import the existing Droid CLI Factory account from `~/.factory`.
+2. Factory browser/device account login.
+3. Use the rotating API keys already configured in `<agent-dir>/factory/api-keys.json` through a non-secret selector.
+
+Use Pi's native **Use an API key** option to enter and store one Factory API key directly.
+
+Pi stores the selected authentication method under the single `factory` provider. Consequently `/logout` shows one Factory entry and removes whichever Factory credential is active. Switching authentication method means running `/login factory` again; the model catalog does not change.
+
+Configured multi-key mode rotates least-recently-used eligible keys and applies error-specific cooldowns. Eligibility is a billing-pool waterfall: monthly, weekly, and 5-hour windows must all be available for the selected Standard or Droid Core model. Direct API-key and OAuth requests share the same transport/model catalog while applying the appropriate organization-header behavior automatically.
+
+## Models
+
+The extension loads one curated catalog from the installed Droid metadata and `factory/models.ts`. Examples:
+
+- `factory/gpt-5.6-luna`
+- `factory/gpt-5.6-sol`
+- `factory/claude-sonnet-5`
+- `factory/grok-4.6`
+- `factory/deepseek-v4-flash-0731`
+- `factory/deepseek-v4-pro`
+- `factory/glm-5.2`
+- `factory/kimi-k3`
+
+There are no `-oauth` or `-api-key` model duplicates. The user-curated catalog excludes every `-fast` variant and the explicit removals documented in `factory/models.ts`. The current Gemini Pro, MiniMax M3, Nemotron 3 Ultra, and Inkling entries remain hidden; reconsider each family only after its vendor releases a newer generation/model.
+
+## Factory dashboard
+
+```text
+/factory
+```
+
+`/factory` opens a full-width account dashboard combining provider status, authentication, Droid/model metadata, rotation cooldowns, and separate Standard and Droid Core usage for every credential. Percentages are explicitly labeled as **used**. Navigate with the arrow keys or `j`/`k`, press `r` to force-refresh every account, and press Escape to close.
+
+Usage is never estimated from Pi token counts: Factory's API already applies model multipliers and cache-hit discounts. Cached records refresh at most every 15 minutes during normal sessions and after Factory runs; the manual command is the explicit force-refresh path.
+
+Configured rotating API keys remain separate. Each label gets its own Standard and Core record, and the extension never sums or averages them. Fresh cached exhaustion skips only that credential for the relevant model pool. Monthly exhaustion makes weekly and 5-hour availability irrelevant; weekly exhaustion makes 5-hour availability irrelevant. Among keys that pass the complete waterfall, least-recently-used ordering distributes traffic. Recognized pre-output authorization, rate, quota, billing, or exhaustion errors cool down that key and retry the next eligible key in the same request. Expired windows do not block a key.
+
+## Required request behavior
+
+Factory requests use:
+
+- `X-Factory-Client: cli`
+- `X-Client-Version: <detected Droid version>`
+- `User-Agent: factory-cli/<version>`
+- OAuth: bearer token plus active Factory organization
+- API key: bearer API key without OAuth-only organization metadata
+
+The transport also sanitizes the Factory-blocked Pi identity phrase before sending requests.
+
+## Maintenance and validation
+
+See `REFRESH_MODELS.md` and `UPDATING.md` for catalog/client updates. After updating Droid, refresh its cached metadata explicitly:
+
+```bash
+FACTORY_DROID_REFRESH=1 pi --list-models factory
+```
+
+Normal Pi startup and `/reload` do not invoke Droid. After extension changes, run `/reload`, then `/login factory` if no unified credential is stored.
+
+From the repository root, run `npm run validate` to typecheck and test this extension with the complete suite.

package/extensions/factory-provider/REFRESH_MODELS.md

@@ -0,0 +1,185 @@
+# Refreshing Factory/Droid models and capabilities
+
+Normal Pi startup/reload must stay fast and deterministic. The runtime extension should not inspect the Droid binary, call `droid exec --help`, or probe Factory endpoints on every load.
+
+Use this guide only when you explicitly want to refresh the local Factory catalog after Droid/Factory changes.
+
+## When to refresh
+
+Refresh when one of these happens:
+
+- Factory adds/removes models.
+- Droid updates and `droid exec --help` shows a changed model list.
+- A model starts failing because its endpoint family changed.
+- Context windows, max output tokens, image/PDF support, or reasoning levels change.
+- Factory changes required headers or client-version behavior.
+
+## Current runtime source of truth
+
+The extension currently reads deterministic local code at startup:
+
+- `factory/models.ts` — model catalog, capabilities, endpoint family routing.
+- `factory/constants.ts` — Factory/WorkOS constants and Droid fallback version.
+- `factory/responses.ts` — per-family routing and request compatibility fixes.
+
+Normal `/reload` should not run Droid.
+
+## Manual refresh checklist
+
+When you ask to refresh models, inspect the installed Droid binary/CLI locally and update the deterministic catalog.
+
+### 1. Check Droid version and help output
+
+```bash
+which droid
+droid --version
+droid exec --help
+```
+
+Capture:
+
+- model IDs
+- display names
+- default model
+- reasoning support/defaults from `Model details`
+- deprecated markers
+
+### 2. Inspect embedded registry for capabilities
+
+Use binary strings around the model registry instead of guessing:
+
+```bash
+DROID_BIN="$(command -v droid)" python3 - <<'PY'
+import os
+from pathlib import Path
+s = Path(os.environ['DROID_BIN']).read_bytes().decode('utf-8', 'ignore')
+for model in [
+    'gpt-5.6-sol',
+    'claude-opus-5',
+    'gemini-3.1-pro-preview',
+    'gemini-3.7-flash',
+    'grok-4.6',
+    'minimax-m3',
+    'glm-5.2-fast',
+    'kimi-k3',
+    'inkling',
+    'glm-5.2',
+    'deepseek-v4-flash-0731',
+    'deepseek-v4-pro',
+]:
+    pat = f'"{model}":{{id:"{model}"'
+    i = s.find(pat)
+    print('\n###', model, i)
+    if i != -1:
+        j = s.find('},"', i + len(pat))
+        print(s[i:j+1].replace('\x00', ' ')[:2000])
+PY
+```
+
+Look for fields like:
+
+- `contextLimits`
+- `maxInputTokens`
+- `maxOutputTokens`
+- `images`
+- `pdf`
+- `apiProviders`
+- `apiModelProvider`
+- `reasoningEffort`
+- `baseVariant`
+- `availableInCLI`
+- `deprecation`
+
+### 3. Check helper constants in the binary
+
+Some models point at shared helper variables. Inspect those too:
+
+```bash
+DROID_BIN="$(command -v droid)" python3 - <<'PY'
+import os
+from pathlib import Path
+s = Path(os.environ['DROID_BIN']).read_bytes().decode('utf-8', 'ignore')
+for name in ['zuT=', 'zNr=', 'YNr=', 'PTT=', 'aiA=', 'S4T=']:
+    i = s.find(name)
+    print('\n', name, i)
+    if i != -1:
+        print(s[i-300:i+600].replace('\x00', ' '))
+PY
+```
+
+### 4. Update deterministic catalog
+
+Edit:
+
+```text
+extensions/factory-provider/factory/models.ts
+```
+
+Update:
+
+- `BINARY_CAPABILITIES`
+- `FALLBACK_REASONING`
+- `familyForModel()` if endpoint family changes
+- `toPiModel()` only if Pi model shape needs adjustment
+
+Preserve the user-curated visibility policy during every refresh:
+
+- Never expose model IDs ending in `-fast`.
+- Keep Haiku 4.5, Opus 5, Gemini 3.1 Pro Preview, GLM 5.2 Fast, Inkling, MiniMax M3, and Nemotron 3 Ultra hidden.
+- Do not restore the current Gemini Pro, MiniMax M3, Nemotron 3 Ultra, or Inkling entries. Reconsider each family only after its vendor releases a newer generation/model.
+- A model reappearing in Droid metadata is not authorization to publish it in Pi.
+
+Endpoint family routing currently means:
+
+- GPT family: `openai-responses` via `https://api.factory.ai/api/llm/o/v1`
+- Kimi / GLM / DeepSeek / Nemotron: `openai-completions` via `https://api.factory.ai/api/llm/o/v1`
+- Claude / MiniMax: `anthropic-messages` via `https://api.factory.ai/api/llm/a`
+- Gemini: custom Factory Gemini route `https://api.factory.ai/api/llm/g/v1/generate`
+
+### 5. Update constants only if changed
+
+Edit:
+
+```text
+extensions/factory-provider/factory/constants.ts
+```
+
+Check/update:
+
+- `FACTORY_CLIENT_PROTOCOL`
+- `FALLBACK_DROID_VERSION`
+- `FACTORY_API_BASE_URL`
+- `WORKOS_BASE_URL`
+- `WORKOS_CLIENT_ID`
+
+### 6. Validate locally
+
+Typecheck:
+
+```bash
+npx --yes -p typescript tsc --noEmit -p /tmp/factory-tsconfig.json
+```
+
+Then test representative non-fast models only:
+
+```bash
+PI_OFFLINE=1 pi -p --no-tools --no-context-files --no-skills --no-prompt-templates --model factory/gpt-5.6-sol 'Reply with exactly: OK'
+PI_OFFLINE=1 pi -p --no-tools --no-context-files --no-skills --no-prompt-templates --model factory/claude-sonnet-5 'Reply with exactly: OK'
+PI_OFFLINE=1 pi -p --no-tools --no-context-files --no-skills --no-prompt-templates --model factory/gemini-3.7-flash 'Reply with exactly: OK'
+PI_OFFLINE=1 pi -p --no-tools --no-context-files --no-skills --no-prompt-templates --model factory/kimi-k3 'Reply with exactly: OK'
+PI_OFFLINE=1 pi -p --no-tools --no-context-files --no-skills --no-prompt-templates --model factory/glm-5.2 'Reply with exactly: OK'
+```
+
+Avoid fast variants unless specifically debugging them to reduce spend.
+
+## Known gotchas
+
+- Do not run Droid inspection during normal extension load.
+- OAuth requests require `X-Factory-Org-Id` and organization-scoped token refreshes include `organization_id`; direct API-key requests use their own account scope without OAuth-only organization metadata.
+- Factory may block specific Pi system-prompt phrases; compatibility fixes live in `factory/responses.ts`.
+- Factory Anthropic currently rejects system prompts on this OAuth path; `factory/responses.ts` omits Pi's system prompt for Anthropic-family models.
+- Some Factory models use OpenAI Chat rather than Responses even though they are under the same `/api/llm/o/v1` base.
+- Droid 0.200.0 embeds a conservative 262,144/65,536 Kimi K3 proxy limit; the deterministic catalog intentionally uses Kimi's documented 1,048,576 context and 131,072 default completion limit.
+- Explicitly approved feature-gated models are merged from the deterministic fallback catalog when Droid omits them from help. Catalog visibility does not bypass Factory account/org entitlement; gated endpoints may still reject live requests.
+- Core-model `fireworks`/`baseten` overrides are selected per model from current OpenRouter throughput, latency, uptime, and context data; re-check them when Droid or provider telemetry changes.
+- Gemini uses Factory's custom `/api/llm/g/v1/generate` shape, not the standard Google SDK URL layout.

package/extensions/factory-provider/UPDATING.md

@@ -0,0 +1,97 @@
+# Updating Factory Droid OAuth provider
+
+## Routine update flow
+
+Factory's model list and required client version should follow the installed Droid CLI.
+
+```bash
+droid --version
+droid exec --help
+```
+
+Refresh the deterministic Droid cache explicitly, then reload Pi:
+
+```bash
+FACTORY_DROID_REFRESH=1 pi --list-models factory
+```
+
+```text
+/reload
+```
+
+Normal startup and reload do not invoke Droid; they use the refreshed cache or deterministic fallback catalog.
+
+## Files to update manually if needed
+
+- `factory/constants.ts`
+  - `FACTORY_CLIENT_PROTOCOL`
+  - `FALLBACK_DROID_VERSION`
+  - WorkOS/API base URLs if Factory changes them.
+- `factory/models.ts`
+  - `parseModelsFromDroidHelp()` if Droid help formatting changes.
+  - `BINARY_CAPABILITIES` for context window, max output tokens, image support, and PDF support.
+  - `DROID_MODELS_FALLBACK` if parser fails or Droid is unavailable.
+- `factory/auth.ts`
+  - WorkOS device/refresh flow and Droid encrypted auth import.
+
+## Updating Droid
+
+Try Droid's updater first:
+
+```bash
+droid update
+```
+
+If unavailable, reinstall via Factory's current installer:
+
+```bash
+curl -fsSL https://app.factory.ai/cli | sh
+```
+
+Then verify:
+
+```bash
+which droid
+droid --version
+droid exec --help
+```
+
+## Binary inspection checklist
+
+If Factory changes endpoints or headers, inspect the installed binary locally:
+
+```bash
+strings "$(which droid)" | rg 'api/llm/o/v1|X-Factory-Client|X-Client-Version|workos|authorize/device|client_01HNM'
+```
+
+Known current values:
+
+- Model registry values are embedded near the Droid binary strings for `$o={...}` with fields like `contextLimits`, `images`, and `pdf`.
+- Examples verified through Droid 0.200.0:
+  - Gemini 3.7 Flash: `maxInputTokens: 1000000`, `maxOutputTokens: 65536`, PDF and image input enabled, with `low`, `medium`, and `high` reasoning.
+  - Inkling: `maxInputTokens: 1040000`, `maxOutputTokens: 32768`, images enabled, PDF disabled, Fireworks and Baseten routes.
+  - DeepSeek V4 Flash 0731: `maxInputTokens: 1040000`, `maxOutputTokens: 131072`, images/PDF disabled, Fireworks route.
+  - Claude Opus 4.8: `contextLimits: zuT` => `maxInputTokens: 867000`, `maxOutputTokens: 128000`, `pdf: true`, images enabled.
+  - Claude Sonnet 4.6: `maxInputTokens: 931000`, `maxOutputTokens: 64000`.
+  - GPT-5.6/GPT-5.5 Pro: `maxInputTokens: 1050000`, `maxOutputTokens: 128000`.
+  - Grok 4.6: `maxInputTokens: 200000`, `maxOutputTokens: 63356`, images enabled, PDF disabled.
+  - MiniMax M3: `maxInputTokens: 512000`, `maxOutputTokens: 64000`, images enabled, PDF disabled.
+  - GLM-5.2: `maxInputTokens: 1040000`, `maxOutputTokens: 131072`, no images/PDF.
+  - GLM-5.2 Fast: `maxInputTokens: 524288`, `maxOutputTokens: 131072`, no images/PDF.
+  - DeepSeek V4 Pro: `maxInputTokens: 1040000`, `maxOutputTokens: 65536`, no images/PDF.
+- Responses base: `https://api.factory.ai/api/llm/o/v1`
+- Required headers:
+  - `X-Factory-Client: cli`
+  - `X-Client-Version: <droid --version>`
+- WorkOS base: `https://api.workos.com/user_management`
+- Production WorkOS client ID: `client_01HNM792M5G5G1A2THWPXKFMXB`
+
+## Smoke test after updates
+
+1. `/reload`
+2. `/login factory` if not logged in.
+3. Run `/factory`.
+4. Confirm every configured credential appears in the dashboard with separately labeled Standard and Droid Core usage.
+5. Send a tiny prompt with `factory/gpt-5.6-sol` or another known model.
+
+If Factory responds with `Unable to determine client version`, inspect/update `FACTORY_CLIENT_PROTOCOL` or Droid version detection.