Pi Project Update

Here is today's Pi Project Update for Wednesday October 28th. Pi has added a more informative extension-update experience. Extension authors can now declare a changelog path in their package manifest, while packages without that field can fall back to a standard CHANGELOG.md file. After an extension update, Pi records the installed version and, on the next interactive launch, displays the entries users missed under an Extension Updates section. First-time installs remain quiet, and a collapse setting can reduce updates to one line per package. It gives extension users a clearer answer to the question: what actually changed after an update? [1]

A major internal refactor also modernizes Pi’s model catalog. Rather than deriving every model from one generator, the project now defines providers individually, applies shared rules for major model families including Claude, GPT, DeepSeek, Kimi, and Google, and reads models.dev through its version-two API. Command-line behavior stays the same, but the new structure should make it easier to maintain providers and respond to rapidly changing model inventories.

Pi is also reducing unnecessary prompt churn and token overhead. When an extension re-submits the same active tools in a different order, Pi now preserves the existing order instead of generating a needless system-prompt update. That avoids cache misses on providers that cannot apply mid-conversation system messages. Separately, Code Mode now summarizes union-shaped tool outputs by their fields rather than embedding massive rendered TypeScript types. One reported tool had been adding roughly 8,000 characters to every request; complex multiline types now point users to a dedicated description command instead.

Finally, several quality-of-life fixes target terminal use and resilience. Fullscreen mode moves the model-scope notice into Pi’s header so it does not remain in shell scrollback after exit. Starting Pi from a deleted directory now produces a clear instruction to change to an existing directory instead of an uncaught Node error. The Markdown renderer also correctly ends bare links at Chinese punctuation.

The theme today is efficient clarity: better update communication, a more maintainable provider foundation, and fewer hidden costs or confusing artifacts in everyday sessions. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Tuesday October 27th. Yesterday’s most consequential compatibility fix updates Pi’s OpenCode routing. Instead of sending every OpenCode and OpenCode Go request through a shared inference address, Pi now selects the documented endpoint for each API protocol: OpenAI-style completions and responses, Anthropic messages, Google’s generative API, and Jev models all receive their own correct paths. The team verified real requests across those protocols, while Go requests reached the expected subscription check. This reduces the chance that future OpenCode endpoint changes break existing Pi model configurations. [1]

Extension-driven interfaces also received several practical fixes. Inline custom dialogs can now declare that they are blocked waiting for user input, allowing Pi to report that state through its terminal program-status signal. That matters for approval prompts and other custom interactions, which previously looked like the agent was still working. Separately, replacing the editor component no longer hides an open extension dialog and leaves its promise hanging. Pi keeps the dialog visible until it is answered, then restores focus to the new editor.

For model access, Pi has changed the default OpenAI model from gpt-5.5 to gpt-6.1-sol. The update applies after login, at startup fallback, and when users explicitly choose the OpenAI provider without naming a model. It aligns the standard OpenAI path with the defaults already used for OpenAI Codex and GitHub Copilot, addressing reports that the previous model no longer worked with ChatGPT subscriptions. [2]

There are also quality-of-life improvements across the terminal and package workflow. Kitty-protocol users gain reliable F1 through F12 shortcuts, including modified function keys, while F13 and above no longer insert invisible characters into prompts. Package installation, removal, and extension updates now suppress npm audit and funding noise—particularly important because following npm’s suggested audit fix inside Pi’s managed extension directory could install a duplicate Pi dependency tree.

The broader trend is ecosystem resilience: Pi is tightening provider integrations, making extension UI state observable and recoverable, and eliminating configuration traps that create confusing failures for advanced users. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Monday October 26th. A security-focused report today flags a potentially serious startup problem in Pi 1.4.0: before a project has been trusted, Pi may read that project’s `.pi/settings.json` without first checking its type or size. A malicious repository could make that file a symlink to `/dev/zero`, causing Pi to hang and consume memory before showing its trust prompt. The proposed remedy is to defer project-settings reads until trust is established, reject symlinks and non-regular files, and cap file sizes. [1]

A second privacy issue concerns session storage on shared machines. Newly created session JSONL files reportedly inherit ordinary system permissions—typically readable by other local users—and their directories can also be broadly accessible. Since sessions may include prompts, source code, tool output, and secrets, the proposed change is straightforward: create new session files with owner-only permissions, matching Pi’s existing handling of its authentication file.

MCP integration is another major theme. One report says an interrupted OAuth login can leave stale authorization state and code-verifier data behind, making the next login fail even after `/mcp logout`. Other proposals would make client shutdown resilient when a cleanup callback fails, automatically prefer Client ID Metadata Documents when an authorization server advertises them, and loosen protected-resource URL validation where standards allow related resource URLs. Together, these reports point to a push for MCP connections that recover cleanly from partial failures instead of requiring manual JSON cleanup.

Finally, contributors identified several agent-loop correctness problems: Pi’s grep tool can corrupt UTF-16 search results when surrounding context is requested, while switching a conversation from another provider to an OpenAI Responses model can replay tool calls without their required namespace and trigger a 400 error. Both cases matter because they can give an agent either misleading source text or an abrupt failure precisely when users switch models. [2]

The broader trend is defensive reliability. Today’s activity is less about new capabilities than tightening trust boundaries, protecting local data, and ensuring that cleanup, search, OAuth, and cross-provider conversation history behave predictably under failure conditions. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Sunday October 25th. Pi has shipped a useful fix for anyone running local or self-hosted models through URL-style provider IDs. Previously, a command such as `--model provider/model` could fail when the provider’s own identifier included a slash—for example, an ID derived from a local llama.cpp server URL. Pi split the reference at the first slash, mistaking part of the URL for the complete provider name. The resolver now compares against known provider IDs and selects the longest valid match. That restores model selection for local-model extensions, including references with thinking-level suffixes, and regression tests confirm the behavior. [1]

A second fix targets extension-package management when the Pi agent directory is a symbolic link. Users who keep their Pi configuration inside a dotfiles repository could see `package-lock.json` paths become more deeply nested after every package install or update. Pi was passing the symlinked directory to npm as its installation prefix. It now resolves the actual filesystem path before invoking npm, pnpm, or Bun, preventing lockfile growth while leaving Pi’s extension-loading paths unchanged. The project verified the fix through automated tests and a repeated manual install-and-remove reproduction.

Testing isolation has also tightened. Pi’s `pi-test.sh --no-env` mode is intended to launch without provider credentials, but its hard-coded cleanup list had fallen behind the growing catalog of supported environment variables. API keys for services including DeepSeek, Moonshot, Cloudflare, Nvidia, and others could still leak into an ostensibly credential-free test. Today’s change adds 26 missing variables, so offline and no-environment checks more reliably reflect a clean installation.

Finally, Windows development checks are now consistent with macOS and Linux. A repository script used Windows backslashes in relative paths while its allow and deny patterns expected forward slashes. That could both report false violations and miss real dependency-boundary problems. Normalizing separators before comparison fixes the discrepancy. [2]

The pattern across today’s work is operational consistency: Pi is making model references, package installs, test environments, and cross-platform validation behave predictably in the configurations advanced users actually run. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Saturday October 24th. Pi’s most significant new engineering work is aimed at preventing slow or stalled agent processes under heavy streaming loads. A commit today changes how streamed tool-call arguments are handled for OpenAI-compatible completions: instead of repeatedly reparsing an ever-growing JSON string on every incoming chunk, Pi now parses incrementally. The old pattern could create quadratic work for large tool arguments and freeze a shared, single-process agent host. This is a meaningful scalability improvement for long-running or multi-session deployments.

The project also continues building its durable-agent infrastructure. New Chord and Durable changes fold pending operations for slow consumers, while the Watch mechanism now delivers one callback per busy period rather than overwhelming a consumer with redundant updates. Another addition, appendText, makes inexpensive string appends available to Durable partial commits. Together, these are backend-oriented changes, but they point toward more efficient state synchronization when agents are persistent and reactive.

Yesterday’s merged fixes address several concrete user-facing failures. Gemini tool calls now work correctly with literal schema values: Pi converts string and numeric JSON Schema const fields into single-value enums before sending them to Google. Gemini had ignored const constraints, causing models to invent values that Pi then rejected during validation.

Pi also made large-session forks dramatically more efficient. Forking previously opened and closed the target session file once per copied entry, so a 73-megabyte session with thousands of entries could take more than 30 seconds on systems with endpoint monitoring. The revised implementation writes through one file descriptor, cutting thousands of file opens down to one write operation.

Finally, the model picker now displays customized model names when they add useful context, helping users distinguish configured OpenRouter variants and aliases without cluttering the full catalog.

The emerging theme is operational maturity: Pi is reducing avoidable work in streaming, durable state handling, and disk I/O, while making model configuration and provider behavior easier to trust. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Friday October 23rd. Pi has fixed a terminal-rendering bug that could let a deeply nested Markdown blockquote crash the application. A pasted line containing dozens of greater-than signs could make each quote level repeatedly wrap and prefix the previous one, causing output to grow exponentially. At typical terminal widths, this could turn a tiny message into thousands or even millions of lines, eventually triggering a JavaScript stack error and exiting Pi. The new renderer stops adding borders once there is no room left, preserves the quoted content, and avoids another large-array failure mode. A regression test covers 60 nested quote levels. [1]

Another important reliability improvement changes what happens when a configured extension package cannot be installed. Previously, one bad npm package in settings could abort Pi startup with a raw Node stack trace—even for simple commands such as help, model listing, or a one-shot prompt. Pi now skips only the package that failed, starts with packages that did install, and prints a clear warning with the appropriate `pi remove` command. Failed sources are also not retried repeatedly within the same process, reducing startup delays and duplicate npm errors. [2]

The project also improved model identity tracking for agent integrations. Pi message terminal events now retain the physical model that actually generated a response, rather than only a virtual or alias model name. That is particularly useful for routing layers that offer labels such as “cheap,” where downstream tools need to know the real provider model for accounting, compatibility, or deciding whether reasoning traces remain valid.

Finally, standalone binary builds have been updated for Bun version 1.4.4. The change was tested across macOS, Linux, and Windows on both ARM and x86 architectures, including streaming cancellation, file tools, image resizing, HTTPS, and session resume.

The common theme is graceful degradation. Pi is hardening the paths where malformed content, unavailable dependencies, abstraction layers, or packaging changes previously could turn into a crash or an opaque failure. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Thursday October 22nd. Pi’s most significant update today improves cost accuracy for OpenRouter users. Rather than relying solely on catalog estimates, Pi now uses the actual total cost returned by OpenRouter for each request. That matters because OpenRouter can route the same model to providers with very different prices, making estimated charges wrong by two or three times in some cases. Pi will retain estimated input, output, and cache breakdowns, but its headline total now reflects the amount actually billed. A new flag also identifies when a usage total came directly from a provider, giving users and extensions clearer accounting provenance. [1]

Pi is also preparing preview packages for contributors and early adopters. The new automation can publish installable package previews from pull requests, backed by a dedicated workflow and test coverage. In practical terms, this should make it easier to test a proposed fix or feature before it lands in a formal release, without manually building the monorepo from source. That shortens the feedback loop for extension authors and downstream integrators.

Yesterday’s reliability work addressed two subtle coding-agent failures. First, Pi now removes matching tool results whenever it hides a truncated assistant tool call during length-limit recovery. Previously, a resumed session could retain a tool result without the corresponding tool call, causing OpenAI to reject every later prompt. Second, Pi’s built-in grep now invokes ripgrep with its configuration disabled. Personal ripgrep settings could silently change an agent’s regex search into a literal search, producing incomplete results without an obvious error. Searches should now behave consistently across machines.

The project also released Pi version 1.4.0, alongside fixes for Anthropic system-message ordering and continued work on durable-storage infrastructure.

The larger trend is trustworthiness in the agent loop: accurate financial reporting, deterministic tools, recoverable session history, and faster community validation through preview builds. Pi is increasingly focusing not just on what agents can do, but on making their behavior reproducible, inspectable, and safe to operate at scale. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Wednesday October 21st. Yesterday’s development focused heavily on making Pi more dependable when providers, terminals, and long-running sessions behave imperfectly.

First, Pi tightened its OpenAI Codex support. The project removed two Codex model entries that OpenAI no longer serves to ChatGPT-account users, preventing users from selecting models that would fail every request. Pi also expanded retry handling for proxy-relayed “stream disconnected” failures and corrected status-code matching so numbers embedded in request IDs do not accidentally trigger retries. Together, these changes should reduce confusing dead ends while avoiding inappropriate repeat requests.

Second, compaction is receiving an important correctness fix. When Pi compacted a conversation in the middle of a turn, a user’s custom `/compact` instructions could be dropped from the prefix-summary request. That meant a requested focus—such as preserving implementation decisions or test results—might be ignored precisely when the session was being condensed. The update now carries those instructions into both summary paths, improving continuity in very long agent sessions.

The terminal interface also saw practical polish. File autocomplete now escapes regular-expression characters in single-segment `@` queries, so filenames such as `[id].tsx` and `(group).ts` can be completed literally instead of silently returning no results. Pi additionally prevents an unclosed display-math marker from swallowing a later Markdown table. And Rex terminal users gain Kitty image-protocol support, enabling inline images where that terminal supports them. [1]

Finally, several fixes improve Pi’s behavior around background execution and system integration. Codemode scripts are now queued rather than immediately rejected when the worker limit is reached, which is especially useful for hosts running multiple agents in one process. Pi also keeps Wayland clipboard helpers outside its process group, so suspending Pi with Control-Z should no longer freeze clipboard pastes. A separate fix accepts UTF-8 BOM-marked MCP configuration files, easing interoperability with Windows-generated JSON.

The broader trend is clear: Pi is concentrating on graceful recovery and accurate state—across providers, compacted context, terminal rendering, and embedded agent workflows. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Tuesday October 20th. Today’s most consequential change improves prompt-cache stability for OpenAI Responses, Codex, and Copilot integrations. Pi fixed a case where removing or redeclaring a tool caused later deferred tool loads to rewrite the top-level tool list, invalidating the provider’s cached prompt prefix. In one reported session, that meant cache reads fell from more than 153,000 tokens to zero and uncached input jumped dramatically. The new approach keeps tool declarations in incremental additions where supported, while communicating removals separately. For long-running, tool-heavy coding sessions, this should reduce repeated context costs and latency.

Pi also merged a pair of internationalization fixes for Markdown emphasis. Chinese, Japanese, and Korean text could leave bold markers visible when fullwidth punctuation appeared beside the closing double asterisks—a common pattern in AI-generated CJK prose. The project now uses a narrowly scoped CJK-aware emphasis tokenizer in both the terminal interface and HTML export, with regression tests for the same cases. English Markdown behavior remains unchanged, while CJK-language transcripts should look correct whether viewed live or exported. [1]

Yesterday, Pi added recovery for GitHub Copilot request-size overflows. Very large sessions, particularly those containing many images, could exceed Copilot’s request limit and require users to manually run compaction. The update improves automatic overflow handling, reducing a frustrating failure point in long multimodal conversations. [2]

There is also continued polish for platform-specific terminal use. Yesterday’s Windows updates improve shell discovery from nonstandard install locations and accept runnable Windows Store shell aliases that Node’s older existence checks could reject. Pi additionally recognizes the Rex terminal, enabling OSC 8 hyperlinks and truecolor output while keeping unsupported terminal-image features disabled.

The broader trend is a focus on preserving continuity: cached context survives changing tools, long sessions recover from provider limits, rendering works across languages and exports, and terminal setup becomes less brittle across environments. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!

Here is today's Pi Project Update for Monday October 19th. Yesterday, Pi added telemetry foundations across its AI and durable-agent components. New commits make telemetry available as an always-present span on the shared context object, then propagate that information through Chord contexts with span links and metrics. This is mostly infrastructure rather than a user-facing feature, but it could make distributed and long-running agent runs far easier to observe, measure, and diagnose. As Pi Durable evolves toward persistent automation, consistent tracing is becoming a key operational requirement.

Pi also updated its model catalog for MiniMax. The new MiniMax-M3.1-Flash model has been added, while only older MiniMax models are hidden. That should ensure the latest lightweight MiniMax option appears in Pi’s supported provider listings rather than being filtered out by the project’s explicit allowlist. It is another example of the maintenance burden behind a broad model catalog: model availability is not just a provider announcement, but a combination of identifiers, compatibility settings, defaults, and generated catalog data.

Several newly closed reports highlight potential improvements in the terminal experience. One calls for drag-selection autoscroll to accelerate based on pointer distance and hold time, instead of remaining fixed at roughly 20 lines per second. Another proposes lazy loading for inline tool-result images, displaying compact placeholders until a user clicks to expand. For image-heavy or long transcript sessions, that could reduce redraws, terminal transfers, and sluggish scrolling—particularly over remote connections. [1]

The latest user reports also focus on avoiding silent failure modes in agent workflows. Examples include a subagent configuration that can accidentally receive zero tools without warning, a race between pending model changes and session-tree navigation, and a streaming OpenAI-compatible request that may not retry after an unexpected mid-stream abort. These are reports, not confirmed fixes, but together they point to the same priority: making extensions, tool registration, session state, and network recovery explicit and observable.

The broader trend is a shift from feature breadth toward dependable operations. Pi is continuing to add models and polish its interface, while investing in telemetry and surfacing the difficult edge cases that matter most for persistent, tool-using agents. Thank you for listening to Pi Project Update from The Daily FM. See you tomorrow!