@agentclientprotocol/codex-acp 1.1.12 → 1.1.14

package/dist/index.js

@@ -23560,7 +23560,7 @@ function createAgentTextThoughtChunk(text, messageId, meta3) {
 var GOAL_EXTENSION_VERSION = 1;
 var GOAL_CONTROL_METHOD = "_session/goal";
 var LEGACY_GOAL_CONTROL_METHOD = "_codex/session/goal_control";
-var GOAL_CONTROL_ACTIONS = ["pause", "resume", "clear"];
+var GOAL_CONTROL_ACTIONS = ["set", "pause", "resume", "clear"];
 
 // src/ThreadGoalSnapshot.ts
 function toGoalStatus(status) {
@@ -26161,7 +26161,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "1.1.12",
+  version: "1.1.14",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -26222,7 +26222,7 @@ var package_default = {
   },
   dependencies: {
     "@agentclientprotocol/sdk": "^1.3.0",
-    "@openai/codex": "^0.146.1",
+    "@openai/codex": "^0.147.0",
     diff: "^9.0.0",
     open: "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",
@@ -26624,12 +26624,16 @@ var CodexAcpClient = class {
     const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
     return response?.goal ?? null;
   }
-  async setGoal(sessionId, objective, onTurnStarted) {
-    return await this.codexClient.runGoalSet({
+  async setGoal(sessionId, objective, onTurnStarted, onGoalSet) {
+    const params = {
       threadId: sessionId,
       objective,
       status: "active"
-    }, onTurnStarted);
+    };
+    if (onGoalSet === void 0) {
+      return await this.codexClient.runGoalSet(params, onTurnStarted);
+    }
+    return await this.codexClient.runGoalSet(params, onTurnStarted, void 0, onGoalSet);
   }
   async setGoalStatus(sessionId, status) {
     let updatedGoal = null;
@@ -26644,11 +26648,15 @@ var CodexAcpClient = class {
     }
     return updatedGoal;
   }
-  async resumeGoal(sessionId, onTurnStarted) {
-    return await this.codexClient.runGoalSet({
+  async resumeGoal(sessionId, onTurnStarted, onGoalSet) {
+    const params = {
       threadId: sessionId,
       status: "active"
-    }, onTurnStarted);
+    };
+    if (onGoalSet === void 0) {
+      return await this.codexClient.runGoalSet(params, onTurnStarted);
+    }
+    return await this.codexClient.runGoalSet(params, onTurnStarted, void 0, onGoalSet);
   }
   async clearGoal(sessionId) {
     await this.codexClient.runGoalClear({ threadId: sessionId });
@@ -27189,6 +27197,10 @@ function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEff
 }
 
 // src/CodexCommands.ts
+var GOAL_CONTINUATION_PROMPT = [{
+  type: "text",
+  text: "Continue working toward the active goal."
+}];
 var CodexCommands = class {
   connection;
   codexAcpClient;
@@ -27477,7 +27489,7 @@ var CodexCommands = class {
   }
   createGoalCommandResult(turnCompleted) {
     if (turnCompleted === null) {
-      return { handled: true };
+      return { handled: false, prompt: GOAL_CONTINUATION_PROMPT };
     }
     return {
       handled: true,
@@ -28731,6 +28743,7 @@ var CodexAcpServer = class _CodexAcpServer {
   closingSessions;
   sessionGenerations;
   sessionOpenGenerations;
+  goalControlGenerations;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode, getRecentStderr) {
     this.sessions = /* @__PURE__ */ new Map();
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
@@ -28740,6 +28753,7 @@ var CodexAcpServer = class _CodexAcpServer {
     this.closingSessions = /* @__PURE__ */ new Map();
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
+    this.goalControlGenerations = /* @__PURE__ */ new Map();
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.defaultAuthRequest = defaultAuthRequest ?? null;
@@ -28829,12 +28843,51 @@ var CodexAcpServer = class _CodexAcpServer {
           throw RequestError.invalidParams(void 0, `Unknown session: ${methodRequest.params.sessionId}`);
         }
         const sessionGeneration = this.getSessionGeneration(sessionState.sessionId);
-        if (methodRequest.params.action === "pause" || methodRequest.params.action === "resume") {
-          const status = methodRequest.params.action === "pause" ? "paused" : "active";
-          const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, status));
+        const goalControlGeneration = this.bumpGoalControlGeneration(sessionState.sessionId);
+        if (methodRequest.params.action === "set") {
+          const objective = methodRequest.params.objective;
+          let updatedGoal = null;
+          const turnCompleted = await this.runWithProcessCheck(() => this.codexAcpClient.setGoal(
+            sessionState.sessionId,
+            objective,
+            void 0,
+            (goal) => {
+              updatedGoal = goal;
+            }
+          ));
+          if (turnCompleted === null && updatedGoal !== null) {
+            await this.startGoalContinuationIfCurrent(
+              sessionState,
+              sessionGeneration,
+              goalControlGeneration,
+              updatedGoal
+            );
+          }
+        } else if (methodRequest.params.action === "pause") {
+          const goal = await this.runWithProcessCheck(() => this.codexAcpClient.setGoalStatus(sessionState.sessionId, "paused"));
           if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
             await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(goal), false);
           }
+        } else if (methodRequest.params.action === "resume") {
+          let updatedGoal = null;
+          const turnCompleted = await this.runWithProcessCheck(() => this.codexAcpClient.resumeGoal(
+            sessionState.sessionId,
+            void 0,
+            (goal) => {
+              updatedGoal = goal;
+            }
+          ));
+          if (updatedGoal !== null && this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
+            await this.publishGoalSnapshot(sessionState, toThreadGoalSnapshot(updatedGoal), false);
+          }
+          if (turnCompleted === null && updatedGoal !== null) {
+            await this.startGoalContinuationIfCurrent(
+              sessionState,
+              sessionGeneration,
+              goalControlGeneration,
+              updatedGoal
+            );
+          }
         } else if (methodRequest.params.action === "clear") {
           await this.runWithProcessCheck(() => this.codexAcpClient.clearGoal(sessionState.sessionId));
           if (this.goalPublishIsCurrent(sessionState, sessionGeneration)) {
@@ -28934,6 +28987,11 @@ Check ${configPath} and project .codex directories, especially their config.toml
   getSessionGeneration(sessionId) {
     return this.sessionGenerations.get(sessionId) ?? 0;
   }
+  bumpGoalControlGeneration(sessionId) {
+    const generation = (this.goalControlGenerations.get(sessionId) ?? 0) + 1;
+    this.goalControlGenerations.set(sessionId, generation);
+    return generation;
+  }
   bumpSessionGeneration(sessionId) {
     const generation = this.getSessionGeneration(sessionId) + 1;
     this.sessionGenerations.set(sessionId, generation);
@@ -29131,6 +29189,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
         this.pendingTurnStarts.delete(params.sessionId);
         this.activePrompts.delete(params.sessionId);
         this.steeringQueues.delete(params.sessionId);
+        this.goalControlGenerations.delete(params.sessionId);
       }
       this.endSessionCloseFence(params.sessionId);
     }
@@ -29488,29 +29547,48 @@ Check ${configPath} and project .codex directories, especially their config.toml
    *     fails or is cancelled before the turn starts.
    */
   async startNewTurnFromSteering(params) {
+    await this.startNewTurnFromExternalPrompt(params, "Steering");
+    return { outcome: "startedNewTurn" };
+  }
+  async startGoalContinuationIfCurrent(sessionState, sessionGeneration, goalControlGeneration, expectedGoal) {
+    await this.startNewTurnFromExternalPrompt({
+      sessionId: sessionState.sessionId,
+      prompt: GOAL_CONTINUATION_PROMPT
+    }, "Goal continuation", async () => {
+      if (!this.goalPublishIsCurrent(sessionState, sessionGeneration) || this.goalControlGenerations.get(sessionState.sessionId) !== goalControlGeneration) {
+        return false;
+      }
+      const currentGoal = await this.runWithProcessCheck(() => this.codexAcpClient.getGoal(sessionState.sessionId));
+      return currentGoal?.status === "active" && currentGoal.objective === expectedGoal.objective && currentGoal.createdAt === expectedGoal.createdAt && this.goalControlGenerations.get(sessionState.sessionId) === goalControlGeneration;
+    });
+  }
+  async startNewTurnFromExternalPrompt(params, source, canStart = async () => true) {
     const previousPrompt = this.activePrompts.get(params.sessionId);
     await previousPrompt?.completion;
     if (this.sessionIsClosing(params.sessionId)) {
       throw RequestError.invalidRequest(`Session ${params.sessionId} is closing`);
     }
+    if (!await canStart()) {
+      return false;
+    }
     return await new Promise((resolve, reject) => {
       let turnStarted = false;
       const promptDone = this.prompt(params, void 0, () => {
         turnStarted = true;
-        logger.log("Steering session started a new turn", { sessionId: params.sessionId });
-        resolve({ outcome: "startedNewTurn" });
+        logger.log(`${source} started a new turn`, { sessionId: params.sessionId });
+        resolve(true);
       });
       promptDone.then(
         (response) => {
           if (!turnStarted && response.stopReason === "cancelled") {
             reject(RequestError.invalidRequest(`Session ${params.sessionId} was cancelled before the steering turn started`));
           } else {
-            resolve({ outcome: "startedNewTurn" });
+            resolve(turnStarted);
           }
         },
         (error51) => {
           if (turnStarted) {
-            logger.error(`Steering-started prompt for session ${params.sessionId} failed`, error51);
+            logger.error(`${source} prompt for session ${params.sessionId} failed`, error51);
           } else {
             reject(error51);
           }
@@ -30271,6 +30349,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           _meta: this.buildQuotaMeta(sessionState)
         };
       }
+      const effectiveParams = commandResult.prompt === void 0 ? params : { ...params, prompt: commandResult.prompt };
       if (this.sessionIsClosing(params.sessionId)) {
         return this.cancelledPromptResponse(sessionState);
       }
@@ -30283,7 +30362,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
           reason: sessionState.account?.type === "apiKey" ? "API key" : "model lacks reasoning"
         });
       }
-      if (!sessionState.supportedInputModalities.includes("image") && params.prompt.some((b) => b.type === "image")) {
+      if (!sessionState.supportedInputModalities.includes("image") && effectiveParams.prompt.some((b) => b.type === "image")) {
         throw RequestError.invalidRequest("The current model does not support image input");
       }
       const agentMode = sessionState.agentMode;
@@ -30294,7 +30373,7 @@ Check ${configPath} and project .codex directories, especially their config.toml
       ensurePendingTurnStart();
       const sendPromptPromise = this.runWithProcessCheck(
         () => this.codexAcpClient.sendPrompt(
-          params,
+          effectiveParams,
           agentMode,
           modelId,
           serviceTier,
@@ -31532,10 +31611,17 @@ var sessionSteerParamsParser = external_exports.object({
   sessionId: external_exports.string(),
   prompt: external_exports.array(external_exports.any())
 }).passthrough();
-var goalControlParamsParser = external_exports.object({
-  sessionId: external_exports.string(),
-  action: external_exports.enum(["pause", "resume", "clear"])
-}).passthrough();
+var goalControlParamsParser = external_exports.discriminatedUnion("action", [
+  external_exports.object({
+    sessionId: external_exports.string(),
+    action: external_exports.literal("set"),
+    objective: external_exports.string().trim().min(1)
+  }).passthrough(),
+  external_exports.object({
+    sessionId: external_exports.string(),
+    action: external_exports.enum(["pause", "resume", "clear"])
+  }).passthrough()
+]);
 if (process.argv.includes("--version")) {
   console.log(`${package_default.name} ${package_default.version}`);
   process.exit(0);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.12",
+  "version": "1.1.14",
   "description": "",
   "main": "dist/index.js",
   "bin": {
@@ -64,7 +64,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
-    "@openai/codex": "^0.146.1",
+    "@openai/codex": "^0.147.0",
     "diff": "^9.0.0",
     "open": "^11.0.0",
     "vscode-jsonrpc": "^9.0.1",