@agentclientprotocol/codex-acp 0.0.42 → 0.0.44

package/dist/index.js

@@ -18958,7 +18958,7 @@ var package_default = {
   publishConfig: {
     access: "public"
   },
-  version: "0.0.42",
+  version: "0.0.44",
   description: "",
   main: "dist/index.js",
   bin: {
@@ -19163,11 +19163,11 @@ var CodexAcpClient = class {
       approvalPolicy: null,
       sandbox: null,
       baseInstructions: null,
-      config: this.createSessionConfig(request.cwd, request.mcpServers ?? []),
+      config: await this.createSessionConfig(request.cwd, request.mcpServers ?? []),
       cwd: request.cwd,
       developerInstructions: null,
       model: null,
-      modelProvider: this.getModelProvider(),
+      modelProvider: this.getResumeModelProvider(),
       personality: null,
       threadId: request.sessionId
     });
@@ -19184,11 +19184,11 @@ var CodexAcpClient = class {
       approvalPolicy: null,
       sandbox: null,
       baseInstructions: null,
-      config: this.createSessionConfig(request.cwd, request.mcpServers ?? []),
+      config: await this.createSessionConfig(request.cwd, request.mcpServers ?? []),
       cwd: request.cwd,
       developerInstructions: null,
       model: null,
-      modelProvider: this.getModelProvider(),
+      modelProvider: this.getResumeModelProvider(),
       personality: null,
       threadId: request.sessionId
     });
@@ -19204,7 +19204,7 @@ var CodexAcpClient = class {
   async newSession(request) {
     await this.refreshSkills(request.cwd, request._meta);
     const response = await this.codexClient.threadStart({
-      config: this.createSessionConfig(request.cwd, request.mcpServers),
+      config: await this.createSessionConfig(request.cwd, request.mcpServers),
       modelProvider: this.getModelProvider(),
       model: null,
       cwd: request.cwd,
@@ -19232,7 +19232,7 @@ var CodexAcpClient = class {
   getMcpServerStartupVersion() {
     return this.codexClient.getMcpServerStartupVersion();
   }
-  createSessionConfig(projectPath, mcpServers) {
+  async createSessionConfig(projectPath, mcpServers) {
     const mergedConfig = {
       ...mergeGatewayConfig(this.config, this.gatewayConfig),
       projects: {
@@ -19244,14 +19244,30 @@ var CodexAcpClient = class {
     if (mcpServers.length === 0) {
       return mergedConfig;
     }
+    const existingNames = await this.getConfigMcpServerNames(projectPath);
+    const uniqueServers = mcpServers.filter((mcp) => !existingNames.has(mcp.name));
+    if (uniqueServers.length === 0) {
+      return mergedConfig;
+    }
     return {
       ...mergedConfig,
-      "mcp_servers": Object.fromEntries(mcpServers.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp)]))
+      "mcp_servers": Object.fromEntries(uniqueServers.map((mcp) => [mcp.name, this.createMcpSeverConfig(mcp)]))
     };
   }
+  async getConfigMcpServerNames(projectPath) {
+    const response = await this.codexClient.configRead({ includeLayers: true, cwd: projectPath });
+    const mcpServers = response?.config?.["mcp_servers"];
+    if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+      return /* @__PURE__ */ new Set();
+    }
+    return new Set(Object.keys(mcpServers));
+  }
   getModelProvider() {
     return this.gatewayConfig?.modelProvider ?? this.modelProvider;
   }
+  getResumeModelProvider() {
+    return this.getModelProvider() ?? "openai";
+  }
   async refreshSkills(cwd, meta) {
     if (!cwd) {
       return;
@@ -19305,7 +19321,7 @@ var CodexAcpClient = class {
     const input = buildPromptItems(request.prompt);
     const effort = modelId.effort;
     await this.refreshSkills(cwd, request._meta);
-    await this.codexClient.turnStart({
+    return await this.codexClient.runTurn({
       outputSchema: null,
       threadId: request.sessionId,
       input,
@@ -19317,7 +19333,6 @@ var CodexAcpClient = class {
       effort,
       model: modelId.model
     });
-    return await this.codexClient.awaitTurnCompleted();
   }
   async listSkills(params) {
     return this.codexClient.listSkills(params ?? {});
@@ -19937,7 +19952,7 @@ var CodexAcpServer = class {
       logger.log(`Create new session...`);
       sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.newSession(request));
     }
-    const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    const account = await this.getActiveAccount();
     const { sessionId, currentModelId, models } = sessionMetadata;
     const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, "sessionId" in request);
     const currentModel = this.findCurrentModel(models, currentModelId);
@@ -19952,7 +19967,7 @@ var CodexAcpServer = class {
       totalTokenUsage: null,
       modelContextWindow: null,
       rateLimits: null,
-      account: accountResponse.account,
+      account,
       cwd: request.cwd,
       sessionMcpServers
     };
@@ -19969,6 +19984,13 @@ var CodexAcpServer = class {
     const sessionModeState = sessionState.agentMode.toSessionModeState();
     return [sessionId, sessionModelState, sessionModeState];
   }
+  async getActiveAccount() {
+    if (this.codexAcpClient.getModelProvider()) {
+      return null;
+    }
+    const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    return accountResponse.account;
+  }
   async loadSession(params) {
     logger.log("Loading session...", { sessionId: params.sessionId });
     const {
@@ -20108,7 +20130,7 @@ var CodexAcpServer = class {
     const sessionMetadata = await this.runWithProcessCheck(
       () => this.codexAcpClient.loadSession(request)
     );
-    const accountResponse = await this.runWithProcessCheck(() => this.codexAcpClient.getAccount());
+    const account = await this.getActiveAccount();
     const { sessionId, currentModelId, models, thread } = sessionMetadata;
     const sessionMcpServers = this.resolveSessionMcpServers(requestedMcpServers, true);
     const currentModel = this.findCurrentModel(models, currentModelId);
@@ -20123,7 +20145,7 @@ var CodexAcpServer = class {
       totalTokenUsage: null,
       modelContextWindow: null,
       rateLimits: null,
-      account: accountResponse.account,
+      account,
       cwd: request.cwd,
       sessionMcpServers
     };
@@ -20551,6 +20573,8 @@ var CodexAppServerClient = class {
   mcpServerStartupVersion = 0;
   mcpServerStartupStates = /* @__PURE__ */ new Map();
   mcpServerStartupResolvers = [];
+  pendingTurnCompletionResolvers = /* @__PURE__ */ new Map();
+  turnCompletionCaptures = /* @__PURE__ */ new Map();
   constructor(connection) {
     this.connection = connection;
     this.connection.onUnhandledNotification((data) => {
@@ -20564,6 +20588,9 @@ var CodexAppServerClient = class {
         });
         this.resolveMcpServerStartupResolvers();
       }
+      if (isTurnCompletedNotification(serverNotification)) {
+        this.recordTurnCompleted(serverNotification.params);
+      }
       this.notify(serverNotification);
       for (const callback of this.codexEventHandlers) {
         callback({ eventType: "notification", ...serverNotification });
@@ -20603,6 +20630,23 @@ var CodexAppServerClient = class {
   async turnStart(params) {
     return await this.sendRequest({ method: "turn/start", params });
   }
+  async runTurn(params) {
+    const capturedCompletions = [];
+    const releaseCapture = this.captureTurnCompletions(params.threadId, (event) => {
+      capturedCompletions.push(event);
+    });
+    try {
+      const turnStarted = await this.turnStart(params);
+      const earlyCompletion = capturedCompletions.find((event) => event.turn.id === turnStarted.turn.id);
+      releaseCapture();
+      if (earlyCompletion) {
+        return earlyCompletion;
+      }
+      return await this.awaitTurnCompleted(params.threadId, turnStarted.turn.id);
+    } finally {
+      releaseCapture();
+    }
+  }
   async turnInterrupt(params) {
     return await this.sendRequest({ method: "turn/interrupt", params });
   }
@@ -20657,11 +20701,10 @@ var CodexAppServerClient = class {
     return await this.sendRequest({ method: "account/read", params });
   }
   //TODO create type-safe helper
-  async awaitTurnCompleted() {
+  async awaitTurnCompleted(threadId, turnId) {
     return await new Promise((resolve) => {
-      this.connection.onNotification("turn/completed", (event) => {
-        resolve(event);
-      });
+      const threadResolvers = this.getOrCreatePendingTurnCompletionResolvers(threadId);
+      threadResolvers.set(turnId, resolve);
     });
   }
   async listModels(params = { cursor: null, limit: null }) {
@@ -20683,10 +20726,62 @@ var CodexAppServerClient = class {
   }
   notificationHandlers = /* @__PURE__ */ new Map();
   notify(notification) {
+    const threadId = extractThreadId(notification);
+    if (threadId !== null) {
+      const handler = this.notificationHandlers.get(threadId);
+      if (handler) {
+        handler(notification);
+      }
+      return;
+    }
     for (const notificationHandler of this.notificationHandlers.values()) {
       notificationHandler(notification);
     }
   }
+  recordTurnCompleted(event) {
+    const threadResolvers = this.pendingTurnCompletionResolvers.get(event.threadId);
+    const resolve = threadResolvers?.get(event.turn.id);
+    if (resolve) {
+      threadResolvers.delete(event.turn.id);
+      if (threadResolvers.size === 0) {
+        this.pendingTurnCompletionResolvers.delete(event.threadId);
+      }
+      resolve(event);
+      return;
+    }
+    const captures = this.turnCompletionCaptures.get(event.threadId);
+    if (!captures) {
+      return;
+    }
+    for (const capture of captures) {
+      capture(event);
+    }
+  }
+  getOrCreatePendingTurnCompletionResolvers(threadId) {
+    const existing = this.pendingTurnCompletionResolvers.get(threadId);
+    if (existing) {
+      return existing;
+    }
+    const created = /* @__PURE__ */ new Map();
+    this.pendingTurnCompletionResolvers.set(threadId, created);
+    return created;
+  }
+  captureTurnCompletions(threadId, capture) {
+    const captures = this.turnCompletionCaptures.get(threadId) ?? /* @__PURE__ */ new Set();
+    captures.add(capture);
+    this.turnCompletionCaptures.set(threadId, captures);
+    let released = false;
+    return () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      captures.delete(capture);
+      if (captures.size === 0) {
+        this.turnCompletionCaptures.delete(threadId);
+      }
+    };
+  }
   resolveMcpServerStartupResolvers() {
     const pendingResolvers = [];
     for (const resolver of this.mcpServerStartupResolvers) {
@@ -20746,6 +20841,16 @@ var CodexAppServerClient = class {
 function isMcpServerStatusUpdatedNotification(notification) {
   return notification.method === "mcpServer/startupStatus/updated";
 }
+function isTurnCompletedNotification(notification) {
+  return notification.method === "turn/completed";
+}
+function extractThreadId(notification) {
+  const params = notification.params;
+  if (params && typeof params.threadId === "string") {
+    return params.threadId;
+  }
+  return null;
+}
 
 // src/login.ts
 function parseArgs(args) {

package/package.json

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