@kodelyth/codex 2026.5.40 → 2026.5.42

package/src/app-server/delivery-no-reply-runtime-contract.test.ts

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import type { EmbeddedRunAttemptParams } from "klaw/plugin-sdk/agent-harness";
+import { DELIVERY_NO_REPLY_RUNTIME_CONTRACT } from "klaw/plugin-sdk/agent-runtime-test-contracts";
+import { isSilentReplyPayloadText } from "klaw/plugin-sdk/reply-chunking";
+import { afterEach, describe, expect, it } from "vitest";
+import { CodexAppServerEventProjector } from "./event-projector.js";
+import { createCodexTestModel } from "./test-support.js";
+
+const THREAD_ID = "thread-delivery-contract";
+const TURN_ID = "turn-delivery-contract";
+const tempDirs = new Set<string>();
+
+type ProjectorNotification = Parameters<CodexAppServerEventProjector["handleNotification"]>[0];
+
+async function createParams(): Promise<EmbeddedRunAttemptParams> {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "klaw-codex-delivery-contract-"));
+  tempDirs.add(tempDir);
+  const sessionFile = path.join(tempDir, "session.jsonl");
+  SessionManager.open(sessionFile);
+  return {
+    prompt: DELIVERY_NO_REPLY_RUNTIME_CONTRACT.prompt,
+    sessionId: DELIVERY_NO_REPLY_RUNTIME_CONTRACT.sessionId,
+    sessionKey: DELIVERY_NO_REPLY_RUNTIME_CONTRACT.sessionKey,
+    sessionFile,
+    workspaceDir: tempDir,
+    runId: DELIVERY_NO_REPLY_RUNTIME_CONTRACT.runId,
+    provider: "codex",
+    modelId: "gpt-5.4-codex",
+    model: createCodexTestModel("codex"),
+    thinkLevel: "medium",
+  } as EmbeddedRunAttemptParams;
+}
+
+function forCurrentTurn(
+  method: ProjectorNotification["method"],
+  params: Record<string, unknown>,
+): ProjectorNotification {
+  return {
+    method,
+    params: { threadId: THREAD_ID, turnId: TURN_ID, ...params },
+  } as ProjectorNotification;
+}
+
+afterEach(async () => {
+  for (const tempDir of tempDirs) {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+  tempDirs.clear();
+});
+
+describe("Delivery/NO_REPLY runtime contract - Codex app-server adapter", () => {
+  it.each([
+    DELIVERY_NO_REPLY_RUNTIME_CONTRACT.silentText,
+    `  ${DELIVERY_NO_REPLY_RUNTIME_CONTRACT.silentText}  `,
+    DELIVERY_NO_REPLY_RUNTIME_CONTRACT.jsonSilentText,
+  ])("preserves silent terminal text %s for shared delivery suppression", async (text) => {
+    const projector = new CodexAppServerEventProjector(await createParams(), THREAD_ID, TURN_ID);
+    await projector.handleNotification(
+      forCurrentTurn("item/agentMessage/delta", {
+        itemId: "msg-1",
+        delta: text,
+      }),
+    );
+
+    const result = projector.buildResult({
+      didSendViaMessagingTool: false,
+      messagingToolSentTexts: [],
+      messagingToolSentMediaUrls: [],
+      messagingToolSentTargets: [],
+      toolMediaUrls: [],
+      toolAudioAsVoice: false,
+    });
+
+    expect(result.assistantTexts).toEqual([text.trim()]);
+    expect(isSilentReplyPayloadText(result.assistantTexts[0])).toBe(true);
+  });
+});

package/src/app-server/dynamic-tool-diagnostics.ts

@@ -0,0 +1,73 @@
+import { emitTrustedDiagnosticEvent } from "klaw/plugin-sdk/diagnostic-runtime";
+import type { CodexDynamicToolCallParams, CodexDynamicToolCallResponse } from "./protocol.js";
+
+type DynamicToolDiagnosticContext = {
+  call: CodexDynamicToolCallParams;
+  runId?: string | undefined;
+  sessionId?: string | undefined;
+  sessionKey?: string | undefined;
+};
+
+export function emitDynamicToolStartedDiagnostic(params: DynamicToolDiagnosticContext): void {
+  emitTrustedDiagnosticEvent({
+    type: "tool.execution.started",
+    runId: params.runId,
+    sessionId: params.sessionId,
+    sessionKey: params.sessionKey,
+    toolName: params.call.tool,
+    toolCallId: params.call.callId,
+  });
+}
+
+export function emitDynamicToolErrorDiagnostic(
+  params: DynamicToolDiagnosticContext & {
+    durationMs: number;
+  },
+): void {
+  emitTrustedDiagnosticEvent({
+    type: "tool.execution.error",
+    runId: params.runId,
+    sessionId: params.sessionId,
+    sessionKey: params.sessionKey,
+    toolName: params.call.tool,
+    toolCallId: params.call.callId,
+    durationMs: params.durationMs,
+    errorCategory: "codex_dynamic_tool_error",
+  });
+}
+
+export function emitDynamicToolTerminalDiagnostic(
+  params: DynamicToolDiagnosticContext & {
+    response: CodexDynamicToolCallResponse;
+    durationMs: number;
+  },
+): void {
+  const terminalType =
+    params.response.diagnosticTerminalType ?? (params.response.success ? "completed" : "error");
+  if (terminalType === "completed") {
+    emitTrustedDiagnosticEvent({
+      type: "tool.execution.completed",
+      runId: params.runId,
+      sessionId: params.sessionId,
+      sessionKey: params.sessionKey,
+      toolName: params.call.tool,
+      toolCallId: params.call.callId,
+      durationMs: params.durationMs,
+    });
+    return;
+  }
+  if (terminalType === "blocked") {
+    emitTrustedDiagnosticEvent({
+      type: "tool.execution.blocked",
+      runId: params.runId,
+      sessionId: params.sessionId,
+      sessionKey: params.sessionKey,
+      toolName: params.call.tool,
+      toolCallId: params.call.callId,
+      deniedReason: "plugin-before-tool-call",
+      reason: "Tool call blocked",
+    });
+    return;
+  }
+  emitDynamicToolErrorDiagnostic(params);
+}

package/src/app-server/dynamic-tool-profile.ts

@@ -0,0 +1,69 @@
+import type { CodexDynamicToolsLoading, CodexPluginConfig } from "./config.js";
+
+export const CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES = [
+  "read",
+  "write",
+  "edit",
+  "apply_patch",
+  "exec",
+  "process",
+  "update_plan",
+  "tool_call",
+  "tool_describe",
+  "tool_search",
+  "tool_search_code",
+] as const;
+
+const DYNAMIC_TOOL_NAME_ALIASES: Record<string, string> = {
+  bash: "exec",
+  "apply-patch": "apply_patch",
+};
+
+type CodexDynamicToolProfileEnv = {
+  KLAW_BUILD_PRIVATE_QA?: string;
+  KLAW_QA_FORCE_RUNTIME?: string;
+};
+
+export function normalizeCodexDynamicToolName(name: string): string {
+  const normalized = name.trim().toLowerCase();
+  return DYNAMIC_TOOL_NAME_ALIASES[normalized] ?? normalized;
+}
+
+export function isForcedPrivateQaCodexRuntime(
+  env: CodexDynamicToolProfileEnv = process.env,
+): boolean {
+  return (
+    env.KLAW_BUILD_PRIVATE_QA === "1" && env.KLAW_QA_FORCE_RUNTIME?.trim().toLowerCase() === "codex"
+  );
+}
+
+export function resolveCodexDynamicToolsLoading(
+  config: Pick<CodexPluginConfig, "codexDynamicToolsLoading">,
+  env: CodexDynamicToolProfileEnv = process.env,
+): CodexDynamicToolsLoading {
+  return isForcedPrivateQaCodexRuntime(env)
+    ? "direct"
+    : (config.codexDynamicToolsLoading ?? "searchable");
+}
+
+export function filterCodexDynamicTools<T extends { name: string }>(
+  tools: T[],
+  config: Pick<CodexPluginConfig, "codexDynamicToolsExclude">,
+  env: CodexDynamicToolProfileEnv = process.env,
+): T[] {
+  const excludes = new Set<string>();
+  if (!isForcedPrivateQaCodexRuntime(env)) {
+    for (const name of CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES) {
+      excludes.add(name);
+    }
+  }
+  for (const name of config.codexDynamicToolsExclude ?? []) {
+    const trimmed = normalizeCodexDynamicToolName(name);
+    if (trimmed) {
+      excludes.add(trimmed);
+    }
+  }
+  return excludes.size === 0
+    ? tools
+    : tools.filter((tool) => !excludes.has(normalizeCodexDynamicToolName(tool.name)));
+}