pi-advisor-flow 0.10.1-dev.1 → 0.11.1-dev.1

package/CHANGELOG.md

@@ -4,12 +4,17 @@ All notable changes to this project are documented here.
 
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0/).
 
-## Unreleased
+## 0.11.0 - 2026-10-03
 
 ### Added
 
 - Native Pi Codemode composition for `ask_advisor`: scripts receive structured advice, IDs, normalized usage, and existing skip metadata, while interactive responses remain unchanged. Documented deterministic-check composition and explicit draft disclosure limits.
 
+### Fixed
+
+- Advisor invocation guidelines no longer replace the whole system prompt, so prompt sections from other extensions, such as the list of MCP servers, still reach the model.
+- Braces Vulnerability patched (CVE-2026-93687)
+
 ## 0.10.0 - 2026-10-02
 
 ### Added

package/dist/index.js

@@ -1854,6 +1854,14 @@ var resolveConfiguredModel = async (ctx, ref, label) => {
   if (!model) {
     throw new Error(`${label} model not found: ${ref}`);
   }
+  const { streamSimple } = ctx.modelRegistry;
+  if (streamSimple) {
+    return {
+      model,
+      ref,
+      streamSimple: streamSimple.bind(ctx.modelRegistry)
+    };
+  }
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
   if (!auth.ok) {
     throw new Error(auth.error);
@@ -1949,9 +1957,28 @@ var createCoalescedUpdate = (publish, intervalMs = ADVISOR_STREAM_UPDATE_INTERVA
     }
   };
 };
-var collectTextStream = async (resolved, options, streamModel = stream) => {
-  let thinking = "";
-  let text = "";
+var SIMPLE_REASONING_LEVELS = ["minimal", "low", "medium", "high", "xhigh", "max"];
+var toSimpleReasoning = (effort) => {
+  if (effort === undefined || effort === "off") {
+    return;
+  }
+  const level = SIMPLE_REASONING_LEVELS.find((candidate) => candidate === effort);
+  if (!level) {
+    throw new Error(`Unsupported Advisor reasoning level: ${effort}`);
+  }
+  return level;
+};
+var createTextEventStream = (resolved, options, streamModel) => {
+  const context = {
+    messages: options.messages,
+    systemPrompt: options.systemPrompt
+  };
+  if (!streamModel && resolved.streamSimple) {
+    return resolved.streamSimple(resolved.model, context, {
+      reasoning: toSimpleReasoning(options.reasoning),
+      signal: options.signal
+    });
+  }
   const streamOptions = {
     apiKey: resolved.apiKey,
     env: resolved.env,
@@ -1962,7 +1989,12 @@ var collectTextStream = async (resolved, options, streamModel = stream) => {
   if (options.reasoning !== undefined) {
     streamOptions.reasoningEffort = options.reasoning;
   }
-  const eventStream = streamModel(resolved.model, { messages: options.messages, systemPrompt: options.systemPrompt }, streamOptions);
+  return (streamModel ?? stream)(resolved.model, context, streamOptions);
+};
+var collectTextStream = async (resolved, options, streamModel) => {
+  let thinking = "";
+  let text = "";
+  const eventStream = createTextEventStream(resolved, options, streamModel);
   for await (const event of eventStream) {
     if (event.type === "thinking_delta") {
       thinking += event.delta;
@@ -9025,7 +9057,9 @@ var registerToolLifecycle = ({
       ctx.ui.setStatus("advisor-usage", undefined);
     }
   });
-  pi.on("before_agent_start", (_event, ctx) => {
+  pi.on("before_agent_start", (event, ctx) => {
+    const { sections } = event.systemPromptOptions;
+    delete sections.advisor_invocation_settings;
     if (!pi.getActiveTools().includes("ask_advisor")) {
       return;
     }
@@ -9039,13 +9073,11 @@ var registerToolLifecycle = ({
       guidelines.push(`Advisor calls remaining this session: ${budget}.
 Reserve calls for material decisions, repeated failures, or final review.`);
     }
-    return guidelines.length > 0 ? {
-      systemPrompt: `${ctx.getSystemPrompt()}
-
-Advisor invocation settings:
+    if (guidelines.length > 0) {
+      sections.advisor_invocation_settings = `Advisor invocation settings:
 ${guidelines.map((rule) => `- ${rule}`).join(`
-`)}`
-    } : undefined;
+`)}`;
+    }
   });
   pi.on("input", () => {
     session.clearFollowUps();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.10.1-dev.1",
+  "version": "0.11.1-dev.1",
   "description": "Advanced Executor/Advisor flow for Pi, fully configurable and extendable.",
   "keywords": [
     "advisor",
@@ -93,6 +93,7 @@
   },
   "overrides": {
     "brace-expansion": "5.0.12",
+    "braces": "github:micromatch/braces#d0d575e55e74a4e0218e5248fafb79efc3e54ebb",
     "is-unicode-supported": "npm:@socketregistry/is-unicode-supported@1.0.5",
     "safe-buffer": "npm:@socketregistry/safe-buffer@1.0.9",
     "undici": "8.11.2"

package/src/model-stream.ts

@@ -2,19 +2,27 @@ import { stream } from "@earendil-works/pi-ai/compat";
 import type {
   Api,
   AssistantMessage,
+  AssistantMessageEventStream,
+  Context,
   Message,
   Model,
+  SimpleStreamOptions,
 } from "@earendil-works/pi-ai/compat";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { splitRef } from "./config/state.ts";
 
 export interface ResolvedConfiguredModel {
-  apiKey: string;
+  apiKey?: string;
   env?: Record<string, string>;
   headers?: Record<string, string | null>;
   model: Model<Api>;
   ref: string;
+  streamSimple?: (
+    model: Model<Api>,
+    context: Context,
+    options?: SimpleStreamOptions
+  ) => AssistantMessageEventStream;
 }
 
 export const resolveConfiguredModel = async (
@@ -31,6 +39,14 @@ export const resolveConfiguredModel = async (
   if (!model) {
     throw new Error(`${label} model not found: ${ref}`);
   }
+  const { streamSimple } = ctx.modelRegistry;
+  if (streamSimple) {
+    return {
+      model,
+      ref,
+      streamSimple: streamSimple.bind(ctx.modelRegistry),
+    };
+  }
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
   if (!auth.ok) {
     throw new Error(auth.error);
@@ -179,30 +195,61 @@ export const createCoalescedUpdate = <T>(
   };
 };
 
-export const collectTextStream = async (
+const SIMPLE_REASONING_LEVELS: readonly NonNullable<
+  SimpleStreamOptions["reasoning"]
+>[] = ["minimal", "low", "medium", "high", "xhigh", "max"];
+
+const toSimpleReasoning = (
+  effort: string | undefined
+): SimpleStreamOptions["reasoning"] => {
+  if (effort === undefined || effort === "off") {
+    return undefined;
+  }
+  const level = SIMPLE_REASONING_LEVELS.find(
+    (candidate) => candidate === effort
+  );
+  if (!level) {
+    throw new Error(`Unsupported Advisor reasoning level: ${effort}`);
+  }
+  return level;
+};
+
+const createTextEventStream = (
   resolved: ResolvedConfiguredModel,
   options: CollectTextStreamOptions,
-  streamModel: typeof stream = stream
-): Promise<CollectedTextStream> => {
-  let thinking = "";
-  let text = "";
-  const streamOptions: Parameters<typeof streamModel>[2] = {
+  streamModel?: typeof stream
+): AssistantMessageEventStream => {
+  const context: Context = {
+    messages: options.messages,
+    systemPrompt: options.systemPrompt,
+  };
+  if (!streamModel && resolved.streamSimple) {
+    return resolved.streamSimple(resolved.model, context, {
+      reasoning: toSimpleReasoning(options.reasoning),
+      signal: options.signal,
+    });
+  }
+  const streamOptions: NonNullable<Parameters<typeof stream>[2]> = {
     apiKey: resolved.apiKey,
     env: resolved.env,
     headers: resolved.headers,
-    // SAFETY: stream() models the provider-facing reasoning field as never; options.reasoning is the Pi-facing effort string.
-    reasoning: options.reasoning as never,
+    reasoning: options.reasoning,
     signal: options.signal,
   };
   if (options.reasoning !== undefined) {
-    // SAFETY: reasoningEffort takes the same effort string; kept absent when reasoning is unset.
-    streamOptions.reasoningEffort = options.reasoning as never;
+    streamOptions.reasoningEffort = options.reasoning;
   }
-  const eventStream = streamModel(
-    resolved.model,
-    { messages: options.messages, systemPrompt: options.systemPrompt },
-    streamOptions
-  );
+  return (streamModel ?? stream)(resolved.model, context, streamOptions);
+};
+
+export const collectTextStream = async (
+  resolved: ResolvedConfiguredModel,
+  options: CollectTextStreamOptions,
+  streamModel?: typeof stream
+): Promise<CollectedTextStream> => {
+  let thinking = "";
+  let text = "";
+  const eventStream = createTextEventStream(resolved, options, streamModel);
 
   for await (const event of eventStream) {
     if (event.type === "thinking_delta") {

package/src/tools/register-lifecycle.ts

@@ -71,7 +71,9 @@ export const registerToolLifecycle = ({
     }
   });
 
-  pi.on("before_agent_start", (_event, ctx) => {
+  pi.on("before_agent_start", (event, ctx) => {
+    const { sections } = event.systemPromptOptions;
+    delete sections.advisor_invocation_settings;
     if (!pi.getActiveTools().includes("ask_advisor")) {
       return;
     }
@@ -88,11 +90,9 @@ export const registerToolLifecycle = ({
         `Advisor calls remaining this session: ${budget}.\nReserve calls for material decisions, repeated failures, or final review.`
       );
     }
-    return guidelines.length > 0
-      ? {
-          systemPrompt: `${ctx.getSystemPrompt()}\n\nAdvisor invocation settings:\n${guidelines.map((rule) => `- ${rule}`).join("\n")}`,
-        }
-      : undefined;
+    if (guidelines.length > 0) {
+      sections.advisor_invocation_settings = `Advisor invocation settings:\n${guidelines.map((rule) => `- ${rule}`).join("\n")}`;
+    }
   });
 
   pi.on("input", () => {