@get-bb/plugin-sdk 0.4.40 → 0.4.47

package/dist/internal/host-policy.js

@@ -280,6 +280,42 @@ var RPC_METHOD_PATTERN = /^[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*$/;
 var BACKGROUND_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var CLI_COMMAND_NAME_PATTERN = /^[a-z0-9-]+$/;
 var AGENT_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var PLUGIN_PROVIDER_ENV_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
+var PLUGIN_PROVIDER_ENV_MAX_ENTRIES = 32;
+var pluginProviderEnvEntrySchema = z3.object({
+  name: z3.string().regex(PLUGIN_PROVIDER_ENV_NAME_PATTERN),
+  value: z3.union([
+    z3.string(),
+    z3.object({ serverPath: z3.string().startsWith("/") }).strict()
+  ]),
+  reason: z3.string(),
+  secret: z3.boolean()
+}).strict();
+var pluginProviderEnvEntriesSchema = z3.array(pluginProviderEnvEntrySchema).max(PLUGIN_PROVIDER_ENV_MAX_ENTRIES).superRefine((entries, context) => {
+  const names = /* @__PURE__ */ new Set();
+  for (let index = 0; index < entries.length; index += 1) {
+    const name = entries[index]?.name;
+    if (name !== void 0 && names.has(name)) {
+      context.addIssue({
+        code: "custom",
+        path: [index, "name"],
+        message: "must be unique within one resolver"
+      });
+    }
+    if (name !== void 0) names.add(name);
+  }
+});
+function validatePluginProviderEnvEntries(value) {
+  const parsed = pluginProviderEnvEntriesSchema.safeParse(value);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const path = issue?.path.length ? `[${issue.path.join(".")}] ` : "";
+    throw new Error(
+      `provider environment contribution ${path}${issue?.message ?? "is invalid"}`
+    );
+  }
+  return parsed.data;
+}
 var PLUGIN_AGENT_STATIC_INSTRUCTIONS_MAX_CHARS = 4096;
 var PLUGIN_AGENT_STATUS_LABEL_MAX_CHARS = 80;
 var PLUGIN_AGENT_SELECTION_MAX_IDS = 256;
@@ -1716,6 +1752,8 @@ export {
   PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES,
   PLUGIN_PROVIDER_COMPOSER_ACTION_VALUES,
   PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS,
+  PLUGIN_PROVIDER_ENV_MAX_ENTRIES,
+  PLUGIN_PROVIDER_ENV_NAME_PATTERN,
   PLUGIN_PROVIDER_PERMISSION_MODE_VALUES,
   PLUGIN_PROVIDER_REASONING_LEVEL_VALUES,
   PROVIDER_ID_PATTERN,
@@ -1749,6 +1787,7 @@ export {
   undeclaredIconProblem,
   validatePluginAiServiceDeclaration,
   validatePluginProviderDeclaration,
+  validatePluginProviderEnvEntries,
   validateSettingsUpdate,
   zodSchemaToJsonSchema
 };

package/dist/internal/plugin-app-collector.js

@@ -213,6 +213,127 @@ function collectComposerCustomization(registration, seenIds, onRejected) {
 }
 
 // src/internal/plugin-app-collector.ts
+var sidebarFooterCommandSequence = 0;
+var SIDEBAR_FOOTER_ACTION_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "icon",
+  "kind",
+  "onActivate"
+]);
+var SIDEBAR_FOOTER_DISCLOSURE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "icon",
+  "kind",
+  "component"
+]);
+var SidebarFooterItemRuntime = class {
+  listeners = /* @__PURE__ */ new Set();
+  snapshot = {
+    command: null
+  };
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getSnapshot = () => this.snapshot;
+  acknowledgeCommand = (sequence) => {
+    if (this.snapshot.command?.sequence !== sequence) return;
+    this.snapshot = { ...this.snapshot, command: null };
+    this.emit();
+  };
+  createDisclosureController() {
+    return Object.freeze({
+      open: () => this.request("open"),
+      close: () => this.request("close"),
+      toggle: () => this.request("toggle")
+    });
+  }
+  request(kind) {
+    sidebarFooterCommandSequence += 1;
+    this.snapshot = {
+      ...this.snapshot,
+      command: { sequence: sidebarFooterCommandSequence, kind }
+    };
+    this.emit();
+  }
+  emit() {
+    for (const listener of this.listeners) listener();
+  }
+};
+function adaptSidebarFooterAction(registration) {
+  return {
+    source: "sidebarFooterAction",
+    id: registration.id,
+    label: registration.title,
+    icon: registration.icon,
+    kind: "action",
+    onActivate: ({ openPluginDetails }) => registration.run({ openSettings: openPluginDetails }),
+    runtime: new SidebarFooterItemRuntime()
+  };
+}
+var SidebarFooterCollector = class {
+  constructor(collected, allCollected, seenIds) {
+    this.collected = collected;
+    this.allCollected = allCollected;
+    this.seenIds = seenIds;
+  }
+  collected;
+  allCollected;
+  seenIds;
+  register(registration) {
+    const kind = "experimental_sidebarFooter.register";
+    const id = requireSlotId(kind, registration?.id);
+    requireUniqueId(kind, this.seenIds, id);
+    const label = requireNonEmptyString(kind, "label", registration.label);
+    const icon = requireNonEmptyString(kind, "icon", registration.icon);
+    const runtime = new SidebarFooterItemRuntime();
+    if (registration.kind === "action") {
+      this.rejectUnknownKeys(kind, registration, SIDEBAR_FOOTER_ACTION_KEYS);
+      if (typeof registration.onActivate !== "function") {
+        throw new Error(`${kind}: "onActivate" must be a function`);
+      }
+      const item = {
+        id,
+        label,
+        icon,
+        kind: "action",
+        onActivate: registration.onActivate,
+        source: "experimental_sidebarFooter",
+        runtime
+      };
+      this.collected.push(item);
+      this.allCollected.push(item);
+      return;
+    }
+    if (registration.kind === "disclosure") {
+      this.rejectUnknownKeys(
+        kind,
+        registration,
+        SIDEBAR_FOOTER_DISCLOSURE_KEYS
+      );
+      const item = {
+        id,
+        label,
+        icon,
+        kind: "disclosure",
+        component: requireComponent(kind, registration.component),
+        source: "experimental_sidebarFooter",
+        runtime
+      };
+      this.collected.push(item);
+      this.allCollected.push(item);
+      return runtime.createDisclosureController();
+    }
+    throw new Error(`${kind}: "kind" must be "action" or "disclosure"`);
+  }
+  rejectUnknownKeys(kind, registration, allowed) {
+    for (const key of Object.keys(registration)) {
+      if (!allowed.has(key)) throw new Error(`${kind}: unknown field "${key}"`);
+    }
+  }
+};
 var NAV_PANEL_REGISTRATION_KEYS = new Set(
   Object.keys({
     id: true,
@@ -242,7 +363,12 @@ function rejectStaleNavPanelKeys(kind, registration) {
     }
   }
 }
+var sidebarFooterItemsByRegistrationSet = /* @__PURE__ */ new WeakMap();
+function getCollectedSidebarFooterItems(registrations) {
+  return sidebarFooterItemsByRegistrationSet.get(registrations) ?? null;
+}
 function collectPluginAppRegistrations(definition, onComposerCustomizationRejected = (reason) => console.warn(reason)) {
+  const sidebarFooterItems = [];
   const collected = {
     homepageSections: [],
     settingsSections: [],
@@ -253,6 +379,7 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
     composerCustomizations: [],
     pendingInteractions: [],
     sidebarFooterActions: [],
+    experimentalSidebarFooterItems: [],
     experimentalSidebarNavigations: [],
     threadLists: [],
     threadHeaderActions: [],
@@ -266,6 +393,7 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
     timelineRenderers: [],
     contentScripts: []
   };
+  sidebarFooterItemsByRegistrationSet.set(collected, sidebarFooterItems);
   const seenIds = {
     homepageSection: /* @__PURE__ */ new Set(),
     settingsSection: /* @__PURE__ */ new Set(),
@@ -275,7 +403,7 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
     newThreadPanelAction: /* @__PURE__ */ new Set(),
     composerCustomization: /* @__PURE__ */ new Set(),
     pendingInteraction: /* @__PURE__ */ new Set(),
-    sidebarFooterAction: /* @__PURE__ */ new Set(),
+    sidebarFooterItem: /* @__PURE__ */ new Set(),
     sidebarNavigation: /* @__PURE__ */ new Set(),
     threadList: /* @__PURE__ */ new Set(),
     threadHeaderAction: /* @__PURE__ */ new Set(),
@@ -466,16 +594,18 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
       sidebarFooterAction(registration) {
         const kind = "slots.sidebarFooterAction";
         const id = requireSlotId(kind, registration?.id);
-        requireUniqueId(kind, seenIds.sidebarFooterAction, id);
+        requireUniqueId(kind, seenIds.sidebarFooterItem, id);
         if (typeof registration.run !== "function") {
           throw new Error(`${kind}: "run" must be a function`);
         }
-        collected.sidebarFooterActions.push({
+        const legacyRegistration = {
           id,
           title: requireNonEmptyString(kind, "title", registration.title),
           icon: requireNonEmptyString(kind, "icon", registration.icon),
           run: registration.run
-        });
+        };
+        collected.sidebarFooterActions.push(legacyRegistration);
+        sidebarFooterItems.push(adaptSidebarFooterAction(legacyRegistration));
       },
       experimental_sidebarNavigation(registration) {
         const kind = "slots.experimental_sidebarNavigation";
@@ -637,6 +767,11 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
         });
       }
     },
+    experimental_sidebarFooter: new SidebarFooterCollector(
+      collected.experimentalSidebarFooterItems,
+      sidebarFooterItems,
+      seenIds.sidebarFooterItem
+    ),
     composer: {
       customize(registration) {
         const customization = collectComposerCustomization(
@@ -664,5 +799,7 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
   return collected;
 }
 export {
-  collectPluginAppRegistrations
+  adaptSidebarFooterAction,
+  collectPluginAppRegistrations,
+  getCollectedSidebarFooterItems
 };

package/dist/provider-bridge-acp.js

@@ -189,11 +189,11 @@ var promptInputSchema = z2.discriminatedUnion("type", [
 function isSelectedPromptCommandMention(mention, selector) {
   return mention.resource.kind === "command" && mention.resource.trigger === selector.trigger && mention.resource.name === selector.name;
 }
-var BUILTIN_COMPACT_COMMAND = { trigger: "/", name: "compact" };
-function isStandaloneBuiltinCompactCommand(input) {
+function isStandaloneBuiltinCommand(input, name) {
+  const selector = { trigger: "/", name };
   const selected = input.flatMap(
     (item) => item.type === "text" ? item.mentions.filter(
-      (mention2) => isSelectedPromptCommandMention(mention2, BUILTIN_COMPACT_COMMAND)
+      (mention2) => isSelectedPromptCommandMention(mention2, selector)
     ).map((mention2) => ({ mention: mention2, text: item.text })) : []
   );
   const standalone = selected[0];
@@ -201,13 +201,15 @@ function isStandaloneBuiltinCompactCommand(input) {
     return false;
   }
   const { mention, text } = standalone;
-  if (mention.resource.kind !== "command" || mention.resource.source !== "command" || mention.resource.origin !== "builtin" || text.slice(mention.start, mention.end) !== "/compact") {
+  if (mention.resource.kind !== "command" || mention.resource.source !== "command" || mention.resource.origin !== "builtin" || text.slice(mention.start, mention.end) !== `/${name}`) {
     return false;
   }
-  return removeCommandMentionsFromPromptInput(
-    input,
-    BUILTIN_COMPACT_COMMAND
-  ).every((item) => item.type === "text" && item.text.trim() === "");
+  return removeCommandMentionsFromPromptInput(input, selector).every(
+    (item) => item.type === "text" && item.text.trim() === ""
+  );
+}
+function isStandaloneBuiltinCompactCommand(input) {
+  return isStandaloneBuiltinCommand(input, "compact");
 }
 function commandRemovalRanges(input, selector) {
   return input.mentions.filter((mention) => isSelectedPromptCommandMention(mention, selector)).map((mention) => ({
@@ -684,13 +686,21 @@ var threadEventItemPresentationTintSchema = z6.object({
   light: z6.string().min(1),
   dark: z6.string().min(1)
 });
+var THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH = 80;
+var threadEventItemPresentationBadgeSchema = z6.object({
+  glyph: z6.string().min(1),
+  label: z6.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  hint: z6.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  tone: z6.enum(["neutral", "destructive"])
+});
 var threadEventItemPresentationSchema = z6.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
   title: z6.string().optional(),
   detail: z6.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
   suppress: z6.boolean().optional(),
-  tint: threadEventItemPresentationTintSchema.optional()
+  tint: threadEventItemPresentationTintSchema.optional(),
+  badge: threadEventItemPresentationBadgeSchema.optional()
 });
 
 // ../domain/src/provider-extension-kind.ts
@@ -1409,6 +1419,10 @@ var threadEventScopeDefinitionByType = {
     policy: "thread",
     rationale: "Subscription usage is account-scoped state that can affect multiple turns and threads."
   },
+  "provider.env-resolved": {
+    policy: "thread",
+    rationale: "Resolved provider environment is session state and can change between turns."
+  },
   "thread/extensionState/updated": {
     policy: "thread",
     rationale: "Plugin-declared thread state is current thread metadata (like goals), not part of a specific turn transcript; latest snapshot per kind wins."
@@ -2052,6 +2066,25 @@ var unscopedProviderEventSchema = z14.discriminatedUnion("type", [
     providerThreadId: z14.string(),
     rateLimits: providerRateLimitStateSchema
   }),
+  z14.object({
+    type: z14.literal("provider.env-resolved"),
+    threadId: z14.string(),
+    providerThreadId: z14.string(),
+    entries: z14.array(
+      z14.object({
+        name: z14.string(),
+        source: z14.union([
+          z14.literal("shell"),
+          z14.object({ plugin: z14.string() }).strict()
+        ]),
+        value: z14.union([
+          z14.string(),
+          z14.object({ masked: z14.literal(true) }).strict()
+        ]),
+        reason: z14.string().optional()
+      }).strict()
+    )
+  }),
   z14.object({
     type: z14.literal("thread/extensionState/updated"),
     threadId: z14.string(),
@@ -2705,7 +2738,8 @@ var sessionReplacedNotificationSchema = z23.object({
   threadId: z23.string().min(1),
   providerThreadId: z23.string().min(1).nullable(),
   reason: z23.string().min(1),
-  contextLost: z23.boolean().default(false)
+  contextLost: z23.boolean().default(false),
+  showRuntimeNote: z23.boolean().default(false)
 }).passthrough();
 var providerRawNotificationSchema = z23.object({
   threadId: z23.string().min(1).optional(),

package/dist/provider-bridge-testing.js

@@ -322,13 +322,21 @@ var threadEventItemPresentationTintSchema = z4.object({
   light: z4.string().min(1),
   dark: z4.string().min(1)
 });
+var THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH = 80;
+var threadEventItemPresentationBadgeSchema = z4.object({
+  glyph: z4.string().min(1),
+  label: z4.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  hint: z4.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  tone: z4.enum(["neutral", "destructive"])
+});
 var threadEventItemPresentationSchema = z4.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
   title: z4.string().optional(),
   detail: z4.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
   suppress: z4.boolean().optional(),
-  tint: threadEventItemPresentationTintSchema.optional()
+  tint: threadEventItemPresentationTintSchema.optional(),
+  badge: threadEventItemPresentationBadgeSchema.optional()
 });
 
 // ../domain/src/provider-extension-kind.ts
@@ -1041,6 +1049,10 @@ var threadEventScopeDefinitionByType = {
     policy: "thread",
     rationale: "Subscription usage is account-scoped state that can affect multiple turns and threads."
   },
+  "provider.env-resolved": {
+    policy: "thread",
+    rationale: "Resolved provider environment is session state and can change between turns."
+  },
   "thread/extensionState/updated": {
     policy: "thread",
     rationale: "Plugin-declared thread state is current thread metadata (like goals), not part of a specific turn transcript; latest snapshot per kind wins."
@@ -1693,6 +1705,25 @@ var unscopedProviderEventSchema = z12.discriminatedUnion("type", [
     providerThreadId: z12.string(),
     rateLimits: providerRateLimitStateSchema
   }),
+  z12.object({
+    type: z12.literal("provider.env-resolved"),
+    threadId: z12.string(),
+    providerThreadId: z12.string(),
+    entries: z12.array(
+      z12.object({
+        name: z12.string(),
+        source: z12.union([
+          z12.literal("shell"),
+          z12.object({ plugin: z12.string() }).strict()
+        ]),
+        value: z12.union([
+          z12.string(),
+          z12.object({ masked: z12.literal(true) }).strict()
+        ]),
+        reason: z12.string().optional()
+      }).strict()
+    )
+  }),
   z12.object({
     type: z12.literal("thread/extensionState/updated"),
     threadId: z12.string(),
@@ -4564,7 +4595,8 @@ var sessionReplacedNotificationSchema = z24.object({
   threadId: z24.string().min(1),
   providerThreadId: z24.string().min(1).nullable(),
   reason: z24.string().min(1),
-  contextLost: z24.boolean().default(false)
+  contextLost: z24.boolean().default(false),
+  showRuntimeNote: z24.boolean().default(false)
 }).passthrough();
 var providerRawNotificationSchema = z24.object({
   threadId: z24.string().min(1).optional(),
@@ -6372,15 +6404,6 @@ function isRequest(message) {
 function isResponse(message) {
   return message.id !== void 0 && message.method === void 0;
 }
-function countTurnBoundaries(events) {
-  let started = 0;
-  let completed = 0;
-  for (const event of events) {
-    if (event.type === "turn/started") started += 1;
-    if (event.type === "turn/completed") completed += 1;
-  }
-  return { started, completed };
-}
 function planRuntimeSteps(recording, assembler) {
   const steps = [];
   const assembled = [];
@@ -6401,7 +6424,7 @@ function planRuntimeSteps(recording, assembler) {
     steps.push({
       entry,
       message: parseWire(entry.line),
-      gate: countTurnBoundaries(assembled),
+      gate: countTurns(assembled),
       eventsBefore: assembled.length
     });
   }
@@ -6650,7 +6673,7 @@ async function replayRecording(options) {
     await waitFor(
       `${step.gate.started} turn/started and ${step.gate.completed} turn/completed before ${method}`,
       () => {
-        const live = countTurnBoundaries(events);
+        const live = countTurns(events);
         return live.started >= step.gate.started && live.completed >= step.gate.completed;
       }
     );

package/dist/provider-bridge.js

@@ -1460,11 +1460,11 @@ var promptInputSchema = z6.discriminatedUnion("type", [
 function isSelectedPromptCommandMention(mention, selector) {
   return mention.resource.kind === "command" && mention.resource.trigger === selector.trigger && mention.resource.name === selector.name;
 }
-var BUILTIN_COMPACT_COMMAND = { trigger: "/", name: "compact" };
-function isStandaloneBuiltinCompactCommand(input) {
+function isStandaloneBuiltinCommand(input, name) {
+  const selector = { trigger: "/", name };
   const selected = input.flatMap(
     (item) => item.type === "text" ? item.mentions.filter(
-      (mention2) => isSelectedPromptCommandMention(mention2, BUILTIN_COMPACT_COMMAND)
+      (mention2) => isSelectedPromptCommandMention(mention2, selector)
     ).map((mention2) => ({ mention: mention2, text: item.text })) : []
   );
   const standalone = selected[0];
@@ -1472,13 +1472,15 @@ function isStandaloneBuiltinCompactCommand(input) {
     return false;
   }
   const { mention, text } = standalone;
-  if (mention.resource.kind !== "command" || mention.resource.source !== "command" || mention.resource.origin !== "builtin" || text.slice(mention.start, mention.end) !== "/compact") {
+  if (mention.resource.kind !== "command" || mention.resource.source !== "command" || mention.resource.origin !== "builtin" || text.slice(mention.start, mention.end) !== `/${name}`) {
     return false;
   }
-  return removeCommandMentionsFromPromptInput(
-    input,
-    BUILTIN_COMPACT_COMMAND
-  ).every((item) => item.type === "text" && item.text.trim() === "");
+  return removeCommandMentionsFromPromptInput(input, selector).every(
+    (item) => item.type === "text" && item.text.trim() === ""
+  );
+}
+function isStandaloneBuiltinCompactCommand(input) {
+  return isStandaloneBuiltinCommand(input, "compact");
 }
 function commandRemovalRanges(input, selector) {
   return input.mentions.filter((mention) => isSelectedPromptCommandMention(mention, selector)).map((mention) => ({
@@ -1980,13 +1982,21 @@ var threadEventItemPresentationTintSchema = z10.object({
   light: z10.string().min(1),
   dark: z10.string().min(1)
 });
+var THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH = 80;
+var threadEventItemPresentationBadgeSchema = z10.object({
+  glyph: z10.string().min(1),
+  label: z10.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  hint: z10.string().min(1).max(THREAD_EVENT_ITEM_PRESENTATION_BADGE_LABEL_MAX_LENGTH),
+  tone: z10.enum(["neutral", "destructive"])
+});
 var threadEventItemPresentationSchema = z10.object({
   label: threadEventItemPresentationLabelSchema,
   icon: threadEventItemPresentationIconSchema,
   title: z10.string().optional(),
   detail: z10.string().max(THREAD_EVENT_ITEM_PRESENTATION_DETAIL_MAX_LENGTH).optional(),
   suppress: z10.boolean().optional(),
-  tint: threadEventItemPresentationTintSchema.optional()
+  tint: threadEventItemPresentationTintSchema.optional(),
+  badge: threadEventItemPresentationBadgeSchema.optional()
 });
 
 // ../domain/src/provider-extension-kind.ts
@@ -2714,6 +2724,10 @@ var threadEventScopeDefinitionByType = {
     policy: "thread",
     rationale: "Subscription usage is account-scoped state that can affect multiple turns and threads."
   },
+  "provider.env-resolved": {
+    policy: "thread",
+    rationale: "Resolved provider environment is session state and can change between turns."
+  },
   "thread/extensionState/updated": {
     policy: "thread",
     rationale: "Plugin-declared thread state is current thread metadata (like goals), not part of a specific turn transcript; latest snapshot per kind wins."
@@ -3357,6 +3371,25 @@ var unscopedProviderEventSchema = z18.discriminatedUnion("type", [
     providerThreadId: z18.string(),
     rateLimits: providerRateLimitStateSchema
   }),
+  z18.object({
+    type: z18.literal("provider.env-resolved"),
+    threadId: z18.string(),
+    providerThreadId: z18.string(),
+    entries: z18.array(
+      z18.object({
+        name: z18.string(),
+        source: z18.union([
+          z18.literal("shell"),
+          z18.object({ plugin: z18.string() }).strict()
+        ]),
+        value: z18.union([
+          z18.string(),
+          z18.object({ masked: z18.literal(true) }).strict()
+        ]),
+        reason: z18.string().optional()
+      }).strict()
+    )
+  }),
   z18.object({
     type: z18.literal("thread/extensionState/updated"),
     threadId: z18.string(),
@@ -4280,7 +4313,8 @@ var sessionReplacedNotificationSchema = z29.object({
   threadId: z29.string().min(1),
   providerThreadId: z29.string().min(1).nullable(),
   reason: z29.string().min(1),
-  contextLost: z29.boolean().default(false)
+  contextLost: z29.boolean().default(false),
+  showRuntimeNote: z29.boolean().default(false)
 }).passthrough();
 var providerRawNotificationSchema = z29.object({
   threadId: z29.string().min(1).optional(),