@agentclientprotocol/codex-acp 1.2.0 → 1.3.0

package/dist/index.js

@@ -22777,8 +22777,20 @@ function createTerminalOutputMeta(mode, terminalId, data) {
   }
 }
 
+// src/ContextCompactionMeta.ts
+var CONTEXT_COMPACTION_META_KEY = "contextCompaction";
+var CONTEXT_COMPACTION_META_VERSION = 1;
+function createContextCompactionMeta(metadata = {}) {
+  return {
+    [CONTEXT_COMPACTION_META_KEY]: {
+      version: CONTEXT_COMPACTION_META_VERSION,
+      ...metadata
+    }
+  };
+}
+
 // src/CodexToolCallMapper.ts
-var CONTEXT_COMPACTION_META = { contextCompaction: true };
+var CONTEXT_COMPACTION_META = createContextCompactionMeta();
 function toAcpStatus(status) {
   switch (status) {
     case "inProgress":
@@ -22925,8 +22937,8 @@ function createContextCompactionStartUpdate(item) {
   return {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
-    kind: "other",
-    title: "Context compacting",
+    kind: "think",
+    title: "Compact conversation",
     status: "in_progress",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22935,7 +22947,7 @@ function createContextCompactionCompleteUpdate(item) {
   return {
     sessionUpdate: "tool_call_update",
     toolCallId: item.id,
-    title: "Context compacted",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -22944,8 +22956,8 @@ function createCompletedContextCompactionUpdate(item) {
   return {
     sessionUpdate: "tool_call",
     toolCallId: item.id,
-    kind: "other",
-    title: "Context compacted",
+    kind: "think",
+    title: "Compact conversation",
     status: "completed",
     _meta: CONTEXT_COMPACTION_META
   };
@@ -23608,19 +23620,60 @@ var AIR_SESSION_FAILURE_KEY = "sessionFailure";
 var AIR_EXTENSION_VERSION = 1;
 
 // src/CodexEventHandler.ts
-var SESSION_FAILURE_PRESENTATION = {
-  transport_lost: { message: "Connection to Codex was lost.", retryable: true, actions: ["reconnect", "retry"] },
-  auth_required: { message: "Sign in to continue using Codex.", retryable: false, actions: ["login"] },
-  rate_limited: { message: "The Codex rate limit was reached.", retryable: true, actions: ["retry"] },
-  quota_exhausted: { message: "The Codex usage quota is exhausted.", retryable: false, actions: ["new_session"] },
-  overloaded: { message: "Codex is temporarily overloaded.", retryable: true, actions: ["retry"] },
-  context_exhausted: { message: "This conversation has reached its context limit.", retryable: false, actions: ["new_turn"] },
-  budget_exhausted: { message: "This session has reached its usage budget.", retryable: false, actions: ["new_session"] },
-  policy_denied: { message: "The request was blocked by provider policy.", retryable: false, actions: [] },
-  bad_request: { message: "Codex could not process this request.", retryable: false, actions: ["new_turn"] },
-  provider_error: { message: "The model provider reported an error.", retryable: true, actions: ["retry"] },
-  internal_error: { message: "Codex encountered an internal error.", retryable: true, actions: ["retry"] }
+var MAX_SESSION_FAILURE_TITLE_LENGTH = 240;
+var SESSION_FAILURE_POLICY = {
+  transport_lost: {
+    category: "connection",
+    actions: ["retry", "new_session"]
+  },
+  auth_required: {
+    category: "access",
+    actions: ["login"]
+  },
+  rate_limited: {
+    category: "limit",
+    actions: ["retry"]
+  },
+  quota_exhausted: {
+    category: "limit",
+    actions: []
+  },
+  overloaded: {
+    category: "service",
+    actions: ["retry"]
+  },
+  context_exhausted: {
+    category: "limit",
+    actions: ["new_session"]
+  },
+  budget_exhausted: {
+    category: "limit",
+    actions: ["new_session"]
+  },
+  policy_denied: {
+    category: "request",
+    actions: []
+  },
+  bad_request: {
+    category: "request",
+    actions: []
+  },
+  provider_error: {
+    category: "service",
+    actions: ["retry"]
+  },
+  internal_error: {
+    category: "service",
+    actions: ["retry", "new_session"]
+  }
 };
+var SYNTHETIC_FAILURE_TITLE = {
+  transport_lost: "Connection to Codex was lost.",
+  internal_error: "Codex encountered an internal error."
+};
+function nextSessionFailureRevision(previous, id) {
+  return previous?.id === id ? previous.revision + 1 : 1;
+}
 var STRING_CODEX_ERROR_CATEGORIES = {
   contextWindowExceeded: "context_exhausted",
   sessionBudgetExceeded: "budget_exhausted",
@@ -23648,6 +23701,12 @@ var CodexEventHandler = class _CodexEventHandler {
   supportsTypedSessionFailures;
   sessionFailureEpoch;
   pendingErrors = [];
+  failuresById = /* @__PURE__ */ new Map();
+  activeFailureIdByScope = /* @__PURE__ */ new Map();
+  failureTurnIdById = /* @__PURE__ */ new Map();
+  allocatedFailureScopes = /* @__PURE__ */ new Set();
+  lastSessionNotice;
+  nextNoticeId = 1;
   failure = null;
   completedPlan = null;
   activeFuzzyFileSearchSessions = /* @__PURE__ */ new Set();
@@ -23672,19 +23731,22 @@ var CodexEventHandler = class _CodexEventHandler {
     this.supportsTypedSessionFailures = supportsTypedSessionFailures;
     this.sessionFailureEpoch = sessionFailureEpoch;
     this.session = new ACPSessionConnection(connection, sessionState.sessionId);
+    if (sessionState.sessionFailure !== void 0) {
+      this.failuresById.set(sessionState.sessionFailure.id, sessionState.sessionFailure);
+    }
   }
   getFailure() {
     return this.failure;
   }
   getTerminalSessionFailureMeta(turnId, allowUnattributed = false) {
     const failure = this.sessionState.sessionFailure;
-    if (!this.supportsTypedSessionFailures || failure?.phase !== "active" || (failure.turnId === void 0 ? !allowUnattributed : turnId === null || failure.turnId !== turnId)) {
+    if (!this.supportsTypedSessionFailures || failure === void 0 || (this.failureTurnIdById.get(failure.id) === void 0 ? !allowUnattributed : turnId === null || this.failureTurnIdById.get(failure.id) !== turnId)) {
       return null;
     }
     return this.createSessionFailureMeta(failure);
   }
-  recordSyntheticTerminalFailure(category, turnId) {
-    this.recordSessionFailure(category, turnId ?? void 0);
+  recordSyntheticTerminalFailure(kind, turnId) {
+    this.recordSessionFailure(kind, turnId ?? void 0, "error", SYNTHETIC_FAILURE_TITLE[kind]);
   }
   /**
    * Handles notifications after the prompt-local handler has been disposed. The app-server subscription
@@ -23701,12 +23763,16 @@ var CodexEventHandler = class _CodexEventHandler {
       return;
     }
     if (notification.params.willRetry) {
-      await this.session.update(this.createSafeErrorDiagnostic(notification.params));
+      await this.session.update(this.createSessionFailureUpdate(this.recordRetryWarning(notification.params, false)));
       return;
     }
     const failure = this.recordSessionFailure(
-      this.sessionFailureCategory(notification.params.error.codexErrorInfo),
-      void 0
+      this.sessionFailureKind(notification.params.error.codexErrorInfo),
+      notification.params.turnId,
+      "error",
+      notification.params.error.message,
+      void 0,
+      false
     );
     await this.session.update(this.createSessionFailureUpdate(failure));
   }
@@ -23732,21 +23798,19 @@ var CodexEventHandler = class _CodexEventHandler {
     }
   }
   async clearSessionFailure() {
+    delete this.sessionState.sessionFailure;
+  }
+  async completeSuccessfulTurn(turnId) {
+    this.lastSessionNotice = void 0;
+    if (!this.supportsTypedSessionFailures || turnId === null) return;
     const active = this.sessionState.sessionFailure;
-    if (!this.supportsTypedSessionFailures || active?.phase !== "active") {
-      return;
-    }
-    const cleared = {
-      ...active,
-      revision: active.revision + 1,
-      phase: "cleared"
-    };
-    await this.session.update(this.createSessionFailureUpdate(cleared));
-    this.sessionState.sessionFailure = cleared;
+    if (active?.id !== this.activeFailureIdByScope.get(turnId) || active?.severity !== "warning") return;
+    this.activeFailureIdByScope.delete(turnId);
+    delete this.sessionState.sessionFailure;
   }
   async handleFailedTurn(turn) {
     const activeFailure = this.sessionState.sessionFailure;
-    if (!this.supportsTypedSessionFailures || turn.status !== "failed" || this.failure !== null || activeFailure?.phase === "active" && activeFailure.turnId === turn.id) {
+    if (!this.supportsTypedSessionFailures || turn.status !== "failed" || this.failure !== null || this.failureTurnIdById.get(activeFailure?.id ?? "") === turn.id && activeFailure?.severity === "error") {
       return;
     }
     const error51 = turn.error ?? {
@@ -23805,14 +23869,19 @@ var CodexEventHandler = class _CodexEventHandler {
   async createUpdateEvent(notification) {
     switch (notification.method) {
       case "item/agentMessage/delta":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.createTextEvent(notification.params);
       case "item/plan/delta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createPlanDeltaEvent(notification.params);
       case "item/started":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.createItemEvent(notification.params);
       case "item/completed":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.completeItemEvent(notification.params);
       case "turn/plan/updated":
+        this.completeRetryIncidentOnTurnProgress();
         return await this.updatePlan(notification.params);
       case "error":
         return await this.createErrorEvent(notification.params);
@@ -23851,8 +23920,10 @@ var CodexEventHandler = class _CodexEventHandler {
           closed: true
         });
       case "item/commandExecution/outputDelta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createCommandOutputDeltaEvent(notification.params);
       case "item/mcpToolCall/progress":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createMcpToolProgressEvent(notification.params);
       case "account/rateLimits/updated":
         this.handleRateLimitsUpdated(notification.params);
@@ -23863,6 +23934,8 @@ var CodexEventHandler = class _CodexEventHandler {
         return this.createWarningEvent(notification.params);
       case "guardianWarning":
         return null;
+      case "deprecationNotice":
+        return this.createDeprecationNoticeEvent(notification.params);
       case "item/autoApprovalReview/started":
         return this.handleGuardianApprovalReviewStarted(notification.params);
       case "item/autoApprovalReview/completed":
@@ -23870,10 +23943,13 @@ var CodexEventHandler = class _CodexEventHandler {
       case "thread/compacted":
         return this.createContextCompactedEvent();
       case "item/reasoning/summaryTextDelta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningDeltaEvent(notification.params);
       case "item/reasoning/textDelta":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningDeltaEvent(notification.params);
       case "item/reasoning/summaryPartAdded":
+        this.completeRetryIncidentOnTurnProgress();
         return this.createReasoningSectionBreakEvent(notification.params);
       case "model/rerouted":
         return this.createModelReroutedEvent(notification.params);
@@ -23916,7 +23992,6 @@ var CodexEventHandler = class _CodexEventHandler {
       case "windowsSandbox/setupCompleted":
       case "account/login/completed":
       case "skills/changed":
-      case "deprecationNotice":
       case "mcpServer/oauthLogin/completed":
       case "externalAgentConfig/import/completed":
       case "rawResponseItem/completed":
@@ -23944,14 +24019,31 @@ var CodexEventHandler = class _CodexEventHandler {
     return createAgentTextMessageChunk(event.delta, event.itemId, createCodexMessagePhaseMeta(phase));
   }
   async createConfigWarningEvent(event) {
-    const detailsText = event.details ? `
+    if (this.supportsTypedSessionFailures) {
+      return this.createSessionFailureUpdate(this.recordSessionNotice(...this.sessionNoticeContent(event.summary, event.details)));
+    }
+    const text = event.details ? `${event.summary}
 
-${event.details}` : "";
-    return createAgentTextMessageChunk(`Config warning: ${event.summary}${detailsText}
+${event.details}` : event.summary;
+    return createAgentTextMessageChunk(`Config warning: ${text}
 
 `);
   }
+  /**
+   * Unlike `warning` and `configWarning`, this notification was dropped outright, so there is no
+   * legacy rendering to preserve. It is surfaced only to clients that negotiated typed records;
+   * every other client keeps seeing exactly what it sees today, which is nothing.
+   */
+  createDeprecationNoticeEvent(event) {
+    if (!this.supportsTypedSessionFailures) return null;
+    return this.createSessionFailureUpdate(
+      this.recordSessionNotice(...this.sessionNoticeContent(event.summary, event.details))
+    );
+  }
   createWarningEvent(event) {
+    if (this.supportsTypedSessionFailures) {
+      return this.createSessionFailureUpdate(this.recordSessionNotice(event.message));
+    }
     return createAgentTextMessageChunk(`Warning: ${event.message}
 
 `);
@@ -24329,7 +24421,13 @@ ${event.stdin}
     }
     if (params.turnId !== this.sessionState.currentTurnId) {
       if (this.supportsTypedSessionFailures) {
-        return this.createSafeErrorDiagnostic(params);
+        const failure = params.willRetry ? this.recordRetryWarning(params) : this.recordSessionFailure(
+          this.sessionFailureKind(params.error.codexErrorInfo),
+          params.turnId,
+          "error",
+          params.error.message
+        );
+        return this.createSessionFailureUpdate(failure);
       }
       return this.createCodexSessionInfoUpdate({
         error: { ...params.error, turnId: params.turnId, willRetry: params.willRetry }
@@ -24337,7 +24435,7 @@ ${event.stdin}
     }
     if (params.willRetry) {
       if (this.supportsTypedSessionFailures) {
-        return this.createSafeErrorDiagnostic(params);
+        return this.createSessionFailureUpdate(this.recordRetryWarning(params));
       }
       return this.createCodexSessionInfoUpdate({
         error: {
@@ -24362,39 +24460,86 @@ ${event.stdin}
 
 `);
   }
-  createSafeErrorDiagnostic(params) {
-    const category = this.sessionFailureCategory(params.error.codexErrorInfo);
-    return this.createCodexSessionInfoUpdate({
-      error: {
-        category,
-        message: SESSION_FAILURE_PRESENTATION[category].message,
-        turnId: params.turnId,
-        willRetry: params.willRetry
-      }
-    });
-  }
   recordTypedSessionFailure(params) {
-    const category = this.sessionFailureCategory(params.error.codexErrorInfo);
-    this.recordSessionFailure(category, params.turnId);
-  }
-  recordSessionFailure(category, turnId) {
-    const presentation = SESSION_FAILURE_PRESENTATION[category];
-    const previous = this.sessionState.sessionFailure;
-    const id = previous?.phase === "active" ? previous.id : turnId === void 0 ? `${this.sessionState.sessionId}:error:${this.sessionFailureEpoch}` : `${turnId}:error`;
+    const kind = this.sessionFailureKind(params.error.codexErrorInfo);
+    this.recordSessionFailure(kind, params.turnId, "error", params.error.message);
+  }
+  recordSessionFailure(kind, turnId, severity, title, actionsOverride, attributeToTurn = true) {
+    const policy = SESSION_FAILURE_POLICY[kind];
+    const scope = turnId ?? this.sessionState.sessionId;
+    const id = this.activeFailureIdByScope.get(scope) ?? this.allocateFailureId(scope, turnId);
+    const previous = this.failuresById.get(id);
     const failure = {
       id,
-      revision: previous?.id === id ? previous.revision + 1 : 1,
-      phase: "active",
-      category,
-      source: "codex",
-      safeMessage: presentation.message,
-      retryable: presentation.retryable,
-      actions: presentation.actions,
-      ...turnId === void 0 ? {} : { turnId }
+      revision: nextSessionFailureRevision(previous, id),
+      category: policy.category,
+      severity,
+      title,
+      actions: actionsOverride ?? policy.actions
     };
+    this.failuresById.set(id, failure);
+    this.failureTurnIdById.set(id, attributeToTurn ? turnId : void 0);
+    this.activeFailureIdByScope.set(scope, id);
     this.sessionState.sessionFailure = failure;
+    this.lastSessionNotice = void 0;
     return failure;
   }
+  allocateFailureId(scope, turnId) {
+    if (turnId !== void 0 && !this.allocatedFailureScopes.has(scope)) {
+      this.allocatedFailureScopes.add(scope);
+      return `${turnId}:error`;
+    }
+    this.allocatedFailureScopes.add(scope);
+    return `${scope}:error:${this.sessionFailureEpoch}:${this.nextNoticeId++}`;
+  }
+  /**
+   * A retry warning remains the active incident until Codex produces turn content again. That content is
+   * the only positive signal available from app-server that the turn recovered; a later error then starts
+   * a new incident instead of overwriting the historical reconnect entry. Terminal errors remain active so
+   * duplicate late notifications cannot append duplicate transcript rows.
+   */
+  completeRetryIncidentOnTurnProgress() {
+    const turnId = this.sessionState.currentTurnId;
+    if (turnId === null) return;
+    const activeId = this.activeFailureIdByScope.get(turnId);
+    if (activeId === void 0 || this.failuresById.get(activeId)?.severity !== "warning") return;
+    this.activeFailureIdByScope.delete(turnId);
+    if (this.sessionState.sessionFailure?.id === activeId) {
+      delete this.sessionState.sessionFailure;
+    }
+  }
+  recordRetryWarning(params, attributeToTurn = true) {
+    const kind = this.sessionFailureKind(params.error.codexErrorInfo);
+    return this.recordSessionFailure(
+      kind,
+      params.turnId,
+      "warning",
+      params.error.message,
+      [],
+      attributeToTurn
+    );
+  }
+  recordSessionNotice(title, details) {
+    const key = `${title}\0${details ?? ""}`;
+    const previous = this.lastSessionNotice?.key === key ? this.lastSessionNotice.failure : void 0;
+    const id = previous?.id ?? `${this.sessionState.sessionId}:notice:${this.sessionFailureEpoch}:${this.nextNoticeId++}`;
+    const notice = {
+      id,
+      revision: nextSessionFailureRevision(previous, id),
+      category: "unknown",
+      severity: "warning",
+      title,
+      ...details === void 0 ? {} : { details },
+      actions: []
+    };
+    this.lastSessionNotice = { key, failure: notice };
+    return notice;
+  }
+  sessionNoticeContent(summary, details) {
+    if (details === null) return [summary];
+    const combinedTitle = `${summary} \u2014 ${details}`;
+    return combinedTitle.length <= MAX_SESSION_FAILURE_TITLE_LENGTH ? [combinedTitle] : [summary, details];
+  }
   createSessionFailureMeta(failure) {
     return {
       [JETBRAINS_META_KEY]: {
@@ -24411,7 +24556,7 @@ ${event.stdin}
       _meta: this.createSessionFailureMeta(failure)
     };
   }
-  sessionFailureCategory(error51) {
+  sessionFailureKind(error51) {
     if (this.isAuthenticationRequiredError(error51)) return "auth_required";
     if (this.getHttpStatusCode(error51) === 429) return "rate_limited";
     if (typeof error51 === "string") {
@@ -26386,7 +26531,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.2.0",
+  version: "1.3.0",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26541,6 +26686,8 @@ function isRootPath(value) {
 
 // src/CodexAcpClient.ts
 var CUSTOM_GATEWAY_PROVIDER_ID = "custom-gateway";
+var OPENAI_PROVIDER_ID = "openai";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 var SUPPORTED_GATEWAY_PROTOCOLS = {
   openai: "responses"
 };
@@ -26754,34 +26901,47 @@ var CodexAcpClient = class {
     };
   }
   /**
-   * `providers/list`: returns the single client-configurable custom gateway
-   * provider. `current` carries only non-secret routing (never headers), and is
-   * `null` when the provider is not configured/disabled.
+   * `providers/list`: returns Codex's OpenAI slot. With no ACP override, the
+   * slot reports native OpenAI routing; headers are never exposed.
    */
   listProviders() {
     const gatewayConfig = this.gatewayConfig;
     const current = gatewayConfig ? {
       apiType: gatewayApiTypeFromConfig(gatewayConfig),
       baseUrl: gatewayConfig.config.base_url
-    } : null;
+    } : this.getNativeProviderConfig();
     return [
       {
-        providerId: CUSTOM_GATEWAY_PROVIDER_ID,
+        providerId: OPENAI_PROVIDER_ID,
         supported: Object.keys(SUPPORTED_GATEWAY_PROTOCOLS),
         required: false,
         current
       }
     ];
   }
+  getNativeProviderConfig() {
+    const configuredProviderId = this.modelProvider ?? (typeof this.config["model_provider"] === "string" ? this.config["model_provider"] : null);
+    const configuredProviders = this.config["model_providers"];
+    if (configuredProviderId && configuredProviders && typeof configuredProviders === "object" && !Array.isArray(configuredProviders)) {
+      const configuredProvider = configuredProviders[configuredProviderId];
+      if (configuredProvider && typeof configuredProvider === "object" && !Array.isArray(configuredProvider)) {
+        const baseUrl = configuredProvider["base_url"];
+        if (typeof baseUrl === "string" && baseUrl.length > 0) {
+          return { apiType: "openai", baseUrl };
+        }
+      }
+    }
+    return { apiType: "openai", baseUrl: DEFAULT_OPENAI_BASE_URL };
+  }
   /**
    * `providers/set`: replaces the full configuration for the custom gateway
    * provider. Rejects unknown provider ids with `invalid_params`.
    */
   setProvider(request) {
-    if (request.providerId !== CUSTOM_GATEWAY_PROVIDER_ID) {
+    if (request.providerId !== OPENAI_PROVIDER_ID) {
       throw RequestError.invalidParams(
         { providerId: request.providerId },
-        `Unknown providerId "${request.providerId}"; only "${CUSTOM_GATEWAY_PROVIDER_ID}" is configurable`
+        `Unknown providerId "${request.providerId}"; only "${OPENAI_PROVIDER_ID}" is configurable`
       );
     }
     this.applyGatewayConfig({
@@ -26795,7 +26955,7 @@ var CodexAcpClient = class {
    * unknown provider id is idempotent success (RFD behavior §7).
    */
   disableProvider(request) {
-    if (request.providerId === CUSTOM_GATEWAY_PROVIDER_ID) {
+    if (request.providerId === OPENAI_PROVIDER_ID) {
       this.gatewayConfig = null;
     }
   }
@@ -30559,8 +30719,9 @@ Check ${configPath} and project .codex directories, especially their config.toml
     let eventHandler = null;
     let promptNotificationsActive = true;
     const clearRecoveredSessionFailure = async (handler) => {
+      await handler.completeSuccessfulTurn(sessionState.currentTurnId);
       const current = sessionState.sessionFailure;
-      if (recoverableSessionFailure?.phase === "active" && current?.phase === "active" && current.id === recoverableSessionFailure.id && current.revision === recoverableSessionFailure.revision) {
+      if (recoverableSessionFailure !== void 0 && current !== void 0 && current.id === recoverableSessionFailure.id && current.revision === recoverableSessionFailure.revision) {
         await handler.clearSessionFailure();
       }
     };
@@ -30850,8 +31011,10 @@ Check ${configPath} and project .codex directories, especially their config.toml
       const isProcessExit = err instanceof RequestError && err.code === CODEX_PROCESS_EXITED_ERROR_CODE;
       const isUnexpectedFailure = !(err instanceof RequestError);
       if (eventHandler !== null && clientSupportsTypedSessionFailures(this.clientCapabilities) && (isProcessExit || isUnexpectedFailure)) {
-        const category = isProcessExit ? "transport_lost" : "internal_error";
-        eventHandler.recordSyntheticTerminalFailure(category, sessionState.currentTurnId);
+        eventHandler.recordSyntheticTerminalFailure(
+          isProcessExit ? "transport_lost" : "internal_error",
+          sessionState.currentTurnId
+        );
         const failureResponse = this.terminalFailurePromptResponse(
           sessionState,
           eventHandler,

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "main": "dist/index.js",
   "bin": {