@codexhost/cli-win32-arm64 0.14.0 → 0.15.0

package/app/plugins/grok/plugin.mjs

@@ -3634,10 +3634,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);
       }
     }
@@ -15384,6 +15384,51 @@ var hostInteractionIdSchema = opaqueIdSchema.brand();
 var threadPrewarmDiscardParamsSchema = external_exports.object({ threadId: hostThreadIdSchema });
 var threadPrewarmDiscardResultSchema = external_exports.object({ discarded: external_exports.boolean() });
 
+// ../../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) });
+
 // ../../shared-contracts/dist/console.js
 var consoleAnnouncementSchema = external_exports.strictObject({
   title: external_exports.string().trim().min(1).max(200),
@@ -16560,6 +16605,42 @@ function validateHostApprovalResponse(interaction, response) {
   return interaction.actions.some(({ id }) => id === response.actionId) ? null : invalidRequest("Approval Response contains an undeclared action ID");
 }
 
+// ../../harness-adapter/dist/question.js
+function invalidRequest2(message) {
+  return { code: "invalidRequest", message, retryable: false };
+}
+function validateHostQuestionResponse(interaction, response) {
+  const questionIds = new Set(interaction.questions.map(({ id }) => id));
+  if (response.cancelled) {
+    return Object.keys(response.answers).length === 0 ? null : invalidRequest2("Cancelled Question Response must not contain answers");
+  }
+  for (const answerId of Object.keys(response.answers)) {
+    if (!questionIds.has(answerId)) {
+      return invalidRequest2("Question Response contains an unknown Question ID");
+    }
+  }
+  for (const question of interaction.questions) {
+    const answers = response.answers[question.id] ?? [];
+    if (!question.optional && answers.length === 0) {
+      return invalidRequest2("Question Response omits a required answer");
+    }
+    if (question.type === "text") {
+      if (answers.length > 1) {
+        return invalidRequest2("Text Question accepts at most one answer");
+      }
+      continue;
+    }
+    if (!question.multiple && answers.length > 1) {
+      return invalidRequest2("Single-choice Question accepts at most one answer");
+    }
+    const declared = new Set(question.options.map(({ value }) => value));
+    if (!question.allowOther && answers.some((answer) => !declared.has(answer))) {
+      return invalidRequest2("Question Response contains an undeclared choice");
+    }
+  }
+  return null;
+}
+
 // ../../harness-adapter/dist/output-channel.js
 var HarnessOutputChannel = class {
   outputs;
@@ -16681,26 +16762,26 @@ function parseHostUsage(value) {
     }
   }
   const indicators = value.composerIndicators === void 0 ? {} : { composerIndicators: composerIndicatorsSchema.parse(value.composerIndicators) };
-  for (const field of [
+  for (const field2 of [
     "totalCredits",
     "contextUsagePercent",
     "apiOutputTokensPerSecond"
   ]) {
-    const candidate = value[field];
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a finite non-negative number`);
+      throw new Error(`Harness Usage '${field2}' must be a finite non-negative number`);
     }
   }
-  for (const field of tokenFields) {
-    const candidate = value[field];
+  for (const field2 of tokenFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
-  for (const field of safeIntegerFields) {
-    const candidate = value[field];
+  for (const field2 of safeIntegerFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isSafeInteger(candidate) || candidate < 0)) {
-      throw new Error(`Harness Usage '${field}' must be a non-negative safe integer`);
+      throw new Error(`Harness Usage '${field2}' must be a non-negative safe integer`);
     }
   }
   if (value.outputTokensPerSecond !== void 0 && (typeof value.outputTokensPerSecond !== "number" || !Number.isFinite(value.outputTokensPerSecond) || value.outputTokensPerSecond < 0)) {
@@ -16709,10 +16790,10 @@ function parseHostUsage(value) {
   if (value.totalCostUsd !== void 0 && (typeof value.totalCostUsd !== "number" || !Number.isFinite(value.totalCostUsd) || value.totalCostUsd < 0)) {
     throw new Error("Harness Usage 'totalCostUsd' must be a finite non-negative number");
   }
-  for (const field of percentFields) {
-    const candidate = value[field];
+  for (const field2 of percentFields) {
+    const candidate = value[field2];
     if (candidate !== void 0 && (typeof candidate !== "number" || !Number.isFinite(candidate) || candidate < 0 || candidate > 100)) {
-      throw new Error(`Harness Usage '${field}' must be between 0 and 100`);
+      throw new Error(`Harness Usage '${field2}' must be between 0 and 100`);
     }
   }
   if (value.sessionCacheUsage !== void 0) {
@@ -21938,10 +22019,10 @@ function stringField(value, key) {
 function numberField(value, key) {
   if (!isRecord6(value))
     return void 0;
-  const field = value[key];
-  if (field === null)
+  const field2 = value[key];
+  if (field2 === null)
     return null;
-  return typeof field === "number" && Number.isFinite(field) ? field : void 0;
+  return typeof field2 === "number" && Number.isFinite(field2) ? field2 : void 0;
 }
 function decodeBytes(value) {
   if (!Array.isArray(value) || value.length === 0)
@@ -22140,13 +22221,13 @@ function isRecord7(value) {
 function idField(value, key) {
   if (!isRecord7(value))
     return void 0;
-  const field = value[key];
-  if (typeof field === "string") {
-    const trimmed = field.trim();
+  const field2 = value[key];
+  if (typeof field2 === "string") {
+    const trimmed = field2.trim();
     return trimmed.length > 0 ? trimmed : void 0;
   }
-  if (typeof field === "number" && Number.isFinite(field))
-    return String(field);
+  if (typeof field2 === "number" && Number.isFinite(field2))
+    return String(field2);
   return void 0;
 }
 function stringField2(value, key) {
@@ -23398,6 +23479,163 @@ var GrokPermissionConfirmation = class {
   }
 };
 
+// dist/grok-questions.js
+var GROK_ASK_USER_QUESTION_METHOD = "_x.ai/ask_user_question";
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function parseGrokQuestionRequest(value) {
+  if (!isRecord12(value) || !nonEmptyString(value.sessionId) || !nonEmptyString(value.toolCallId) || value.mode !== "default" && value.mode !== "plan" || !Array.isArray(value.questions) || value.questions.length === 0)
+    throw new Error("Grok question requires sessionId, toolCallId, mode and nonempty questions");
+  const seen = /* @__PURE__ */ new Set();
+  const questions = value.questions.map((question) => {
+    if (!isRecord12(question) || !nonEmptyString(question.question) || seen.has(question.question) || !Array.isArray(question.options) || question.multiSelect != null && typeof question.multiSelect !== "boolean" || question.multi_select != null && typeof question.multi_select !== "boolean")
+      throw new Error("Grok question text must be unique and options/multiSelect must be valid");
+    if (question.multiSelect != null && question.multi_select != null && question.multiSelect !== question.multi_select)
+      throw new Error("Grok question contains conflicting multi-select flags");
+    seen.add(question.question);
+    const labels = /* @__PURE__ */ new Set();
+    const options = question.options.map((option) => {
+      if (!isRecord12(option) || !nonEmptyString(option.label) || labels.has(option.label) || typeof option.description !== "string" || option.preview != null && typeof option.preview !== "string")
+        throw new Error("Grok question options require unique labels and text descriptions/previews");
+      labels.add(option.label);
+      return {
+        label: option.label,
+        description: option.description,
+        ...typeof option.preview === "string" ? { preview: option.preview } : {}
+      };
+    });
+    return {
+      question: question.question,
+      options,
+      multiple: question.multiSelect === true || question.multi_select === true
+    };
+  });
+  return { sessionId: value.sessionId, toolCallId: value.toolCallId, mode: value.mode, questions };
+}
+var GrokQuestions = class {
+  turnId;
+  randomUUID;
+  emit;
+  #pending = /* @__PURE__ */ new Map();
+  #seenToolCalls = /* @__PURE__ */ new Set();
+  #closed = false;
+  constructor(turnId, randomUUID2, emit) {
+    this.turnId = turnId;
+    this.randomUUID = randomUUID2;
+    this.emit = emit;
+  }
+  has(interactionId) {
+    return this.#pending.has(interactionId);
+  }
+  ask(request) {
+    if (this.#closed || this.#seenToolCalls.has(request.toolCallId))
+      return Promise.resolve({ outcome: "cancelled" });
+    this.#seenToolCalls.add(request.toolCallId);
+    const interaction = {
+      type: "question",
+      interactionId: hostInteractionIdSchema.parse(this.randomUUID()),
+      turnId: this.turnId,
+      title: "Grok",
+      questions: request.questions.map((question, index) => question.options.length ? {
+        id: `q${index}`,
+        type: "choice",
+        prompt: question.question,
+        options: question.options.map(({ label, description, preview }) => ({
+          value: label,
+          label,
+          description: [description, preview].filter(Boolean).join("\n\n")
+        })),
+        multiple: question.multiple,
+        allowOther: true,
+        optional: true
+      } : {
+        id: `q${index}`,
+        type: "text",
+        prompt: question.question,
+        multiline: true,
+        secret: false,
+        optional: true
+      })
+    };
+    return new Promise((resolve) => {
+      this.#pending.set(interaction.interactionId, { request, interaction, resolve });
+      this.emit({ kind: "interaction", interaction });
+    });
+  }
+  respond(command) {
+    const pending = this.#pending.get(command.interactionId);
+    if (!pending)
+      return this.#error("invalidState", "Grok Question is not pending");
+    if (command.response.type !== "question")
+      return this.#error("invalidRequest", "Grok Question requires a Question Response");
+    const response = command.response;
+    const error53 = validateHostQuestionResponse(pending.interaction, response);
+    if (error53)
+      return { ok: false, error: error53 };
+    if (response.cancelled) {
+      this.#settle(pending, { outcome: "cancelled" }, "cancelled");
+      return { ok: true, value: { accepted: true } };
+    }
+    const answers = /* @__PURE__ */ new Map();
+    const annotations = /* @__PURE__ */ new Map();
+    for (const [index, question] of pending.request.questions.entries()) {
+      const values = response.answers[`q${index}`];
+      if (!values?.length)
+        continue;
+      if (values.some((answer) => !nonEmptyString(answer)) || new Set(values).size !== values.length)
+        return this.#error("invalidRequest", "Grok answers must be nonempty and unique");
+      const selected = values.map((answer) => question.options.find(({ label }) => label === answer));
+      const other = values.filter((_, position) => !selected[position]);
+      if (other.length > 1)
+        return this.#error("invalidRequest", "Grok question accepts only one Other response");
+      answers.set(question.question, selected.map((option) => option?.label ?? "Other"));
+      const previews = selected.flatMap((option) => option?.preview !== void 0 ? [option.preview] : []);
+      if (previews.length || other.length)
+        annotations.set(question.question, {
+          ...previews.length ? { preview: previews.join("\n\n") } : {},
+          ...other.length ? { notes: other[0] } : {}
+        });
+    }
+    this.#settle(pending, {
+      outcome: "accepted",
+      answers: Object.fromEntries(answers),
+      ...annotations.size ? { annotations: Object.fromEntries(annotations) } : {}
+    }, "responded");
+    return { ok: true, value: { accepted: true } };
+  }
+  withdraw(toolCallId) {
+    for (const pending of this.#pending.values()) {
+      if (pending.request.toolCallId === toolCallId)
+        this.#settle(pending, { outcome: "cancelled" }, "cancelled");
+    }
+  }
+  cancel() {
+    this.#closed = true;
+    for (const pending of this.#pending.values())
+      this.#settle(pending, { outcome: "cancelled" }, "cancelled");
+  }
+  #settle(pending, response, reason) {
+    this.#pending.delete(pending.interaction.interactionId);
+    pending.resolve(response);
+    this.emit({
+      kind: "event",
+      event: {
+        type: "interaction.closed",
+        interactionId: pending.interaction.interactionId,
+        turnId: this.turnId,
+        reason
+      }
+    });
+  }
+  #error(code, message) {
+    return { ok: false, error: { code, message, retryable: false } };
+  }
+};
+
 // dist/acp-transport.js
 var GrokTransportError = class extends Error {
   kind;
@@ -23409,16 +23647,16 @@ var GrokTransportError = class extends Error {
     this.name = "GrokTransportError";
   }
 };
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function acpToolName(update, metadata) {
-  if (!isRecord12(update))
+  if (!isRecord13(update))
     return void 0;
   if (typeof update.name === "string" && update.name.length > 0)
     return update.name;
-  const meta3 = isRecord12(update._meta) ? update._meta : metadata;
-  const tool = meta3 && isRecord12(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
+  const meta3 = isRecord13(update._meta) ? update._meta : metadata;
+  const tool = meta3 && isRecord13(meta3["x.ai/tool"]) ? meta3["x.ai/tool"] : void 0;
   return tool && typeof tool.name === "string" && tool.name.length > 0 ? tool.name : void 0;
 }
 function errorText(error53) {
@@ -23474,7 +23712,7 @@ function signalProcessTree(child, signal) {
   try {
     process.kill(-child.pid, signal);
   } catch (error53) {
-    if (!isRecord12(error53) || error53.code !== "ESRCH")
+    if (!isRecord13(error53) || error53.code !== "ESRCH")
       throw error53;
   }
 }
@@ -23517,6 +23755,10 @@ function transportEvent(update, metadata) {
   const subagent = grokSubagentEventFromUpdate(extension);
   if (subagent)
     return subagent;
+  if (extension.sessionUpdate === "interaction_resolved") {
+    const toolCallId = extension.tool_call_id ?? extension.toolCallId;
+    return typeof toolCallId === "string" && toolCallId.trim().length > 0 ? { type: "interaction.resolved", toolCallId, ...metadata ? { metadata } : {} } : null;
+  }
   switch (update.sessionUpdate) {
     case "user_message_chunk":
     case "agent_message_chunk":
@@ -23584,7 +23826,7 @@ async function readNativeSignals(options, sessionId) {
   }
 }
 function isMissingFile(error53) {
-  return isRecord12(error53) && error53.code === "ENOENT";
+  return isRecord13(error53) && error53.code === "ENOENT";
 }
 async function locateGrokNativeSession(options, sessionId) {
   if (sessionId.length === 0)
@@ -23607,7 +23849,7 @@ async function locateGrokNativeSession(options, sessionId) {
     try {
       summaryRaw = await readFile3(path12.join(grokHomeDir(options), "sessions", entry.name, sessionId, "summary.json"), "utf8");
     } catch (error53) {
-      if (isMissingFile(error53) || isRecord12(error53) && error53.code === "ENOTDIR")
+      if (isMissingFile(error53) || isRecord13(error53) && error53.code === "ENOTDIR")
         continue;
       throw new GrokTransportError("unavailable", "Grok Native Session metadata could not be read", {
         cause: error53
@@ -23619,10 +23861,10 @@ async function locateGrokNativeSession(options, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord12(parsed))
+    if (!isRecord13(parsed))
       continue;
     const info = parsed.info;
-    const cwd = isRecord12(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path12.resolve(info.cwd) : path12.resolve(decodeURIComponent(entry.name));
+    const cwd = isRecord13(info) && typeof info.cwd === "string" && info.cwd.length > 0 ? path12.resolve(info.cwd) : path12.resolve(decodeURIComponent(entry.name));
     const sourceWorkspaceDir = typeof parsed.source_workspace_dir === "string" && parsed.source_workspace_dir.length > 0 ? path12.resolve(parsed.source_workspace_dir) : void 0;
     matches.push({
       cwd,
@@ -23655,12 +23897,12 @@ function parseNativeHistory(contents, sessionId) {
     } catch {
       throw new GrokTransportError("protocolError", "Grok Native history contains invalid JSON");
     }
-    if (!isRecord12(record2) || !isRecord12(record2.params))
+    if (!isRecord13(record2) || !isRecord13(record2.params))
       continue;
     const params = record2.params;
-    if (params.sessionId !== sessionId || !isRecord12(params.update))
+    if (params.sessionId !== sessionId || !isRecord13(params.update))
       continue;
-    const metadata = isRecord12(params._meta) ? params._meta : void 0;
+    const metadata = isRecord13(params._meta) ? params._meta : void 0;
     const event = transportEvent(params.update, metadata);
     if (event)
       events.push(metadata ? { ...event, metadata } : event);
@@ -23724,7 +23966,7 @@ var GrokAcpTransport = class {
     if (!this.#connection)
       throw new GrokTransportError("unavailable", "Grok ACP is unavailable");
     const result = await withTimeout(this.#connection.request("_x.ai/session/usage", { sessionId: this.sessionId }), this.#options.commandTimeoutMs, "Grok Session usage");
-    return isRecord12(result) ? result.usage : void 0;
+    return isRecord13(result) ? result.usage : void 0;
   }
   async readHistory(sessionId, cwd = this.#options.cwd) {
     return readGrokNativeHistory({ ...this.#options, cwd }, sessionId);
@@ -23898,7 +24140,8 @@ var GrokAcpTransport = class {
     const connection = new ClientSideConnection(() => ({
       sessionUpdate: (params) => this.#handleUpdate(params),
       requestPermission: (params) => this.#handlePermission(params),
-      extNotification: (method, params) => this.#handleExtensionNotification(method, params)
+      extNotification: (method, params) => this.#handleExtensionNotification(method, params),
+      extMethod: (method, params) => this.#handleExtMethod(method, params)
     }), stream);
     this.#connection = connection;
     child.once("error", (error53) => this.#fault(new GrokTransportError("processExited", error53.message)));
@@ -23918,7 +24161,7 @@ var GrokAcpTransport = class {
     this.#initialize = initialize;
     return initialize;
   }
-  async runTurn(text, onEvent, onPermission) {
+  async runTurn(text, onEvent, onPermission, onQuestion = async () => ({ outcome: "cancelled" })) {
     const connection = this.#connection;
     if (!connection || !this.#sessionId || this.#closed || this.#closing) {
       throw new GrokTransportError("unavailable", "Grok ACP Session is unavailable");
@@ -23927,7 +24170,7 @@ var GrokAcpTransport = class {
       throw new Error("Grok ACP Session already has an active Prompt");
     if (this.#permissionConfirmation)
       throw new GrokTransportError("unavailable", "Grok ACP Session has an active operation");
-    const active = { onEvent, onPermission };
+    const active = { onEvent, onPermission, onQuestion };
     this.#activePrompt = active;
     try {
       return await connection.prompt({
@@ -23986,7 +24229,7 @@ var GrokAcpTransport = class {
       ...reasoningEffort ? { reasoningEffort } : {},
       ...contextWindowTokens !== void 0 ? { _meta: { contextWindow: contextWindowTokens } } : {}
     });
-    if (!isRecord12(response) || !isRecord12(response._meta) || !isRecord12(response._meta.model)) {
+    if (!isRecord13(response) || !isRecord13(response._meta) || !isRecord13(response._meta.model)) {
       throw new GrokTransportError("protocolError", "Grok rejected Model configuration");
     }
     const selected = response._meta.model.Ok;
@@ -24026,7 +24269,7 @@ var GrokAcpTransport = class {
             permission_mode: mode
           });
           const response = await connection.request("_x.ai/session/info", { sessionId });
-          if (!isRecord12(response) || !isRecord12(response.result) || response.result.sessionId !== sessionId) {
+          if (!isRecord13(response) || !isRecord13(response.result) || response.result.sessionId !== sessionId) {
             throw new Error("Grok did not confirm the target Session");
           }
         })()
@@ -24081,7 +24324,7 @@ var GrokAcpTransport = class {
       this.#availableCommands = parseGrokAvailableCommands(update.availableCommands);
       return;
     }
-    const metadata = isRecord12(notification._meta) ? notification._meta : void 0;
+    const metadata = isRecord13(notification._meta) ? notification._meta : void 0;
     const event = transportEvent(notification.update, metadata);
     if (!event)
       return;
@@ -24096,7 +24339,7 @@ var GrokAcpTransport = class {
   #handleExtensionNotification(method, params) {
     if (!isGrokExtensionSessionUpdateMethod(method))
       return;
-    if (typeof params.sessionId !== "string" || !isRecord12(params.update))
+    if (typeof params.sessionId !== "string" || !isRecord13(params.update))
       return;
     this.#handleUpdate(params);
   }
@@ -24106,6 +24349,20 @@ var GrokAcpTransport = class {
     }
     return this.#activePrompt.onPermission({ request: params, options: params.options });
   }
+  async #handleExtMethod(method, params) {
+    if (method !== GROK_ASK_USER_QUESTION_METHOD)
+      throw RequestError.methodNotFound(method);
+    let request;
+    try {
+      request = parseGrokQuestionRequest(params);
+    } catch (error53) {
+      throw RequestError.invalidParams(void 0, errorText(error53));
+    }
+    const active = this.#activePrompt;
+    if (!active || this.#closed || this.#closing || this.#replay !== null || this.#activeCompact !== null || request.sessionId !== this.#sessionId)
+      return { outcome: "cancelled" };
+    return { ...await active.onQuestion(request) };
+  }
   #fault(error53) {
     this.#permissionConfirmation?.reject(error53);
     if (this.#closing || this.#closed)
@@ -24238,7 +24495,7 @@ var SessionImportScope = class {
 // dist/session-import.js
 var MAX_METADATA_BYTES = 4 * 1024 * 1024;
 var SUBAGENT_SESSION_KINDS = /* @__PURE__ */ new Set(["subagent", "subagent_resume"]);
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function readJson(file2, signal) {
@@ -24251,7 +24508,7 @@ function processAlive(pid) {
     process.kill(pid, 0);
     return true;
   } catch (error53) {
-    return isRecord13(error53) && error53.code === "EPERM";
+    return isRecord14(error53) && error53.code === "EPERM";
   }
 }
 async function firstUserText(file2, signal) {
@@ -24268,10 +24525,10 @@ async function firstUserText(file2, signal) {
       } catch {
         continue;
       }
-      const update = isRecord13(entry) && isRecord13(entry.params) ? entry.params.update : null;
-      if (!isRecord13(update) || update.sessionUpdate !== "user_message_chunk")
+      const update = isRecord14(entry) && isRecord14(entry.params) ? entry.params.update : null;
+      if (!isRecord14(update) || update.sessionUpdate !== "user_message_chunk")
         continue;
-      const text = isRecord13(update.content) ? update.content.text : null;
+      const text = isRecord14(update.content) ? update.content.text : null;
       return typeof text === "string" ? text : "";
     }
     return null;
@@ -24348,7 +24605,7 @@ var GrokSessionImport = class {
     if (!Array.isArray(entries))
       return active;
     for (const entry of entries) {
-      if (isRecord13(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
+      if (isRecord14(entry) && typeof entry.session_id === "string" && processAlive(entry.pid))
         active.add(entry.session_id);
     }
     return active;
@@ -24397,7 +24654,7 @@ var GrokSessionImport = class {
         return null;
       try {
         const summary = await readJson(files[0], signal);
-        if (!isRecord13(summary) || !isRecord13(summary.info) || summary.info.id !== nativeSessionId)
+        if (!isRecord14(summary) || !isRecord14(summary.info) || summary.info.id !== nativeSessionId)
           return null;
         if (typeof summary.session_kind === "string" && SUBAGENT_SESSION_KINDS.has(summary.session_kind))
           return null;
@@ -24624,7 +24881,7 @@ var GrokSubagentLifecycle = class {
 };
 
 // dist/grok-models.js
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonBlank(value) {
@@ -24636,7 +24893,7 @@ function thinkingOptions(value) {
   const seen = /* @__PURE__ */ new Set();
   const options = [];
   for (const candidate of value) {
-    if (!isRecord14(candidate) || !nonBlank(candidate.label))
+    if (!isRecord15(candidate) || !nonBlank(candidate.label))
       continue;
     const id = harnessThinkingOptionIdSchema.safeParse(candidate.id ?? candidate.value);
     if (!id.success || seen.has(id.data))
@@ -24647,7 +24904,7 @@ function thinkingOptions(value) {
   return options;
 }
 function parseGrokModelState(value) {
-  if (!isRecord14(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
+  if (!isRecord15(value) || !nonBlank(value.currentModelId) || !Array.isArray(value.availableModels)) {
     return null;
   }
   const currentModel = harnessModelRefSchema.safeParse({ id: value.currentModelId });
@@ -24659,12 +24916,12 @@ function parseGrokModelState(value) {
   const models = [];
   let currentThinkingOptionId;
   for (const candidate of value.availableModels) {
-    if (!isRecord14(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
+    if (!isRecord15(candidate) || !nonBlank(candidate.modelId) || !nonBlank(candidate.name))
       continue;
     const ref = harnessModelRefSchema.safeParse({ id: candidate.modelId });
     if (!ref.success)
       continue;
-    const metadata = isRecord14(candidate._meta) ? candidate._meta : {};
+    const metadata = isRecord15(candidate._meta) ? candidate._meta : {};
     const options2 = thinkingOptions(metadata.reasoningEfforts);
     if (Array.isArray(metadata.contextWindows) && metadata.contextWindows.includes(5e5)) {
       defaultContextWindowTokensByModel.set(ref.data.id, 5e5);
@@ -24703,10 +24960,10 @@ function parseGrokModelState(value) {
   };
 }
 function modelStateFromInitialize(response) {
-  return parseGrokModelState(isRecord14(response._meta) ? response._meta.modelState : void 0);
+  return parseGrokModelState(isRecord15(response._meta) ? response._meta.modelState : void 0);
 }
 function modelStateFromSessionResponse(response) {
-  return parseGrokModelState(isRecord14(response) ? response.models : void 0);
+  return parseGrokModelState(isRecord15(response) ? response.models : void 0);
 }
 function stateForGrokModel(modelState, nativeState, model2 = modelState.currentModel, thinkingOptionId = modelState.currentThinkingOptionId, permissionModeId) {
   const selectedModel = model2;
@@ -24730,7 +24987,7 @@ import os6 from "node:os";
 import path14 from "node:path";
 var GROK_CREDITS_ENDPOINT = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var REQUEST_TIMEOUT_MS = 15e3;
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finitePercent(value) {
@@ -24739,7 +24996,7 @@ function finitePercent(value) {
   return Math.min(100, Math.max(0, value));
 }
 function nonNegativeCentValue(value) {
-  if (!isRecord15(value))
+  if (!isRecord16(value))
     return void 0;
   const amount = value.val === void 0 ? 0 : value.val;
   if (typeof amount !== "number" || !Number.isFinite(amount) || amount < 0)
@@ -24763,7 +25020,7 @@ function productUsageFrom(value) {
   if (!Array.isArray(value))
     return void 0;
   const products = value.flatMap((entry) => {
-    if (!isRecord15(entry) || typeof entry.product !== "string")
+    if (!isRecord16(entry) || typeof entry.product !== "string")
       return [];
     const usagePercent = finitePercent(entry.usagePercent);
     const labels = {
@@ -24784,10 +25041,10 @@ function productUsageFrom(value) {
   return products.length > 0 ? products : void 0;
 }
 function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  if (!isRecord15(value) || !isRecord15(value.config))
+  if (!isRecord16(value) || !isRecord16(value.config))
     return null;
   const config2 = value.config;
-  const period = isRecord15(config2.currentPeriod) ? config2.currentPeriod : void 0;
+  const period = isRecord16(config2.currentPeriod) ? config2.currentPeriod : void 0;
   const periodType = periodTypeFrom(period?.type);
   const resetsAt = (typeof period?.end === "string" && period.end.length > 0 ? period.end : void 0) ?? (typeof config2.billingPeriodEnd === "string" && config2.billingPeriodEnd.length > 0 ? config2.billingPeriodEnd : void 0);
   let usedPercent = finitePercent(config2.creditUsagePercent);
@@ -24814,11 +25071,11 @@ function parseGrokCreditsResponse(value, fetchedAt = (/* @__PURE__ */ new Date()
   };
 }
 function selectAccessToken(auth, now) {
-  if (!isRecord15(auth))
+  if (!isRecord16(auth))
     return null;
-  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord15(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
+  const entries = Object.entries(auth).filter(([issuer, value]) => (issuer === "https://auth.x.ai" || issuer.startsWith("https://auth.x.ai::")) && isRecord16(value) && typeof value.key === "string" && value.key.length > 0).sort(([left], [right]) => Number(right.startsWith("https://auth.x.ai")) - Number(left.startsWith("https://auth.x.ai")));
   for (const [, value] of entries) {
-    if (!isRecord15(value) || typeof value.key !== "string")
+    if (!isRecord16(value) || typeof value.key !== "string")
       continue;
     if (typeof value.expires_at === "string") {
       const expiresAt = Date.parse(value.expires_at);
@@ -24889,7 +25146,7 @@ async function fetchGrokCredits(input = {}) {
 
 // dist/grok-usage.js
 var USD_TICKS_PER_DOLLAR = 1e10;
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalToken(value) {
@@ -24906,7 +25163,7 @@ function combineUsage(base, next) {
   return base === null ? next : parseHostUsage({ ...base, ...next });
 }
 function usageFromNative(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return null;
   const inputTokens = optionalToken(value.inputTokens);
   const cachedRead = optionalToken(value.cachedReadTokens);
@@ -24930,7 +25187,7 @@ function usageFromNative(value) {
   }
 }
 function usageFromResponse(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return null;
   const buckets = [
     value.input_tokens,
@@ -24959,10 +25216,10 @@ var GrokTurnUsage = class {
   #durationMs = 0;
   #latestCacheHit;
   constructor(base, emptySession = false) {
-    for (const field of summedUsageFields) {
-      const value = base?.[field];
+    for (const field2 of summedUsageFields) {
+      const value = base?.[field2];
       if (value !== void 0)
-        this.#totals[field] = value;
+        this.#totals[field2] = value;
     }
     this.#cacheComplete = base?.sessionCacheUsage !== void 0 || emptySession;
   }
@@ -25001,10 +25258,10 @@ var GrokTurnUsage = class {
     if (usage?.inputTokens === void 0 || usage.cachedInputTokens === void 0)
       this.#cacheComplete = false;
     if (usage) {
-      for (const field of summedUsageFields) {
-        const value = usage[field];
+      for (const field2 of summedUsageFields) {
+        const value = usage[field2];
         if (value !== void 0)
-          this.#totals[field] = (this.#totals[field] ?? 0) + value;
+          this.#totals[field2] = (this.#totals[field2] ?? 0) + value;
       }
       if (duration3 > 0 && usage.outputTokens !== void 0) {
         this.#outputTokens += usage.outputTokens;
@@ -25030,7 +25287,7 @@ var GrokTurnUsage = class {
   }
 };
 function usageFromSignals(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return null;
   try {
     return parseHostUsage({
@@ -25050,7 +25307,7 @@ var summedUsageFields = [
   "totalTokens"
 ];
 function nativeCostTicks(value) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return void 0;
   const ticks = value.costUsdTicks;
   if (typeof ticks !== "number" || !Number.isSafeInteger(ticks) || ticks < 0)
@@ -25058,7 +25315,7 @@ function nativeCostTicks(value) {
   return ticks;
 }
 function sessionCostFromNative(value, initialCostUsd) {
-  if (!isRecord16(value))
+  if (!isRecord17(value))
     return void 0;
   if (value.costIsPartial !== void 0 && value.costIsPartial !== false)
     return void 0;
@@ -25087,7 +25344,7 @@ function sessionUsageFromHistory(events) {
       continue;
     const usage = usageFromNative(event.usage);
     const ticks2 = nativeCostTicks(event.usage);
-    const complete = isRecord16(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
+    const complete = isRecord17(event.usage) && (event.usage.usageIsIncomplete === void 0 || event.usage.usageIsIncomplete === false) && usage?.inputTokens !== void 0 && usage.cachedInputTokens !== void 0 && usage.cachedInputTokens <= usage.inputTokens;
     latestByKey.set(key, { usage, complete, ...ticks2 !== void 0 ? { ticks: ticks2 } : {} });
   }
   if (latestByKey.size === 0)
@@ -25098,11 +25355,11 @@ function sessionUsageFromHistory(events) {
   for (const entry of latestByKey.values()) {
     if (!entry.usage)
       continue;
-    for (const field of summedUsageFields) {
-      const value = entry.usage[field];
+    for (const field2 of summedUsageFields) {
+      const value = entry.usage[field2];
       if (value === void 0)
         continue;
-      totals2[field] = (totals2[field] ?? 0) + value;
+      totals2[field2] = (totals2[field2] ?? 0) + value;
     }
     if (entry.ticks === void 0)
       continue;
@@ -25141,7 +25398,7 @@ function usageFromCompact(tokensAfter, contextWindowTokens) {
 function usageFromUpdate(update, metadata, contextWindowTokens) {
   try {
     if (update?.sessionUpdate === "usage_update") {
-      const cost = isRecord16(update.cost) ? update.cost : null;
+      const cost = isRecord17(update.cost) ? update.cost : null;
       return parseHostUsage({
         contextUsedTokens: update.used,
         contextWindowTokens: update.size,
@@ -25379,6 +25636,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command,
+      questions: new GrokQuestions(command.turnId, this.#randomUUID, (output) => this.#channel.emit(output)),
       usage: new GrokTurnUsage(this.#usage, this.#snapshot.turns.length === 0),
       agent: null,
       agentMessageId: null,
@@ -25400,7 +25658,7 @@ var GrokHarnessSession = class {
     };
     this.#active = active;
     this.#event({ type: "turn.started", turnId: command.turnId });
-    void this.#transport.runTurn(text, (event) => this.#handleEvent(active, event), (request) => this.#requestPermission(active, request)).then((response) => this.#settleFromHistory(active, terminalOutcome2(response, active.cancellationRequested), response), (error53) => this.#settleFromHistory(active, {
+    void this.#transport.runTurn(text, (event) => this.#handleEvent(active, event), (request) => this.#requestPermission(active, request), (request) => this.#active === active && this.#phase === "open" && !active.cancellationRequested ? active.questions.ask(request) : Promise.resolve({ outcome: "cancelled" })).finally(() => active.questions.cancel()).then((response) => this.#settleFromHistory(active, terminalOutcome2(response, active.cancellationRequested), response), (error53) => this.#settleFromHistory(active, {
       status: "failed",
       error: normalizeError(error53, "nativeFailure")
     }));
@@ -25469,6 +25727,7 @@ var GrokHarnessSession = class {
     });
     const active = {
       command: { type: "turn.start", turnId: command.turnId, input: [] },
+      questions: new GrokQuestions(command.turnId, this.#randomUUID, (output) => this.#channel.emit(output)),
       agent: null,
       agentMessageId: null,
       rawAgentText: "",
@@ -25648,6 +25907,7 @@ var GrokHarnessSession = class {
     if (active.cancellationRequested)
       return { ok: true, value: { cancellationRequested: true } };
     active.cancellationRequested = true;
+    active.questions.cancel();
     for (const approval of active.approvals.values()) {
       approval.resolve({ outcome: { outcome: "cancelled" } });
     }
@@ -25660,9 +25920,11 @@ var GrokHarnessSession = class {
   }
   async #respond(command) {
     const active = this.#active;
+    if (active?.questions.has(command.interactionId))
+      return active.questions.respond(command);
     const pending = active?.approvals.get(command.interactionId);
     if (!active || !pending)
-      return { ok: false, error: invalidState("Grok Approval is not pending") };
+      return { ok: false, error: invalidState("Grok Interaction is not pending") };
     if (command.response.type !== "approval") {
       return {
         ok: false,
@@ -25723,6 +25985,10 @@ var GrokHarnessSession = class {
   #handleEvent(active, event) {
     if (this.#active !== active || this.#phase !== "open")
       return;
+    if (event.type === "interaction.resolved") {
+      active.questions.withdraw(event.toolCallId);
+      return;
+    }
     const requestUsage = active.usage?.observe(event);
     if (requestUsage) {
       this.#publishUsage(requestUsage, active.command.turnId, true);
@@ -26122,6 +26388,7 @@ var GrokHarnessSession = class {
   #finish(active, outcome, usage = null, nativeTurnRef) {
     if (this.#active !== active)
       return;
+    active.questions.cancel();
     const itemOutcome = outcome;
     this.#completeReasoning(active, itemOutcome);
     this.#completeAgent(active, itemOutcome);
@@ -26178,6 +26445,7 @@ var GrokHarnessSession = class {
     const active = this.#active;
     if (active) {
       active.cancellationRequested = true;
+      active.questions.cancel();
       for (const approval of active.approvals.values())
         approval.resolve({ outcome: { outcome: "cancelled" } });
       await this.#transport.cancel().catch(() => void 0);