mcp-codex-worker 0.1.19 → 0.1.21

package/src/app.ts

@@ -1,28 +1,13 @@
 import {
   createToolDefinitions,
-  type RequestRespondInput,
-  type ThreadListInput,
-  type ThreadReadInput,
-  type ThreadResumeInput,
-  type ThreadStartInput,
   type ToolDefinition,
-  type TurnInterruptInput,
-  type TurnStartInput,
-  type TurnSteerInput,
-  type WaitInput,
   type SpawnTaskInput,
   type WaitTaskInput,
   type RespondTaskInput,
   type MessageTaskInput,
   type CancelTaskInput,
 } from './mcp/tool-definitions.js';
-import { buildRequestBanner, buildThreadBanner } from './mcp/tool-banners.js';
-import {
-  renderRequestListMarkdown,
-  renderThreadListMarkdown,
-  renderThreadMarkdown,
-} from './mcp/task-markdown.js';
-import { OPERATION_BRIDGE_TIMEOUT_MS, OPERATION_POLL_INTERVAL_MS, REQUEST_TIMEOUT_MS } from './config/defaults.js';
+import { OPERATION_BRIDGE_TIMEOUT_MS, OPERATION_POLL_INTERVAL_MS } from './config/defaults.js';
 import { CodexRuntime } from './services/codex-runtime.js';
 import { TaskManager } from './task/task-manager.js';
 import type { TaskState } from './task/task-state.js';
@@ -38,6 +23,7 @@ import {
   renderVerboseLog,
 } from './mcp/resource-renderers.js';
 import { validateResponseAgainstCapabilities } from './execution/provider-capabilities.js';
+// Persistence utilities — re-exported for external use; not called directly in this module.
 import { saveState, loadState, persistenceDir, applyRecovery } from './task/task-persistence.js';
 
 export interface ResourceDefinition {
@@ -72,45 +58,11 @@ export class CodexWorkerApp {
   }
 
   async listTools(): Promise<ToolDefinition[]> {
-    try {
-      const modelIds = await this.runtime.listVisibleModelIds();
-      return createToolDefinitions({
-        modelIds,
-        threadBanner: buildThreadBanner(this.runtime),
-        requestBanner: buildRequestBanner(this.runtime),
-      });
-    } catch {
-      return createToolDefinitions({ modelIds: [], threadBanner: '', requestBanner: '' });
-    }
+    return createToolDefinitions();
   }
 
   listResources(): ResourceDefinition[] {
-    const base: ResourceDefinition[] = [
-      {
-        uri: 'codex://threads',
-        name: 'Codex Threads',
-        description: 'All tracked threads with status',
-        mimeType: 'text/markdown',
-      },
-      {
-        uri: 'codex://models',
-        name: 'Codex Models',
-        description: 'Visible models from `model/list`',
-        mimeType: 'application/json',
-      },
-      {
-        uri: 'codex://account',
-        name: 'Codex Account',
-        description: 'Account data from `account/read`',
-        mimeType: 'application/json',
-      },
-      {
-        uri: 'codex://requests',
-        name: 'Codex Requests',
-        description: 'Pending server requests from app-server',
-        mimeType: 'application/json',
-      },
-    ];
+    const base: ResourceDefinition[] = [];
 
     // Task tracking resources
     base.push(
@@ -160,23 +112,6 @@ export class CodexWorkerApp {
       }
     }
 
-    for (const threadId of this.runtime.listKnownThreadIds()) {
-      base.push(
-        {
-          uri: `codex://thread/${threadId}`,
-          name: `Thread ${threadId}`,
-          description: 'Thread status and guidance',
-          mimeType: 'text/markdown',
-        },
-        {
-          uri: `codex://thread/${threadId}/events`,
-          name: `Thread ${threadId} events`,
-          description: 'Observed notifications for this thread',
-          mimeType: 'application/json',
-        },
-      );
-    }
-
     return base;
   }
 
@@ -223,81 +158,6 @@ export class CodexWorkerApp {
       return { mimeType: 'text/markdown', text: renderTaskDetail(task) };
     }
 
-    // ---- Legacy codex:// resources ----
-    if (uri === 'codex://threads') {
-      const response = await this.runtime.request('thread/list', { limit: 50 }) as {
-        data?: Array<{ id?: string }>;
-      };
-      for (const row of response.data ?? []) {
-        if (typeof row.id === 'string') {
-          this.runtime.rememberThreadId(row.id);
-        }
-      }
-      return {
-        mimeType: 'text/markdown',
-        text: renderThreadListMarkdown(
-          response.data ?? [],
-          this.runtime.getPendingServerRequests(false),
-        ),
-      };
-    }
-
-    if (uri === 'codex://models') {
-      return {
-        mimeType: 'application/json',
-        text: JSON.stringify({ data: await this.runtime.listModels(false) }, null, 2),
-      };
-    }
-
-    if (uri === 'codex://account') {
-      const [account, limits] = await Promise.all([
-        this.runtime.request('account/read', {}),
-        this.runtime.request('account/rateLimits/read', {}),
-      ]);
-      return {
-        mimeType: 'application/json',
-        text: JSON.stringify({ account, rate_limits: limits }, null, 2),
-      };
-    }
-
-    if (uri === 'codex://requests') {
-      return {
-        mimeType: 'application/json',
-        text: JSON.stringify({
-          requests: this.runtime.getPendingServerRequests(false),
-        }, null, 2),
-      };
-    }
-
-    const threadEventsMatch = /^codex:\/\/thread\/([^/]+)\/events$/.exec(uri);
-    if (threadEventsMatch) {
-      const threadId = decodeURIComponent(threadEventsMatch[1]!);
-      return {
-        mimeType: 'application/json',
-        text: JSON.stringify({
-          thread_id: threadId,
-          events: await this.runtime.getThreadEvents(threadId),
-        }, null, 2),
-      };
-    }
-
-    const threadMatch = /^codex:\/\/thread\/([^/]+)$/.exec(uri);
-    if (threadMatch) {
-      const threadId = decodeURIComponent(threadMatch[1]!);
-      const response = await this.runtime.request('thread/read', {
-        threadId,
-        includeTurns: true,
-      });
-      return {
-        mimeType: 'text/markdown',
-        text: renderThreadMarkdown(
-          response,
-          this.runtime.getOperationsForThread(threadId),
-          this.runtime.getPendingServerRequests(false),
-        ),
-      };
-    }
-
     return {
       mimeType: 'application/json',
       text: JSON.stringify({ error: `Unknown resource URI: ${uri}` }, null, 2),
@@ -312,30 +172,6 @@ export class CodexWorkerApp {
     }
     const validated = tool.validate(args ?? {});
     switch (name) {
-      case 'codex-thread-start':
-        return this.handleThreadStart(validated as ThreadStartInput);
-      case 'codex-thread-resume':
-        return this.handleThreadResume(validated as ThreadResumeInput);
-      case 'codex-thread-read':
-        return this.handleThreadRead(validated as ThreadReadInput);
-      case 'codex-thread-list':
-        return this.handleThreadList(validated as ThreadListInput);
-      case 'codex-turn-start':
-        return this.handleTurnStart(validated as TurnStartInput);
-      case 'codex-turn-steer':
-        return this.handleTurnSteer(validated as TurnSteerInput);
-      case 'codex-turn-interrupt':
-        return this.handleTurnInterrupt(validated as TurnInterruptInput);
-      case 'codex-request-list':
-        return renderRequestListMarkdown(
-          this.runtime.getPendingServerRequests(
-            Boolean((validated as { include_resolved?: boolean }).include_resolved),
-          ),
-        );
-      case 'codex-request-respond':
-        return this.handleRequestRespond(validated as RequestRespondInput);
-      case 'codex-wait':
-        return this.handleWait(validated as WaitInput);
       case 'spawn-task':
         return this.handleSpawnTask(validated as SpawnTaskInput);
       case 'wait-task':
@@ -351,270 +187,8 @@ export class CodexWorkerApp {
     }
   }
 
-  private async handleThreadStart(input: ThreadStartInput): Promise<string> {
-    const built = await this.runtime.buildThreadStartParams({
-      model: input.model,
-      cwd: input.cwd,
-      developerInstructions: input.developer_instructions,
-    });
-    const response = await this.runtime.request('thread/start', built.params);
-    const threadId = (response as { thread?: { id?: string } }).thread?.id;
-    if (threadId) {
-      this.runtime.rememberThreadId(threadId);
-    }
-
-    const remapNote = built.remappedFrom ? ` (remapped from ${built.remappedFrom})` : '';
-    const modelLine = built.params.model
-      ? `model: \`${built.params.model as string}\`${remapNote}`
-      : `model: server default${remapNote}`;
-    return [
-      `**Thread started**`,
-      `thread_id: \`${threadId ?? 'unknown'}\``,
-      modelLine,
-      '',
-      '**What to do next:**',
-      `- Use \`codex-turn-start\` with \`thread_id: "${threadId}"\` to send the agent its task.`,
-      '- After starting a turn, use `codex-wait` with `operation_id` to block until it finishes or asks for approval.',
-      '- Check `codex-request-list` after starting turns -- agents often need approval for commands or file changes.',
-    ].join('\n');
-  }
-
-  private async handleThreadResume(input: ThreadResumeInput): Promise<string> {
-    const built = await this.runtime.buildThreadResumeParams({
-      threadId: input.thread_id,
-      model: input.model,
-      cwd: input.cwd,
-      developerInstructions: input.developer_instructions,
-    });
-    await this.runtime.request('thread/resume', built.params);
-    this.runtime.rememberThreadId(input.thread_id);
-
-    return [
-      `**Thread resumed**`,
-      `thread_id: \`${input.thread_id}\``,
-      '',
-      '**What to do next:**',
-      '- Use `codex-turn-start` to send a new task to this thread.',
-      '- The thread\'s previous context is loaded -- the agent remembers prior conversation.',
-    ].join('\n');
-  }
-
-  private async handleThreadRead(input: ThreadReadInput): Promise<string> {
-    const response = await this.runtime.request('thread/read', {
-      threadId: input.thread_id,
-      includeTurns: input.include_turns ?? true,
-    });
-    this.runtime.rememberThreadId(input.thread_id);
-    return renderThreadMarkdown(
-      response,
-      this.runtime.getOperationsForThread(input.thread_id),
-      this.runtime.getPendingServerRequests(false),
-    );
-  }
-
-  private async handleThreadList(input: ThreadListInput): Promise<string> {
-    const response = await this.runtime.request('thread/list', {
-      limit: input.limit,
-      cursor: input.cursor ?? null,
-    }) as {
-      data?: Array<{ id?: string }>;
-    };
-    for (const row of response.data ?? []) {
-      if (typeof row.id === 'string') {
-        this.runtime.rememberThreadId(row.id);
-      }
-    }
-    return renderThreadListMarkdown(
-      response.data ?? [],
-      this.runtime.getPendingServerRequests(false),
-    );
-  }
-
-  private async handleTurnStart(input: TurnStartInput): Promise<string> {
-    const built = await this.runtime.buildTurnStartParams({
-      threadId: input.thread_id,
-      userInput: input.user_input,
-      model: input.model,
-    });
-    await this.runtime.ensureThreadLoaded(input.thread_id, input.model);
-    const bridged = await this.runtime.requestWithBridge('turn/start', built.params, {
-      threadId: input.thread_id,
-    });
-
-    const remapNote = built.remappedFrom ? ` (remapped from ${built.remappedFrom})` : '';
-    const header = [
-      `thread_id: \`${input.thread_id}\``,
-      `operation_id: \`${bridged.operationId}\`${remapNote}`,
-    ];
-
-    if (bridged.status === 'pending_request') {
-      const reqCount = bridged.pendingRequestIds?.length ?? 0;
-      return [
-        `**Turn started -- approval needed**`,
-        ...header,
-        `pending_requests: ${reqCount}`,
-        '',
-        '**ACTION REQUIRED:**',
-        'The agent needs approval before it can proceed. Use `codex-request-list` to see what it needs, then `codex-request-respond` to approve or decline.',
-        '',
-        '**After approving:**',
-        `Use \`codex-wait\` with \`operation_id: "${bridged.operationId}"\` to block until the turn completes.`,
-      ].join('\n');
-    }
-
-    if (bridged.status === 'completed') {
-      return [
-        `**Turn completed**`,
-        ...header,
-        '',
-        '**What to do next:**',
-        `- Use \`codex-thread-read\` with \`thread_id: "${input.thread_id}"\` to inspect the agent's output and file changes.`,
-        '- Use `codex-turn-start` to send follow-up instructions.',
-      ].join('\n');
-    }
-
-    return [
-      `**Turn started -- agent working**`,
-      ...header,
-      '',
-      '**What to do next:**',
-      `- Use \`codex-wait\` with \`operation_id: "${bridged.operationId}"\` to block until the agent finishes or asks for approval.`,
-      '- Check `codex-request-list` for any pending approvals.',
-      '- For parallel work, start turns on other threads now.',
-    ].join('\n');
-  }
-
-  private async handleTurnSteer(input: TurnSteerInput): Promise<string> {
-    const params = this.runtime.buildTurnSteerParams({
-      threadId: input.thread_id,
-      expectedTurnId: input.expected_turn_id,
-      userInput: input.user_input,
-    });
-    const bridged = await this.runtime.requestWithBridge('turn/steer', params, {
-      threadId: input.thread_id,
-    });
-
-    return [
-      `**Turn steered**`,
-      `thread_id: \`${input.thread_id}\``,
-      `operation_id: \`${bridged.operationId}\``,
-      '',
-      'The agent is adjusting course with your new instructions.',
-      `Use \`codex-wait\` with \`operation_id: "${bridged.operationId}"\` to block until it finishes.`,
-    ].join('\n');
-  }
-
-  private async handleTurnInterrupt(input: TurnInterruptInput): Promise<string> {
-    await this.runtime.request('turn/interrupt', {
-      threadId: input.thread_id,
-      turnId: input.turn_id,
-    });
-
-    return [
-      `**Turn interrupted**`,
-      `thread_id: \`${input.thread_id}\``,
-      `turn_id: \`${input.turn_id}\``,
-      '',
-      'The turn has been stopped. Use `codex-turn-start` to begin a new turn with corrected instructions.',
-    ].join('\n');
-  }
-
-  private async handleRequestRespond(input: RequestRespondInput): Promise<string> {
-    const pending = this.runtime.getPendingServerRequest(input.request_id);
-    if (!pending) {
-      throw new Error(`Pending server request not found: ${String(input.request_id)}`);
-    }
-
-    const payload = this.buildServerRequestPayload(pending.method, input);
-    await this.runtime.respondToServerRequest(input.request_id, payload);
-
-    return [
-      `**Request responded**`,
-      `request_id: \`${String(input.request_id)}\``,
-      `method: \`${pending.method}\``,
-      '',
-      '**What to do next:**',
-      '- The agent will continue working. Use `codex-wait` to block until it finishes or needs another approval.',
-      '- Check `codex-request-list` for any remaining pending requests.',
-    ].join('\n');
-  }
-
-  private async handleWait(input: WaitInput): Promise<string> {
-    const timeoutMs = input.timeout_ms ?? REQUEST_TIMEOUT_MS;
-    const pollIntervalMs = input.poll_interval_ms ?? OPERATION_POLL_INTERVAL_MS;
-
-    if (input.operation_id) {
-      const operation = await this.runtime.waitForOperation(input.operation_id, timeoutMs, pollIntervalMs);
-      const threadId = operation.threadId ?? 'unknown';
-
-      if (operation.status === 'failed') {
-        return [
-          `**Operation failed**`,
-          `operation_id: \`${operation.operationId}\``,
-          `error: ${operation.error ?? 'unknown error'}`,
-          '',
-          '**What to do next:**',
-          `- Use \`codex-thread-read\` with \`thread_id: "${threadId}"\` to inspect what happened.`,
-          '- Fix the issue and use `codex-turn-start` to retry.',
-        ].join('\n');
-      }
-
-      if (operation.pendingRequestIds.length > 0) {
-        return [
-          `**Operation paused -- approval needed**`,
-          `operation_id: \`${operation.operationId}\``,
-          `pending_requests: ${operation.pendingRequestIds.length}`,
-          '',
-          '**ACTION REQUIRED:**',
-          'Use `codex-request-list` to see what the agent needs, then `codex-request-respond` to approve.',
-          `After approving, call \`codex-wait\` again with \`operation_id: "${operation.operationId}"\`.`,
-        ].join('\n');
-      }
-
-      return [
-        `**Operation completed**`,
-        `operation_id: \`${operation.operationId}\``,
-        `thread_id: \`${threadId}\``,
-        '',
-        '**What to do next:**',
-        `- Use \`codex-thread-read\` with \`thread_id: "${threadId}"\` to inspect the agent's output.`,
-        '- Use `codex-turn-start` to send follow-up instructions.',
-      ].join('\n');
-    }
-
-    if (input.thread_id) {
-      const start = Date.now();
-      while (Date.now() - start <= timeoutMs) {
-        const response = await this.runtime.request('thread/read', {
-          threadId: input.thread_id,
-          includeTurns: false,
-        }) as {
-          thread?: {
-            status?: { type?: string };
-          };
-        };
-        const statusType = response.thread?.status?.type;
-        if (statusType !== 'active') {
-          return [
-            `**Thread idle**`,
-            `thread_id: \`${input.thread_id}\``,
-            `status: \`${statusType ?? 'unknown'}\``,
-            '',
-            '**What to do next:**',
-            `- Use \`codex-thread-read\` with \`thread_id: "${input.thread_id}"\` to review the agent's work.`,
-            '- Use `codex-turn-start` to send another task.',
-          ].join('\n');
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      }
-      throw new Error(`Timed out waiting for thread ${input.thread_id}`);
-    }
-
-    return renderRequestListMarkdown(this.runtime.getPendingServerRequests(false));
-  }
-
   // ---------------------------------------------------------------------------
-  // New unified task tool handlers
+  // Unified task tool handlers
   // ---------------------------------------------------------------------------
 
   private async handleSpawnTask(input: SpawnTaskInput): Promise<string> {
@@ -909,47 +483,4 @@ export class CodexWorkerApp {
       ...(notFound.length > 0 ? { not_found: notFound } : {}),
     }, null, 2);
   }
-
-  private buildServerRequestPayload(method: string, input: RequestRespondInput): unknown {
-    if (input.payload) {
-      return input.payload;
-    }
-
-    switch (method) {
-      case 'item/commandExecution/requestApproval':
-      case 'item/fileChange/requestApproval':
-        return {
-          decision: input.decision ?? 'accept',
-        };
-      case 'item/tool/requestUserInput':
-        return {
-          answers: input.answers ?? {},
-        };
-      case 'mcpServer/elicitation/request':
-        return {
-          action: input.action ?? 'accept',
-          content: input.content ?? null,
-          _meta: input.meta ?? null,
-        };
-      case 'item/permissions/requestApproval':
-        return {
-          permissions: input.permissions ?? {},
-          scope: input.scope ?? 'session',
-        };
-      case 'item/tool/call':
-        return {
-          contentItems: [],
-          success: true,
-        };
-      case 'applyPatchApproval':
-      case 'execCommandApproval':
-        return {
-          decision: input.decision ?? 'approved',
-        };
-      default:
-        throw new Error(
-          `No default response payload for request method ${method}. Provide payload explicitly.`,
-        );
-    }
-  }
 }