harness-mix 0.1.0

package/src/native-ui/renderer-extension/src/renderer-model-client.ts

@@ -0,0 +1,567 @@
+import {
+  harnessAccountListResultSchema,
+  type HarnessAccountListResult,
+  codexAccountUsageParamsSchema,
+  codexAccountUsageResultSchema,
+  codexAccountResetCreditConsumeParamsSchema,
+  codexAccountResetCreditConsumeResultSchema,
+  type CodexAccountUsageParams,
+  type CodexAccountUsageResult,
+  type CodexAccountResetCreditConsumeParams,
+  type CodexAccountResetCreditConsumeResult,
+  codexAccountActivateParamsSchema,
+  codexAccountCreateParamsSchema,
+  codexAccountDeleteParamsSchema,
+  codexAccountDeleteResultSchema,
+  codexAccountListResultSchema,
+  codexAccountLoginCancelParamsSchema,
+  codexAccountLoginCancelResultSchema,
+  codexAccountLoginCompletedSchema,
+  codexAccountLoginStartParamsSchema,
+  codexAccountLoginStartResultSchema,
+  codexAccountMutationResultSchema,
+  externalThreadForkParamsSchema,
+  externalThreadForkResultSchema,
+  harnessCommandCatalogSchema,
+  harnessCommandsInspectParamsSchema,
+  harnessConfigurationStateSchema,
+  harnessInspectParamsSchema,
+  harnessInspectionSchema,
+  harnessPluginListResultSchema,
+  type HarnessPluginListResult,
+  harnessWebUiOpenParamsSchema,
+  harnessWebUiOpenResultSchema,
+  harnessModelSelectionStateSchema,
+  hostThreadIdSchema,
+  threadInspectionParamsSchema,
+  threadInspectionSchema,
+  threadCommandExecuteParamsSchema,
+  threadCommandExecuteResultSchema,
+  threadCommandsInspectParamsSchema,
+  threadDelegateParamsSchema,
+  threadDelegationResultSchema,
+  threadHarnessSwitchParamsSchema,
+  threadHarnessSwitchResultSchema,
+  threadMessageParamsSchema,
+  threadModelSelectParamsSchema,
+  threadPermissionModeSelectParamsSchema,
+  threadThinkingSelectParamsSchema,
+  threadOwnershipListParamsSchema,
+  threadOwnershipListResultSchema,
+  threadUsageInspectionParamsSchema,
+  threadUsageInspectionSchema,
+  updateCheckResultSchema,
+  updateEmptyParamsSchema,
+  updateStartResultSchema,
+  updateStatusResultSchema,
+  type ExternalThreadForkParams,
+  type ExternalThreadForkResult,
+  type CodexAccountActivateParams,
+  type CodexAccountCreateParams,
+  type CodexAccountDeleteParams,
+  type CodexAccountDeleteResult,
+  type CodexAccountListResult,
+  type CodexAccountLoginCancelParams,
+  type CodexAccountLoginCancelResult,
+  type CodexAccountLoginCompleted,
+  type CodexAccountLoginStartParams,
+  type CodexAccountLoginStartResult,
+  type CodexAccountMutationResult,
+  type HarnessCommandCatalog,
+  type HarnessCommandsInspectParams,
+  type HarnessConfigurationState,
+  type HarnessInspection,
+  type HarnessInspectParams,
+  type HarnessWebUiOpenParams,
+  type HarnessModelSelectionState,
+  type ThreadInspection,
+  type ThreadInspectionParams,
+  type ThreadCommandExecuteParams,
+  type ThreadCommandExecuteResult,
+  type ThreadCommandsInspectParams,
+  type ThreadDelegateParams,
+  type ThreadDelegationResult,
+  type ThreadHarnessSwitchParams,
+  type ThreadHarnessSwitchResult,
+  type ThreadMessageParams,
+  type ThreadModelSelectParams,
+  type ThreadPermissionModeSelectParams,
+  type ThreadThinkingSelectParams,
+  type ThreadOwnershipListParams,
+  type ThreadOwnershipListResult,
+  type ThreadUsageInspection,
+  type ThreadUsageInspectionParams,
+  type UpdateCheckResult,
+  type UpdateStartResult,
+  type UpdateStatusResult,
+} from "@codexhost/shared-contracts";
+
+import {
+  createRendererRequestSender,
+  RendererMethodUnavailableError,
+} from "./renderer-request-sender.js";
+import {
+  createRendererSessionImportClient,
+  type RendererSessionImportClient,
+} from "./renderer-session-import-client.js";
+
+export const HARNESS_INSPECT_METHOD = "codexhost/harness/inspect";
+export const HARNESS_INSTALL_METHOD = "codexhost/harness/install";
+export const HARNESS_PLUGIN_LIST_METHOD = "codexhost/harness/plugins/list";
+export const HARNESS_WEB_UI_OPEN_METHOD = "codexhost/harness/web-ui/open";
+export const THREAD_FORK_METHOD = "codexhost/thread/fork";
+export const THREAD_HARNESS_SWITCH_METHOD = "codexhost/thread/harness/switch";
+export const THREAD_INSPECT_METHOD = "codexhost/thread/inspect";
+export const HARNESS_COMMANDS_INSPECT_METHOD = "codexhost/harness/commands/inspect";
+export const THREAD_COMMANDS_INSPECT_METHOD = "codexhost/thread/commands/inspect";
+export const THREAD_COMMAND_EXECUTE_METHOD = "codexhost/thread/command/execute";
+export const THREAD_DELEGATE_METHOD = "codexhost/thread/delegate";
+export const THREAD_MESSAGE_METHOD = "codexhost/thread/message";
+export const THREAD_MODEL_SELECT_METHOD = "codexhost/thread/model/select";
+export const THREAD_THINKING_SELECT_METHOD = "codexhost/thread/thinking/select";
+export const THREAD_PERMISSION_MODE_SELECT_METHOD = "codexhost/thread/permission-mode/select";
+export const THREAD_OWNERSHIP_LIST_METHOD = "codexhost/thread/ownership/list";
+export const THREAD_USAGE_INSPECT_METHOD = "codexhost/thread/usage/inspect";
+export const THREAD_USAGE_UPDATED_METHOD = "codexhost/thread/usage/updated";
+export const THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
+export const UPDATE_CHECK_METHOD = "codexhost/update/check";
+export const UPDATE_START_METHOD = "codexhost/update/start";
+export const UPDATE_STATUS_METHOD = "codexhost/update/status";
+export const CODEX_ACCOUNT_LIST_METHOD = "codexhost/account/list";
+export const CODEX_ACCOUNT_REFRESH_METHOD = "codexhost/account/refresh";
+export const CODEX_ACCOUNT_CREATE_METHOD = "codexhost/account/create";
+export const CODEX_ACCOUNT_DELETE_METHOD = "codexhost/account/delete";
+export const CODEX_ACCOUNT_ACTIVATE_METHOD = "codexhost/account/activate";
+export const CODEX_ACCOUNT_LOGIN_START_METHOD = "codexhost/account/login/start";
+export const CODEX_ACCOUNT_LOGIN_CANCEL_METHOD = "codexhost/account/login/cancel";
+export const CODEX_ACCOUNT_LOGIN_COMPLETED_METHOD = "codexhost/account/login/completed";
+export const CODEX_ACCOUNT_RESET_CREDIT_CONSUME_METHOD =
+  "codexhost/account/rate-limit-reset/consume";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function notifiedThreadId(notification: unknown): ThreadUsageInspectionParams["threadId"] | null {
+  if (
+    !isRecord(notification) ||
+    (notification.method !== THREAD_TOKEN_USAGE_UPDATED_METHOD &&
+      notification.method !== THREAD_USAGE_UPDATED_METHOD)
+  ) {
+    return null;
+  }
+  const params = notification.params;
+  if (!isRecord(params)) return null;
+  const parsed = hostThreadIdSchema.safeParse(params.threadId);
+  return parsed.success ? parsed.data : null;
+}
+
+interface RequestManagerCandidate {
+  addNotificationCallback?: (
+    method: string | readonly string[],
+    callback: (notification: unknown) => void,
+  ) => () => void;
+  sendRequest?: (method: string, params: unknown, options?: unknown) => Promise<unknown> | unknown;
+  requestClient?: RequestManagerCandidate;
+}
+
+function notificationTarget(manager: RequestManagerCandidate): RequestManagerCandidate | null {
+  if (typeof manager.addNotificationCallback === "function") return manager;
+  const nested = manager.requestClient;
+  return nested && typeof nested.addNotificationCallback === "function" ? nested : null;
+}
+
+export interface RendererModelClient extends Partial<RendererSessionImportClient> {
+  listCollaborationAgents?(): Promise<Array<{ id: string; name: string; available: boolean; lead: boolean }>>;
+  currentHostId?(): string | null;
+  listHarnessPlugins?(): Promise<HarnessPluginListResult>;
+  clientForHost?(hostId: string): RendererModelClient | null;
+  forkThread(input: ExternalThreadForkParams): Promise<ExternalThreadForkResult>;
+  switchHarness(input: ThreadHarnessSwitchParams): Promise<ThreadHarnessSwitchResult>;
+  inspectHarness(input: HarnessInspectParams): Promise<HarnessInspection>;
+  installHarness?(input: { harnessId: string }): Promise<{ success: boolean; command?: string; stdout?: string; stderr?: string; error?: string }>;
+  openHarnessWebUi?(input: HarnessWebUiOpenParams): Promise<void>;
+  inspectThread(input: ThreadInspectionParams): Promise<ThreadInspection>;
+  inspectHarnessCommands(input: HarnessCommandsInspectParams): Promise<HarnessCommandCatalog>;
+  inspectThreadCommands(input: ThreadCommandsInspectParams): Promise<HarnessCommandCatalog>;
+  executeThreadCommand(input: ThreadCommandExecuteParams): Promise<ThreadCommandExecuteResult>;
+  listThreadOwnership(input: ThreadOwnershipListParams): Promise<ThreadOwnershipListResult>;
+  inspectThreadUsage(input: ThreadUsageInspectionParams): Promise<ThreadUsageInspection>;
+  subscribeThreadUsage?(listener: (update: ThreadUsageInspection) => void): () => void;
+  selectThreadModel(input: ThreadModelSelectParams): Promise<HarnessModelSelectionState>;
+  selectThreadThinking(input: ThreadThinkingSelectParams): Promise<HarnessModelSelectionState>;
+  selectThreadPermissionMode(
+    input: ThreadPermissionModeSelectParams,
+  ): Promise<HarnessConfigurationState>;
+  checkUpdate(): Promise<UpdateCheckResult>;
+  startUpdate(): Promise<UpdateStartResult>;
+  readUpdateStatus(): Promise<UpdateStatusResult>;
+  inspectCodexAccountUsage?(input: CodexAccountUsageParams): Promise<CodexAccountUsageResult>;
+  consumeCodexAccountResetCredit?(
+    input: CodexAccountResetCreditConsumeParams,
+  ): Promise<CodexAccountResetCreditConsumeResult>;
+  listHarnessAccounts?(): Promise<HarnessAccountListResult>;
+  listCodexAccounts(): Promise<CodexAccountListResult>;
+  refreshCodexAccounts(): Promise<CodexAccountListResult>;
+  createCodexAccount(input: CodexAccountCreateParams): Promise<CodexAccountMutationResult>;
+  deleteCodexAccount(input: CodexAccountDeleteParams): Promise<CodexAccountDeleteResult>;
+  activateCodexAccount(input: CodexAccountActivateParams): Promise<CodexAccountMutationResult>;
+  startCodexAccountLogin(
+    input: CodexAccountLoginStartParams,
+  ): Promise<CodexAccountLoginStartResult>;
+  cancelCodexAccountLogin(
+    input: CodexAccountLoginCancelParams,
+  ): Promise<CodexAccountLoginCancelResult>;
+  subscribeCodexAccountLogin(listener: (result: CodexAccountLoginCompleted) => void): () => void;
+}
+
+export function createThreadUsageSubscriptionRelay(): {
+  connect(client: Pick<RendererModelClient, "subscribeThreadUsage">): void;
+  subscribe(listener: (update: ThreadUsageInspection) => void): () => void;
+  dispose(): void;
+} {
+  const listeners = new Set<(update: ThreadUsageInspection) => void>();
+  let removeNotificationCallback: (() => void) | null = null;
+  return {
+    connect(client) {
+      if (removeNotificationCallback || listeners.size === 0) return;
+      try {
+        removeNotificationCallback =
+          client.subscribeThreadUsage?.((update) => {
+            for (const listener of listeners) listener(update);
+          }) ?? null;
+      } catch {
+        removeNotificationCallback = null;
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size > 0) return;
+        removeNotificationCallback?.();
+        removeNotificationCallback = null;
+      };
+    },
+    dispose() {
+      removeNotificationCallback?.();
+      removeNotificationCallback = null;
+      listeners.clear();
+    },
+  };
+}
+
+export function createRendererModelClient(
+  candidates: readonly RequestManagerCandidate[],
+): RendererModelClient | null {
+  const managers = candidates.filter(
+    (
+      candidate,
+    ): candidate is RequestManagerCandidate &
+      Required<Pick<RequestManagerCandidate, "sendRequest">> =>
+      typeof candidate.sendRequest === "function",
+  );
+  const source = managers[0];
+  if (managers.length !== 1 || !source) return null;
+  const manager = {
+    sendRequest: createRendererRequestSender((method, params) =>
+      source.sendRequest(method, params),
+    ),
+  };
+
+  const inspectHarness = async (input: HarnessInspectParams): Promise<HarnessInspection> => {
+    const params = harnessInspectParamsSchema.parse(input);
+    const result = await manager.sendRequest(HARNESS_INSPECT_METHOD, params);
+    return harnessInspectionSchema.parse(result);
+  };
+  const inspectHarnessCommands = async (
+    input: HarnessCommandsInspectParams,
+  ): Promise<HarnessCommandCatalog> => {
+    const params = harnessCommandsInspectParamsSchema.parse(input);
+    const result = await manager.sendRequest(HARNESS_COMMANDS_INSPECT_METHOD, params);
+    return harnessCommandCatalogSchema.parse(result);
+  };
+  const inspectThreadCommands = async (
+    input: ThreadCommandsInspectParams,
+  ): Promise<HarnessCommandCatalog> => {
+    const params = threadCommandsInspectParamsSchema.parse(input);
+    const result = await manager.sendRequest(THREAD_COMMANDS_INSPECT_METHOD, params);
+    return harnessCommandCatalogSchema.parse(result);
+  };
+  const executeThreadCommand = async (
+    input: ThreadCommandExecuteParams,
+  ): Promise<ThreadCommandExecuteResult> => {
+    const params = threadCommandExecuteParamsSchema.parse(input);
+    const result = await manager.sendRequest(THREAD_COMMAND_EXECUTE_METHOD, params);
+    return threadCommandExecuteResultSchema.parse(result);
+  };
+  const inspectThreadUsage = async (
+    input: ThreadUsageInspectionParams,
+  ): Promise<ThreadUsageInspection> => {
+    const params = threadUsageInspectionParamsSchema.parse(input);
+    const result = await manager.sendRequest(THREAD_USAGE_INSPECT_METHOD, params);
+    return threadUsageInspectionSchema.parse(result);
+  };
+  const selectThreadModel = async (
+    input: ThreadModelSelectParams,
+  ): Promise<HarnessModelSelectionState> => {
+    const params = threadModelSelectParamsSchema.parse(input);
+    const result = await manager.sendRequest(THREAD_MODEL_SELECT_METHOD, params);
+    return harnessModelSelectionStateSchema.parse(result);
+  };
+  const selectThreadThinking = async (
+    input: ThreadThinkingSelectParams,
+  ): Promise<HarnessModelSelectionState> => {
+    const params = threadThinkingSelectParamsSchema.parse(input);
+    const result = await manager.sendRequest(THREAD_THINKING_SELECT_METHOD, params);
+    return harnessModelSelectionStateSchema.parse(result);
+  };
+  const selectThreadPermissionMode = async (
+    input: ThreadPermissionModeSelectParams,
+  ): Promise<HarnessConfigurationState> => {
+    const params = threadPermissionModeSelectParamsSchema.parse(input);
+    const result = await manager.sendRequest(THREAD_PERMISSION_MODE_SELECT_METHOD, params);
+    return harnessConfigurationStateSchema.parse(result);
+  };
+
+  return Object.freeze({
+    async listCollaborationAgents(): Promise<Array<{ id: string; name: string; available: boolean; lead: boolean }>> {
+      const result = await manager.sendRequest('codexhost/collaboration/agents', {});
+      if (!Array.isArray(result) || !result.every(a => a && typeof a.id === 'string' && typeof a.name === 'string' && typeof a.available === 'boolean' && typeof a.lead === 'boolean')) throw new Error('Invalid collaboration catalog');
+      return result;
+    },
+    ...createRendererSessionImportClient(async (method, params) =>
+      manager.sendRequest(method, params),
+    ),
+    async forkThread(input: ExternalThreadForkParams): Promise<ExternalThreadForkResult> {
+      const params = externalThreadForkParamsSchema.parse(input);
+      const result = await manager.sendRequest(THREAD_FORK_METHOD, params);
+      return externalThreadForkResultSchema.parse(result);
+    },
+    // 原地切换 Harness：历史保留在 Host 线程上，切换后首轮由 Host 附带一次性上下文信封
+    async switchHarness(input: ThreadHarnessSwitchParams): Promise<ThreadHarnessSwitchResult> {
+      const params = threadHarnessSwitchParamsSchema.parse(input);
+      const result = await manager.sendRequest(THREAD_HARNESS_SWITCH_METHOD, params);
+      return threadHarnessSwitchResultSchema.parse(result);
+    },
+    // 跨 Harness 协作：委派新子任务 / 跟进既有子任务；等待链由父线程协作 Turn 承载
+    async delegateThread(input: ThreadDelegateParams): Promise<ThreadDelegationResult> {
+      const params = threadDelegateParamsSchema.parse(input);
+      const result = await manager.sendRequest(THREAD_DELEGATE_METHOD, params);
+      return threadDelegationResultSchema.parse(result);
+    },
+    async messageThread(input: ThreadMessageParams): Promise<ThreadDelegationResult> {
+      const params = threadMessageParamsSchema.parse(input);
+      const result = await manager.sendRequest(THREAD_MESSAGE_METHOD, params);
+      return threadDelegationResultSchema.parse(result);
+    },
+    inspectHarness,
+    async installHarness(input: { harnessId: string }): Promise<{ success: boolean; command?: string; stdout?: string; stderr?: string; error?: string }> {
+      const result = await manager.sendRequest(HARNESS_INSTALL_METHOD, input);
+      return result as { success: boolean; command?: string; stdout?: string; stderr?: string; error?: string };
+    },
+    async listHarnessPlugins(): Promise<HarnessPluginListResult> {
+      return harnessPluginListResultSchema.parse(
+        await manager.sendRequest(HARNESS_PLUGIN_LIST_METHOD, {}),
+      );
+    },
+    async openHarnessWebUi(input: HarnessWebUiOpenParams): Promise<void> {
+      const params = harnessWebUiOpenParamsSchema.parse(input);
+      const result = await manager.sendRequest(HARNESS_WEB_UI_OPEN_METHOD, params);
+      harnessWebUiOpenResultSchema.parse(result);
+    },
+    async inspectThread(input: ThreadInspectionParams): Promise<ThreadInspection> {
+      const params = threadInspectionParamsSchema.parse(input);
+      let result: unknown;
+      try {
+        result = await manager.sendRequest(THREAD_INSPECT_METHOD, params);
+      } catch (error) {
+        if (!(error instanceof RendererMethodUnavailableError)) throw error;
+
+        // Stock Codex has no Host inspection API. Verify its native Thread on
+        // this same connection; neither an RPC failure nor a missing Account
+        // establishes ownership. Match the external markers used by the Host.
+        const native = await manager.sendRequest("thread/read", {
+          threadId: params.threadId,
+          includeTurns: false,
+        });
+        const thread = isRecord(native) ? native.thread : null;
+        if (
+          !isRecord(thread) ||
+          thread.id !== params.threadId ||
+          typeof thread.modelProvider !== "string" ||
+          !thread.modelProvider ||
+          thread.modelProvider === "codexhost" ||
+          typeof thread.cliVersion !== "string" ||
+          !thread.cliVersion ||
+          thread.cliVersion === "codexhost"
+        ) {
+          throw new Error("Native Thread response cannot establish Codex ownership");
+        }
+        return { owner: "codex", locked: true };
+      }
+      return threadInspectionSchema.parse(result);
+    },
+    inspectHarnessCommands,
+    inspectThreadCommands,
+    executeThreadCommand,
+    async listThreadOwnership(
+      input: ThreadOwnershipListParams,
+    ): Promise<ThreadOwnershipListResult> {
+      const params = threadOwnershipListParamsSchema.parse(input);
+      const value = await manager.sendRequest(THREAD_OWNERSHIP_LIST_METHOD, params);
+      const result = threadOwnershipListResultSchema.parse(value);
+      if (
+        result.threads.length !== params.threadIds.length ||
+        result.threads.some((thread, index) => thread.threadId !== params.threadIds[index])
+      ) {
+        throw new Error("Thread ownership-list result does not match the requested IDs");
+      }
+      return result;
+    },
+    inspectThreadUsage,
+    subscribeThreadUsage(listener: (update: ThreadUsageInspection) => void): () => void {
+      const notifications = notificationTarget(source);
+      if (!notifications?.addNotificationCallback) {
+        throw new Error("Renderer Usage notification callback is unavailable");
+      }
+      let disposed = false;
+      const generations = new Map<ThreadUsageInspectionParams["threadId"], number>();
+      const removeNotificationCallback = notifications.addNotificationCallback(
+        [THREAD_TOKEN_USAGE_UPDATED_METHOD, THREAD_USAGE_UPDATED_METHOD],
+        (notification) => {
+          const threadId = notifiedThreadId(notification);
+          if (!threadId) return;
+          const generation = (generations.get(threadId) ?? 0) + 1;
+          generations.set(threadId, generation);
+          void inspectThreadUsage({ threadId })
+            .then((update) => {
+              if (!disposed && generations.get(threadId) === generation) listener(update);
+            })
+            .catch(() => undefined);
+        },
+      );
+      return () => {
+        if (disposed) return;
+        disposed = true;
+        generations.clear();
+        removeNotificationCallback();
+      };
+    },
+    selectThreadModel,
+    selectThreadThinking,
+    selectThreadPermissionMode,
+    async checkUpdate(): Promise<UpdateCheckResult> {
+      const result = await manager.sendRequest(
+        UPDATE_CHECK_METHOD,
+        updateEmptyParamsSchema.parse({}),
+      );
+      return updateCheckResultSchema.parse(result);
+    },
+    async startUpdate(): Promise<UpdateStartResult> {
+      const result = await manager.sendRequest(
+        UPDATE_START_METHOD,
+        updateEmptyParamsSchema.parse({}),
+      );
+      return updateStartResultSchema.parse(result);
+    },
+    async readUpdateStatus(): Promise<UpdateStatusResult> {
+      const result = await manager.sendRequest(
+        UPDATE_STATUS_METHOD,
+        updateEmptyParamsSchema.parse({}),
+      );
+      return updateStatusResultSchema.parse(result);
+    },
+    async inspectCodexAccountUsage(
+      input: CodexAccountUsageParams,
+    ): Promise<CodexAccountUsageResult> {
+      const result = await manager.sendRequest(
+        "codexhost/account/usage/inspect",
+        codexAccountUsageParamsSchema.parse(input),
+      );
+      return codexAccountUsageResultSchema.parse(result);
+    },
+    async consumeCodexAccountResetCredit(
+      input: CodexAccountResetCreditConsumeParams,
+    ): Promise<CodexAccountResetCreditConsumeResult> {
+      const result = await manager.sendRequest(
+        CODEX_ACCOUNT_RESET_CREDIT_CONSUME_METHOD,
+        codexAccountResetCreditConsumeParamsSchema.parse(input),
+      );
+      return codexAccountResetCreditConsumeResultSchema.parse(result);
+    },
+    async listHarnessAccounts(): Promise<HarnessAccountListResult> {
+      return harnessAccountListResultSchema.parse(
+        await manager.sendRequest("codexhost/harness/accounts/list", {}),
+      );
+    },
+    async listCodexAccounts(): Promise<CodexAccountListResult> {
+      const result = await manager.sendRequest(CODEX_ACCOUNT_LIST_METHOD, {});
+      return codexAccountListResultSchema.parse(result);
+    },
+    async refreshCodexAccounts(): Promise<CodexAccountListResult> {
+      const result = await manager.sendRequest(CODEX_ACCOUNT_REFRESH_METHOD, {});
+      return codexAccountListResultSchema.parse(result);
+    },
+    async createCodexAccount(input: CodexAccountCreateParams): Promise<CodexAccountMutationResult> {
+      const result = await manager.sendRequest(
+        CODEX_ACCOUNT_CREATE_METHOD,
+        codexAccountCreateParamsSchema.parse(input),
+      );
+      return codexAccountMutationResultSchema.parse(result);
+    },
+    async deleteCodexAccount(input: CodexAccountDeleteParams): Promise<CodexAccountDeleteResult> {
+      const result = await manager.sendRequest(
+        CODEX_ACCOUNT_DELETE_METHOD,
+        codexAccountDeleteParamsSchema.parse(input),
+      );
+      return codexAccountDeleteResultSchema.parse(result);
+    },
+    async activateCodexAccount(
+      input: CodexAccountActivateParams,
+    ): Promise<CodexAccountMutationResult> {
+      const result = await manager.sendRequest(
+        CODEX_ACCOUNT_ACTIVATE_METHOD,
+        codexAccountActivateParamsSchema.parse(input),
+      );
+      return codexAccountMutationResultSchema.parse(result);
+    },
+    async startCodexAccountLogin(
+      input: CodexAccountLoginStartParams,
+    ): Promise<CodexAccountLoginStartResult> {
+      const result = await manager.sendRequest(
+        CODEX_ACCOUNT_LOGIN_START_METHOD,
+        codexAccountLoginStartParamsSchema.parse(input),
+      );
+      return codexAccountLoginStartResultSchema.parse(result);
+    },
+    async cancelCodexAccountLogin(
+      input: CodexAccountLoginCancelParams,
+    ): Promise<CodexAccountLoginCancelResult> {
+      const result = await manager.sendRequest(
+        CODEX_ACCOUNT_LOGIN_CANCEL_METHOD,
+        codexAccountLoginCancelParamsSchema.parse(input),
+      );
+      return codexAccountLoginCancelResultSchema.parse(result);
+    },
+    subscribeCodexAccountLogin(listener: (result: CodexAccountLoginCompleted) => void): () => void {
+      const notifications = notificationTarget(source);
+      if (!notifications?.addNotificationCallback) {
+        throw new Error("Renderer Account login notification callback is unavailable");
+      }
+      return notifications.addNotificationCallback(
+        CODEX_ACCOUNT_LOGIN_COMPLETED_METHOD,
+        (notification) => {
+          if (
+            !isRecord(notification) ||
+            notification.method !== CODEX_ACCOUNT_LOGIN_COMPLETED_METHOD
+          ) {
+            return;
+          }
+          const result = codexAccountLoginCompletedSchema.safeParse(notification.params);
+          if (result.success) listener(result.data);
+        },
+      );
+    },
+  });
+}

package/src/native-ui/renderer-extension/src/renderer-model-picker-positioning.ts

@@ -0,0 +1,65 @@
+const MAIN_MENU_SIDE_OFFSET = 8;
+const COLLISION_PADDING = 8;
+
+export const RENDERER_MODEL_PICKER_MAIN_MENU_WIDTH = 260;
+export const RENDERER_MODEL_PICKER_THINKING_COLUMN_WIDTH = 176;
+export const RENDERER_MODEL_PICKER_MODEL_MENU_MAX_HEIGHT = 360;
+
+export interface RendererMenuRect {
+  left: number;
+  right: number;
+  top: number;
+}
+
+export interface RendererViewport {
+  width: number;
+  height: number;
+}
+
+export interface RendererMenuPlacement {
+  left: number;
+  top?: number;
+  bottom?: number;
+  width: number;
+  maxHeight?: number;
+}
+
+function clampPosition(value: number, minimum: number, maximum: number): number {
+  return Math.min(Math.max(value, minimum), Math.max(minimum, maximum));
+}
+
+function fitWidth(preferredWidth: number, viewportWidth: number): number {
+  return Math.max(
+    COLLISION_PADDING,
+    Math.min(preferredWidth, viewportWidth - COLLISION_PADDING * 2),
+  );
+}
+
+// 模型列 +（可选）思考强度列的单弹层总宽度，随视口收缩
+export function rendererModelPickerMenuWidth(twoColumn: boolean, viewportWidth: number): number {
+  const preferred = twoColumn
+    ? RENDERER_MODEL_PICKER_MAIN_MENU_WIDTH + RENDERER_MODEL_PICKER_THINKING_COLUMN_WIDTH
+    : RENDERER_MODEL_PICKER_MAIN_MENU_WIDTH;
+  return fitWidth(preferred, viewportWidth);
+}
+
+export function rendererModelPickerMainMenuPlacement(
+  triggerRect: RendererMenuRect,
+  viewport: RendererViewport,
+  width = RENDERER_MODEL_PICKER_MAIN_MENU_WIDTH,
+): RendererMenuPlacement {
+  const maxLeft = viewport.width - COLLISION_PADDING - width;
+  return {
+    left: clampPosition(triggerRect.right - width, COLLISION_PADDING, maxLeft),
+    width,
+    bottom: Math.max(COLLISION_PADDING, viewport.height - triggerRect.top + MAIN_MENU_SIDE_OFFSET),
+    // 弹层自触发器向上展开：可用高度 = 触发器顶部到视口顶部
+    maxHeight: Math.max(
+      COLLISION_PADDING * 2,
+      Math.min(
+        RENDERER_MODEL_PICKER_MODEL_MENU_MAX_HEIGHT,
+        triggerRect.top - MAIN_MENU_SIDE_OFFSET - COLLISION_PADDING,
+      ),
+    ),
+  };
+}