@moxt-ai/mobius 0.0.323 → 0.0.324

package/dist/runtime.js

@@ -500,11 +500,10 @@ function terminateProcess2(child, signal) {
 var windowsPermissions = `
 $ErrorActionPreference = 'Stop'
 $ProgressPreference = 'SilentlyContinue'
-Import-Module (Join-Path $PSHOME 'Modules/Microsoft.PowerShell.Security/Microsoft.PowerShell.Security.psd1')
 $item = Get-Item -LiteralPath $env:MOBIUS_PERMISSION_PATH -Force
 if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw 'Unsafe path' }
 $sid = [Security.Principal.WindowsIdentity]::GetCurrent().User
-$acl = Get-Acl -LiteralPath $item.FullName
+$acl = $item.GetAccessControl()
 $owner = $acl.GetOwner([Security.Principal.SecurityIdentifier])
 if ($owner -ne $sid -and -not ($owner.Value -eq 'S-1-5-32-544' -and ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator))) { throw 'Path is not user-owned' }
 if ($env:MOBIUS_PERMISSION_PRIVATE -eq '1') {
@@ -518,7 +517,7 @@ if ($env:MOBIUS_PERMISSION_PRIVATE -eq '1') {
     $private.SetOwner($sid)
     $private.SetAccessRuleProtection($true, $false)
     $private.AddAccessRule($rule)
-    Set-Acl -LiteralPath $item.FullName -AclObject $private
+    $item.SetAccessControl($private)
 }
 `;
 var windowsPermissionsTimeoutMs = 3e4;
@@ -21387,6 +21386,8 @@ var sessionConfigureCommandSchema = external_exports.object({
   ...sessionIdentityFields,
   booleanValue: external_exports.boolean(),
   configId: external_exports.string().min(1).max(128),
+  // Omitted by legacy clients: explicit edits retain last-write-wins behavior.
+  expectedConfigurationRevision: identifierStringSchema.optional(),
   kind: external_exports.literal(SESSION_CONFIGURE_KIND),
   requestId: identifierStringSchema,
   value: external_exports.string().max(500),
@@ -21394,6 +21395,8 @@ var sessionConfigureCommandSchema = external_exports.object({
 }).readonly();
 var sessionConfigUpdatedEventSchema = external_exports.object({
   configOptions: sessionConfigOptionsSchema,
+  // An opaque Runtime generation token; absent on older Runtimes.
+  configurationRevision: identifierStringSchema.optional(),
   kind: external_exports.literal(SESSION_CONFIG_UPDATED_KIND),
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
@@ -21412,6 +21415,8 @@ var sessionConfigReadCommandSchema = external_exports.object({
 }).readonly();
 var sessionConfigReadResultSchema = external_exports.object({
   configOptions: sessionConfigOptionsSchema,
+  // An opaque Runtime generation token; absent on older Runtimes.
+  configurationRevision: identifierStringSchema.optional(),
   kind: external_exports.literal(SESSION_CONFIG_READ_RESULT_KIND),
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
@@ -21445,9 +21450,17 @@ var encodeSessionRenamedEvent = (message) => encodeZodMessage(message, sessionRe
 // ../mobius-sdk/src/protocol/session/files/index.ts
 var FILE_READ_KIND = "file.read";
 var FILE_BEGIN_KIND = "file.begin";
-var FILE_CHUNK_KIND = "file.chunk";
 var FILE_END_KIND = "file.end";
 var FILE_FAILED_KIND = "file.failed";
+var CONTENT_WRITE_KIND = "content.write";
+var CONTENT_COMMIT_KIND = "content.commit";
+var CONTENT_READY_KIND = "content.ready";
+var CONTENT_AVAILABLE_KIND = "content.available";
+var CONTENT_CHUNK_MAX_BYTES = 192 * 1024;
+var CONTENT_WRITE_MAX_BYTES = 32 * 1024 * 1024;
+var PROMPT_IMAGE_MAX_BYTES = 5e6;
+var CONTENT_CHUNK_MAGIC = new Uint8Array([77, 66, 67, 49]);
+var CONTENT_CHUNK_HEADER_BYTES = CONTENT_CHUNK_MAGIC.byteLength + 1 + 4;
 var fileReadCommandSchema = external_exports.object({
   kind: external_exports.literal(FILE_READ_KIND),
   maxBytes: external_exports.number().int().positive().max(128 * 1024 * 1024),
@@ -21464,13 +21477,86 @@ var fileBeginEventSchema = external_exports.object({
   requestId: identifierStringSchema,
   sessionId: identifierStringSchema
 }).readonly();
-var fileChunkEventSchema = external_exports.object({
-  data: external_exports.string().min(1).max(4e5),
-  kind: external_exports.literal(FILE_CHUNK_KIND),
+var contentWriteCommandSchema = external_exports.object({
+  byteLength: external_exports.number().int().positive().max(CONTENT_WRITE_MAX_BYTES),
+  contentKey: external_exports.string().regex(/^[a-f0-9]{64}$/u),
+  contentKind: external_exports.enum(["image", "resource"]),
+  kind: external_exports.literal(CONTENT_WRITE_KIND),
+  mediaType: external_exports.string().min(1).max(255),
+  name: external_exports.string().min(1).max(500),
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+}).readonly();
+var contentCommitCommandSchema = external_exports.object({
+  kind: external_exports.literal(CONTENT_COMMIT_KIND),
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+}).readonly();
+var contentReadyEventSchema = external_exports.object({
+  kind: external_exports.literal(CONTENT_READY_KIND),
+  requestId: identifierStringSchema,
+  sessionId: identifierStringSchema
+}).readonly();
+var contentAvailableEventSchema = external_exports.object({
+  byteLength: external_exports.number().int().positive().max(CONTENT_WRITE_MAX_BYTES),
+  contentKey: external_exports.string().regex(/^[a-f0-9]{64}$/u),
+  kind: external_exports.literal(CONTENT_AVAILABLE_KIND),
   requestId: identifierStringSchema,
-  sequence: external_exports.number().int().nonnegative().max(1024),
   sessionId: identifierStringSchema
 }).readonly();
+function binaryBytes(value) {
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  throw new Error("Content chunk must be a binary WebSocket frame");
+}
+function encodeContentChunkFrame(frame) {
+  if (!isIdentifier(frame.requestId)) {
+    throw new Error("Content chunk request identifier is invalid");
+  }
+  if (!Number.isSafeInteger(frame.sequence) || frame.sequence < 0 || frame.sequence > 4294967295) {
+    throw new Error("Content chunk sequence is invalid");
+  }
+  if (frame.bytes.byteLength < 1 || frame.bytes.byteLength > CONTENT_CHUNK_MAX_BYTES) {
+    throw new Error("Content chunk size is invalid");
+  }
+  const requestId = new TextEncoder().encode(frame.requestId);
+  if (requestId.byteLength > 255) {
+    throw new Error("Content chunk request identifier is too long");
+  }
+  const encoded = new Uint8Array(CONTENT_CHUNK_HEADER_BYTES + requestId.byteLength + frame.bytes.byteLength);
+  encoded.set(CONTENT_CHUNK_MAGIC, 0);
+  encoded[CONTENT_CHUNK_MAGIC.byteLength] = requestId.byteLength;
+  new DataView(encoded.buffer).setUint32(CONTENT_CHUNK_MAGIC.byteLength + 1, frame.sequence);
+  encoded.set(requestId, CONTENT_CHUNK_HEADER_BYTES);
+  encoded.set(frame.bytes, CONTENT_CHUNK_HEADER_BYTES + requestId.byteLength);
+  return encoded;
+}
+function decodeContentChunkFrame(value) {
+  const encoded = binaryBytes(value);
+  if (encoded.byteLength <= CONTENT_CHUNK_HEADER_BYTES || !CONTENT_CHUNK_MAGIC.every((byte, index2) => encoded[index2] === byte)) {
+    throw new Error("Content chunk frame header is invalid");
+  }
+  const requestIdLength = encoded[CONTENT_CHUNK_MAGIC.byteLength] ?? 0;
+  const payloadOffset = CONTENT_CHUNK_HEADER_BYTES + requestIdLength;
+  if (requestIdLength < 1 || payloadOffset >= encoded.byteLength) {
+    throw new Error("Content chunk frame length is invalid");
+  }
+  const requestId = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(
+    encoded.subarray(CONTENT_CHUNK_HEADER_BYTES, payloadOffset)
+  );
+  const bytes = encoded.slice(payloadOffset);
+  const sequence = new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength).getUint32(
+    CONTENT_CHUNK_MAGIC.byteLength + 1
+  );
+  if (!isIdentifier(requestId) || bytes.byteLength > CONTENT_CHUNK_MAX_BYTES) {
+    throw new Error("Content chunk frame is invalid");
+  }
+  return { bytes, requestId, sequence };
+}
 var fileEndEventSchema = external_exports.object({
   kind: external_exports.literal(FILE_END_KIND),
   requestId: identifierStringSchema,
@@ -21487,12 +21573,18 @@ var decodeFileReadCommand = (encoded) => decodeZodMessage(encoded, fileReadComma
 var encodeFileReadCommand = (message) => encodeZodMessage(message, fileReadCommandSchema);
 var decodeFileBeginEvent = (encoded) => decodeZodMessage(encoded, fileBeginEventSchema);
 var encodeFileBeginEvent = (message) => encodeZodMessage(message, fileBeginEventSchema);
-var decodeFileChunkEvent = (encoded) => decodeZodMessage(encoded, fileChunkEventSchema);
-var encodeFileChunkEvent = (message) => encodeZodMessage(message, fileChunkEventSchema);
 var decodeFileEndEvent = (encoded) => decodeZodMessage(encoded, fileEndEventSchema);
 var encodeFileEndEvent = (message) => encodeZodMessage(message, fileEndEventSchema);
 var decodeFileFailedEvent = (encoded) => decodeZodMessage(encoded, fileFailedEventSchema);
 var encodeFileFailedEvent = (message) => encodeZodMessage(message, fileFailedEventSchema);
+var decodeContentWriteCommand = (encoded) => decodeZodMessage(encoded, contentWriteCommandSchema);
+var encodeContentWriteCommand = (message) => encodeZodMessage(message, contentWriteCommandSchema);
+var decodeContentCommitCommand = (encoded) => decodeZodMessage(encoded, contentCommitCommandSchema);
+var encodeContentCommitCommand = (message) => encodeZodMessage(message, contentCommitCommandSchema);
+var decodeContentReadyEvent = (encoded) => decodeZodMessage(encoded, contentReadyEventSchema);
+var encodeContentReadyEvent = (message) => encodeZodMessage(message, contentReadyEventSchema);
+var decodeContentAvailableEvent = (encoded) => decodeZodMessage(encoded, contentAvailableEventSchema);
+var encodeContentAvailableEvent = (message) => encodeZodMessage(message, contentAvailableEventSchema);
 
 // ../mobius-sdk/src/protocol/shared/tool-input.ts
 var MAX_CONTENT_LENGTH = 1e6;
@@ -21749,6 +21841,7 @@ var sessionReadyEventSchema = external_exports.object({
   capabilities: sessionCapabilitiesSchema,
   commands: external_exports.array(sessionCommandSchema).max(500).readonly(),
   configOptions: sessionConfigOptionsSchema,
+  configurationRevision: identifierStringSchema.optional(),
   directoryId: DIRECTORY_IDENTIFIER,
   directoryLabel: external_exports.string().min(1).max(MAX_WORKSPACE_PATH_LENGTH),
   kind: external_exports.literal(SESSION_READY_KIND),
@@ -21836,21 +21929,16 @@ var SessionHistoryPolicy = Object.freeze({
   ExecutionOnly: "execution-only"
 });
 var MAX_PROMPT_LENGTH = 1e5;
-var MAX_PROMPT_ATTACHMENT_LENGTH = 6e6;
-var promptImageSchema = external_exports.object({
-  data: external_exports.string().min(1).max(4e6),
+var MAX_PROMPT_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+var promptAttachmentSchema = external_exports.object({
+  byteLength: external_exports.number().int().positive().max(MAX_PROMPT_ATTACHMENT_BYTES),
+  contentKey: external_exports.string().regex(/^[a-f0-9]{64}$/u),
+  kind: external_exports.enum(["image", "resource"]),
   mimeType: external_exports.string().min(1).max(255),
-  name: external_exports.string().min(1).max(500)
-}).readonly();
-var promptResourceSchema = external_exports.object({
-  mimeType: external_exports.string().max(255),
   name: external_exports.string().min(1).max(500),
-  text: external_exports.string().max(1e6),
-  type: external_exports.enum(["embedded", "link"]),
   uri: external_exports.string().min(1).max(4096)
 }).readonly();
-var decodePromptImagesValue = (value) => decodeZodValue(value, external_exports.array(promptImageSchema).max(8).readonly());
-var decodePromptResourcesValue = (value) => decodeZodValue(value, external_exports.array(promptResourceSchema).max(16).readonly());
+var decodePromptAttachmentsValue = (value) => decodeZodValue(value, external_exports.array(promptAttachmentSchema).max(16).readonly());
 function readPromptDisposition(value) {
   const field = value["disposition"];
   if (field === void 0 || field === SessionPromptDisposition.Reject) {
@@ -21869,13 +21957,12 @@ function decodeSessionPromptCommand(encoded) {
   const hasSessionConfigurations = Object.hasOwn(value, "sessionConfigurations");
   assertKind(value, SESSION_PROMPT_KIND);
   const prompt = readText(value, "prompt", MAX_PROMPT_LENGTH);
-  const images = decodePromptImagesValue(value["images"]);
-  const resources = decodePromptResourcesValue(value["resources"]);
-  const attachmentLength = images.reduce((total, image) => total + image.data.length, 0) + resources.reduce((total, resource) => total + resource.text.length, 0);
-  if (attachmentLength > MAX_PROMPT_ATTACHMENT_LENGTH) {
+  const attachments = !Object.hasOwn(value, "attachments") && Array.isArray(value["images"]) && Array.isArray(value["resources"]) ? [] : decodePromptAttachmentsValue(value["attachments"]);
+  const attachmentBytes = attachments.reduce((total, attachment) => total + attachment.byteLength, 0);
+  if (attachmentBytes > MAX_PROMPT_ATTACHMENT_BYTES) {
     throw new ProtocolMessageError("Prompt attachments are too large");
   }
-  if (prompt.trim().length === 0 && images.length === 0 && resources.length === 0) {
+  if (prompt.trim().length === 0 && attachments.length === 0) {
     throw new ProtocolMessageError("Prompt must contain content");
   }
   const disposition = readPromptDisposition(value);
@@ -21895,13 +21982,12 @@ function decodeSessionPromptCommand(encoded) {
     commandId: readIdentifier(value, "commandId"),
     directoryId: readDirectoryIdentifier(value, "directoryId"),
     disposition,
-    images,
+    attachments,
     ...value["historyPolicy"] === void 0 ? {} : {
       historyPolicy: readHistoryPolicy(value)
     },
     kind: SESSION_PROMPT_KIND,
     prompt,
-    resources,
     ...hasSessionConfigurations ? { sessionConfigurations } : {},
     sessionId: readIdentifier(value, "sessionId"),
     targetCommandId
@@ -21937,7 +22023,15 @@ function decodeSessionPromptDispositionCommand(encoded) {
   };
 }
 function encodeSessionPromptCommand(message) {
-  return JSON.stringify(decodeSessionPromptCommand(JSON.stringify(message)));
+  const command = decodeSessionPromptCommand(JSON.stringify(message));
+  return JSON.stringify({
+    ...command,
+    // Keep text prompts compatible with the previous Runtime release while
+    // attachments move to the content-key protocol. Older Runtimes ignore
+    // `attachments` and require both legacy arrays to be present.
+    images: [],
+    resources: []
+  });
 }
 function encodeSessionCancelCommand(message) {
   return JSON.stringify(decodeSessionCancelCommand(JSON.stringify(message)));
@@ -22022,9 +22116,7 @@ var nativeSessionResultSchema = external_exports.discriminatedUnion("action", [
       external_exports.object({
         commandId: identifierStringSchema,
         prompt: external_exports.string().max(1e5),
-        images: external_exports.array(promptImageSchema).max(8).readonly(),
-        // Absent from daemons that predate it; a client then cannot restore the prompt's files.
-        resources: external_exports.array(promptResourceSchema).max(16).readonly().optional()
+        attachments: external_exports.array(promptAttachmentSchema).max(16).readonly()
       }).readonly()
     ).readonly(),
     turn: activeTurnSnapshotSchema.nullable()
@@ -22626,6 +22718,16 @@ var serviceToDaemonSignatures = {
     decodeAgentCatalogDiscoverCommand
   ),
   [FILE_READ_KIND]: defineMessageSignature(FILE_READ_KIND, encodeFileReadCommand, decodeFileReadCommand),
+  [CONTENT_WRITE_KIND]: defineMessageSignature(
+    CONTENT_WRITE_KIND,
+    encodeContentWriteCommand,
+    decodeContentWriteCommand
+  ),
+  [CONTENT_COMMIT_KIND]: defineMessageSignature(
+    CONTENT_COMMIT_KIND,
+    encodeContentCommitCommand,
+    decodeContentCommitCommand
+  ),
   [SESSION_LIST_KIND]: defineMessageSignature(SESSION_LIST_KIND, encodeSessionListCommand, decodeSessionListCommand),
   [SESSION_QUERY_KIND]: defineMessageSignature(
     SESSION_QUERY_KIND,
@@ -22785,9 +22887,14 @@ var daemonToServiceSignatures = {
     decodeAgentCatalogDiscoveryFailedEvent
   ),
   [FILE_BEGIN_KIND]: defineMessageSignature(FILE_BEGIN_KIND, encodeFileBeginEvent, decodeFileBeginEvent),
-  [FILE_CHUNK_KIND]: defineMessageSignature(FILE_CHUNK_KIND, encodeFileChunkEvent, decodeFileChunkEvent),
   [FILE_END_KIND]: defineMessageSignature(FILE_END_KIND, encodeFileEndEvent, decodeFileEndEvent),
   [FILE_FAILED_KIND]: defineMessageSignature(FILE_FAILED_KIND, encodeFileFailedEvent, decodeFileFailedEvent),
+  [CONTENT_READY_KIND]: defineMessageSignature(CONTENT_READY_KIND, encodeContentReadyEvent, decodeContentReadyEvent),
+  [CONTENT_AVAILABLE_KIND]: defineMessageSignature(
+    CONTENT_AVAILABLE_KIND,
+    encodeContentAvailableEvent,
+    decodeContentAvailableEvent
+  ),
   [SESSION_LISTED_KIND]: defineMessageSignature(
     SESSION_LISTED_KIND,
     encodeSessionsListedEvent,
@@ -32275,7 +32382,7 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.323",
+  version: "0.0.324",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -83559,7 +83666,8 @@ var PreparedSession = class {
   configOptions;
   prompted;
   restored;
-  constructor(agentName, agentVersion, capabilities, commands, configOptions, prompted, restored) {
+  configurationRevision;
+  constructor(agentName, agentVersion, capabilities, commands, configOptions, prompted, restored, configurationRevision) {
     this.agentName = agentName;
     this.agentVersion = agentVersion;
     this.capabilities = capabilities;
@@ -83567,6 +83675,7 @@ var PreparedSession = class {
     this.configOptions = configOptions;
     this.prompted = prompted;
     this.restored = restored;
+    this.configurationRevision = configurationRevision;
   }
 };
 var AgentSettingsSnapshot = class {
@@ -84606,7 +84715,8 @@ var AgentSession = class _AgentSession {
   #agentVersion = "";
   #capabilities = unsupportedSessionCapabilities();
   #commands = [];
-  #configRevision = 0;
+  #configRevision = crypto.randomUUID();
+  #configurationChanges = new SerialTaskQueue();
   #configOptions = [];
   #sessionConfigurations = new SessionConfigurations();
   #nativeHistoryOwnership = { kind: "unbound" };
@@ -84775,7 +84885,8 @@ var AgentSession = class _AgentSession {
     this.#commands,
     this.#configOptions,
     this.#prompted,
-    this.#restored
+    this.#restored,
+    this.#configRevision
   );
   ensureHistoryLoaded = async (signal) => {
     if (!this.#capabilities.loadSession) {
@@ -84905,12 +85016,23 @@ var AgentSession = class _AgentSession {
     const configured = await this.#adapter.configureSession(this.#target(), selection, signal);
     if (this.#configRevision === configRevision) {
       this.#configOptions = configured;
+      this.#configRevision = crypto.randomUUID();
+      await this.#publishConfiguration();
     }
   };
-  configure = async (options) => {
+  // The revision check and Agent mutation share one queue, including legacy callers.
+  // A lost response may have committed: reread after a conflict, never replay an edit blindly.
+  configure = async (options) => this.#configurationChanges.run(async (signal) => {
+    if (options.expectedConfigurationRevision !== void 0 && options.expectedConfigurationRevision !== this.#configRevision) {
+      throw new AcpExecutionError(
+        "Session settings changed. Review the current settings before applying your selection again.",
+        {},
+        "session_configuration_conflict"
+      );
+    }
     await this.#applyConfiguration(
       options.valueType === "boolean" ? { type: "boolean", configId: options.configId, booleanValue: options.booleanValue } : { type: "select", configId: options.configId, value: options.value },
-      options.signal
+      signal
     );
     const applied = this.#configOptions.find((option) => option.id === options.configId);
     if (applied === void 0) {
@@ -84918,7 +85040,24 @@ var AgentSession = class _AgentSession {
     }
     this.#sessionConfigurations.select(applied);
     this.writeStoredSession((/* @__PURE__ */ new Date()).toISOString());
-    return this.#configOptions;
+    return { configOptions: this.#configOptions, configurationRevision: this.#configRevision };
+  }, options.signal);
+  #publishConfiguration = async () => {
+    const event = this.#store.events.append(this.#mobiusSessionId, {
+      type: "acp",
+      payload: {
+        sessionUpdate: "config_option_update",
+        configOptions: this.#configOptions.map((option) => ({
+          category: option.category,
+          description: option.description,
+          id: option.id,
+          name: option.name,
+          ...option.type === "boolean" ? { type: "boolean", currentValue: option.booleanValue } : { type: "select", currentValue: option.currentValue, options: option.values }
+        }))
+      }
+    });
+    await this.#getObserver().onSessionEvent?.(event);
+    await this.emitConfigUpdate();
   };
   #target = () => ({
     nativeSessionId: this.#updates.sessionId(),
@@ -85096,6 +85235,13 @@ var AgentSession = class _AgentSession {
     this.#nativeHistoryOwnership = { kind: "agent-owned" };
   };
   #processEvent = async (event) => {
+    if (event.kind === "configuration" || event.kind === "mode") {
+      this.#configOptions = event.kind === "configuration" ? event.configOptions : this.#configOptions.map(
+        (option) => option.category === "mode" ? { ...option, currentValue: event.modeId } : option
+      );
+      this.#configRevision = crypto.randomUUID();
+      this.#captureSelectedConfigurationValues();
+    }
     if (this.#sessionLoad.kind === "capturing") {
       await this.#sessionLoad.history.record(event.payload);
     } else if (this.#sessionLoad.kind === "loaded" || this.#sessionLoad.kind === "execution-only") {
@@ -85116,17 +85262,7 @@ var AgentSession = class _AgentSession {
         });
         return;
       case "configuration":
-        this.#configOptions = event.configOptions;
-        this.#configRevision += 1;
-        this.#captureSelectedConfigurationValues();
-        await this.emitConfigUpdate();
-        return;
       case "mode":
-        this.#configOptions = this.#configOptions.map(
-          (option) => option.category === "mode" ? { ...option, currentValue: event.modeId } : option
-        );
-        this.#configRevision += 1;
-        this.#captureSelectedConfigurationValues();
         await this.emitConfigUpdate();
         return;
       case "info":
@@ -85189,6 +85325,7 @@ var AgentSession = class _AgentSession {
   }
   setConfigOptions(options) {
     this.#configOptions = options;
+    this.#configRevision = crypto.randomUUID();
   }
   setNativeHistoryOwnership(ownership) {
     this.#nativeHistoryOwnership = ownership;
@@ -85210,6 +85347,7 @@ var AgentSession = class _AgentSession {
   emitConfigUpdate = async () => {
     await this.#getObserver().onConfig({
       configOptions: this.#configOptions,
+      configurationRevision: this.#configRevision,
       kind: SESSION_CONFIG_UPDATED_KIND,
       requestId: `agent-update-${crypto.randomUUID()}`,
       sessionId: this.#mobiusSessionId
@@ -85608,7 +85746,7 @@ var SessionManager2 = class {
           (option) => option.id === "model" || option.category === "model"
         );
         const modelIsFixed = modelOption2?.type === "select" && modelOption2.values.length < 2 && modelOption2.currentValue === model;
-        const configOptions = model === void 0 || modelIsFixed ? prepared.configOptions : await runtime.configure({
+        const configOptions = model === void 0 || modelIsFixed ? prepared.configOptions : (await runtime.configure({
           ...options2,
           booleanValue: false,
           configId: modelOption2?.id ?? "model",
@@ -85616,7 +85754,7 @@ var SessionManager2 = class {
           sessionId: `agent-settings-${crypto.randomUUID()}`,
           value: model,
           valueType: "select"
-        });
+        })).configOptions;
         return new AgentSettingsSnapshot(
           prepared.agentName,
           prepared.agentVersion,
@@ -86452,19 +86590,22 @@ function promptContent(command) {
   if (command.prompt.length > 0) {
     content.push({ text: command.prompt, type: "text" });
   }
-  for (const image of command.images) {
-    content.push({
-      data: image.data,
-      mimeType: image.mimeType,
-      type: "image"
-    });
-  }
-  for (const resource of command.resources) {
+  for (const attachment of command.attachments) {
     content.push(
-      resource.type === "embedded" ? {
-        resource: { mimeType: resource.mimeType, text: resource.text, uri: resource.uri },
-        type: "resource"
-      } : { mimeType: resource.mimeType, name: resource.name, type: "resource_link", uri: resource.uri }
+      attachment.kind === "image" ? {
+        byteLength: attachment.byteLength,
+        imageKey: attachment.contentKey,
+        mimeType: attachment.mimeType,
+        type: "external_image",
+        uri: attachment.uri
+      } : {
+        byteLength: attachment.byteLength,
+        encoding: "text",
+        mimeType: attachment.mimeType,
+        resourceKey: attachment.contentKey,
+        type: "external_resource",
+        uri: attachment.uri
+      }
     );
   }
   return content;
@@ -87143,8 +87284,7 @@ var SessionTurns = class {
         queued.push({
           commandId: candidate.command.commandId,
           prompt: candidate.command.prompt,
-          images: candidate.command.images,
-          resources: candidate.command.resources
+          attachments: candidate.command.attachments
         });
       }
       return { turn: turnSnapshot ?? null, queued };
@@ -87441,7 +87581,7 @@ import { join as join27 } from "node:path";
 
 // src/storage/files/scratch-directory.ts
 import { randomUUID as randomUUID15 } from "node:crypto";
-import { lstat as lstat4, mkdir as mkdir5, readdir as readdir6, realpath as realpath7, rename as rename4, rm as rm3, stat as stat6, utimes, writeFile as writeFile2 } from "node:fs/promises";
+import { lstat as lstat4, mkdir as mkdir5, readdir as readdir6, readFile as readFile6, realpath as realpath7, rename as rename4, rm as rm3, stat as stat6, utimes, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname11, join as join26 } from "node:path";
 async function atomicWrite(path7, bytes, signal) {
   const temporary = `${path7}.${randomUUID15()}.tmp`;
@@ -87505,6 +87645,12 @@ var ScratchDirectory = class {
       return null;
     }
   };
+  /** Reads a regular file owned by this scratch directory after validating its canonical path. */
+  read = async (path7, signal) => {
+    const resolved = await this.resolveFile(path7);
+    signal.throwIfAborted();
+    return resolved === null ? null : new Uint8Array(await readFile6(resolved, { signal }));
+  };
   removeAll = async () => {
     await rm3(this.#root, { force: true, recursive: true });
   };
@@ -87606,6 +87752,11 @@ var LocalExternalContentStore = class {
     signal.throwIfAborted();
     return resolvedPath === null ? null : { mediaType: entry.mediaType, name: entry.name, path: resolvedPath };
   };
+  read = (sessionId, request, signal) => this.#track(async () => {
+    const active = AbortSignal.any([signal, this.#lifetime.signal]);
+    const resolved = await this.#resolve(sessionId, request, active);
+    return resolved === null ? null : this.#scratch.read(resolved.path, active);
+  });
   [Symbol.asyncDispose] = async () => {
     clearInterval(this.#expirationTimer);
     this.#lifetime.abort();
@@ -88271,6 +88422,12 @@ function send(socket, message) {
   }
   socket.send(encodeDaemonToServiceMessage(message));
 }
+function sendContentChunk(socket, requestId, sequence, bytes) {
+  if (socket.readyState !== WebSocket2.OPEN) {
+    throw new Error("Relay connection is not open");
+  }
+  socket.send(encodeContentChunkFrame({ bytes, requestId, sequence }));
+}
 function reportOperationFailure(socket, requestId, sessionId, error62, runtimeTimings = []) {
   if (socket.readyState !== WebSocket2.OPEN) {
     return;
@@ -88890,13 +89047,133 @@ function createAgentSettingsCommands(context) {
   ];
 }
 
+// src/runtime/command/registry/content-write/index.ts
+import { createHash as createHash9 } from "node:crypto";
+function createContentWriteCommands(context) {
+  const pending = /* @__PURE__ */ new Map();
+  const operations = /* @__PURE__ */ new Set();
+  const fail = (command, error62) => {
+    pending.delete(command.requestId);
+    send(context.socket, {
+      code: "content_write_failed",
+      kind: FILE_FAILED_KIND,
+      message: error62 instanceof Error ? error62.message : "The content could not be stored",
+      requestId: command.requestId,
+      sessionId: command.sessionId
+    });
+  };
+  const write = {
+    kind: CONTENT_WRITE_KIND,
+    handle: (_commandContext, message) => {
+      if (message.kind !== CONTENT_WRITE_KIND) {
+        throw new Error("Command kind mismatch");
+      }
+      const existing = pending.get(message.requestId);
+      if (existing !== void 0) {
+        if (JSON.stringify(existing.command) !== JSON.stringify(message)) {
+          fail(message, new Error("The content request identifier is already in use"));
+          return;
+        }
+      } else {
+        pending.set(message.requestId, {
+          bytes: new Uint8Array(message.byteLength),
+          command: message,
+          hash: createHash9("sha256"),
+          receivedBytes: 0,
+          sequence: 0
+        });
+      }
+      send(context.socket, {
+        kind: CONTENT_READY_KIND,
+        requestId: message.requestId,
+        sessionId: message.sessionId
+      });
+    }
+  };
+  const commit = {
+    kind: CONTENT_COMMIT_KIND,
+    handle: (_commandContext, message) => {
+      if (message.kind !== CONTENT_COMMIT_KIND) {
+        throw new Error("Command kind mismatch");
+      }
+      const state = pending.get(message.requestId);
+      if (state === void 0 || state.command.sessionId !== message.sessionId) {
+        fail(message, new Error("The content upload is unavailable"));
+        return;
+      }
+      pending.delete(message.requestId);
+      const operation = (async () => {
+        try {
+          if (state.receivedBytes !== state.command.byteLength) {
+            throw new Error("The content upload ended at an unexpected length");
+          }
+          if (state.hash.digest("hex") !== state.command.contentKey) {
+            throw new Error("The content upload failed integrity validation");
+          }
+          const stored = await context.externalContent.put({
+            bytes: state.bytes,
+            kind: state.command.contentKind,
+            mediaType: state.command.mediaType,
+            name: state.command.name,
+            sessionId: state.command.sessionId,
+            signal: context.signal
+          });
+          if (stored.key !== state.command.contentKey || stored.byteLength !== state.command.byteLength) {
+            throw new Error("Stored content did not match the upload");
+          }
+          send(context.socket, {
+            byteLength: stored.byteLength,
+            contentKey: stored.key,
+            kind: CONTENT_AVAILABLE_KIND,
+            requestId: message.requestId,
+            sessionId: message.sessionId
+          });
+        } catch (error62) {
+          if (!context.signal.aborted) {
+            fail(message, error62);
+          }
+        }
+      })();
+      operations.add(operation);
+      void operation.finally(() => operations.delete(operation));
+    }
+  };
+  return {
+    commands: [write, commit],
+    receiveChunk: (frame) => {
+      const state = pending.get(frame.requestId);
+      if (state === void 0) {
+        context.diagnostics.daemonDiagnostic("content_chunk_discarded", frame.requestId, {
+          reason: "upload_unavailable",
+          sequence: frame.sequence.toString()
+        });
+        return;
+      }
+      if (frame.sequence !== state.sequence || state.receivedBytes + frame.bytes.byteLength > state.command.byteLength) {
+        fail(state.command, new Error("The content upload contains invalid chunks"));
+        return;
+      }
+      state.bytes.set(frame.bytes, state.receivedBytes);
+      state.hash.update(frame.bytes);
+      pending.set(frame.requestId, {
+        ...state,
+        receivedBytes: state.receivedBytes + frame.bytes.byteLength,
+        sequence: state.sequence + 1
+      });
+    },
+    settle: async () => {
+      pending.clear();
+      await Promise.allSettled([...operations]);
+    }
+  };
+}
+
 // src/runtime/command/registry/file-read/index.ts
 import { WebSocket as WebSocket5 } from "undici";
 
 // src/session/content/session-files.ts
 import { basename as basename8, extname as extname2, isAbsolute as isAbsolute16, join as join31, normalize as normalize3, resolve as resolve17 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-var CHUNK_BYTES = 192 * 1024;
 function requestedPath(value) {
   if (value.includes("\0")) {
     return null;
@@ -88936,7 +89213,7 @@ async function resolveFile(value, workingDirectory, signal) {
   }
   return null;
 }
-async function streamLocalFile(command, send2, signal, workingDirectory, externalContent) {
+async function streamLocalFile(command, send2, sendChunk, signal, workingDirectory, externalContent) {
   const external = await externalContent.resolve(command.sessionId, command.path, signal);
   const target = external?.path ?? await resolveFile(command.path, workingDirectory, signal);
   if (target === null) {
@@ -88958,14 +89235,8 @@ async function streamLocalFile(command, send2, signal, workingDirectory, externa
     sessionId: command.sessionId
   });
   let sequence = 0;
-  for await (const bytes of readFileChunks(target, CHUNK_BYTES, signal)) {
-    send2({
-      data: Buffer.from(bytes).toString("base64"),
-      kind: FILE_CHUNK_KIND,
-      requestId: command.requestId,
-      sequence,
-      sessionId: command.sessionId
-    });
+  for await (const bytes of readFileChunks(target, CONTENT_CHUNK_MAX_BYTES, signal)) {
+    sendChunk(command.requestId, sequence, bytes);
     sequence += 1;
   }
   const after = await readPathMetadata(target);
@@ -88990,6 +89261,7 @@ var fileReadCommand = {
     void streamLocalFile(
       message,
       (response) => send(socket, response),
+      (requestId, sequence, bytes) => sendContentChunk(socket, requestId, sequence, bytes),
       signal,
       sessions.findSessions([message.sessionId])[0]?.cwd ?? null,
       externalContent
@@ -89587,7 +89859,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
   if (sessionConfigurationMatches(option, selection)) {
     return options;
   }
-  return await sessions.configureSession({
+  return (await sessions.configureSession({
     adapter,
     additionalDirectories,
     agent,
@@ -89599,7 +89871,7 @@ async function applySessionConfigurationSelection(sessions, options, selection,
     signal,
     value: selection.value,
     valueType: selection.valueType
-  });
+  })).configOptions;
 }
 async function applyCompleteSessionConfiguration(sessions, initialOptions, selections, agent, adapter, cwd, additionalDirectories, commandId, sessionId, signal) {
   let options = initialOptions;
@@ -89636,8 +89908,7 @@ function warnIgnoredSetting(event, commandId, sessionId, agentId, selection, cat
 }
 
 // src/session/prompt/prompt-artifacts.ts
-var ARTIFACT_SCHEME = "mobius-artifact:";
-var MAX_AGENT_IMAGE_BASE64_LENGTH = 4e6;
+import { createHash as createHash10 } from "node:crypto";
 var MAX_AGENT_RESOURCE_BYTE_LENGTH = 1e6;
 var PromptArtifactError = class extends OperationError {
   constructor(code, message, options = {}) {
@@ -89653,99 +89924,60 @@ var ResolvedPromptArtifacts = class {
     this.resources = resources;
   }
 };
-var PromptArtifactReference = class {
-  artifactId;
-  byteLength;
-  resource;
-  sha256;
-  constructor(artifactId, byteLength, sha256, resource) {
-    this.artifactId = artifactId;
-    this.byteLength = byteLength;
-    this.resource = resource;
-    this.sha256 = sha256;
-  }
-};
-function parseReference(resource) {
-  let url2;
-  try {
-    url2 = new URL(resource.uri);
-  } catch (cause) {
-    throw new PromptArtifactError("artifact_reference_invalid", "The prompt artifact reference is invalid", {
-      cause
-    });
-  }
-  const keys = [...url2.searchParams.keys()].sort();
-  const artifactId = url2.pathname;
-  const encodedByteLength = url2.searchParams.get("byteLength") ?? "";
-  const sha256 = url2.searchParams.get("sha256") ?? "";
-  const byteLength = Number(encodedByteLength);
-  if (url2.protocol !== ARTIFACT_SCHEME || url2.hash.length > 0 || resource.type !== "link" || resource.text.length > 0 || !isIdentifier(artifactId) || keys.length !== 2 || keys[0] !== "byteLength" || keys[1] !== "sha256" || !/^[1-9][0-9]*$/.test(encodedByteLength) || !Number.isSafeInteger(byteLength) || !/^[a-f0-9]{64}$/.test(sha256)) {
-    throw new PromptArtifactError("artifact_reference_invalid", "The prompt artifact reference is invalid");
-  }
-  return new PromptArtifactReference(artifactId, byteLength, sha256, resource);
-}
 function isTextMediaType(mediaType) {
   return mediaType.startsWith("text/") || mediaType === "application/json" || mediaType.endsWith("+json") || mediaType === "application/xml" || mediaType.endsWith("+xml");
 }
-async function resolvePromptArtifacts(download, command, signal) {
-  const images = [...command.images];
+async function resolvePromptArtifacts(read, attachments, signal) {
+  const images = [];
   const resources = [];
-  for (const resource of command.resources) {
+  for (const attachment of attachments) {
     signal.throwIfAborted();
-    if (!resource.uri.startsWith(ARTIFACT_SCHEME)) {
-      resources.push(resource);
-      continue;
+    const bytes = await read(attachment, signal);
+    if (bytes.byteLength !== attachment.byteLength || createHash10("sha256").update(bytes).digest("hex") !== attachment.contentKey) {
+      throw new PromptArtifactError(
+        "artifact_integrity_failed",
+        "The prompt attachment failed integrity validation"
+      );
     }
-    const reference = parseReference(resource);
-    const bytes = await download(
-      {
-        artifactId: reference.artifactId,
-        byteLength: reference.byteLength,
-        commandId: command.commandId,
-        mimeType: reference.resource.mimeType,
-        sessionId: command.sessionId,
-        sha256: reference.sha256
-      },
-      signal
-    );
-    if (resource.mimeType.startsWith("image/")) {
-      const data = Buffer.from(bytes).toString("base64");
-      if (data.length > MAX_AGENT_IMAGE_BASE64_LENGTH || images.length >= 8) {
+    if (attachment.kind === "image") {
+      if (bytes.byteLength > PROMPT_IMAGE_MAX_BYTES || images.length >= 8) {
         throw new PromptArtifactError(
           "artifact_too_large_for_agent",
-          "The prompt artifact exceeds the Agent image limit"
+          "The prompt attachment exceeds the Agent image limit"
         );
       }
-      images.push({ data, mimeType: resource.mimeType, name: resource.name });
+      images.push({
+        data: Buffer.from(bytes).toString("base64"),
+        mimeType: attachment.mimeType,
+        name: attachment.name
+      });
       continue;
     }
-    if (!isTextMediaType(resource.mimeType)) {
+    if (!isTextMediaType(attachment.mimeType)) {
       throw new PromptArtifactError(
         "artifact_media_type_unsupported",
-        "The Agent cannot consume this prompt artifact media type"
+        "The Agent cannot consume this prompt attachment media type"
       );
     }
     if (bytes.byteLength > MAX_AGENT_RESOURCE_BYTE_LENGTH || resources.length >= 16) {
       throw new PromptArtifactError(
         "artifact_too_large_for_agent",
-        "The prompt artifact exceeds the Agent resource limit"
+        "The prompt attachment exceeds the Agent resource limit"
       );
     }
     let text2;
     try {
       text2 = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     } catch (cause) {
-      throw new PromptArtifactError("artifact_encoding_invalid", "The prompt artifact is not valid UTF-8 text", {
-        cause
-      });
+      throw new PromptArtifactError(
+        "artifact_encoding_invalid",
+        "The prompt attachment is not valid UTF-8 text",
+        {
+          cause
+        }
+      );
     }
-    resources.push({
-      mimeType: resource.mimeType,
-      name: resource.name,
-      text: text2,
-      type: "embedded",
-      uri: resource.uri
-    });
+    resources.push({ mimeType: attachment.mimeType, text: text2, type: "embedded", uri: attachment.uri });
   }
   return new ResolvedPromptArtifacts(images, resources);
 }
@@ -89756,7 +89988,7 @@ async function executePrompt({
   eventProjection,
   command,
   resolveAgent,
-  downloadArtifact,
+  readArtifact,
   reportFailure,
   directories,
   sessions,
@@ -89838,7 +90070,7 @@ async function executePrompt({
       stream.epoch,
       availability.disposition
     );
-    const attachments = await resolvePromptArtifacts(downloadArtifact, command, signal);
+    const attachments = await resolvePromptArtifacts(readArtifact, command.attachments, signal);
     let stopReason;
     if (availability.disposition === SessionPromptDisposition.Steer) {
       await sessions.steerPrompt({
@@ -89898,115 +90130,6 @@ async function executePrompt({
   }
 }
 
-// src/runtime/relay/artifact-download.ts
-import { createHash as createHash9 } from "node:crypto";
-import { fetch as fetch4 } from "undici";
-var ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS = 2e4;
-function downloadUrl(config2, artifact) {
-  const url2 = relayHttpEndpoint(config2.relayUrl);
-  let channelPath = "";
-  if (url2.pathname.endsWith("/daemon")) {
-    channelPath = url2.pathname.slice(0, -"/daemon".length);
-  } else {
-    const runtimePath = "/v1/runtimes/connect";
-    if (!url2.pathname.endsWith(runtimePath)) {
-      throw new PromptArtifactError("artifact_endpoint_invalid", "The Relay artifact endpoint is invalid");
-    }
-    channelPath = `${url2.pathname.slice(0, -runtimePath.length)}/channels/${encodeURIComponent(config2.channelId)}`;
-  }
-  url2.pathname = `${channelPath}/sessions/${encodeURIComponent(artifact.sessionId)}/commands/${encodeURIComponent(artifact.commandId)}/artifacts/${encodeURIComponent(artifact.artifactId)}/content`;
-  return url2;
-}
-async function responseBytes(response, expectedByteLength, signal) {
-  const declaredLength = response.headers.get("content-length") ?? "";
-  if (!/^(0|[1-9][0-9]*)$/.test(declaredLength) || Number(declaredLength) !== expectedByteLength || response.body === null) {
-    throw new PromptArtifactError("artifact_integrity_failed", "The prompt artifact failed integrity validation");
-  }
-  const reader = response.body.getReader();
-  const chunks = [];
-  let byteLength = 0;
-  try {
-    while (true) {
-      signal.throwIfAborted();
-      const chunk = await reader.read();
-      signal.throwIfAborted();
-      if (chunk.done) {
-        break;
-      }
-      byteLength += chunk.value.byteLength;
-      if (byteLength > expectedByteLength) {
-        await reader.cancel("Artifact response exceeded its authorization");
-        throw new PromptArtifactError(
-          "artifact_integrity_failed",
-          "The prompt artifact failed integrity validation"
-        );
-      }
-      chunks.push(chunk.value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  if (byteLength !== expectedByteLength) {
-    throw new PromptArtifactError("artifact_integrity_failed", "The prompt artifact failed integrity validation");
-  }
-  const bytes = new Uint8Array(byteLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return bytes;
-}
-async function downloadPromptArtifact(config2, artifact, signal) {
-  signal.throwIfAborted();
-  const timeoutSignal = AbortSignal.timeout(ARTIFACT_DOWNLOAD_TIMEOUT_MILLISECONDS);
-  const requestSignal = AbortSignal.any([signal, timeoutSignal]);
-  let response;
-  try {
-    response = await fetch4(downloadUrl(config2, artifact), {
-      dispatcher: environmentProxyDispatcher,
-      headers: {
-        accept: artifact.mimeType,
-        "accept-encoding": "identity",
-        ...relayAuthorization(config2.relayUrl)
-      },
-      signal: requestSignal
-    });
-    if (!response.ok) {
-      await response.body?.cancel();
-      throw new PromptArtifactError(
-        "artifact_download_rejected",
-        "The Relay rejected the prompt artifact download"
-      );
-    }
-    if (response.headers.get("content-type") !== artifact.mimeType || response.headers.get("x-mobius-artifact-id") !== artifact.artifactId || response.headers.get("x-mobius-sha256") !== artifact.sha256) {
-      await response.body?.cancel();
-      throw new PromptArtifactError(
-        "artifact_integrity_failed",
-        "The prompt artifact failed integrity validation"
-      );
-    }
-    const bytes = await responseBytes(response, artifact.byteLength, requestSignal);
-    if (createHash9("sha256").update(bytes).digest("hex") !== artifact.sha256) {
-      throw new PromptArtifactError(
-        "artifact_integrity_failed",
-        "The prompt artifact failed integrity validation"
-      );
-    }
-    return bytes;
-  } catch (error62) {
-    signal.throwIfAborted();
-    if (error62 instanceof PromptArtifactError) {
-      throw error62;
-    }
-    throw new PromptArtifactError(
-      timeoutSignal.aborted ? "artifact_download_timeout" : "artifact_download_failed",
-      timeoutSignal.aborted ? "The prompt artifact download timed out" : "The prompt artifact could not be downloaded",
-      { cause: error62 }
-    );
-  }
-}
-
 // src/runtime/command/registry/prompt.ts
 var sessionPromptCommand = {
   kind: SESSION_PROMPT_KIND,
@@ -90060,7 +90183,17 @@ var sessionPromptCommand = {
       eventProjection: context.eventProjection,
       command: message,
       resolveAgent: context.resolveAgent,
-      downloadArtifact: (artifact, signal) => downloadPromptArtifact(context.config, artifact, signal),
+      readArtifact: async (artifact, signal) => {
+        const bytes = await context.externalContent.read(
+          message.sessionId,
+          `mobius-content:${artifact.kind}:${artifact.contentKey}`,
+          signal
+        );
+        if (bytes === null) {
+          throw new Error("The prompt attachment is unavailable");
+        }
+        return bytes;
+      },
       reportFailure: context.diagnostics.daemonDiagnostic,
       directories: context.directories,
       sessions: context.sessions,
@@ -90142,7 +90275,7 @@ async function prepareSession(command, recovery, closed, config2, resolveAgent,
     };
     const prepared = command.transient === true ? await sessions.inspectSession(preparation, metrics) : recovery.kind === "history-required" ? await sessions.restoreSession(preparation, metrics, closed) : await sessions.prepareSession(preparation, metrics, closed);
     const configuration = command.configuration;
-    const configOptions = configuration === void 0 ? prepared.configOptions : await metrics.measure(
+    const snapshot = configuration === void 0 ? prepared : await metrics.measure(
       "configuration",
       async () => await sessions.configureSession({
         ...preparation,
@@ -90160,7 +90293,8 @@ async function prepareSession(command, recovery, closed, config2, resolveAgent,
       agentVersion: prepared.agentVersion,
       capabilities: prepared.capabilities,
       commands: prepared.commands,
-      configOptions,
+      configOptions: snapshot.configOptions,
+      configurationRevision: snapshot.configurationRevision,
       directoryId: command.directoryId,
       directoryLabel: resolved.directoryLabel,
       kind: "session.ready",
@@ -90293,11 +90427,12 @@ async function executeSessionConfigure(socket, command, config2, resolveAgent, d
       command.additionalDirectoryIds,
       signal
     );
-    const configOptions = await sessions.configureSession({
+    const snapshot = await sessions.configureSession({
       additionalDirectories: resolved.additionalDirectories,
       ...await resolveAgent(command.agentId, signal, command.sessionId),
       booleanValue: command.booleanValue,
       configId: command.configId,
+      ...command.expectedConfigurationRevision === void 0 ? {} : { expectedConfigurationRevision: command.expectedConfigurationRevision },
       cwd: resolved.cwd,
       requestId: command.requestId,
       sessionId: command.sessionId,
@@ -90306,7 +90441,7 @@ async function executeSessionConfigure(socket, command, config2, resolveAgent, d
       valueType: command.valueType
     });
     send(socket, {
-      configOptions,
+      ...snapshot,
       kind: "session.config.updated",
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -90426,6 +90561,7 @@ async function executeSessionConfigRead(socket, command, config2, resolveAgent,
     );
     send(socket, {
       configOptions: ready.configOptions,
+      configurationRevision: ready.configurationRevision,
       kind: SESSION_CONFIG_READ_RESULT_KIND,
       requestId: command.requestId,
       sessionId: command.sessionId
@@ -90465,6 +90601,7 @@ var sessionConfigReadCommand = {
 
 // src/runtime/command/registry/index.ts
 function createCommandRegistry(context) {
+  const contentWrites = createContentWriteCommands(context);
   const commands = [
     runtimeDiagnosticsCommand,
     runtimePingCommand,
@@ -90473,6 +90610,7 @@ function createCommandRegistry(context) {
     ...createNativeSessionCommands(context),
     ...createAgentCatalogCommands(context),
     ...createAgentSettingsCommands(context),
+    ...contentWrites.commands,
     fileReadCommand,
     sessionCancelCommand,
     sessionCloseCommand,
@@ -90495,8 +90633,12 @@ function createCommandRegistry(context) {
       }
       command.handle(context, message);
     },
+    dispatchChunk: (message) => contentWrites.receiveChunk(decodeContentChunkFrame(message)),
     settle: async () => {
-      await Promise.all(commands.flatMap((command) => command.settle === void 0 ? [] : [command.settle()]));
+      await Promise.all([
+        contentWrites.settle(),
+        ...commands.flatMap((command) => command.settle === void 0 ? [] : [command.settle()])
+      ]);
     }
   };
 }
@@ -90558,6 +90700,7 @@ function connectRelay(url2, signal) {
       dispatcher,
       headers
     });
+    socket.binaryType = "arraybuffer";
     let released = false;
     const release = (reason) => {
       if (released) {
@@ -90921,7 +91064,16 @@ async function runRelayConnection({
       const handleMessage = (event) => {
         const encoded = event.data;
         if (typeof encoded !== "string") {
-          failAndClose(new Error("Relay sent a non-text message"), 4003, "Text message required", "protocol");
+          try {
+            commands.dispatchChunk(encoded);
+          } catch (error62) {
+            failAndClose(
+              new Error("Relay sent an invalid content chunk", { cause: error62 }),
+              4008,
+              "Invalid content chunk",
+              "protocol"
+            );
+          }
           return;
         }
         try {