chore(pi): upgrade agent to 1.0.0

Author: Bill Leoutsakos

apps/sim/executor/handlers/pi/cloud/cli-runtime.test.ts

@@ -0,0 +1,88 @@
+import { execFile } from 'node:child_process'
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+import { describe, expect, it } from 'vitest'
+import { PI_EVENT_FILTER_SOURCE } from '@/executor/handlers/pi/cloud/event-filter-source'
+import { buildPiScript } from '@/executor/handlers/pi/cloud/shared'
+import { PI_PACKAGE_VERSION } from '@/scripts/pi-sandbox-packages'
+
+const exec = promisify(execFile)
+
+async function invokeSandbox(version: string, exitCode = 0) {
+  const root = await mkdtemp(join(tmpdir(), 'sim-pi-cli-'))
+  const workspace = join(root, 'workspace')
+  const repo = join(workspace, 'repo')
+  const bin = join(root, 'bin')
+  await mkdir(repo, { recursive: true })
+  await mkdir(bin)
+  await writeFile(join(workspace, 'pi-prompt.txt'), 'fixture prompt')
+  await writeFile(join(workspace, 'sim-pi-event-filter.mjs'), PI_EVENT_FILTER_SOURCE)
+  await writeFile(
+    join(bin, 'pi'),
+    `#!/bin/bash
+if [ "$1" = "--version" ]; then
+  printf "%s\\n" "${version}"
+  exit 0
+fi
+printf "%s" "$PI_CODING_AGENT_DIR" > "${root}/invoked"
+printf "%s\\n" '{"type":"message_update","assistantMessageEvent":{"type":"text_delta","delta":"ok"}}'
+exit ${exitCode}
+`,
+    { mode: 0o700 }
+  )
+  const script = buildPiScript().replaceAll('/workspace', workspace)
+  try {
+    const result = await exec('/bin/bash', ['-c', script], {
+      env: {
+        ...process.env,
+        PATH: `${bin}:${process.env.PATH}`,
+        PI_PROVIDER: 'fixture',
+        PI_MODEL: 'fixture',
+        PI_THINKING: 'off',
+      },
+    }).then(
+      ({ stdout, stderr }) => ({ code: 0, stdout, stderr }),
+      (error: { code: number; stdout: string; stderr: string }) => error
+    )
+    const invoked = await readFile(join(root, 'invoked'), 'utf8').catch(() => null)
+    const settings = invoked
+      ? await readFile(join(invoked, 'settings.json'), 'utf8').catch(() => null)
+      : null
+    const storedFiles = invoked ? await readdir(invoked).catch(() => []) : []
+    return { ...result, invoked, settings, storedFiles, repo }
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+}
+
+describe('sandbox Pi runtime boundary', () => {
+  it.each(['0.80.10', 'unexpected-version'])(
+    'rejects %s before starting the agent',
+    async (version) => {
+      const result = await invokeSandbox(version)
+      expect(result.code).not.toBe(0)
+      expect(result.invoked).toBeNull()
+      expect(result.stderr).toMatch(/rebuild|update/i)
+      expect(result.stderr).toContain(PI_PACKAGE_VERSION)
+    }
+  )
+
+  it('uses private settings outside the repository with warming off and no saved credentials', async () => {
+    const result = await invokeSandbox(PI_PACKAGE_VERSION)
+    expect(result.code).toBe(0)
+    expect(result.invoked).toBeTruthy()
+    expect(result.invoked?.startsWith(result.repo)).toBe(false)
+    expect(JSON.parse(result.settings ?? '{}')).toEqual({ cacheWarming: 'off' })
+    expect(result.storedFiles).toEqual(['settings.json'])
+    expect(JSON.parse(result.stdout.trim())).toEqual({
+      type: 'message_update',
+      assistantMessageEvent: { type: 'text_delta', delta: 'ok' },
+    })
+  })
+
+  it('propagates a failing CLI even when the stdout filter succeeds', async () => {
+    expect((await invokeSandbox(PI_PACKAGE_VERSION, 42)).code).toBe(42)
+  })
+})

apps/sim/executor/handlers/pi/cloud/event-filter-source.ts

@@ -2,10 +2,9 @@
  * The stdout filter the sandbox modes pipe the Pi CLI through, written at runtime like the search
  * extension and the review tools script next to it.
  *
- * Pi's `--mode json` writes `JSON.stringify(event)` for every session event with no filtering, and
- * `message_update` repeats the whole assistant message alongside each delta — so raw stdout grows
- * with the square of the response length, and `tool_execution_end`, `turn_end`, and `agent_end`
- * each add a full tool result, turn transcript, or run transcript on top of that.
+ * Pi 1.0 emits delta-only `message_update` events, but `tool_execution_end`, `turn_end`, and
+ * `agent_end` still include tool results and transcripts. The filter preserves Sim's event
+ * contract without retaining those cumulative payloads.
  *
  * The reduction has to happen in the sandbox because by the time Sim could drop the bytes they are
  * already retained: E2B's SDK accumulates every callback-delivered chunk internally, so its adapter

apps/sim/executor/handlers/pi/cloud/installed-cli.test.ts

@@ -0,0 +1,109 @@
+import { execFile } from 'node:child_process'
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import * as http from 'node:http'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { promisify } from 'node:util'
+import { describe, expect, it } from 'vitest'
+import { PI_EVENT_FILTER_SOURCE } from '@/executor/handlers/pi/cloud/event-filter-source'
+import { buildPiScript } from '@/executor/handlers/pi/cloud/shared'
+import {
+  FIXTURE_KEY,
+  startPiProviderFixture,
+} from '@/executor/handlers/pi/core/__fixtures__/provider'
+import { applyPiEvent, createPiTotals, parseJsonLine } from '@/executor/handlers/pi/core/events'
+import { PI_SEARCH_EXTENSION_SOURCE } from '@/executor/handlers/pi/search/extension-source'
+
+const exec = promisify(execFile)
+
+describe('installed Pi CLI wire', () => {
+  it('loads explicit Sim search with --no-extensions and keeps warming disabled', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'sim-pi-installed-cli-'))
+    const workspace = join(root, 'workspace')
+    const fixture = await startPiProviderFixture(http)
+    try {
+      const repo = join(workspace, 'repo')
+      const bin = join(root, 'bin')
+      const providerPath = join(root, 'provider.ts')
+      const searchPath = join(workspace, 'sim-search-extension.ts')
+      const preload = join(root, 'preload.mjs')
+      await mkdir(join(repo, '.pi', 'extensions'), { recursive: true })
+      await mkdir(bin)
+      await writeFile(
+        join(repo, '.pi', 'extensions', 'poison.ts'),
+        'throw new Error("repository extension loaded")'
+      )
+      await writeFile(join(workspace, 'pi-prompt.txt'), 'search-fixture')
+      await writeFile(join(workspace, 'sim-pi-event-filter.mjs'), PI_EVENT_FILTER_SOURCE)
+      await writeFile(searchPath, PI_SEARCH_EXTENSION_SOURCE)
+      await writeFile(
+        providerPath,
+        `export default function(pi) { pi.registerProvider("fixture", ${JSON.stringify({ ...fixture.provider, apiKey: FIXTURE_KEY })}) }`
+      )
+      await writeFile(
+        preload,
+        `const guard = (originalFetch) => (input, init) => {
+ const url = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url);
+ if (url.origin === "https://api.exa.ai" && url.pathname === "/search") return originalFetch(${JSON.stringify(`${fixture.baseUrl}/exa`)}, init);
+ if (url.origin === ${JSON.stringify(fixture.baseUrl)}) return originalFetch(input, init);
+ throw new Error("Unexpected external fixture traffic: " + url.origin);
+};
+let guardedFetch = guard(globalThis.fetch);
+Object.defineProperty(globalThis, "fetch", { configurable: true, get: () => guardedFetch, set: (fetch) => { guardedFetch = guard(fetch); } });`
+      )
+      const cli = join(
+        dirname(fileURLToPath(import.meta.resolve('@earendil-works/pi-coding-agent'))),
+        'bundle',
+        'cli.js'
+      )
+      await writeFile(join(bin, 'pi'), `#!/bin/bash\nexec node "${cli}" "$@"\n`, { mode: 0o700 })
+      const script = buildPiScript('/workspace/sim-search-extension.ts', {
+        disableRepositoryResources: true,
+      })
+        .replaceAll('/workspace', workspace)
+        .replace(' < ', ` -e ${providerPath} < `)
+      const { stdout } = await exec('/bin/bash', ['-c', script], {
+        env: {
+          ...process.env,
+          PATH: `${bin}:${process.env.PATH}`,
+          NODE_OPTIONS: `--import ${preload}`,
+          PI_OFFLINE: '1',
+          PI_PROVIDER: 'fixture',
+          PI_MODEL: 'fixture-model',
+          PI_THINKING: 'medium',
+          SIM_SEARCH_PROVIDER: 'exa',
+          SIM_SEARCH_API_KEY: FIXTURE_KEY,
+        },
+        timeout: 15_000,
+      })
+      const totals = createPiTotals()
+      for (const line of stdout.split('\n')) {
+        const event = parseJsonLine(line)
+        if (event) applyPiEvent(totals, event)
+      }
+      expect(JSON.stringify(fixture.requests.at(-1)?.body.messages)).toContain(
+        'Offline search evidence'
+      )
+      expect(totals).toEqual({
+        finalText: 'fixture complete',
+        inputTokens: 14,
+        outputTokens: 6,
+        toolCalls: [{ name: 'web_search', isError: false }],
+      })
+      expect(fixture.requests.map(({ path }) => path)).toEqual([
+        '/v1/chat/completions',
+        '/exa',
+        '/v1/chat/completions',
+      ])
+      const agentDir = join(workspace, 'sim-pi-agent')
+      expect(JSON.parse(await readFile(join(agentDir, 'settings.json'), 'utf8'))).toEqual({
+        cacheWarming: 'off',
+      })
+      expect(JSON.parse(await readFile(join(agentDir, 'auth.json'), 'utf8'))).toEqual({})
+    } finally {
+      await fixture.close()
+      await rm(root, { recursive: true, force: true })
+    }
+  }, 30_000)
+})

apps/sim/executor/handlers/pi/cloud/review/backend.test.ts

@@ -201,6 +201,7 @@ describe('runCloudReviewPi', () => {
 
     expect(mockSetRuntimeApiKey).toHaveBeenCalledWith('anthropic', 'sk-byok')
     expect(mockRemoveRuntimeApiKey).toHaveBeenCalledWith('anthropic')
+    expect(mockSdk.SettingsManager.inMemory).toHaveBeenCalledWith({ cacheWarming: 'off' })
     expect(mockCreateSealedResourceLoader).toHaveBeenCalledTimes(1)
     expect(mockCreateAgentSession).toHaveBeenCalledWith(
       expect.objectContaining({

apps/sim/executor/handlers/pi/cloud/review/backend.ts

@@ -300,7 +300,7 @@ export const runCloudReviewPi: PiBackendRun<PiCloudReviewRunParams> = async (par
             )
           }
 
-          const settingsManager = sdk.SettingsManager.inMemory()
+          const settingsManager = sdk.SettingsManager.inMemory({ cacheWarming: 'off' })
           const resourceLoader = createSealedPiResourceLoader(
             sdk,
             buildReviewSystemPrompt(Boolean(searchTool))

apps/sim/executor/handlers/pi/cloud/shared.ts

@@ -9,6 +9,7 @@ import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
 import { resolvePiSandboxLifetimeMs } from '@/lib/execution/remote-sandbox/pi-lifetime'
 import { PI_EVENT_FILTER_PATH } from '@/executor/handlers/pi/cloud/event-filter-source'
 import { scrubPiSecrets } from '@/executor/handlers/pi/core/redaction'
+import { PI_PACKAGE_VERSION } from '@/scripts/pi-sandbox-packages'
 
 export const REPO_DIR = '/workspace/repo'
 export const PROMPT_PATH = '/workspace/pi-prompt.txt'
@@ -141,6 +142,10 @@ export const PUSH_SCRIPT = `cd ${REPO_DIR}
  * there first — skipping that write does not fall back to the raw stream, it fails the run on the
  * missing module.
  *
+ * Rejects stale images before starting the agent. Each invocation resets Sim's private agent
+ * directory outside the clone, so neither stored credentials nor cache-warming settings can leak
+ * between rounds. Model credentials remain environment-only.
+ *
  * Selects `/bin/bash` explicitly because `pipefail` is not portable to `/bin/sh`, and without it
  * the pipeline reports the filter's exit code rather than Pi's, so an upstream crash would read as
  * a clean run. Both dedicated Pi images are Debian-based and provide Bash, so provider
@@ -165,7 +170,17 @@ export function buildPiScript(
       ? ' --no-extensions'
       : ''
   const extensionArgs = extensionPath ? ` -e ${extensionPath}` : ''
-  return `/bin/bash -o pipefail -c 'cd ${REPO_DIR}
+  return `/bin/bash -o pipefail -c 'set -e
+if ! PI_INSTALLED_VERSION="$(pi --version 2>/dev/null)" || [ "$PI_INSTALLED_VERSION" != "${PI_PACKAGE_VERSION}" ]; then
+  printf "%s\\n" "Pi sandbox runtime must be ${PI_PACKAGE_VERSION}. Rebuild or update the configured Pi sandbox image before running this workflow." >&2
+  exit 1
+fi
+export PI_CODING_AGENT_DIR=/workspace/sim-pi-agent
+(umask 077
+rm -rf "$PI_CODING_AGENT_DIR"
+mkdir -p "$PI_CODING_AGENT_DIR"
+printf "%s\\n" "{\\"cacheWarming\\":\\"off\\"}" > "$PI_CODING_AGENT_DIR/settings.json")
+cd ${REPO_DIR}
 pi -p --mode json --provider "$PI_PROVIDER" --model "$PI_MODEL" --thinking "$PI_THINKING"${repositoryArgs}${extensionArgs} < ${PROMPT_PATH} | node ${PI_EVENT_FILTER_PATH}'`
 }
 

apps/sim/executor/handlers/pi/core/__fixtures__/provider.ts

@@ -0,0 +1,119 @@
+import { once } from 'node:events'
+import type * as NodeHTTP from 'node:http'
+import type { AddressInfo } from 'node:net'
+import type { ProviderConfig } from '@earendil-works/pi-coding-agent'
+
+export const FIXTURE_KEY = 'pi-offline-fixture-key'
+
+export async function startPiProviderFixture(http: typeof NodeHTTP) {
+  const requests: Array<{ path: string; body: Record<string, unknown>; authorization?: string }> =
+    []
+  let onRequest: (() => void) | undefined
+  const requested = new Promise<void>((resolve) => {
+    onRequest = resolve
+  })
+  const server = http.createServer(async (request, response) => {
+    let raw = ''
+    for await (const chunk of request) raw += chunk
+    const body = JSON.parse(raw || '{}') as Record<string, unknown>
+    requests.push({ path: request.url ?? '', body, authorization: request.headers.authorization })
+    onRequest?.()
+    if (request.url === '/exa') {
+      response.setHeader('content-type', 'application/json')
+      response.end(
+        JSON.stringify({
+          results: [
+            {
+              title: 'Fixture result',
+              url: 'https://example.com/fixture',
+              text: 'Offline search evidence',
+            },
+          ],
+        })
+      )
+      return
+    }
+    const messages = Array.isArray(body.messages) ? body.messages : []
+    const prompt = JSON.stringify(messages)
+    if (prompt.includes('provider-error')) {
+      response.writeHead(400, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          error: { message: `provider failed ${FIXTURE_KEY}`, type: 'invalid_request_error' },
+        })
+      )
+      return
+    }
+    response.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' })
+    const chunk = (delta: Record<string, unknown>, finish: string | null = null) => {
+      response.write(
+        `data: ${JSON.stringify({ id: 'fixture', object: 'chat.completion.chunk', model: 'fixture-model', choices: [{ index: 0, delta, finish_reason: finish }] })}\n\n`
+      )
+    }
+    chunk({ role: 'assistant' })
+    if (prompt.includes('cancel-fixture')) return
+    const hasToolResult = messages.some((message: { role?: string }) => message.role === 'tool')
+    if (!hasToolResult) {
+      chunk({ reasoning_content: 'checking fixture' })
+      const search = prompt.includes('search-fixture')
+      chunk({
+        tool_calls: [
+          {
+            index: 0,
+            id: 'call-fixture',
+            type: 'function',
+            function: {
+              name: search ? 'web_search' : 'fixture_tool',
+              arguments: JSON.stringify(
+                search ? { query: 'fixture query' } : { value: 'fixture input' }
+              ),
+            },
+          },
+        ],
+      })
+      chunk({}, 'tool_calls')
+    } else {
+      chunk({ content: 'fixture complete' })
+      chunk({}, 'stop')
+    }
+    response.write(
+      `data: ${JSON.stringify({ id: 'fixture', choices: [], usage: { prompt_tokens: 7, completion_tokens: 3, total_tokens: 10 } })}\n\ndata: [DONE]\n\n`
+    )
+    response.end()
+  })
+  server.listen(0, '127.0.0.1')
+  await once(server, 'listening')
+  const baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`
+  const provider: ProviderConfig = {
+    baseUrl: `${baseUrl}/v1`,
+    api: 'openai-completions',
+    models: [
+      {
+        id: 'fixture-model',
+        name: 'Offline fixture',
+        reasoning: true,
+        input: ['text'],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 100_000,
+        maxTokens: 1000,
+        compat: {
+          supportsDeveloperRole: false,
+          supportsStore: false,
+          supportsReasoningEffort: false,
+        },
+      },
+    ],
+  }
+  return {
+    baseUrl,
+    provider,
+    requests,
+    requested,
+    async close() {
+      server.closeAllConnections()
+      await new Promise<void>((resolve, reject) =>
+        server.close((error) => (error ? reject(error) : resolve()))
+      )
+    },
+  }
+}