0sec-cli 0.22.1 → 0.22.4

package/chunks/{chunk-6YNKRUMC.js → chunk-NJLKFC66.js}

@@ -763,6 +763,7 @@ var string = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
+var bigint = /^\d+n?$/;
 var integer = /^\d+$/;
 var number = /^-?\d+(?:\.\d+)?/i;
 var boolean = /true|false/i;
@@ -1340,11 +1341,11 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
   inst._zod.check = (payload) => {
     try {
       const orig = payload.value;
-      const url = new URL(orig);
-      const href = url.href;
+      const url2 = new URL(orig);
+      const href = url2.href;
       if (def.hostname) {
         def.hostname.lastIndex = 0;
-        if (!def.hostname.test(url.hostname)) {
+        if (!def.hostname.test(url2.hostname)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -1358,7 +1359,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
       }
       if (def.protocol) {
         def.protocol.lastIndex = 0;
-        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
+        if (!def.protocol.test(url2.protocol.endsWith(":") ? url2.protocol.slice(0, -1) : url2.protocol)) {
           payload.issues.push({
             code: "invalid_format",
             format: "url",
@@ -1631,6 +1632,26 @@ var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
     return payload;
   };
 });
+var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = bigint;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = BigInt(payload.value);
+      } catch (_) {
+      }
+    if (typeof payload.value === "bigint")
+      return payload;
+    payload.issues.push({
+      expected: "bigint",
+      code: "invalid_type",
+      input: payload.value,
+      inst
+    });
+    return payload;
+  };
+});
 var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.pattern = _null;
@@ -1668,6 +1689,30 @@ var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
     return payload;
   };
 });
+var $ZodDate = /* @__PURE__ */ $constructor("$ZodDate", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce) {
+      try {
+        payload.value = new Date(payload.value);
+      } catch (_err) {
+      }
+    }
+    const input = payload.value;
+    const isDate = input instanceof Date;
+    const isValidDate = isDate && !Number.isNaN(input.getTime());
+    if (isValidDate)
+      return payload;
+    payload.issues.push({
+      expected: "date",
+      code: "invalid_type",
+      input,
+      ...isDate ? { received: "Invalid Date" } : {},
+      inst
+    });
+    return payload;
+  };
+});
 function handleArrayResult(result, final, index) {
   if (result.issues.length) {
     final.issues.push(...prefixIssues(index, result.issues));
@@ -2507,6 +2552,13 @@ function _string(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedString(Class2, params) {
+  return new Class2({
+    type: "string",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _email(Class2, params) {
   return new Class2({
     type: "string",
@@ -2751,6 +2803,14 @@ function _number(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedNumber(Class2, params) {
+  return new Class2({
+    type: "number",
+    coerce: true,
+    checks: [],
+    ...normalizeParams(params)
+  });
+}
 function _int(Class2, params) {
   return new Class2({
     type: "number",
@@ -2766,6 +2826,20 @@ function _boolean(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedBoolean(Class2, params) {
+  return new Class2({
+    type: "boolean",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
+function _coercedBigint(Class2, params) {
+  return new Class2({
+    type: "bigint",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _null2(Class2, params) {
   return new Class2({
     type: "null",
@@ -2788,6 +2862,13 @@ function _never(Class2, params) {
     ...normalizeParams(params)
   });
 }
+function _coercedDate(Class2, params) {
+  return new Class2({
+    type: "date",
+    coerce: true,
+    ...normalizeParams(params)
+  });
+}
 function _lt(value, params) {
   return new $ZodCheckLessThan({
     check: "less_than",
@@ -3935,6 +4016,9 @@ var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
   $ZodURL.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function url(params) {
+  return _url(ZodURL, params);
+}
 var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
   $ZodEmoji.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -4037,6 +4121,27 @@ var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
 function boolean2(params) {
   return _boolean(ZodBoolean, params);
 }
+var ZodBigInt = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
+  $ZodBigInt.init(inst, def);
+  ZodType.init(inst, def);
+  inst.gte = (value, params) => inst.check(_gte(value, params));
+  inst.min = (value, params) => inst.check(_gte(value, params));
+  inst.gt = (value, params) => inst.check(_gt(value, params));
+  inst.gte = (value, params) => inst.check(_gte(value, params));
+  inst.min = (value, params) => inst.check(_gte(value, params));
+  inst.lt = (value, params) => inst.check(_lt(value, params));
+  inst.lte = (value, params) => inst.check(_lte(value, params));
+  inst.max = (value, params) => inst.check(_lte(value, params));
+  inst.positive = (params) => inst.check(_gt(BigInt(0), params));
+  inst.negative = (params) => inst.check(_lt(BigInt(0), params));
+  inst.nonpositive = (params) => inst.check(_lte(BigInt(0), params));
+  inst.nonnegative = (params) => inst.check(_gte(BigInt(0), params));
+  inst.multipleOf = (value, params) => inst.check(_multipleOf(value, params));
+  const bag = inst._zod.bag;
+  inst.minValue = bag.minimum ?? null;
+  inst.maxValue = bag.maximum ?? null;
+  inst.format = bag.format ?? null;
+});
 var ZodNull = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
   $ZodNull.init(inst, def);
   ZodType.init(inst, def);
@@ -4065,6 +4170,15 @@ var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
 function never(params) {
   return _never(ZodNever, params);
 }
+var ZodDate = /* @__PURE__ */ $constructor("ZodDate", (inst, def) => {
+  $ZodDate.init(inst, def);
+  ZodType.init(inst, def);
+  inst.min = (value, params) => inst.check(_gte(value, params));
+  inst.max = (value, params) => inst.check(_lte(value, params));
+  const c = inst._zod.bag;
+  inst.minDate = c.minimum ? new Date(c.minimum) : null;
+  inst.maxDate = c.maximum ? new Date(c.maximum) : null;
+});
 var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
   $ZodArray.init(inst, def);
   ZodType.init(inst, def);
@@ -4434,7 +4548,197 @@ function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
 
+// node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks, pendingFragments = [];
+  let isFirstChunk = true, id, data = "", dataLines = 0, eventType;
+  function feed(chunk) {
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && pendingFragments.push(trailing2);
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk);
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0;
+    const trailing = processLines(input);
+    trailing !== "" && pendingFragments.push(trailing);
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// node_modules/.pnpm/eventsource-parser@3.0.8/node_modules/eventsource-parser/dist/stream.js
+var EventSourceParserStream = class extends TransformStream {
+  constructor({ onError, onRetry, onComment } = {}) {
+    let parser;
+    super({
+      start(controller) {
+        parser = createParser({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          },
+          onError(error) {
+            onError === "terminate" ? controller.error(error) : typeof onError == "function" && onError(error);
+          },
+          onRetry,
+          onComment
+        });
+      },
+      transform(chunk) {
+        parser.feed(chunk);
+      }
+    });
+  }
+};
+
 export {
+  NEVER,
   $constructor,
   config,
   joinValues,
@@ -4447,16 +4751,27 @@ export {
   safeParseAsync,
   $ZodType,
   $ZodObject,
+  _coercedString,
+  _coercedNumber,
+  _coercedBoolean,
+  _coercedBigint,
+  _coercedDate,
   toJSONSchema,
   iso_exports,
   safeParseAsync2,
+  ZodString,
   string2 as string,
+  url,
+  ZodNumber,
   number2 as number,
+  ZodBoolean,
   boolean2 as boolean,
+  ZodBigInt,
   _null3 as _null,
   any,
   unknown,
   never,
+  ZodDate,
   array,
   object,
   looseObject,
@@ -4470,5 +4785,6 @@ export {
   lazy,
   custom,
   _instanceof,
-  preprocess
+  preprocess,
+  EventSourceParserStream
 };

package/chunks/{chunk-W6UWZFKL.js → chunk-O6KPVYOI.js}

@@ -1,12 +1,28 @@
 #!/usr/bin/env node
 import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
+import {
+  readCacheUsage
+} from "./chunk-RS4MAN3Q.js";
 
 // packages/core/dist/runtime/process.js
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { writeFileSync } from "node:fs";
+function readGeminiUsage(raw) {
+  if (!raw || typeof raw !== "object")
+    return void 0;
+  const stats = raw;
+  if (typeof stats.input_tokens !== "number" || typeof stats.output_tokens !== "number")
+    return void 0;
+  const outputTokens = typeof stats.total_tokens === "number" ? Math.max(stats.output_tokens, stats.total_tokens - stats.input_tokens) : stats.output_tokens;
+  return {
+    inputTokens: stats.input_tokens,
+    outputTokens,
+    ...typeof stats.cached === "number" ? { cachedInputTokens: stats.cached } : {}
+  };
+}
 var dim = (text) => `\x1B[2m${text}\x1B[0m`;
 function formatToolDetail(input) {
   const inp = input;
@@ -95,13 +111,20 @@ var ProcessRuntime = class {
   type;
   config;
   command;
+  observedModel;
   constructor(config) {
     this.type = config.type;
     this.config = config;
     this.command = RUNTIME_COMMANDS[config.type] ?? config.type;
   }
+  resolvedModel() {
+    return this.observedModel ?? this.config.model ?? "unknown";
+  }
   async execute(prompt, context) {
     const start = Date.now();
+    if (context?.signal?.aborted) {
+      return { output: "", exitCode: null, timedOut: false, durationMs: 0, error: "Runtime execution cancelled." };
+    }
     const args = this.buildArgs(prompt, context);
     const env = this.buildEnv(context);
     const onToolCall = this.config.onToolCall;
@@ -110,13 +133,18 @@ var ProcessRuntime = class {
       let stderr = "";
       let resultText = "";
       let timedOut = false;
+      let usage;
+      let usageByModel;
+      let runtimeError;
+      let streamBuffer = "";
       const isJsonStream = args.includes("stream-json") || args.includes("--json");
       let proc;
       try {
         proc = spawn(this.command, args, {
           cwd: this.config.cwd ?? process.cwd(),
           env: { ...process.env, ...env },
-          stdio: ["ignore", "pipe", "pipe"]
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: process.platform !== "win32"
         });
       } catch (err) {
         resolve2({
@@ -132,11 +160,20 @@ var ProcessRuntime = class {
         const text = chunk.toString();
         stdout += text;
         if (isJsonStream) {
-          for (const line of text.split("\n")) {
+          streamBuffer += text;
+          let newline = streamBuffer.indexOf("\n");
+          while (newline >= 0) {
+            const line = streamBuffer.slice(0, newline);
+            streamBuffer = streamBuffer.slice(newline + 1);
+            newline = streamBuffer.indexOf("\n");
             if (!line.trim())
               continue;
             try {
               const event = JSON.parse(line);
+              if (typeof event.message?.model === "string")
+                this.observedModel = event.message.model;
+              if (event.type === "init" && typeof event.model === "string")
+                this.observedModel = event.model;
               if (event.type === "assistant" && event.message?.content) {
                 for (const block of event.message.content) {
                   if (block.type === "text") {
@@ -148,6 +185,8 @@ var ProcessRuntime = class {
                 }
               } else if (event.type === "result") {
                 resultText = event.result || resultText;
+                if (event.usage)
+                  usage = readCacheUsage(event.usage);
               }
               if (event.type === "item.started" && event.item?.type === "command_execution") {
                 showToolCall(onToolCall, "shell", { command: event.item.command });
@@ -159,6 +198,29 @@ var ProcessRuntime = class {
                 } else if (event.item.type === "command_execution" && event.item.command) {
                 }
               }
+              if (event.type === "turn.completed" && event.usage) {
+                usage = { inputTokens: Number(event.usage.input_tokens ?? 0), outputTokens: Number(event.usage.output_tokens ?? 0) };
+              }
+              if (this.type === "gemini") {
+                if (event.type === "message" && event.role === "assistant" && typeof event.content === "string") {
+                  resultText += event.content;
+                  this.config.onThinking?.(event.content);
+                } else if (event.type === "tool_use") {
+                  showToolCall(onToolCall, event.tool_name, event.parameters);
+                } else if (event.type === "result") {
+                  usage = readGeminiUsage(event.stats);
+                  if (event.stats?.models && typeof event.stats.models === "object") {
+                    usageByModel = [];
+                    for (const [model, stats] of Object.entries(event.stats.models)) {
+                      const measured = readGeminiUsage(stats);
+                      if (measured)
+                        usageByModel.push({ model, usage: measured });
+                    }
+                  }
+                  if (event.status === "error")
+                    runtimeError = event.error?.message ?? "Gemini CLI returned an error result.";
+                }
+              }
             } catch {
             }
           }
@@ -172,24 +234,53 @@ var ProcessRuntime = class {
           stderr += "\n[0] Subprocess killed: MCP tools require interactive approval. Use --runtime api instead.";
         }
       });
+      let killTimer;
+      const terminate = () => {
+        if (proc.pid && process.platform !== "win32") {
+          try {
+            process.kill(-proc.pid, "SIGTERM");
+          } catch {
+            proc.kill("SIGTERM");
+          }
+        } else
+          proc.kill("SIGTERM");
+        killTimer ??= setTimeout(() => {
+          if (proc.pid && process.platform !== "win32") {
+            try {
+              process.kill(-proc.pid, "SIGKILL");
+            } catch {
+              proc.kill("SIGKILL");
+            }
+          } else
+            proc.kill("SIGKILL");
+        }, 1e3);
+      };
       const timer = setTimeout(() => {
         timedOut = true;
-        proc.kill("SIGTERM");
-        setTimeout(() => proc.kill("SIGKILL"), 5e3);
+        terminate();
       }, this.config.timeout);
+      context?.signal?.addEventListener("abort", terminate, { once: true });
+      if (context?.signal?.aborted)
+        terminate();
       proc.on("close", (code) => {
         clearTimeout(timer);
+        clearTimeout(killTimer);
+        context?.signal?.removeEventListener("abort", terminate);
         const output = isJsonStream ? (resultText || stdout).trim() : stdout.trim();
         resolve2({
           output,
           exitCode: code,
           timedOut,
+          usage,
+          usageByModel,
           durationMs: Date.now() - start,
-          error: code !== 0 ? stderr.trim() || void 0 : void 0
+          error: context?.signal?.aborted ? "Runtime execution cancelled." : runtimeError ?? (code !== 0 ? stderr.trim() || void 0 : void 0)
         });
       });
       proc.on("error", (err) => {
         clearTimeout(timer);
+        clearTimeout(killTimer);
+        context?.signal?.removeEventListener("abort", terminate);
         resolve2({
           output: "",
           exitCode: 1,
@@ -227,6 +318,8 @@ var ProcessRuntime = class {
     switch (this.type) {
       case "claude": {
         const args = ["-p", prompt, "--verbose", "--output-format", "stream-json"];
+        if (this.config.model)
+          args.push("--model", this.config.model);
         if (context?.mcp?.enableTargetTools && context.target && context.scanId) {
           args.push("--mcp-config", buildClaudeMcpConfig(context), "--dangerously-skip-permissions");
         }
@@ -260,6 +353,8 @@ var ProcessRuntime = class {
       }
       case "gemini": {
         const args = ["-p", prompt, "--output-format", "stream-json"];
+        if (this.config.model)
+          args.push("--model", this.config.model);
         return args;
       }
       default: