@get-bb/plugin-sdk 0.4.48 → 0.4.53

package/dist/internal/composer-customization-validation.js

@@ -40,6 +40,14 @@ function requireSlotId(kind, value) {
   }
   return value;
 }
+function requireEnvironmentProviderId(kind, value) {
+  if (typeof value !== "string" || !PLUGIN_SLOT_ID_PATTERN.test(value)) {
+    throw new Error(
+      `${kind}: "environmentProviderId" must match ${String(PLUGIN_SLOT_ID_PATTERN)}, got ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
 function requireProviderId(kind, value) {
   if (typeof value !== "string" || !PLUGIN_SLOT_ID_PATTERN.test(value)) {
     throw new Error(
@@ -248,6 +256,7 @@ export {
   collectComposerCustomization,
   normalizePluginThreadRowStatus,
   requireComponent,
+  requireEnvironmentProviderId,
   requireMessageDirectiveId,
   requireNonEmptyString,
   requireOptionalString,

package/dist/internal/host-policy.js

@@ -1,5 +1,5 @@
 // src/internal/host-policy.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../domain/src/plugin-icon.ts
 function isPluginOwnedIconPath(icon) {
@@ -70,37 +70,54 @@ function isRelativeProviderSkillRootPath(value) {
   return !normalized.startsWith("/") && !/^[a-zA-Z]:\//u.test(normalized) && normalized.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
 }
 
-// ../domain/src/native-roots.ts
+// ../domain/src/json-value.ts
 import { z as z2 } from "zod";
+var jsonValueSchema = z2.lazy(
+  () => z2.union([
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.null(),
+    z2.array(jsonValueSchema),
+    z2.record(z2.string(), jsonValueSchema)
+  ])
+);
+var jsonObjectSchema = z2.record(
+  z2.string(),
+  jsonValueSchema
+);
+
+// ../domain/src/native-roots.ts
+import { z as z3 } from "zod";
 var PROVIDER_NATIVE_ROOTS_MAX = 32;
 var PROVIDER_NATIVE_ROOT_NAME_PREFIX_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,62}:$/u;
-var nativeRootNamePrefixSchema = z2.string().refine(
+var nativeRootNamePrefixSchema = z3.string().refine(
   (value) => value === "" || PROVIDER_NATIVE_ROOT_NAME_PREFIX_PATTERN.test(value),
   "A root name prefix is a plugin-name-like token ending in ':'"
 );
-var nativeRootManifestPathSchema = z2.string().min(1).refine(
+var nativeRootManifestPathSchema = z3.string().min(1).refine(
   isRelativeProviderSkillRootPath,
   "A manifest marker is a relative path without dot segments"
 );
-var relativeNativeRootPathSchema = z2.string().min(1).refine(
+var relativeNativeRootPathSchema = z3.string().min(1).refine(
   isRelativeProviderSkillRootPath,
   "Roots must be relative paths without dot segments"
 );
-var absoluteNativeRootPathSchema = z2.string().min(1).refine(
+var absoluteNativeRootPathSchema = z3.string().min(1).refine(
   isAbsoluteProviderSkillRootPath,
   "Absolute roots must be absolute paths without dot segments"
 );
-var providerNativeRootInputSchema = z2.union([
-  z2.string().min(1),
-  z2.object({
-    path: z2.string().min(1),
+var providerNativeRootInputSchema = z3.union([
+  z3.string().min(1),
+  z3.object({
+    path: z3.string().min(1),
     /** Skills nest in subdirectories (the agent scans recursively). */
-    recursive: z2.boolean().optional(),
+    recursive: z3.boolean().optional(),
     /**
      * Scan the same relative directory in every ancestor of the workspace
      * up to the repository root (`project` roots only).
      */
-    ancestors: z2.boolean().optional(),
+    ancestors: z3.boolean().optional(),
     /**
      * Prepended to every name under the root, a vendor plugin's
      * `plugin-name:`; a prefixed root is listed as a plugin root.
@@ -115,14 +132,14 @@ var providerNativeRootInputSchema = z2.union([
     skipIfManifest: nativeRootManifestPathSchema.optional()
   }).strict()
 ]);
-var providerNativeRootsInputSchema = z2.object({
-  user: z2.array(providerNativeRootInputSchema).optional(),
-  project: z2.array(providerNativeRootInputSchema).optional()
+var providerNativeRootsInputSchema = z3.object({
+  user: z3.array(providerNativeRootInputSchema).optional(),
+  project: z3.array(providerNativeRootInputSchema).optional()
 }).strict();
-var providerNativeRootSchema = z2.object({
-  path: z2.string().min(1),
-  recursive: z2.boolean(),
-  ancestors: z2.boolean(),
+var providerNativeRootSchema = z3.object({
+  path: z3.string().min(1),
+  recursive: z3.boolean(),
+  ancestors: z3.boolean(),
   namePrefix: nativeRootNamePrefixSchema,
   /** Absent: every skill-shaped directory under the root is a skill. */
   skipIfManifest: nativeRootManifestPathSchema.optional()
@@ -131,7 +148,7 @@ function uniqueByPath(roots) {
   return new Set(roots.map((root) => root.path)).size === roots.length;
 }
 function nativeRootSideSchema(side) {
-  return z2.array(
+  return z3.array(
     providerNativeRootSchema.extend({ path: relativeNativeRootPathSchema }).superRefine((root, context) => {
       if (root.ancestors && side !== "project") {
         context.addIssue({
@@ -142,7 +159,7 @@ function nativeRootSideSchema(side) {
     })
   ).max(PROVIDER_NATIVE_ROOTS_MAX).refine(uniqueByPath, "Roots must not repeat a path");
 }
-var providerNativeRootsSchema = z2.object({
+var providerNativeRootsSchema = z3.object({
   user: nativeRootSideSchema("user"),
   project: nativeRootSideSchema("project")
 }).strict();
@@ -168,19 +185,19 @@ function normalizeProviderNativeRoots(roots) {
     project: (roots?.project ?? []).map(normalizeProviderNativeRoot)
   };
 }
-var providerResolvedNativeRootShapeSchema = z2.enum([
+var providerResolvedNativeRootShapeSchema = z3.enum([
   "skills",
   "skill",
   "skill-file",
   "commands",
   "command-file"
 ]);
-var resolvedNativeRootFieldsSchema = z2.object({
+var resolvedNativeRootFieldsSchema = z3.object({
   path: absoluteNativeRootPathSchema,
-  origin: z2.enum(["user", "project"]),
-  recursive: z2.boolean(),
+  origin: z3.enum(["user", "project"]),
+  recursive: z3.boolean(),
   /** Only with origin `project`, for a path inside the workspace. */
-  ancestors: z2.boolean(),
+  ancestors: z3.boolean(),
   namePrefix: nativeRootNamePrefixSchema,
   shape: providerResolvedNativeRootShapeSchema,
   /**
@@ -188,7 +205,7 @@ var resolvedNativeRootFieldsSchema = z2.object({
    * none. A vendor plugin's root SKILL.md takes the plugin's name; absent
    * means the parent directory's name.
    */
-  fallbackName: z2.string().min(1).optional(),
+  fallbackName: z3.string().min(1).optional(),
   /**
    * `skills` only: a file, relative to a skill directory under this root,
    * that marks the directory as a vendor plugin rather than a skill; the
@@ -232,14 +249,14 @@ var resolvedCommandShapes = /* @__PURE__ */ new Set([
   "command-file"
 ]);
 var PROVIDER_RESOLVED_NATIVE_ROOTS_MAX = 256;
-var providerResolvedNativeRootsSchema = z2.object({
-  skills: z2.array(
+var providerResolvedNativeRootsSchema = z3.object({
+  skills: z3.array(
     providerResolvedNativeRootSchema.refine(
       (root) => resolvedSkillShapes.has(root.shape),
       "A skills root needs a skill shape"
     )
   ).max(PROVIDER_RESOLVED_NATIVE_ROOTS_MAX),
-  commands: z2.array(
+  commands: z3.array(
     providerResolvedNativeRootSchema.refine(
       (root) => resolvedCommandShapes.has(root.shape),
       "A commands root needs a command shape"
@@ -250,7 +267,7 @@ var EMPTY_PROVIDER_RESOLVED_NATIVE_ROOTS = Object.freeze({
   skills: Object.freeze([]),
   commands: Object.freeze([])
 });
-var providerNativeRootSetSchema = z2.object({
+var providerNativeRootSetSchema = z3.object({
   skills: providerNativeRootsSchema,
   commands: providerNativeRootsSchema,
   resolved: providerResolvedNativeRootsSchema
@@ -283,16 +300,16 @@ 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()
+var pluginProviderEnvEntrySchema = z4.object({
+  name: z4.string().regex(PLUGIN_PROVIDER_ENV_NAME_PATTERN),
+  value: z4.union([
+    z4.string(),
+    z4.object({ serverPath: z4.string().startsWith("/") }).strict()
   ]),
-  reason: z3.string(),
-  secret: z3.boolean()
+  reason: z4.string(),
+  secret: z4.boolean()
 }).strict();
-var pluginProviderEnvEntriesSchema = z3.array(pluginProviderEnvEntrySchema).max(PLUGIN_PROVIDER_ENV_MAX_ENTRIES).superRefine((entries, context) => {
+var pluginProviderEnvEntriesSchema = z4.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;
@@ -327,26 +344,26 @@ var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,63}$/;
 var PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES = 64 * 1024;
 var SETTING_KEY_PATTERN = /^[a-zA-Z0-9_-]+$/;
 var settingsBaseFields = {
-  label: z3.string().min(1),
-  description: z3.string().min(1).optional()
+  label: z4.string().min(1),
+  description: z4.string().min(1).optional()
 };
-var stringSettingSchemaSchema = z3.custom(
+var stringSettingSchemaSchema = z4.custom(
   (value) => isStandardSchema(value)
 );
-var booleanSettingSchemaSchema = z3.custom(
+var booleanSettingSchemaSchema = z4.custom(
   (value) => isStandardSchema(value)
 );
-var numberSettingSchemaSchema = z3.custom(
+var numberSettingSchemaSchema = z4.custom(
   (value) => isStandardSchema(value)
 );
-var settingDescriptorSchema = z3.discriminatedUnion("type", [
-  z3.object({
-    type: z3.literal("string"),
+var settingDescriptorSchema = z4.discriminatedUnion("type", [
+  z4.object({
+    type: z4.literal("string"),
     ...settingsBaseFields,
-    secret: z3.literal(true).optional(),
-    experimental_multiline: z3.boolean().optional(),
+    secret: z4.literal(true).optional(),
+    experimental_multiline: z4.boolean().optional(),
     experimental_schema: stringSettingSchemaSchema.optional(),
-    default: z3.string().optional()
+    default: z4.string().optional()
   }).strict().refine(
     (descriptor) => !(descriptor.secret === true && descriptor.experimental_multiline === true),
     {
@@ -354,30 +371,30 @@ var settingDescriptorSchema = z3.discriminatedUnion("type", [
       path: ["experimental_multiline"]
     }
   ),
-  z3.object({
-    type: z3.literal("boolean"),
+  z4.object({
+    type: z4.literal("boolean"),
     ...settingsBaseFields,
     experimental_schema: booleanSettingSchemaSchema.optional(),
-    default: z3.boolean().optional()
+    default: z4.boolean().optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("number"),
+  z4.object({
+    type: z4.literal("number"),
     ...settingsBaseFields,
     experimental_schema: numberSettingSchemaSchema.optional(),
-    default: z3.number().finite().optional()
+    default: z4.number().finite().optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("select"),
+  z4.object({
+    type: z4.literal("select"),
     ...settingsBaseFields,
-    options: z3.array(z3.string().min(1)).min(1),
+    options: z4.array(z4.string().min(1)).min(1),
     experimental_schema: stringSettingSchemaSchema.optional(),
-    default: z3.string().optional()
+    default: z4.string().optional()
   }).strict(),
-  z3.object({
-    type: z3.literal("project"),
+  z4.object({
+    type: z4.literal("project"),
     ...settingsBaseFields,
     experimental_schema: stringSettingSchemaSchema.optional(),
-    default: z3.string().optional()
+    default: z4.string().optional()
   }).strict()
 ]);
 function registerSettingDescriptors(target, added) {
@@ -1407,11 +1424,21 @@ function readRpcMethodContract(method, value) {
 function isZodSchemaLike(value) {
   return typeof value === "object" && value !== null && typeof value.safeParse === "function";
 }
+function standardSchemaToJsonSchema(schema) {
+  if (isZodSchemaLike(schema)) {
+    return zodSchemaToJsonSchema(schema);
+  }
+  const convertible = schema;
+  if (typeof convertible.toJSONSchema === "function") {
+    return convertible.toJSONSchema();
+  }
+  throw new Error("the validator exposes no JSON Schema conversion");
+}
 function zodSchemaToJsonSchema(schema) {
   if (typeof schema.toJSONSchema === "function") {
     return schema.toJSONSchema({ io: "input" });
   }
-  return z3.toJSONSchema(schema, { io: "input" });
+  return z4.toJSONSchema(schema, { io: "input" });
 }
 var SINGLE_SCHEMA_KEYWORDS = [
   "additionalItems",
@@ -1632,6 +1659,16 @@ function parsePluginAgentToolPresentation(toolName, value) {
   }
   return presentation;
 }
+function summarizeStandardIssues(issues) {
+  if (issues.length === 0) return "invalid";
+  return issues.map((issue) => {
+    const segments = issue.path === void 0 ? [] : Array.isArray(issue.path) ? issue.path.map(
+      (segment) => typeof segment === "object" && segment !== null ? String(segment.key) : String(segment)
+    ) : [String(issue.path)];
+    const path = segments.length > 0 ? segments.join(".") : "(input)";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
 function summarizeParseIssues(error) {
   const issues = error?.issues;
   if (Array.isArray(issues) && issues.length > 0) {
@@ -1737,11 +1774,140 @@ function storePluginHook(records, hook, handler) {
 function pluginHookAlreadyRegisteredMessage(hook) {
   return `a "${hook}" hook handler is already registered by this plugin`;
 }
+var ENVIRONMENT_PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,63}$/;
+var ENVIRONMENT_PROVIDER_DISPLAY_NAME_MAX_CHARS = 80;
+var ENVIRONMENT_PROVIDER_REQUIREMENT_NAMES = [
+  "projectCheckout",
+  "gitCheckout",
+  "gitRemote",
+  "projectless"
+];
+function validatePluginEnvironmentProviderDeclaration(declaration) {
+  if (typeof declaration !== "object" || declaration === null) {
+    throw new Error("environment provider declaration must be an object");
+  }
+  const id = declaration.id;
+  if (typeof id !== "string" || !ENVIRONMENT_PROVIDER_ID_PATTERN.test(id)) {
+    throw new Error(
+      `invalid environment provider id ${JSON.stringify(id)} \u2014 use 2-64 lowercase letters, digits, or "-", starting with a letter or digit`
+    );
+  }
+  const displayName = typeof declaration.displayName === "string" ? declaration.displayName.trim() : "";
+  if (displayName.length === 0 || displayName.length > ENVIRONMENT_PROVIDER_DISPLAY_NAME_MAX_CHARS) {
+    throw new Error(
+      `environment provider "${id}" needs a displayName of 1-${ENVIRONMENT_PROVIDER_DISPLAY_NAME_MAX_CHARS} characters`
+    );
+  }
+  const icon = declaration.icon === void 0 ? null : z4.string().min(1).parse(declaration.icon).trim();
+  if (icon !== null) {
+    if (isPluginOwnedIconPath(icon))
+      validateProviderRelativePath(icon, `"${id}" icon`);
+    else if (!isNamespacedGlyph(icon) && /[/\\]/u.test(icon))
+      throw new Error(
+        `environment provider "${id}" icon must be a glyph, declared icon, or plugin-relative path`
+      );
+  }
+  if (icon !== null && icon.length === 0) {
+    throw new Error(`environment provider "${id}" declares an empty icon`);
+  }
+  const requires = normalizeEnvironmentProviderRequirements(id, declaration);
+  const inputs = normalizeEnvironmentProviderInputs(id, declaration);
+  if (typeof declaration.create !== "function" || typeof declaration.remove !== "function") {
+    throw new Error(
+      `environment provider "${id}" must declare create and remove functions`
+    );
+  }
+  if (declaration.validate !== void 0 && typeof declaration.validate !== "function") {
+    throw new Error(
+      `environment provider "${id}" declares a validate that is not a function`
+    );
+  }
+  if (declaration.availability !== void 0 && typeof declaration.availability !== "function") {
+    throw new Error(
+      `environment provider "${id}" declares availability that is not a function`
+    );
+  }
+  return {
+    id,
+    displayName,
+    icon,
+    requires,
+    inputs: inputs === null ? null : inputs.schema,
+    inputsJsonSchema: inputs === null ? null : inputs.jsonSchema,
+    availability: declaration.availability ?? null,
+    validate: declaration.validate ?? null,
+    create: declaration.create,
+    remove: declaration.remove,
+    policy: environmentProviderPolicySchema.parse(declaration.policy ?? {})
+  };
+}
+function normalizeEnvironmentProviderInputs(id, declaration) {
+  const inputs = declaration.inputs;
+  if (inputs === void 0) {
+    return null;
+  }
+  if (!isStandardSchema(inputs)) {
+    throw new Error(
+      `environment provider "${id}" declares an inputs that is not a Standard Schema v1 validator`
+    );
+  }
+  let converted;
+  try {
+    converted = JSON.parse(JSON.stringify(standardSchemaToJsonSchema(inputs)));
+  } catch (error) {
+    throw new Error(
+      `environment provider "${id}" declares an inputs validator that cannot be published as JSON Schema (${error instanceof Error ? error.message : String(error)}) \u2014 declare it with zod 4 or a validator exposing toJSONSchema()`
+    );
+  }
+  const jsonSchema = jsonValueSchema.safeParse(converted);
+  if (!jsonSchema.success) {
+    throw new Error(
+      `environment provider "${id}" declares an inputs schema whose JSON Schema is not JSON-serializable`
+    );
+  }
+  return { schema: inputs, jsonSchema: jsonSchema.data };
+}
+function normalizeEnvironmentProviderRequirements(id, declaration) {
+  const requires = declaration.requires ?? {};
+  if (typeof requires !== "object" || requires === null || Array.isArray(requires)) {
+    throw new Error(
+      `environment provider "${id}" declares a requires that is not an object`
+    );
+  }
+  const normalized = {};
+  for (const name of ENVIRONMENT_PROVIDER_REQUIREMENT_NAMES) {
+    const value = requires[name];
+    if (value !== void 0 && typeof value !== "boolean") {
+      throw new Error(
+        `environment provider "${id}" declares a requires.${name} that is not a boolean`
+      );
+    }
+    normalized[name] = value === true;
+  }
+  if (normalized.gitCheckout) {
+    normalized.projectCheckout = true;
+  }
+  if (normalized.projectless && (normalized.projectCheckout || normalized.gitRemote)) {
+    throw new Error(
+      `environment provider "${id}" declares requires.projectless together with a project requirement \u2014 a projectless thread has no checkout or remote`
+    );
+  }
+  return normalized;
+}
+var environmentProviderPolicySchema = z4.object({
+  retireGraceMs: z4.number().int().nonnegative().nullable().default(3e5),
+  pathKeys: z4.enum(["per-thread", "per-attempt"]).default("per-thread")
+}).strict();
+var MACHINE_PROVIDER_REQUIREMENT_NAMES = ["gitRemote"];
 export {
   AGENT_TOOL_NAME_PATTERN,
   BACKGROUND_NAME_PATTERN,
   CLI_COMMAND_NAME_PATTERN,
+  ENVIRONMENT_PROVIDER_DISPLAY_NAME_MAX_CHARS,
+  ENVIRONMENT_PROVIDER_ID_PATTERN,
+  ENVIRONMENT_PROVIDER_REQUIREMENT_NAMES,
   KV_VALUE_MAX_BYTES,
+  MACHINE_PROVIDER_REQUIREMENT_NAMES,
   MENTION_PROVIDER_ID_PATTERN,
   PLUGIN_AGENT_DYNAMIC_INSTRUCTIONS_MAX_CHARS,
   PLUGIN_AGENT_SELECTION_MAX_IDS,
@@ -1785,8 +1951,10 @@ export {
   rejectStaleAgentToolFields,
   storePluginHook,
   summarizeParseIssues,
+  summarizeStandardIssues,
   undeclaredIconProblem,
   validatePluginAiServiceDeclaration,
+  validatePluginEnvironmentProviderDeclaration,
   validatePluginProviderDeclaration,
   validatePluginProviderEnvEntries,
   validateSettingsUpdate,

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

@@ -9,6 +9,14 @@ function requireSlotId(kind, value) {
   }
   return value;
 }
+function requireEnvironmentProviderId(kind, value) {
+  if (typeof value !== "string" || !PLUGIN_SLOT_ID_PATTERN.test(value)) {
+    throw new Error(
+      `${kind}: "environmentProviderId" must match ${String(PLUGIN_SLOT_ID_PATTERN)}, got ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
 function requireProviderId(kind, value) {
   if (typeof value !== "string" || !PLUGIN_SLOT_ID_PATTERN.test(value)) {
     throw new Error(
@@ -391,6 +399,7 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
     commandPaletteActions: [],
     providerIcons: [],
     timelineRenderers: [],
+    environmentProviderInputs: [],
     contentScripts: []
   };
   sidebarFooterItemsByRegistrationSet.set(collected, sidebarFooterItems);
@@ -415,6 +424,7 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
     commandPaletteAction: /* @__PURE__ */ new Set(),
     providerIcon: /* @__PURE__ */ new Set(),
     timelineRenderer: /* @__PURE__ */ new Set(),
+    environmentProviderInputs: /* @__PURE__ */ new Set(),
     contentScript: /* @__PURE__ */ new Set()
   };
   definition.setup({
@@ -765,6 +775,22 @@ function collectPluginAppRegistrations(definition, onComposerCustomizationReject
           kind: itemKind,
           component: requireComponent(kind, registration.component)
         });
+      },
+      experimental_environmentProviderInputs(registration) {
+        const kind = "slots.experimental_environmentProviderInputs";
+        const environmentProviderId = requireEnvironmentProviderId(
+          kind,
+          registration?.environmentProviderId
+        );
+        requireUniqueId(
+          kind,
+          seenIds.environmentProviderInputs,
+          environmentProviderId
+        );
+        collected.environmentProviderInputs.push({
+          environmentProviderId,
+          component: requireComponent(kind, registration.component)
+        });
       }
     },
     experimental_sidebarFooter: new SidebarFooterCollector(

package/dist/provider-bridge-acp.js

@@ -1316,7 +1316,7 @@ var systemThreadProvisioningStatusSchema = z11.enum(
 var systemThreadProvisioningEventDataSchema = z11.object({
   provisioningId: z11.string(),
   status: systemThreadProvisioningStatusSchema,
-  environmentId: z11.string(),
+  environmentId: z11.string().nullable(),
   entries: z11.array(provisioningTranscriptEntrySchema)
 });
 var systemLegacyUserMessageEventDataSchema = z11.object({
@@ -1717,6 +1717,19 @@ var threadEventItemTruncationSchema = z14.object({
   result: threadEventTextTruncationSchema.optional(),
   resultText: threadEventTextTruncationSchema.optional()
 });
+var threadEventImageGenerationItemSchema = z14.object({
+  type: z14.literal("imageGeneration"),
+  id: z14.string(),
+  status: threadEventItemStatusSchema,
+  prompt: z14.string().nullable(),
+  path: z14.string().nullable(),
+  result: z14.string().optional(),
+  error: z14.string().nullable(),
+  transparentBackground: z14.boolean(),
+  truncation: threadEventItemTruncationSchema.optional(),
+  ...itemPresentationField,
+  parentToolCallId: z14.string().optional()
+});
 var threadEventUserContentSchema = z14.discriminatedUnion("type", [
   z14.object({ type: z14.literal("text"), text: z14.string() }),
   z14.object({ type: z14.literal("image"), url: z14.string() }),
@@ -1828,6 +1841,7 @@ var threadEventItemSchema = z14.discriminatedUnion("type", [
   threadEventWebSearchItemSchema,
   threadEventWebFetchItemSchema,
   threadEventImageViewItemSchema,
+  threadEventImageGenerationItemSchema,
   threadEventFileReadItemSchema,
   threadEventSearchItemSchema,
   z14.object({
@@ -2896,6 +2910,14 @@ var deltaItemShapeSchema = z25.discriminatedUnion("type", [
     pattern: z25.string().nullable()
   }),
   z25.object({ type: z25.literal("imageView"), path: z25.string() }),
+  z25.object({
+    type: z25.literal("imageGeneration"),
+    prompt: z25.string().nullable(),
+    path: z25.string().nullable(),
+    result: z25.string().optional(),
+    error: z25.string().nullable(),
+    transparentBackground: z25.boolean()
+  }),
   deltaBackgroundTaskShapeSchema,
   deltaFileReadShapeSchema,
   deltaSearchShapeSchema,
@@ -3831,6 +3853,7 @@ import { promises as fs2, readFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { dirname as dirname2, isAbsolute, basename as basename3, relative, resolve as resolve3 } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { z as z40 } from "zod";
 
 // ../provider-bridge-acp/src/bridge-protocol.ts
@@ -8751,6 +8774,7 @@ async function startAgentSession(request) {
   });
   session = {
     bbThreadId,
+    construction: params,
     providerThreadId: "",
     cwd: params.cwd,
     dialect,
@@ -9484,7 +9508,7 @@ async function handleRequest2(request) {
     }
     case "turn/start": {
       const params = request.params;
-      const session = liveSessionForThread(params.threadId);
+      let session = liveSessionForThread(params.threadId);
       if (session === void 0) {
         sendError(request.id, -32e3, "No active ACP session");
         return;
@@ -9493,6 +9517,26 @@ async function handleRequest2(request) {
         sendError(request.id, -32e3, "A turn is already active");
         return;
       }
+      if (Object.keys(params.options.envVars ?? {}).length > 0) {
+        const envVars = {
+          ...decodeLaunchSpec(params.options.providerOptions)?.env ?? {},
+          ...params.options.envVars
+        };
+        if (!isDeepStrictEqual(envVars, session.construction.envVars ?? {})) {
+          const previousProviderThreadId = session.providerThreadId;
+          session = await startAgentSession({
+            kind: "resume",
+            params: { ...session.construction, envVars },
+            resumeProviderThreadId: previousProviderThreadId
+          });
+          sendNotification(BRIDGE_NOTIFICATION_METHODS.sessionReplaced, {
+            threadId: params.threadId,
+            providerThreadId: session.providerThreadId,
+            reason: "Execution settings changed; the ACP session was rebuilt to apply them.",
+            contextLost: session.providerThreadId !== previousProviderThreadId
+          });
+        }
+      }
       const pending = {
         clientRequestId: params.clientRequestId,
         input: params.input,