@codexhost/cli-linux-arm64 0.14.0 → 0.16.0

package/app/desktop-controller.mjs

@@ -3308,10 +3308,10 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const shape = def.shape;
     const propValues = {};
     for (const key in shape) {
-      const field = shape[key]._zod;
-      if (field.values) {
+      const field2 = shape[key]._zod;
+      if (field2.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v of field.values)
+        for (const v of field2.values)
           propValues[key].add(v);
       }
     }
@@ -14952,6 +14952,8 @@ var usageStatisticsTotalsSchema = external_exports.strictObject({
   cachedInputTokens: count,
   cacheWriteInputTokens: count,
   cacheKnownInputTokens: count,
+  cacheHitCachedInputTokens: count,
+  cacheHitInputTokens: count,
   outputTokens: count,
   reasoningOutputTokens: count,
   /** USD at the public price, summed over the priced requests only. */
@@ -15059,6 +15061,51 @@ var hostInteractionIdSchema = opaqueIdSchema.brand();
 var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
 var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
 
+// packages/shared-contracts/dist/thread-questions.js
+var field = external_exports.discriminatedUnion("type", [
+  external_exports.object({
+    id: external_exports.string().min(1),
+    type: external_exports.literal("choice"),
+    prompt: external_exports.string(),
+    options: external_exports.array(external_exports.object({
+      value: external_exports.string().min(1),
+      label: external_exports.string(),
+      description: external_exports.string().optional()
+    })).min(1),
+    multiple: external_exports.boolean(),
+    allowOther: external_exports.boolean(),
+    optional: external_exports.boolean()
+  }),
+  external_exports.object({
+    id: external_exports.string().min(1),
+    type: external_exports.literal("text"),
+    prompt: external_exports.string(),
+    multiline: external_exports.boolean(),
+    secret: external_exports.literal(false),
+    optional: external_exports.boolean(),
+    placeholder: external_exports.string().optional(),
+    prefill: external_exports.string().optional()
+  })
+]);
+var threadQuestionSchema = external_exports.object({
+  interactionId: external_exports.string().min(1),
+  turnId: external_exports.string().min(1),
+  title: external_exports.string().optional(),
+  questions: external_exports.array(field).min(1)
+}).refine(({ questions }) => questions.some((q) => q.type === "choice" && q.multiple), {
+  message: "Shared cards require at least one multi-select question"
+});
+var threadQuestionsListParamsSchema = external_exports.strictObject({ threadId: external_exports.string().min(1) });
+var threadQuestionsResultSchema = external_exports.object({ questions: external_exports.array(threadQuestionSchema) });
+var threadQuestionRespondParamsSchema = external_exports.strictObject({
+  threadId: external_exports.string().min(1),
+  turnId: external_exports.string().min(1),
+  interactionId: external_exports.string().min(1),
+  answers: external_exports.record(external_exports.string(), external_exports.array(external_exports.string())),
+  cancelled: external_exports.boolean().default(false)
+});
+var threadQuestionRespondResultSchema = external_exports.object({ accepted: external_exports.literal(true) });
+
 // packages/shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -16657,8 +16704,99 @@ function retainRendererHostResponses(client, hostId2, target) {
   };
 }
 
+// packages/desktop-control/src/renderer-prewarm-consumption.ts
+function isolateRendererPrewarmConsumption(manager, discardExternal) {
+  const record2 = (value) => value !== null && typeof value === "object";
+  if (!record2(manager) || !record2(manager.threadCreation)) return null;
+  const creation = manager.threadCreation;
+  const originalStart = manager.startConversation;
+  const original = creation.createConversation;
+  const params = creation.params;
+  if (typeof originalStart !== "function" || typeof original !== "function" || !record2(params))
+    return null;
+  const prototype = Object.getPrototypeOf(creation);
+  if (!record2(prototype) || typeof prototype.constructor !== "function") return null;
+  if (Object.keys(creation).some((key) => key !== "params" && typeof creation[key] !== "function") || /#[A-Za-z_$]/u.test(Function.prototype.toString.call(prototype.constructor)))
+    return null;
+  const pool = params.prewarmedThreadManager;
+  if (!record2(pool) || typeof pool.hasPrewarmedThread !== "function" || typeof pool.consumePrewarmedThread !== "function" || typeof pool.deletePrewarmedThread !== "function")
+    return null;
+  const consume = pool.consumePrewarmedThread;
+  const hasPrewarm = pool.hasPrewarmedThread;
+  const draftModels = /* @__PURE__ */ new Map();
+  const draftIdentity = /* @__PURE__ */ Symbol("codexhost draft creation");
+  const external = (model2) => typeof model2 === "string" && model2.startsWith("codexhost/");
+  const routedStart = function(input, options, ...args) {
+    const draftId = record2(options) ? options.clientThreadId : null;
+    const mode = record2(input) && record2(input.collaborationMode) ? input.collaborationMode : null;
+    const origin = mode ? Reflect.get(mode, draftIdentity) : void 0;
+    if (mode && record2(mode.settings) && external(mode.settings.model))
+      return originalStart.call(this, input, options, ...args);
+    const model2 = (typeof draftId === "string" ? draftModels.get(draftId) : void 0) ?? (typeof origin === "string" ? draftModels.get(origin) : void 0);
+    if (!model2) return originalStart.call(this, input, options, ...args);
+    if (!record2(input) || !record2(input.collaborationMode) || !record2(input.collaborationMode.settings))
+      throw new Error("External draft creation is missing its native Model settings");
+    const routed = {
+      ...input,
+      collaborationMode: {
+        ...input.collaborationMode,
+        settings: { ...input.collaborationMode.settings, model: model2 }
+      }
+    };
+    return originalStart.call(this, routed, options, ...args);
+  };
+  const wrapped = function(input, ...args) {
+    const mode = record2(input) && record2(input.collaborationMode) ? input.collaborationMode : null;
+    const expected = mode && record2(mode.settings) ? mode.settings.model : null;
+    const scopedPool = Object.create(pool);
+    scopedPool.hasPrewarmedThread = (...parameters) => hasPrewarm.apply(pool, parameters);
+    scopedPool.consumePrewarmedThread = async (...consumeArgs) => {
+      const warmed = await consume.apply(pool, consumeArgs);
+      if (!record2(warmed) || !record2(warmed.response)) return warmed;
+      const response = warmed.response;
+      if (!external(expected) && !external(response.model)) return warmed;
+      if (external(expected) && expected === response.model) return warmed;
+      if (record2(response.thread) && typeof response.thread.id === "string") {
+        const threadId = response.thread.id;
+        if (external(response.model)) discardExternal(threadId);
+        else
+          void Promise.resolve().then(() => pool.deletePrewarmedThread(threadId)).catch(() => void 0);
+      }
+      return null;
+    };
+    const invocation = Object.create(creation);
+    invocation.params = { ...params, prewarmedThreadManager: scopedPool };
+    return original.call(invocation, input, ...args);
+  };
+  creation.createConversation = wrapped;
+  manager.startConversation = routedStart;
+  return {
+    selectDraft(draftId, model2, creationModes = []) {
+      if (draftId === void 0) {
+        if (model2 === null) draftModels.clear();
+      } else if (model2 === null) draftModels.delete(draftId);
+      else {
+        if (!draftId.startsWith("client-new-thread:") || !external(model2))
+          throw new Error("External draft route is missing its client Thread identity");
+        draftModels.set(draftId, model2);
+        for (const mode of creationModes)
+          Object.defineProperty(mode, draftIdentity, {
+            configurable: true,
+            enumerable: true,
+            value: draftId
+          });
+      }
+    },
+    dispose() {
+      draftModels.clear();
+      if (manager.startConversation === routedStart) manager.startConversation = originalStart;
+      if (creation.createConversation === wrapped) creation.createConversation = original;
+    }
+  };
+}
+
 // packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
-function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses) {
+function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewarmedThreadManager, isCurrentManager, retainResponses = retainRendererHostResponses, isolateConsumption = isolateRendererPrewarmConsumption) {
   let disposed = false;
   const originalSend = bridge.sendRequest;
   const originalPrewarm = bridge.prewarmThreadStart;
@@ -17039,26 +17177,16 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
     if (threadId && knownOfficialThreadIds.has(threadId)) return false;
     return selectedModel !== null && (method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("review/"));
   };
-  const routeThreadStart = (parameters) => {
-    if (!isRecord3(parameters) || parameters.ephemeral === true) {
-      return parameters;
-    }
-    return {
-      ...parameters,
-      ...selectedModel === null ? {} : { model: selectedModel }
-    };
-  };
   const routedSend = (method, parameters, options) => {
     if (method === "turn/start" || method === "thread/resume" || method === "codexhost/thread/command/execute") {
       const threadId = threadIdFromParameters(parameters);
       if (threadId) externalPrewarms.delete(threadId);
     }
-    const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
     const sendBridged = () => initializeBridge().then(
-      () => enqueueBridgeRequest(method, routedParameters, options)
+      () => enqueueBridgeRequest(method, parameters, options)
     );
-    const sendDirect = () => options === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options);
-    const unresolvedThreadId = shouldResolveThreadOwnership(method, routedParameters);
+    const sendDirect = () => options === void 0 ? originalSend.call(bridge, method, parameters) : originalSend.call(bridge, method, parameters, options);
+    const unresolvedThreadId = shouldResolveThreadOwnership(method, parameters);
     if (unresolvedThreadId) {
       return resolveThreadOwnership(unresolvedThreadId).then(
         (owner) => owner === "external" ? sendBridged() : sendDirect(),
@@ -17074,7 +17202,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         }
       );
     }
-    return shouldUseBridge(method, routedParameters) ? sendBridged() : sendDirect();
+    return shouldUseBridge(method, parameters) ? sendBridged() : sendDirect();
   };
   const publishDraftWorkspace = (parameters) => {
     if (!isRecord3(parameters) || parameters.ephemeral === true) return;
@@ -17104,10 +17232,10 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
   const discardExternalPrewarms = () => {
     for (const threadId of externalPrewarms) discardExternalPrewarm(threadId);
   };
+  const restoreConsumption = isolateConsumption(manager, discardExternalPrewarm);
   const routedPrewarm = (parameters, options) => {
-    const routed = routeThreadStart(parameters);
-    const external = isRecord3(routed) && routed.ephemeral !== true && typeof routed.model === "string" && routed.model.startsWith("codexhost/");
-    const routedParameters = external ? { ...routed, codexhostPrewarm: true } : routed;
+    const external = isRecord3(parameters) && parameters.ephemeral !== true && typeof parameters.model === "string" && parameters.model.startsWith("codexhost/");
+    const routedParameters = external ? { ...parameters, codexhostPrewarm: true } : parameters;
     const generation = prewarmGeneration;
     publishDraftWorkspace(routedParameters);
     const pending = shouldUseBridge("thread/start", routedParameters) ? routedSend("thread/start", routedParameters, options) : options === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options);
@@ -17160,6 +17288,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
   const policy = Object.freeze({
     state: "ready",
     hostId: hostId2,
+    scopedCreation: restoreConsumption !== null,
     owns(candidateManager, candidate, candidateHostId, candidatePrewarmedThreadManager, requiresCurrentManager) {
       return !disposed && candidateManager === manager && candidate === bridge && candidateHostId === hostId2 && candidatePrewarmedThreadManager === prewarmedThreadManager && requiresCurrentManager === !!isCurrentManager;
     },
@@ -17168,12 +17297,13 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
         throw new Error("Renderer request manager is retired");
       return manager;
     },
-    select(model2) {
+    select(model2, draftId, creationModes) {
       if (disposed || isCurrentManager && !isCurrentManager())
         throw new Error("Renderer request manager is retired");
       if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
         throw new Error("Draft route Model must be a codexhost transport carrier");
       }
+      restoreConsumption?.selectDraft(draftId, model2, creationModes);
       if (selectedModel === model2) return false;
       selectedModel = model2;
       prewarmGeneration += 1;
@@ -17194,6 +17324,7 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
       disposed = true;
       prewarmGeneration += 1;
       retireResponses();
+      restoreConsumption?.dispose();
       if (bridge.sendRequest === routedSend) bridge.sendRequest = originalSend;
       if (bridge.prewarmThreadStart === routedPrewarm) {
         bridge.prewarmThreadStart = originalPrewarm;
@@ -17458,12 +17589,14 @@ function directRendererInstaller() {
     const resolveRendererHostManager = ${resolveRendererHostManager.toString()};
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
+    const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
     const routing = (${installRendererHostRouting.toString()})(
       document, window,
       (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
       (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
       (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
+        isolateRendererPrewarmConsumption,
       ),
     );
     // Publish a default draft policy only when its Host is unambiguous. Host