@vtxmacro/cli 2026.9.13 → 2026.9.15

package/README.md

@@ -10,8 +10,8 @@ vtx --version
 ```
 
 The host supports Windows x64 and Linux x64, including WSL. The package installs
-the exact supported OpenAI Codex runtime, GitHub Copilot SDK, and official
-DeepSeek Harness package wave. The VTX host
+the exact supported OpenAI Codex runtime, GitHub Copilot SDK, official
+DeepSeek Harness package wave, and Pi SDK package wave. The VTX host
 verifies the Codex runtime's version and digest before use; it does not borrow a
 Codex binary from PATH or an editor extension.
 For Windows-login auto-start, install and configure the CLI from native Windows;
@@ -70,10 +70,10 @@ and VTX grant. VTX resolves the package-owned pinned Copilot platform runtime
 explicitly and rejects an `auto`-only catalog because it cannot prove the
 effective model.
 
-An explicitly capable durable Codex, Copilot, or DeepSeek Harness model can also
+An explicitly capable durable Codex, Copilot, DeepSeek Harness, or Pi model can also
 control Main in **Agent** mode using the same VTX OAuth grant and its own local
-adapter-specific vendor credential: ChatGPT or Copilot login, or a DeepSeek API
-key. VTX assigns the running bot but does not send a VTX-authored prompt or set
+adapter-specific vendor credential: ChatGPT or Copilot login, or a DeepSeek or
+Pi provider API key. VTX assigns the running bot but does not send a VTX-authored prompt or set
 the analysis cadence. The assigned runtime keeps a durable Agent thread,
 chooses when to wake, requests only the assignment-scoped VTX data it needs (or
 none), and submits the normal structured decision for VTX to validate and
@@ -134,6 +134,27 @@ instance after reconciling an ambiguous fence. An authentication fence clears
 only after a successful replacement key import. Quota and rate-limit failures
 honor their provider retry time or a bounded local cooldown.
 
+For Pi, use a separate instance and import one provider API key privately:
+
+```bash
+vtx inference-host login --instance pi-1
+vtx inference-host pi-login --provider openai --instance pi-1 < /private/path/provider.key
+vtx inference-host doctor --adapter pi --instance pi-1 --json
+vtx inference-host service install --adapter pi --instance pi-1
+```
+
+Pi uses the package-owned SDK and exact provider/model identities. The existing
+Provider / Agent controls apply: Provider receives VTX's prompt and has no
+tools; Main Agent keeps an isolated session and only the three VTX tools.
+The initial qualified models use an OpenAI API key; the release embeds VTX's
+configured exact model IDs and SDK capability mappings. API compatibility alone
+does not qualify a provider. Ordinary Pi
+credentials, extensions, project instructions, and sessions are not imported.
+Subscription OAuth is not enabled by this adapter. Calls with uncertain
+outcomes remain fenced after restart; conversation persistence does not imply
+same-attempt recovery. Uninstall the exact service instance and settle pending
+work before removing its key with `pi-logout --instance pi-1`.
+
 To connect another Codex subscription to the same VTX account, repeat the
 login and service-install commands with a stable local name such as
 `--instance codex-2`. Each named instance has an isolated VTX grant, Codex
@@ -267,6 +288,43 @@ schema plus `provenance` with `source: "external_agent"`, a stable
 `agent-assignment-release` only when intentionally ending the foreground Agent
 session; normal cadence is recorded with `agent-assignment-heartbeat`.
 
+## Exo foreground trading inference
+
+Exo means [exoharness/exo](https://github.com/exoharness/exo). VTX runs a dedicated
+Exo trading harness automatically in Provider and Main Agent modes. It is a
+foreground integration on Linux or WSL, not a durable service or native Exo MCP
+client. Keep the run command open; no separate keeper or manual job shuttling is
+needed. Review and Screener remain Provider-only.
+
+Prepare the supported Exo source revision and its upstream dependencies:
+
+```bash
+git clone https://github.com/exoharness/exo.git
+cd exo
+git checkout c5c1963a3445417e64938c139da88edd9154075d
+pnpm install --frozen-lockfile
+cargo build --release -p exo
+```
+
+Use a separate VTX instance and import its vendor key privately:
+
+```bash
+vtx inference-host login --instance exo-1
+vtx inference-host exo-login --provider openai --instance exo-1 < /private/path/provider.key
+vtx inference-host doctor --adapter exo --exo-root /path/to/exo --instance exo-1 --json
+vtx inference-host run --adapter exo --exo-root /path/to/exo --instance exo-1
+```
+
+Use `--provider venice` instead to import a Venice key into its own instance.
+The host advertises only the imported provider's qualified models and efforts.
+Venice initially supports Gemma 4 31B IT with thinking disabled (`none`);
+OpenAI supports the release-qualified Responses routes. VTX OAuth
+remains in the VTX process and credential store. Exo receives the complete
+Provider prompt or only assignment-scoped Agent tools, without stock shell,
+self-modification, installed tools, or ambient conversation context. Interrupted
+work with an unknown outcome is fenced rather than repeated. After stopping and
+resolving pending work, remove the vendor key with `exo-logout --instance exo-1`.
+
 Claude Code, Antigravity, Gemini CLI, Kiro, Grok Build, Cursor, Amp, Auggie,
 Junie, Warp/Oz, Qwen Code, and OpenCode remain on the explicit foreground host
 path. Their current subscription routing,

package/bin/exo-harness.ts

@@ -0,0 +1,373 @@
+/** Loaded by the pinned exoharness/exo TypeScript executor, never by the web app.
+ * The VTX broker owns OAuth and assignment authority. This module receives only
+ * a turn-scoped broker capability and the selected vendor credential.
+ */
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+type Json = Record<string, unknown>;
+type Message = { role: string; content: unknown };
+type ToolCall = { toolCallId: string; request: { functionName: string; arguments: Json } };
+type Context = {
+  exoharness: { current: { conversation: { getEvents(query: Json): Promise<{ events: unknown[] }> };
+    turn: { addEvents(events: unknown[]): Promise<{ latestEventId: string }> } } };
+};
+type Input = {
+  provider: 'openai' | 'venice';
+  mode: 'provider' | 'agent'; systemPrompt: string; userPrompt: string;
+  outputSchema: Json; decisionSchema: Json; dataContract: { id: string; input_schema: Json }[];
+  requestedModel: string; providerModel: string; reasoningEffort: string;
+  nativeReasoningEffort: string | null; maxRounds: number;
+};
+type ExoHarnessModule = {
+  materializePromptMessages(conversation: unknown, instructions: Message[]): Promise<Message[]>;
+  materializeEventsToMessages(events: unknown[]): Message[];
+  toolResultEvent(id: string, result: unknown): unknown;
+};
+type Runtime = {
+  complete(request: Json): Promise<Json>;
+};
+type ExoModelModule = {
+  ResponsesRuntime: new (options: { apiKey: string; baseURL: string }) => Runtime;
+  ChatCompletionsRuntime: new (options: { apiKey: string; baseURL: string }) => Runtime;
+  responseToLinguaEvents(response: Json): unknown[];
+  responseToolCalls(response: Json): ToolCall[];
+};
+
+const record = (value: unknown): Json => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Json : {};
+const count = (value: unknown): number => {
+  if (!Number.isSafeInteger(value) || Number(value) < 0) throw new Error('exo_usage_invalid');
+  return Number(value);
+};
+const rateLimitCode = async (response: Response): Promise<string> => {
+  if (!response.body) return 'exo_rate_limited';
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let bytes = 0;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timeout = new Promise<never>((_resolve, reject) => { timer = setTimeout(() => reject(new Error('exo_error_body_timeout')), 1000); });
+  try {
+    for (;;) {
+      const part = await Promise.race([reader.read(), timeout]);
+      if (part.done) break;
+      bytes += part.value.byteLength;
+      if (bytes > 16_384) return 'exo_rate_limited';
+      chunks.push(part.value);
+    }
+    const error = record(record(JSON.parse(Buffer.concat(chunks).toString('utf8'))).error);
+    return error.type === 'insufficient_quota' || error.code === 'insufficient_quota'
+      ? 'exo_quota_exhausted' : 'exo_rate_limited';
+  } catch { return 'exo_rate_limited'; }
+  finally { if (timer) clearTimeout(timer); void reader.cancel().catch(() => undefined); }
+};
+const retryAfterDeadline = (value: string | null): number | null => {
+  if (!value || value.length > 128) return null;
+  const now = Date.now();
+  const trimmed = value.trim();
+  const deadline = /^\d+(?:\.\d+)?$/u.test(trimmed) ? now + Number(trimmed) * 1000 : Date.parse(trimmed);
+  return Number.isFinite(deadline) && deadline >= now && deadline - now <= 86_400_000 ? Math.ceil(deadline) : null;
+};
+const textOf = (response: Json): string => (Array.isArray(response.output) ? response.output : [])
+  .flatMap((item) => record(item).type === 'message' && Array.isArray(record(item).content) ? record(item).content as unknown[] : [])
+  .filter((part) => record(part).type === 'output_text')
+  .map((part) => typeof record(part).text === 'string' ? record(part).text : '').join('');
+
+// A whole-response JSON fence is a presentation wrapper, not a schema change.
+// Keep raw provider events intact; the broker validates the unwrapped document.
+const unwrapJsonFence = (text: string): string => {
+  const match = /^```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n```$/iu.exec(text.trim());
+  return match ? match[1] : text;
+};
+
+/** Gemma's tool renderer enumerates properties but misses object union fields.
+ * Add only constraints implied by every object branch. Original union branches
+ * remain untouched, and the broker still validates the canonical input schema.
+ */
+const veniceToolParameters = (value: unknown): unknown => {
+  if (typeof value === 'boolean') return value;
+  const schema = record(value);
+  const existingProperties = record(schema.properties);
+  const properties = Object.fromEntries(Object.entries(existingProperties).map(([name, child]) => [name, veniceToolParameters(child)]));
+  const result: Json = { ...schema, ...(schema.properties ? { properties } : {}) };
+  const union = Array.isArray(schema.anyOf) ? schema.anyOf : Array.isArray(schema.oneOf) ? schema.oneOf : null;
+  if (!union?.length || (schema.type !== undefined && schema.type !== 'object')) return result;
+  const branches = union.map(record);
+  if (!branches.every((branch) => branch.type === 'object')) return result;
+  const commonNames = Object.keys(record(branches[0].properties))
+    .filter((name) => branches.every((branch) => Object.hasOwn(record(branch.properties), name)));
+  const common: Json = {};
+  for (const name of commonNames) {
+    const fields = branches.map((branch) => record(record(branch.properties)[name]));
+    const derived: Json = {};
+    const type = fields[0].type;
+    if (typeof type === 'string' && fields.every((field) => field.type === type)) derived.type = type;
+    if (fields.every((field) => Array.isArray(field.enum))) {
+      derived.enum = [...new Map(fields.flatMap((field) => field.enum as unknown[]).map((entry) => [JSON.stringify(entry), entry])).values()];
+    }
+    common[name] = typeof properties[name] === 'boolean' ? properties[name] : { ...derived, ...record(properties[name]) };
+  }
+  const required = (Array.isArray(branches[0].required) ? branches[0].required : [])
+    .filter((name): name is string => typeof name === 'string' && branches.every((branch) => Array.isArray(branch.required) && branch.required.includes(name)));
+  return { ...result, type: 'object', properties: { ...properties, ...common },
+    ...((required.length || Array.isArray(schema.required)) ? { required: [...new Set([...(Array.isArray(schema.required) ? schema.required : []), ...required])] } : {}) };
+};
+
+const chatResponseEvents = (events: unknown[]): unknown[] => events.map((event) => {
+  const data = record(event);
+  const messages = Array.isArray(data.messages) ? data.messages.map(record) : [];
+  if (data.type !== 'messages' || messages.length < 2 || !messages.every((message) => message.role === 'assistant')) return event;
+  // Exo's Responses-to-Lingua conversion splits one Chat assistant response
+  // into one message per tool call. Keep its calls together so Chat history
+  // never inserts another assistant message before the first call's result.
+  const content = messages.flatMap((message) => {
+    if (Array.isArray(message.content)) return message.content;
+    if (typeof message.content === 'string') return message.content ? [{ type: 'text', text: message.content }] : [];
+    if (message.content === null || message.content === undefined) return [];
+    throw new Error('exo_chat_message_invalid');
+  });
+  return { ...data, messages: [{ role: 'assistant', content }] };
+});
+
+const chatRequestMessages = (harness: ExoHarnessModule, events: unknown[]): Message[] => {
+  // The pinned Chat serializer emits Lingua's tagged argument wrapper; Rust
+  // Lingua persistence also changes numeric argument values. ToolRequested
+  // preserves the original JSON independently, so use its exact ordered
+  // receipt instead of coercing either representation. Stored events stay raw.
+  const requests = events.map((event) => record(record(event).data)).filter((event) => event.type === 'tool_requested');
+  let index = 0;
+  const messages = harness.materializeEventsToMessages(events).map((message) => {
+    if (message.role !== 'assistant' || !Array.isArray(message.content)) return message;
+    return { ...message, content: message.content.map((part) => {
+      const content = record(part);
+      if (content.type !== 'tool_call') return part;
+      const event = requests[index++];
+      const request = record(event?.request);
+      const args = request.arguments;
+      if (!event || event.tool_call_id !== content.tool_call_id || request.function_name !== content.tool_name
+        || args === null || typeof args !== 'object' || Array.isArray(args)) throw new Error('exo_chat_arguments_invalid');
+      return { ...content, arguments: args };
+    }) };
+  });
+  if (index !== requests.length) throw new Error('exo_chat_arguments_invalid');
+  return messages;
+};
+
+const toolsFor = (input: Input): Json[] => input.mode === 'provider' ? [] : [
+  { name: 'vtx_get_data', description: 'Request assignment-scoped VTX data.', parameters: {
+    // Keep the complete branch contract, while exposing its common fields to
+    // Chat tool renderers that enumerate only top-level properties.
+    type: 'object', additionalProperties: false, required: ['capability', 'arguments'],
+    properties: { capability: { type: 'string', enum: input.dataContract.map((entry) => entry.id) }, arguments: { type: 'object' } },
+    oneOf: input.dataContract.map((entry) => ({ type: 'object', additionalProperties: false,
+      required: ['capability', 'arguments'], properties: { capability: { const: entry.id }, arguments: entry.input_schema } })) } },
+  { name: 'vtx_submit_decision', description: 'Submit a canonical VTX decision.', parameters: {
+    type: 'object', additionalProperties: false, required: ['candidate'], properties: { candidate: input.decisionSchema } } },
+  { name: 'vtx_decision_status', description: 'Resolve a VTX decision operation.', parameters: {
+    type: 'object', additionalProperties: false, required: ['operation_id'], properties: { operation_id: { type: 'string', minLength: 1 } } } },
+];
+
+export default {
+  tools: [],
+  async runTurn(context: Context): Promise<void> {
+    const nativeFetch = globalThis.fetch;
+    const brokerUrl = new URL(process.env.VTX_EXO_BRIDGE_URL ?? '');
+    const token = process.env.VTX_EXO_BRIDGE_TOKEN;
+    const source = process.env.VTX_EXO_SOURCE_ROOT;
+    if (brokerUrl.protocol !== 'http:' || brokerUrl.hostname !== '127.0.0.1' || brokerUrl.username || brokerUrl.password
+      || brokerUrl.pathname !== '/' || brokerUrl.search || brokerUrl.hash || !token || !source) throw new Error('exo_bridge_invalid');
+    const broker = async (path: string, body?: Json): Promise<Json> => {
+      const response = await nativeFetch(new URL(path, brokerUrl), {
+        method: body === undefined ? 'GET' : 'POST',
+        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }), redirect: 'error', signal: AbortSignal.timeout(30_000),
+      });
+      if (!response.ok) throw new Error('exo_bridge_rejected');
+      return record(await response.json());
+    };
+    let dispatched = false;
+    let terminalKnown = true;
+    let activeDispatch = false;
+    let roundDispatch = false;
+    let failureCode = 'exo_turn_failed';
+    let retryAtMs: number | null = null;
+    const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0,
+      totalTokens: 0, cacheWriteInputTokens: null, cacheWriteSupported: false };
+    let completedCalls = 0;
+    let lastCompletedResponseId: string | null = null;
+    let currentReceipt: { responseId: string; providerModel: string; reasoningEffort: string } | null = null;
+    const addUsage = (nativeUsage: Json): void => {
+      const inputTokens = count(nativeUsage.input_tokens);
+      const outputTokens = count(nativeUsage.output_tokens);
+      const totalTokens = count(nativeUsage.total_tokens);
+      const cachedTokens = count(record(nativeUsage.input_tokens_details).cached_tokens ?? 0);
+      const reasoningTokens = count(record(nativeUsage.output_tokens_details).reasoning_tokens ?? 0);
+      if (totalTokens !== inputTokens + outputTokens || cachedTokens > inputTokens || reasoningTokens > outputTokens) throw new Error('exo_usage_invalid');
+      usage.inputTokens = count(usage.inputTokens + inputTokens); usage.outputTokens = count(usage.outputTokens + outputTokens);
+      usage.totalTokens = count(usage.totalTokens + totalTokens); usage.cachedInputTokens = count(usage.cachedInputTokens + cachedTokens);
+      usage.reasoningOutputTokens = count(usage.reasoningOutputTokens + reasoningTokens);
+      completedCalls += 1;
+    };
+    try {
+      const input = await broker('/input') as unknown as Input;
+      if (!['openai', 'venice'].includes(input.provider) || !['provider', 'agent'].includes(input.mode) || typeof input.systemPrompt !== 'string' || typeof input.userPrompt !== 'string'
+        || !Number.isSafeInteger(input.maxRounds) || input.maxRounds < 1 || input.maxRounds > 64
+        || typeof input.providerModel !== 'string' || !input.providerModel || typeof input.reasoningEffort !== 'string'
+        || !(input.nativeReasoningEffort === null || typeof input.nativeReasoningEffort === 'string')) throw new Error('exo_input_invalid');
+      const credential = await broker('/credential');
+      const expectedBase = input.provider === 'venice' ? 'https://api.venice.ai/api/v1' : 'https://api.openai.com/v1';
+      const providerBase = new URL(typeof credential.baseURL === 'string' ? credential.baseURL : expectedBase);
+      const localFixture = providerBase.protocol === 'http:' && providerBase.hostname === '127.0.0.1' && Boolean(providerBase.port) && providerBase.pathname === '/v1';
+      if ((!localFixture && providerBase.href !== expectedBase)
+        || providerBase.username || providerBase.password || providerBase.search || providerBase.hash
+        || typeof credential.apiKey !== 'string' || !credential.apiKey) {
+        throw new Error('exo_provider_not_qualified');
+      }
+      if (input.provider === 'venice' && (input.reasoningEffort !== 'none' || input.nativeReasoningEffort !== 'none')) throw new Error('exo_effort_not_qualified');
+      const providerEndpoint = `${providerBase.href}/${input.provider === 'venice' ? 'chat/completions' : 'responses'}`;
+      const harness = await import(pathToFileURL(join(source, 'exoharness/typescript/harness/index.ts')).href) as ExoHarnessModule;
+      const model = await import(pathToFileURL(join(source, 'exoharness/typescript/model-runtime/responses.ts')).href) as ExoModelModule;
+      const definitions = toolsFor(input);
+      const allowed = new Set(definitions.map((tool) => tool.name));
+      // Install before constructing the upstream SDK, which captures fetch.
+      // Each complete() may dispatch once. SDK retries after an uncertain call
+      // are rejected before network I/O; they cannot repeat paid inference.
+      globalThis.fetch = async (resource, options) => {
+        const url = new URL(resource instanceof Request ? resource.url : String(resource));
+        if (url.href !== providerEndpoint || options?.method !== 'POST'
+          || !activeDispatch || roundDispatch || typeof options.body !== 'string') throw new Error('exo_dispatch_rejected');
+        const payload = record(JSON.parse(options.body));
+        if (payload.model !== input.providerModel || payload.stream === true) throw new Error('exo_request_identity_mismatch');
+        const format = { name: 'vtx_result', strict: true, schema: input.outputSchema };
+        if (input.provider === 'venice') {
+          payload.reasoning_effort = 'none';
+          payload.venice_parameters = { disable_thinking: true, strip_thinking_response: false, include_venice_system_prompt: false,
+            enable_web_search: 'off', enable_web_scraping: false, enable_x_search: false, enable_web_citations: false };
+          // Venice's native JSON grammar suppresses tool selection. Agent
+          // supplies the same final schema as context and validates it in VTX.
+          if (input.mode === 'provider') payload.response_format = { type: 'json_schema', json_schema: format };
+          else delete payload.response_format;
+        } else {
+          if (input.nativeReasoningEffort === null) delete payload.reasoning;
+          else payload.reasoning = { effort: input.nativeReasoningEffort };
+          payload.text = { format: { type: 'json_schema', ...format } };
+        }
+        // Exo marks every tool strict, but VTX capability schemas deliberately
+        // preserve optional fields and oneOf. The broker validates their exact
+        // canonical contracts; do not change those semantics for the SDK.
+        if (Array.isArray(payload.tools)) payload.tools = payload.tools.map((tool) => input.provider === 'venice'
+          ? { ...record(tool), function: { ...record(record(tool).function), strict: false,
+            parameters: veniceToolParameters(record(record(tool).function).parameters) } }
+          : { ...record(tool), strict: false });
+        await broker('/dispatch', { model: input.providerModel, reasoningEffort: input.reasoningEffort });
+        roundDispatch = true;
+        dispatched = true;
+        terminalKnown = false;
+        currentReceipt = null;
+        retryAtMs = null;
+        const response = await nativeFetch(resource, { ...options, body: JSON.stringify(payload), redirect: 'error' });
+        const headers = new Headers(response.headers);
+        headers.set('x-should-retry', 'false');
+        // A definite client rejection did not yield a model result. Server and
+        // transport failures stay uncertain, even if an SDK reports an error.
+        if (!response.ok && response.status >= 400 && response.status < 500 && response.status !== 408) terminalKnown = true;
+        if (!response.ok) {
+          retryAtMs = response.status === 429 ? retryAfterDeadline(response.headers.get('retry-after')) : null;
+          failureCode = response.status === 401 ? 'exo_invalid_api_key' : response.status === 429 ? await rateLimitCode(response) : 'exo_provider_rejected';
+          if (response.status !== 429) await response.body?.cancel();
+          return new Response(JSON.stringify({ error: { message: failureCode, code: failureCode } }), { status: response.status, headers });
+        }
+        if (input.provider === 'venice') {
+          try {
+            const raw = record(await response.clone().json());
+            const choices = Array.isArray(raw.choices) ? raw.choices : [];
+            const choice = record(choices[0]);
+            terminalKnown = choices.length === 1 && ['stop', 'tool_calls', 'length', 'content_filter'].includes(String(choice.finish_reason));
+            if (raw.model !== input.providerModel || typeof raw.id !== 'string' || !raw.id) throw new Error('exo_response_identity_mismatch');
+            const controls = record(raw.venice_parameters);
+            if (controls.disable_thinking !== true || controls.strip_thinking_response !== false
+              || controls.include_venice_system_prompt !== false || controls.enable_web_search !== 'off'
+              || controls.enable_web_scraping !== false || controls.enable_x_search !== false || controls.enable_web_citations !== false
+              || record(choice.message).reasoning_content || record(choice.message).reasoning
+              || (record(record(raw.usage).completion_tokens_details).reasoning_tokens ?? 0) !== 0
+              || (raw.reasoning_effort !== undefined && raw.reasoning_effort !== 'none')) throw new Error('exo_response_effort_mismatch');
+            const nativeUsage = record(raw.usage);
+            addUsage({ input_tokens: nativeUsage.prompt_tokens, output_tokens: nativeUsage.completion_tokens, total_tokens: nativeUsage.total_tokens,
+              input_tokens_details: nativeUsage.prompt_tokens_details, output_tokens_details: nativeUsage.completion_tokens_details });
+            lastCompletedResponseId = raw.id;
+            currentReceipt = { responseId: raw.id, providerModel: input.providerModel, reasoningEffort: input.reasoningEffort };
+            // Exo synthesizes completed status for every Chat response. Inspect
+            // the real terminal reason before that normalization can hide loss.
+            if (choices.length !== 1 || !['stop', 'tool_calls'].includes(String(choice.finish_reason))) throw new Error('exo_response_incomplete');
+            const hasTools = Array.isArray(record(choice.message).tool_calls) && (record(choice.message).tool_calls as unknown[]).length > 0;
+            if ((choice.finish_reason === 'tool_calls') !== hasTools) throw new Error('exo_response_incomplete');
+          } catch (error) {
+            failureCode = error instanceof Error && /^exo_[a-z_]+$/u.test(error.message) ? error.message : 'exo_response_invalid';
+            await response.body?.cancel();
+            throw new Error(failureCode);
+          }
+        }
+        return new Response(response.body, { status: response.status, headers });
+      };
+      const RuntimeClass = input.provider === 'venice' ? model.ChatCompletionsRuntime : model.ResponsesRuntime;
+      const runtime = new RuntimeClass({ apiKey: credential.apiKey, baseURL: providerBase.href });
+      for (let round = 0; round < input.maxRounds; round += 1) {
+        const instructions: Message[] = [{ role: 'system', content: input.systemPrompt }, { role: 'user', content: input.userPrompt }];
+        if (input.provider === 'venice' && input.mode === 'agent') instructions.push({
+          role: 'user', content: JSON.stringify({ final_response_schema: input.outputSchema,
+            decision_schema: input.decisionSchema, data_contract: input.dataContract }),
+        });
+        const messages = input.mode === 'provider' ? instructions : input.provider === 'venice'
+          ? [...instructions, ...chatRequestMessages(harness, (await context.exoharness.current.conversation.getEvents({
+            direction: 'asc', types: ['messages', 'tool_requested', 'tool_result'],
+          })).events)]
+          : await harness.materializePromptMessages(context.exoharness.current.conversation, instructions);
+        roundDispatch = false;
+        activeDispatch = true;
+        const response = await runtime.complete({ model: input.providerModel, messages, tools: definitions });
+        activeDispatch = false;
+        // Validate the actual completed provider receipt before exposing any
+        // model tool call to the broker, especially decision submission.
+        if (response.status !== 'completed') throw new Error('exo_response_incomplete');
+        terminalKnown = true;
+        if (response.model !== input.providerModel || typeof response.id !== 'string' || !response.id) throw new Error('exo_response_identity_mismatch');
+        if (input.provider === 'openai') {
+          const effectiveEffort = record(response.reasoning).effort ?? null;
+          if (effectiveEffort !== input.nativeReasoningEffort) throw new Error('exo_response_effort_mismatch');
+          addUsage(record(response.usage));
+          lastCompletedResponseId = response.id;
+          currentReceipt = { responseId: response.id, providerModel: input.providerModel, reasoningEffort: input.reasoningEffort };
+        }
+        const events = model.responseToLinguaEvents(response);
+        await context.exoharness.current.turn.addEvents(input.provider === 'venice' ? chatResponseEvents(events) : events);
+        const calls = model.responseToolCalls(response);
+        if (calls.length === 0) {
+          const rawText = textOf(response);
+          const text = input.provider === 'venice' && input.mode === 'agent' ? unwrapJsonFence(rawText) : rawText;
+          if (!text.trim()) throw new Error('exo_response_empty');
+          await broker('/terminal', { text, providerModel: response.model, reasoningEffort: input.reasoningEffort, responseId: response.id, usage });
+          return;
+        }
+        if (input.mode !== 'agent' || calls.some((call) => !allowed.has(call.request.functionName))) throw new Error('exo_tool_not_allowed');
+        for (const call of calls) {
+          const result = await broker('/tool', { callId: call.toolCallId, tool: call.request.functionName, arguments: call.request.arguments,
+            effectiveModel: input.requestedModel, effectiveReasoningEffort: input.reasoningEffort });
+          // Append the entire result directly. The default registry replaces
+          // results over 8k with previews, which loses assignment data.
+          await context.exoharness.current.turn.addEvents([harness.toolResultEvent(call.toolCallId,
+            result.success === true ? { ok: true, value: result.value } : { ok: false, error: 'vtx_tool_failed', value: result.value })]);
+        }
+      }
+      throw new Error('exo_round_limit');
+    } catch (error) {
+      const code = error instanceof Error && /^exo_[a-z_]+$/u.test(error.message) ? error.message : failureCode;
+      await broker('/failure', { code, dispatched, terminalKnown, usage: completedCalls ? usage : null,
+        responseId: currentReceipt?.responseId ?? null, providerModel: currentReceipt?.providerModel ?? null,
+        reasoningEffort: currentReceipt?.reasoningEffort ?? null, lastCompletedResponseId, retryAtMs }).catch(() => undefined);
+      // Rust surfaces errors and stacks to its caller; do not propagate SDK
+      // diagnostics that can contain prompts, provider bodies, or secrets.
+      throw new Error(code);
+    } finally {
+      globalThis.fetch = nativeFetch;
+    }
+  },
+};

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.13",
+  package_version: "2026.9.15",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",
@@ -90,7 +90,16 @@ var agent_cli_release_default = {
       binary_name: "codex.exe",
       sha256: "e5ef3c4b81d2fb861f3731c91a773d45a1973c6a0b480d6449f80bc8fd749e96"
     }
-  }
+  },
+  pi_coding_agent_package_name: "@earendil-works/pi-coding-agent",
+  pi_ai_package_name: "@earendil-works/pi-ai",
+  pi_version: "0.85.1",
+  pi_support_packages: [
+    "@earendil-works/pi-agent-core",
+    "@earendil-works/pi-telemetry",
+    "@earendil-works/pi-tui",
+    "@earendil-works/chord"
+  ]
 };
 
 // lib/inference-host/config.ts