@locusai/cli 0.11.5 → 0.11.7

package/bin/agent/worker.js

@@ -14731,12 +14731,519 @@ var init_models = __esm(() => {
   init_workspace();
 });
 
+// ../shared/src/protocol/envelope.ts
+var PROTOCOL_VERSION = 1, ProtocolVersionSchema, ProtocolEnvelopeSchema;
+var init_envelope = __esm(() => {
+  init_zod();
+  ProtocolVersionSchema = exports_external.literal(PROTOCOL_VERSION);
+  ProtocolEnvelopeSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.string()
+  });
+});
+
+// ../shared/src/protocol/errors.ts
+var ProtocolErrorCode, ProtocolErrorCodeSchema, ProtocolErrorSchema;
+var init_errors3 = __esm(() => {
+  init_zod();
+  ProtocolErrorCode = {
+    CLI_NOT_FOUND: "CLI_NOT_FOUND",
+    AUTH_EXPIRED: "AUTH_EXPIRED",
+    NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
+    CONTEXT_LIMIT: "CONTEXT_LIMIT",
+    MALFORMED_EVENT: "MALFORMED_EVENT",
+    PROCESS_CRASHED: "PROCESS_CRASHED",
+    SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+    UNKNOWN: "UNKNOWN"
+  };
+  ProtocolErrorCodeSchema = exports_external.enum(ProtocolErrorCode);
+  ProtocolErrorSchema = exports_external.object({
+    code: ProtocolErrorCodeSchema,
+    message: exports_external.string(),
+    details: exports_external.unknown().optional(),
+    recoverable: exports_external.boolean()
+  });
+});
+
+// ../shared/src/protocol/cli-stream.ts
+var CliStreamEventType, CliStreamEventTypeSchema, CliStreamBaseSchema, CliStartEventSchema, CliTextDeltaEventSchema, CliThinkingEventSchema, CliToolStartedEventSchema, CliToolCompletedEventSchema, CliStatusEventSchema, CliErrorEventSchema, CliDoneEventSchema, CliStreamEventSchema;
+var init_cli_stream = __esm(() => {
+  init_zod();
+  init_envelope();
+  init_errors3();
+  CliStreamEventType = {
+    START: "start",
+    TEXT_DELTA: "text_delta",
+    THINKING: "thinking",
+    TOOL_STARTED: "tool_started",
+    TOOL_COMPLETED: "tool_completed",
+    STATUS: "status",
+    ERROR: "error",
+    DONE: "done"
+  };
+  CliStreamEventTypeSchema = exports_external.enum(CliStreamEventType);
+  CliStreamBaseSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    sessionId: exports_external.string(),
+    timestamp: exports_external.number()
+  });
+  CliStartEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.START),
+    payload: exports_external.object({
+      command: exports_external.string(),
+      model: exports_external.string().optional(),
+      provider: exports_external.string().optional(),
+      cwd: exports_external.string().optional()
+    })
+  });
+  CliTextDeltaEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.TEXT_DELTA),
+    payload: exports_external.object({
+      content: exports_external.string()
+    })
+  });
+  CliThinkingEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.THINKING),
+    payload: exports_external.object({
+      content: exports_external.string().optional()
+    })
+  });
+  CliToolStartedEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.TOOL_STARTED),
+    payload: exports_external.object({
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+    })
+  });
+  CliToolCompletedEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.TOOL_COMPLETED),
+    payload: exports_external.object({
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      success: exports_external.boolean(),
+      duration: exports_external.number().optional(),
+      error: exports_external.string().optional()
+    })
+  });
+  CliStatusEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.STATUS),
+    payload: exports_external.object({
+      status: exports_external.string(),
+      message: exports_external.string().optional()
+    })
+  });
+  CliErrorEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.ERROR),
+    payload: exports_external.object({
+      error: ProtocolErrorSchema
+    })
+  });
+  CliDoneEventSchema = CliStreamBaseSchema.extend({
+    type: exports_external.literal(CliStreamEventType.DONE),
+    payload: exports_external.object({
+      exitCode: exports_external.number().int(),
+      duration: exports_external.number(),
+      toolsUsed: exports_external.array(exports_external.string()).optional(),
+      tokensUsed: exports_external.number().optional(),
+      success: exports_external.boolean()
+    })
+  });
+  CliStreamEventSchema = exports_external.discriminatedUnion("type", [
+    CliStartEventSchema,
+    CliTextDeltaEventSchema,
+    CliThinkingEventSchema,
+    CliToolStartedEventSchema,
+    CliToolCompletedEventSchema,
+    CliStatusEventSchema,
+    CliErrorEventSchema,
+    CliDoneEventSchema
+  ]);
+});
+
+// ../shared/src/protocol/context.ts
+var ActiveFileContextSchema, SelectionContextSchema, WorkspaceContextSchema, ContextPayloadSchema;
+var init_context = __esm(() => {
+  init_zod();
+  ActiveFileContextSchema = exports_external.object({
+    filePath: exports_external.string(),
+    languageId: exports_external.string().optional()
+  });
+  SelectionContextSchema = exports_external.object({
+    filePath: exports_external.string(),
+    languageId: exports_external.string().optional(),
+    startLine: exports_external.number().int().min(0),
+    startColumn: exports_external.number().int().min(0),
+    endLine: exports_external.number().int().min(0),
+    endColumn: exports_external.number().int().min(0),
+    text: exports_external.string()
+  });
+  WorkspaceContextSchema = exports_external.object({
+    rootPath: exports_external.string(),
+    name: exports_external.string().optional()
+  });
+  ContextPayloadSchema = exports_external.object({
+    workspace: WorkspaceContextSchema.optional(),
+    activeFile: ActiveFileContextSchema.optional(),
+    selection: SelectionContextSchema.optional()
+  });
+});
+
+// ../shared/src/protocol/session.ts
+var SessionStatus, SessionStatusSchema, SessionTransitionEvent, SessionTransitionEventSchema, SESSION_TRANSITIONS, TERMINAL_STATUSES, SessionMetadataSchema, SessionSummarySchema;
+var init_session = __esm(() => {
+  init_zod();
+  SessionStatus = {
+    IDLE: "idle",
+    STARTING: "starting",
+    RUNNING: "running",
+    STREAMING: "streaming",
+    COMPLETED: "completed",
+    CANCELED: "canceled",
+    INTERRUPTED: "interrupted",
+    FAILED: "failed",
+    RESUMING: "resuming"
+  };
+  SessionStatusSchema = exports_external.enum(SessionStatus);
+  SessionTransitionEvent = {
+    CREATE_SESSION: "create_session",
+    CLI_SPAWNED: "cli_spawned",
+    FIRST_TEXT_DELTA: "first_text_delta",
+    RESULT_RECEIVED: "result_received",
+    USER_STOP: "user_stop",
+    PROCESS_LOST: "process_lost",
+    RESUME: "resume",
+    ERROR: "error"
+  };
+  SessionTransitionEventSchema = exports_external.enum(SessionTransitionEvent);
+  SESSION_TRANSITIONS = [
+    {
+      from: SessionStatus.IDLE,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    },
+    {
+      from: SessionStatus.STARTING,
+      event: SessionTransitionEvent.CLI_SPAWNED,
+      to: SessionStatus.RUNNING
+    },
+    {
+      from: SessionStatus.STARTING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.FIRST_TEXT_DELTA,
+      to: SessionStatus.STREAMING
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.USER_STOP,
+      to: SessionStatus.CANCELED
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.PROCESS_LOST,
+      to: SessionStatus.INTERRUPTED
+    },
+    {
+      from: SessionStatus.RUNNING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.RESULT_RECEIVED,
+      to: SessionStatus.COMPLETED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.USER_STOP,
+      to: SessionStatus.CANCELED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.PROCESS_LOST,
+      to: SessionStatus.INTERRUPTED
+    },
+    {
+      from: SessionStatus.STREAMING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.INTERRUPTED,
+      event: SessionTransitionEvent.RESUME,
+      to: SessionStatus.RESUMING
+    },
+    {
+      from: SessionStatus.RESUMING,
+      event: SessionTransitionEvent.CLI_SPAWNED,
+      to: SessionStatus.RUNNING
+    },
+    {
+      from: SessionStatus.RESUMING,
+      event: SessionTransitionEvent.ERROR,
+      to: SessionStatus.FAILED
+    },
+    {
+      from: SessionStatus.COMPLETED,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    },
+    {
+      from: SessionStatus.CANCELED,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    },
+    {
+      from: SessionStatus.FAILED,
+      event: SessionTransitionEvent.CREATE_SESSION,
+      to: SessionStatus.STARTING
+    }
+  ];
+  TERMINAL_STATUSES = new Set([
+    SessionStatus.COMPLETED,
+    SessionStatus.CANCELED,
+    SessionStatus.FAILED
+  ]);
+  SessionMetadataSchema = exports_external.object({
+    sessionId: exports_external.string(),
+    status: SessionStatusSchema,
+    model: exports_external.string().optional(),
+    createdAt: exports_external.number(),
+    updatedAt: exports_external.number(),
+    title: exports_external.string().optional()
+  });
+  SessionSummarySchema = exports_external.object({
+    sessionId: exports_external.string(),
+    status: SessionStatusSchema,
+    model: exports_external.string().optional(),
+    title: exports_external.string().optional(),
+    createdAt: exports_external.number(),
+    updatedAt: exports_external.number(),
+    messageCount: exports_external.number(),
+    toolCount: exports_external.number()
+  });
+});
+
+// ../shared/src/protocol/host-events.ts
+var HostEventType, HostEventTypeSchema, TimelineEntryKind, TimelineEntryKindSchema, TimelineEntrySchema, SessionStateEventSchema, TextDeltaEventSchema, ToolStartedEventSchema, ToolCompletedEventSchema, ThinkingEventSchema, ErrorEventSchema, SessionListEventSchema, SessionCompletedEventSchema, HostEventSchema;
+var init_host_events = __esm(() => {
+  init_zod();
+  init_envelope();
+  init_errors3();
+  init_session();
+  HostEventType = {
+    SESSION_STATE: "session_state",
+    TEXT_DELTA: "text_delta",
+    TOOL_STARTED: "tool_started",
+    TOOL_COMPLETED: "tool_completed",
+    THINKING: "thinking",
+    ERROR: "error",
+    SESSION_LIST: "session_list",
+    SESSION_COMPLETED: "session_completed"
+  };
+  HostEventTypeSchema = exports_external.enum(HostEventType);
+  TimelineEntryKind = {
+    MESSAGE: "message",
+    TOOL_CALL: "tool_call",
+    STATUS: "status",
+    ERROR: "error",
+    DONE: "done"
+  };
+  TimelineEntryKindSchema = exports_external.enum(TimelineEntryKind);
+  TimelineEntrySchema = exports_external.object({
+    id: exports_external.string(),
+    kind: TimelineEntryKindSchema,
+    timestamp: exports_external.number(),
+    data: exports_external.record(exports_external.string(), exports_external.unknown())
+  });
+  SessionStateEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.SESSION_STATE),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      status: SessionStatusSchema,
+      metadata: SessionMetadataSchema.optional(),
+      timeline: exports_external.array(TimelineEntrySchema).optional()
+    })
+  });
+  TextDeltaEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.TEXT_DELTA),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      content: exports_external.string()
+    })
+  });
+  ToolStartedEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.TOOL_STARTED),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      parameters: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+    })
+  });
+  ToolCompletedEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.TOOL_COMPLETED),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      tool: exports_external.string(),
+      toolId: exports_external.string().optional(),
+      result: exports_external.unknown().optional(),
+      duration: exports_external.number().optional(),
+      success: exports_external.boolean(),
+      error: exports_external.string().optional()
+    })
+  });
+  ThinkingEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.THINKING),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      content: exports_external.string().optional()
+    })
+  });
+  ErrorEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.ERROR),
+    payload: exports_external.object({
+      sessionId: exports_external.string().optional(),
+      error: ProtocolErrorSchema
+    })
+  });
+  SessionListEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.SESSION_LIST),
+    payload: exports_external.object({
+      sessions: exports_external.array(SessionSummarySchema)
+    })
+  });
+  SessionCompletedEventSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(HostEventType.SESSION_COMPLETED),
+    payload: exports_external.object({
+      sessionId: exports_external.string(),
+      summary: exports_external.string().optional()
+    })
+  });
+  HostEventSchema = exports_external.discriminatedUnion("type", [
+    SessionStateEventSchema,
+    TextDeltaEventSchema,
+    ToolStartedEventSchema,
+    ToolCompletedEventSchema,
+    ThinkingEventSchema,
+    ErrorEventSchema,
+    SessionListEventSchema,
+    SessionCompletedEventSchema
+  ]);
+});
+
+// ../shared/src/protocol/ui-intents.ts
+var UIIntentType, UIIntentTypeSchema, SubmitPromptIntentSchema, StopSessionIntentSchema, ResumeSessionIntentSchema, RequestSessionsIntentSchema, RequestSessionDetailIntentSchema, ClearSessionIntentSchema, WebviewReadyIntentSchema, UIIntentSchema;
+var init_ui_intents = __esm(() => {
+  init_zod();
+  init_context();
+  init_envelope();
+  UIIntentType = {
+    SUBMIT_PROMPT: "submit_prompt",
+    STOP_SESSION: "stop_session",
+    RESUME_SESSION: "resume_session",
+    REQUEST_SESSIONS: "request_sessions",
+    REQUEST_SESSION_DETAIL: "request_session_detail",
+    CLEAR_SESSION: "clear_session",
+    WEBVIEW_READY: "webview_ready"
+  };
+  UIIntentTypeSchema = exports_external.enum(UIIntentType);
+  SubmitPromptIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.SUBMIT_PROMPT),
+    payload: exports_external.object({
+      text: exports_external.string().min(1),
+      context: ContextPayloadSchema.optional()
+    })
+  });
+  StopSessionIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.STOP_SESSION),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  ResumeSessionIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.RESUME_SESSION),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  RequestSessionsIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.REQUEST_SESSIONS),
+    payload: exports_external.object({}).optional()
+  });
+  RequestSessionDetailIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.REQUEST_SESSION_DETAIL),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  ClearSessionIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.CLEAR_SESSION),
+    payload: exports_external.object({
+      sessionId: exports_external.string()
+    })
+  });
+  WebviewReadyIntentSchema = exports_external.object({
+    protocol: ProtocolVersionSchema,
+    type: exports_external.literal(UIIntentType.WEBVIEW_READY),
+    payload: exports_external.object({}).optional()
+  });
+  UIIntentSchema = exports_external.discriminatedUnion("type", [
+    SubmitPromptIntentSchema,
+    StopSessionIntentSchema,
+    ResumeSessionIntentSchema,
+    RequestSessionsIntentSchema,
+    RequestSessionDetailIntentSchema,
+    ClearSessionIntentSchema,
+    WebviewReadyIntentSchema
+  ]);
+});
+
+// ../shared/src/protocol/helpers.ts
+var init_helpers = __esm(() => {
+  init_envelope();
+  init_host_events();
+  init_session();
+  init_ui_intents();
+});
+
+// ../shared/src/protocol/index.ts
+var init_protocol = __esm(() => {
+  init_cli_stream();
+  init_context();
+  init_envelope();
+  init_errors3();
+  init_helpers();
+  init_host_events();
+  init_session();
+  init_ui_intents();
+});
+
 // ../shared/src/index.ts
 var init_src = __esm(() => {
   init_common();
   init_constants();
   init_enums();
   init_models();
+  init_protocol();
 });
 
 // ../sdk/src/core/config.ts
@@ -15409,14 +15916,16 @@ class CodexRunner {
   projectPath;
   model;
   log;
+  reasoningEffort;
   activeProcess = null;
   eventEmitter;
   currentToolName;
   timeoutMs;
-  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log, timeoutMs) {
+  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log, timeoutMs, reasoningEffort) {
     this.projectPath = projectPath;
     this.model = model;
     this.log = log;
+    this.reasoningEffort = reasoningEffort;
     this.timeoutMs = timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   }
   setEventEmitter(emitter) {
@@ -15681,6 +16190,9 @@ class CodexRunner {
     if (this.model) {
       args.push("--model", this.model);
     }
+    if (this.reasoningEffort) {
+      args.push("-c", `model_reasoning_effort=${this.reasoningEffort}`);
+    }
     args.push("-");
     return args;
   }
@@ -15735,7 +16247,7 @@ function createAiRunner(provider, config2) {
   const model = config2.model ?? DEFAULT_MODEL[resolvedProvider];
   switch (resolvedProvider) {
     case PROVIDER.CODEX:
-      return new CodexRunner(config2.projectPath, model, config2.log, config2.timeoutMs);
+      return new CodexRunner(config2.projectPath, model, config2.log, config2.timeoutMs, config2.reasoningEffort ?? "high");
     default:
       return new ClaudeRunner(config2.projectPath, model, config2.log, config2.timeoutMs);
   }
@@ -15946,7 +16458,7 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
 }, isDate, isFile, isBlob, isFileList, isStream = (val) => isObject2(val) && isFunction(val.pipe), isFormData = (thing) => {
   let kind;
   return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
-}, isURLSearchParams, isReadableStream, isRequest, isResponse, isHeaders, trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""), _global, isContextDefined = (context) => !isUndefined(context) && context !== _global, extend2 = (a, b, thisArg, { allOwnKeys } = {}) => {
+}, isURLSearchParams, isReadableStream, isRequest, isResponse, isHeaders, trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""), _global, isContextDefined = (context2) => !isUndefined(context2) && context2 !== _global, extend2 = (a, b, thisArg, { allOwnKeys } = {}) => {
   forEach(b, (val, key) => {
     if (thisArg && isFunction(val)) {
       Object.defineProperty(a, key, {
@@ -26694,12 +27206,12 @@ var init_platform = __esm(() => {
 // ../../node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new platform_default.classes.URLSearchParams, {
-    visitor: function(value, key, path, helpers) {
+    visitor: function(value, key, path, helpers2) {
       if (platform_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
       }
-      return helpers.defaultVisitor.apply(this, arguments);
+      return helpers2.defaultVisitor.apply(this, arguments);
     },
     ...options
   });
@@ -26947,7 +27459,7 @@ function parseTokens(str) {
   }
   return tokens;
 }
-function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) {
+function matchHeaderValue(context2, value, header, filter2, isHeaderNameFilter) {
   if (utils_default.isFunction(filter2)) {
     return filter2.call(this, value, header);
   }
@@ -27166,9 +27678,9 @@ var init_AxiosHeaders = __esm(() => {
 // ../../node_modules/axios/lib/core/transformData.js
 function transformData(fns, response) {
   const config2 = this || defaults_default;
-  const context = response || config2;
-  const headers = AxiosHeaders_default.from(context.headers);
-  let data = context.data;
+  const context2 = response || config2;
+  const headers = AxiosHeaders_default.from(context2.headers);
+  let data = context2.data;
   utils_default.forEach(fns, function transform2(fn) {
     data = fn.call(config2, data, headers.normalize(), response ? response.status : undefined);
   });
@@ -28274,13 +28786,13 @@ var require_follow_redirects = __commonJS((exports, module) => {
     }
   };
   RedirectableRequest.prototype._performRequest = function() {
-    var protocol = this._options.protocol;
-    var nativeProtocol = this._options.nativeProtocols[protocol];
+    var protocol2 = this._options.protocol;
+    var nativeProtocol = this._options.nativeProtocols[protocol2];
     if (!nativeProtocol) {
-      throw new TypeError("Unsupported protocol " + protocol);
+      throw new TypeError("Unsupported protocol " + protocol2);
     }
     if (this._options.agents) {
-      var scheme = protocol.slice(0, -1);
+      var scheme = protocol2.slice(0, -1);
       this._options.agent = this._options.agents[scheme];
     }
     var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
@@ -28377,8 +28889,8 @@ var require_follow_redirects = __commonJS((exports, module) => {
     };
     var nativeProtocols = {};
     Object.keys(protocols).forEach(function(scheme) {
-      var protocol = scheme + ":";
-      var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+      var protocol2 = scheme + ":";
+      var nativeProtocol = nativeProtocols[protocol2] = protocols[scheme];
       var wrappedProtocol = exports2[scheme] = Object.create(nativeProtocol);
       function request(input, options, callback) {
         if (isURL(input)) {
@@ -28388,7 +28900,7 @@ var require_follow_redirects = __commonJS((exports, module) => {
         } else {
           callback = options;
           options = validateUrl(input);
-          input = { protocol };
+          input = { protocol: protocol2 };
         }
         if (isFunction2(options)) {
           callback = options;
@@ -28402,7 +28914,7 @@ var require_follow_redirects = __commonJS((exports, module) => {
         if (!isString2(options.host) && !isString2(options.hostname)) {
           options.hostname = "::1";
         }
-        assert2.equal(options.protocol, protocol, "protocol mismatch");
+        assert2.equal(options.protocol, protocol2, "protocol mismatch");
         debug("options", options);
         return new RedirectableRequest(options, callback);
       }
@@ -28529,12 +29041,12 @@ function parseProtocol(url3) {
 // ../../node_modules/axios/lib/helpers/fromDataURI.js
 function fromDataURI(uri, asBlob, options) {
   const _Blob = options && options.Blob || platform_default.classes.Blob;
-  const protocol = parseProtocol(uri);
+  const protocol2 = parseProtocol(uri);
   if (asBlob === undefined && _Blob) {
     asBlob = true;
   }
-  if (protocol === "data") {
-    uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
+  if (protocol2 === "data") {
+    uri = protocol2.length ? uri.slice(protocol2.length + 1) : uri;
     const match = DATA_URL_PATTERN.exec(uri);
     if (!match) {
       throw new AxiosError_default("Invalid URL", AxiosError_default.ERR_INVALID_URL);
@@ -28551,7 +29063,7 @@ function fromDataURI(uri, asBlob, options) {
     }
     return buffer;
   }
-  throw new AxiosError_default("Unsupported protocol " + protocol, AxiosError_default.ERR_NOT_SUPPORT);
+  throw new AxiosError_default("Unsupported protocol " + protocol2, AxiosError_default.ERR_NOT_SUPPORT);
 }
 var DATA_URL_PATTERN;
 var init_fromDataURI = __esm(() => {
@@ -29019,7 +29531,7 @@ class Http2Sessions {
         }
       }
     }
-    const session = http2.connect(authority, options);
+    const session2 = http2.connect(authority, options);
     let removed;
     const removeSession = () => {
       if (removed) {
@@ -29028,7 +29540,7 @@ class Http2Sessions {
       removed = true;
       let entries = authoritySessions, len = entries.length, i = len;
       while (i--) {
-        if (entries[i][0] === session) {
+        if (entries[i][0] === session2) {
           if (len === 1) {
             delete this.sessions[authority];
           } else {
@@ -29038,12 +29550,12 @@ class Http2Sessions {
         }
       }
     };
-    const originalRequestFn = session.request;
+    const originalRequestFn = session2.request;
     const { sessionTimeout } = options;
     if (sessionTimeout != null) {
       let timer;
       let streamsCount = 0;
-      session.request = function() {
+      session2.request = function() {
         const stream4 = originalRequestFn.apply(this, arguments);
         streamsCount++;
         if (timer) {
@@ -29061,13 +29573,13 @@ class Http2Sessions {
         return stream4;
       };
     }
-    session.once("close", removeSession);
+    session2.once("close", removeSession);
     let entry = [
-      session,
+      session2,
       options
     ];
     authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
-    return session;
+    return session2;
   }
 }
 function dispatchBeforeRedirect(options, responseDetails) {
@@ -29176,8 +29688,8 @@ var init_http = __esm(() => {
   isBrotliSupported = utils_default.isFunction(zlib.createBrotliDecompress);
   ({ http: httpFollow, https: httpsFollow } = import_follow_redirects.default);
   isHttps = /https:?/;
-  supportedProtocols = platform_default.protocols.map((protocol) => {
-    return protocol + ":";
+  supportedProtocols = platform_default.protocols.map((protocol2) => {
+    return protocol2 + ":";
   });
   http2Sessions = new Http2Sessions;
   isHttpAdapterSupported = typeof process !== "undefined" && utils_default.kindOf(process) === "process";
@@ -29185,7 +29697,7 @@ var init_http = __esm(() => {
     request(options, cb) {
       const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
       const { http2Options, headers } = options;
-      const session = http2Sessions.getSession(authority, http2Options);
+      const session2 = http2Sessions.getSession(authority, http2Options);
       const {
         HTTP2_HEADER_SCHEME,
         HTTP2_HEADER_METHOD,
@@ -29200,7 +29712,7 @@ var init_http = __esm(() => {
       utils_default.forEach(headers, (header, name) => {
         name.charAt(0) !== ":" && (http2Headers[name] = header);
       });
-      const req = session.request(http2Headers);
+      const req = session2.request(http2Headers);
       req.once("response", (responseHeaders) => {
         const response = req;
         responseHeaders = Object.assign({}, responseHeaders);
@@ -29284,8 +29796,8 @@ var init_http = __esm(() => {
       });
       const fullPath = buildFullPath(config2.baseURL, config2.url, config2.allowAbsoluteUrls);
       const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : undefined);
-      const protocol = parsed.protocol || supportedProtocols[0];
-      if (protocol === "data:") {
+      const protocol2 = parsed.protocol || supportedProtocols[0];
+      if (protocol2 === "data:") {
         if (config2.maxContentLength > -1) {
           const dataUrl = String(config2.url || fullPath || "");
           const estimated = estimateDataURLDecodedBytes(dataUrl);
@@ -29325,8 +29837,8 @@ var init_http = __esm(() => {
           config: config2
         });
       }
-      if (supportedProtocols.indexOf(protocol) === -1) {
-        return reject(new AxiosError_default("Unsupported protocol " + protocol, AxiosError_default.ERR_BAD_REQUEST, config2));
+      if (supportedProtocols.indexOf(protocol2) === -1) {
+        return reject(new AxiosError_default("Unsupported protocol " + protocol2, AxiosError_default.ERR_BAD_REQUEST, config2));
       }
       const headers = AxiosHeaders_default.from(config2.headers).normalize();
       headers.set("User-Agent", "axios/" + VERSION, false);
@@ -29412,7 +29924,7 @@ var init_http = __esm(() => {
         headers: headers.toJSON(),
         agents: { http: config2.httpAgent, https: config2.httpsAgent },
         auth: auth2,
-        protocol,
+        protocol: protocol2,
         family,
         beforeRedirect: dispatchBeforeRedirect,
         beforeRedirects: {},
@@ -29424,7 +29936,7 @@ var init_http = __esm(() => {
       } else {
         options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
         options.port = parsed.port;
-        setProxy(options, config2.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+        setProxy(options, config2.proxy, protocol2 + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
       }
       let transport;
       const isHttpsRequest = isHttps.test(options.protocol);
@@ -29915,9 +30427,9 @@ var init_xhr = __esm(() => {
           _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
         }
       }
-      const protocol = parseProtocol(_config.url);
-      if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
-        reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config2));
+      const protocol2 = parseProtocol(_config.url);
+      if (protocol2 && platform_default.protocols.indexOf(protocol2) === -1) {
+        reject(new AxiosError_default("Unsupported protocol " + protocol2 + ":", AxiosError_default.ERR_BAD_REQUEST, config2));
         return;
       }
       request.send(requestData || null);
@@ -30763,10 +31275,10 @@ var init_HttpStatusCode = __esm(() => {
 
 // ../../node_modules/axios/lib/axios.js
 function createInstance(defaultConfig) {
-  const context = new Axios_default(defaultConfig);
-  const instance = bind(Axios_default.prototype.request, context);
-  utils_default.extend(instance, Axios_default.prototype, context, { allOwnKeys: true });
-  utils_default.extend(instance, context, null, { allOwnKeys: true });
+  const context2 = new Axios_default(defaultConfig);
+  const instance = bind(Axios_default.prototype.request, context2);
+  utils_default.extend(instance, Axios_default.prototype, context2, { allOwnKeys: true });
+  utils_default.extend(instance, context2, null, { allOwnKeys: true });
   instance.create = function create(instanceConfig) {
     return createInstance(mergeConfig(defaultConfig, instanceConfig));
   };
@@ -31317,11 +31829,11 @@ ${line}`;
     writeFileSync(this.progressPath, updated);
   }
   getFullContext() {
-    const context = this.readContext();
+    const context2 = this.readContext();
     const progress = this.readProgress();
     const parts = [];
-    if (context.trim()) {
-      parts.push(context.trim());
+    if (context2.trim()) {
+      parts.push(context2.trim());
     }
     if (progress.trim()) {
       parts.push(progress.trim());
@@ -31664,10 +32176,10 @@ ${task2.description || "No description provided."}
     let hasLocalContext = false;
     if (existsSync4(contextPath)) {
       try {
-        const context = readFileSync4(contextPath, "utf-8");
-        if (context.trim().length > 20) {
+        const context2 = readFileSync4(contextPath, "utf-8");
+        if (context2.trim().length > 20) {
           prompt += `## Project Context (Local)
-${context}
+${context2}
 
 `;
           hasLocalContext = true;
@@ -31797,10 +32309,10 @@ ${query}
     let hasLocalContext = false;
     if (existsSync4(contextPath)) {
       try {
-        const context = readFileSync4(contextPath, "utf-8");
-        if (context.trim().length > 20) {
+        const context2 = readFileSync4(contextPath, "utf-8");
+        if (context2.trim().length > 20) {
           prompt += `## Project Context (Local)
-${context}
+${context2}
 
 `;
           hasLocalContext = true;
@@ -31999,7 +32511,8 @@ function parseWorkerArgs(argv) {
       if (value && !value.startsWith("--"))
         i++;
       config2.provider = resolveProvider(value);
-    }
+    } else if (arg === "--reasoning-effort")
+      config2.reasoningEffort = args[++i];
   }
   if (!config2.agentId || !config2.workspaceId || !config2.apiBase || !config2.apiKey || !config2.projectPath) {
     console.error("Missing required arguments");
@@ -32061,7 +32574,8 @@ class AgentWorker {
     this.aiRunner = createAiRunner(provider, {
       projectPath,
       model: config2.model,
-      log
+      log,
+      reasoningEffort: config2.reasoningEffort
     });
     this.taskExecutor = new TaskExecutor({
       aiRunner: this.aiRunner,