work-ally 0.2.0-alpha.1

package/bridge/src/runtime-client-message-dispatch.ts

@@ -0,0 +1,176 @@
+import { buildReplyFromThreadItems, observeContextCompactionEvent, type RuntimeTurnState } from './runtime-client-agent-messages.ts';
+import { buildTurnResultFromObject, mergeTerminalTurnResult } from './runtime-client-turn-read.ts';
+import { logDebug, logInfo, logWarn } from './logger.ts';
+import {
+  approvalRequestFrom,
+  normalizeRuntimeError,
+  normalizeThreadStatus,
+  serverRequestResolvedEventFrom,
+  userInputRequestFrom,
+  type JsonRpcMessage,
+} from './runtime-client-protocol.ts';
+import type { RuntimeThreadStatus, RuntimeTurnResult, ServerRequestResolvedEvent } from './types.ts';
+
+export interface PendingRuntimeRequest {
+  resolve: (value: any) => void;
+  reject: (error: any) => void;
+  timer: NodeJS.Timeout;
+}
+
+interface RuntimeMessageDispatchDeps {
+  pending: Map<string | number, PendingRuntimeRequest>;
+  turnStates: Map<string, RuntimeTurnState>;
+  cacheThreadStatus: (threadId: string, status: RuntimeThreadStatus | null | undefined) => RuntimeThreadStatus | null;
+  emitServerRequestResolved: (event: ServerRequestResolvedEvent) => void;
+  emitServerRequest: (msg: JsonRpcMessage) => void;
+  emitContextCompactionProgress: (turnId: string, itemId: string) => void;
+  resolveTurnResult: (turnId: string, result: RuntimeTurnResult) => boolean;
+}
+
+export function handleRuntimeRpcMessage(msg: JsonRpcMessage, deps: RuntimeMessageDispatchDeps): void {
+  if (msg.id != null && !msg.method) {
+    handlePendingRequestResolution(msg, deps.pending);
+    return;
+  }
+
+  const resolvedRequest = serverRequestResolvedEventFrom(msg);
+  if (resolvedRequest) {
+    handleServerRequestResolved(resolvedRequest, deps);
+    return;
+  }
+
+  if (msg.id != null && msg.method) {
+    handleServerRequest(msg, deps);
+    return;
+  }
+
+  if (!msg.method) {
+    return;
+  }
+
+  if (observeContextCompactionEvent(deps.turnStates, msg, deps.emitContextCompactionProgress)) {
+    return;
+  }
+
+  if (msg.method === 'thread/status/changed') {
+    handleThreadStatusChanged(msg, deps);
+    return;
+  }
+
+  if (msg.method === 'turn/completed') {
+    handleTurnCompleted(msg, deps);
+  }
+}
+
+function handlePendingRequestResolution(
+  msg: JsonRpcMessage,
+  pendingRequests: Map<string | number, PendingRuntimeRequest>,
+): void {
+  const pending = pendingRequests.get(msg.id!);
+  if (!pending) {
+    return;
+  }
+  pendingRequests.delete(msg.id!);
+  clearTimeout(pending.timer);
+  if (msg.error) {
+    const runtimeError = normalizeRuntimeError(msg.error);
+    logWarn('runtime', 'request_failed', { id: msg.id, error: runtimeError.stack || runtimeError.message, rawError: msg.error });
+    pending.reject(runtimeError);
+    return;
+  }
+  logDebug('runtime', 'request_resolved', { id: msg.id });
+  pending.resolve(msg.result);
+}
+
+function handleServerRequestResolved(
+  event: ServerRequestResolvedEvent,
+  deps: RuntimeMessageDispatchDeps,
+): void {
+  if (event.threadId) {
+    deps.cacheThreadStatus(event.threadId, {
+      type: 'active',
+      activeFlags: [],
+    });
+  }
+  logInfo('runtime', 'server_request_resolved', {
+    requestId: event.requestId,
+    threadId: event.threadId,
+    turnId: event.turnId,
+  });
+  deps.emitServerRequestResolved(event);
+}
+
+function handleServerRequest(msg: JsonRpcMessage, deps: RuntimeMessageDispatchDeps): void {
+  const approval = approvalRequestFrom(msg, '');
+  const userInput = userInputRequestFrom(msg, '');
+  const threadId = approval?.threadId || userInput?.threadId || (typeof msg.params?.threadId === 'string' ? msg.params.threadId : null);
+  const turnId = approval?.turnId || userInput?.turnId || (typeof msg.params?.turnId === 'string' ? msg.params.turnId : null);
+
+  if (approval) {
+    deps.cacheThreadStatus(approval.threadId, {
+      type: 'active',
+      activeFlags: ['waitingOnApproval'],
+    });
+  } else if (userInput) {
+    deps.cacheThreadStatus(userInput.threadId, {
+      type: 'active',
+      activeFlags: ['waitingOnUserInput'],
+    });
+  } else if (msg.method === 'mcpServer/elicitation/request' && threadId) {
+    deps.cacheThreadStatus(threadId, {
+      type: 'active',
+      activeFlags: ['waitingOnUserInput'],
+    });
+  }
+
+  logInfo('runtime', 'server_request', {
+    method: msg.method,
+    id: msg.id,
+    threadId,
+    turnId,
+  });
+  deps.emitServerRequest(msg);
+}
+
+function handleThreadStatusChanged(msg: JsonRpcMessage, deps: RuntimeMessageDispatchDeps): void {
+  const params = msg.params || {};
+  if (typeof params.threadId !== 'string') {
+    return;
+  }
+  const status = deps.cacheThreadStatus(params.threadId, normalizeThreadStatus(params.status));
+  if (!status) {
+    return;
+  }
+  logDebug('runtime', 'thread_status_changed', {
+    threadId: params.threadId,
+    status,
+  });
+}
+
+function handleTurnCompleted(msg: JsonRpcMessage, deps: RuntimeMessageDispatchDeps): void {
+  const params = msg.params || {};
+  const eventResult = buildTurnResultFromObject(
+    (items) => buildReplyFromThreadItems(items),
+    params.turn,
+    typeof params.threadId === 'string' ? params.threadId : null,
+    null,
+  );
+  logInfo('runtime', 'turn_completed_event', {
+    turnId: eventResult?.turnId || params.turn?.id,
+    status: eventResult?.status || params.turn?.status || 'completed',
+  });
+
+  if (!eventResult || !deps.turnStates.has(eventResult.turnId)) {
+    return;
+  }
+
+  const turn = deps.turnStates.get(eventResult.turnId);
+  if (!turn) {
+    return;
+  }
+  turn.completedEventResult = mergeTerminalTurnResult(eventResult, turn.completedEventResult || eventResult);
+  const resolved = turn.completedEventResult;
+  if (resolved.status !== 'completed' || Boolean(resolved.reply)) {
+    deps.resolveTurnResult(eventResult.turnId, resolved);
+  }
+}

package/bridge/src/runtime-client-protocol.ts

@@ -0,0 +1,411 @@
+import type {
+  ApprovalKind,
+  ApprovalRequest,
+  RuntimeErrorDetails,
+  RuntimeProgressMeta,
+  RuntimeThreadActiveFlag,
+  RuntimeThreadStatus,
+  ServerRequestResolvedEvent,
+  UserInputOption,
+  UserInputQuestion,
+  UserInputRequest,
+} from './types.ts';
+
+export type AgentMessagePhase = 'commentary' | 'final_answer' | 'unknown';
+
+export interface JsonRpcMessage {
+  id?: string | number;
+  method?: string;
+  params?: any;
+  result?: any;
+  error?: any;
+}
+
+export type ApprovalPolicy = 'untrusted' | 'on-failure' | 'on-request' | 'never';
+export type SandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+
+export type ReadOnlyAccess =
+  | { type: 'restricted'; includePlatformDefaults?: boolean; readableRoots?: string[] }
+  | { type: 'fullAccess' };
+
+export type SandboxPolicy =
+  | { type: 'readOnly'; networkAccess?: boolean; access?: ReadOnlyAccess }
+  | { type: 'workspaceWrite'; networkAccess?: boolean; readOnlyAccess?: ReadOnlyAccess; writableRoots?: string[]; excludeSlashTmp?: boolean; excludeTmpdirEnvVar?: boolean }
+  | { type: 'dangerFullAccess' }
+  | { type: 'externalSandbox'; networkAccess?: 'restricted' | 'enabled' };
+
+export interface ThreadOptions {
+  approvalPolicy?: ApprovalPolicy | null;
+  sandbox?: SandboxMode | null;
+  developerInstructions?: string | null;
+  baseInstructions?: string | null;
+}
+
+export interface RunTurnOptions {
+  threadId: string;
+  prompt: string;
+  messageId: string;
+  cwd: string;
+  onTurnStarted?: (turnId: string) => Promise<void> | void;
+  onProgress?: (text: string, meta?: RuntimeProgressMeta) => Promise<void> | void;
+  onThreadStatus?: (status: RuntimeThreadStatus, meta?: { threadId?: string | null; turnId?: string | null }) => Promise<void> | void;
+  onApproval?: (approval: ApprovalRequest) => Promise<void> | void;
+  onUserInput?: (request: UserInputRequest) => Promise<void> | void;
+  approvalPolicy?: ApprovalPolicy | null;
+  sandboxPolicy?: SandboxPolicy | null;
+}
+
+const THREAD_ACTIVE_FLAGS = new Set<RuntimeThreadActiveFlag>(['waitingOnApproval', 'waitingOnUserInput']);
+
+export function approvalIdFor(msg: JsonRpcMessage): string {
+  const params = msg.params || {};
+  return String(params.approvalId || msg.id);
+}
+
+export function approvalKindFor(method?: string): ApprovalKind | null {
+  if (method === 'item/commandExecution/requestApproval') {
+    return 'command';
+  }
+  if (method === 'item/fileChange/requestApproval') {
+    return 'file_change';
+  }
+  return null;
+}
+
+export function approvalRequestFrom(msg: JsonRpcMessage, messageId: string): ApprovalRequest | null {
+  const kind = approvalKindFor(msg.method);
+  if (!kind || msg.id == null) {
+    return null;
+  }
+  const params = msg.params || {};
+  return {
+    approvalId: approvalIdFor(msg),
+    kind,
+    requestId: msg.id,
+    threadId: params.threadId,
+    turnId: params.turnId,
+    messageId,
+    command: params.command || null,
+    reason: params.reason || null,
+    grantRoot: params.grantRoot || null,
+    cwd: params.cwd || null,
+  };
+}
+
+export function normalizeThreadStatus(status: any): RuntimeThreadStatus | null {
+  if (!status || typeof status !== 'object') {
+    return null;
+  }
+  const type = typeof status.type === 'string' ? status.type : null;
+  if (type !== 'notLoaded' && type !== 'idle' && type !== 'systemError' && type !== 'active') {
+    return null;
+  }
+  const activeFlags = Array.isArray(status.activeFlags)
+    ? status.activeFlags.filter((flag: unknown): flag is RuntimeThreadActiveFlag => typeof flag === 'string' && THREAD_ACTIVE_FLAGS.has(flag as RuntimeThreadActiveFlag))
+    : [];
+  return { type, activeFlags };
+}
+
+export function normalizeAgentMessagePhase(value: unknown): AgentMessagePhase {
+  if (value === 'commentary' || value === 'final_answer') {
+    return value;
+  }
+  return 'unknown';
+}
+
+export function isContextCompactionType(value: unknown): boolean {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  return value === 'contextCompaction' || value === 'context_compaction';
+}
+
+export function normalizeUserInputOptions(input: unknown): UserInputOption[] | null {
+  if (!Array.isArray(input)) {
+    return null;
+  }
+  const options = input
+    .filter((item) => item && typeof item === 'object')
+    .map((item: any) => ({
+      label: typeof item.label === 'string' ? item.label : '',
+      description: typeof item.description === 'string' ? item.description : '',
+    }))
+    .filter((item) => item.label);
+  return options.length > 0 ? options : null;
+}
+
+export function normalizeUserInputQuestion(input: unknown): UserInputQuestion | null {
+  if (!input || typeof input !== 'object') {
+    return null;
+  }
+  const raw = input as Record<string, unknown>;
+  if (typeof raw.id !== 'string' || typeof raw.header !== 'string' || typeof raw.question !== 'string') {
+    return null;
+  }
+  return {
+    id: raw.id,
+    header: raw.header,
+    question: raw.question,
+    isOther: raw.isOther === true,
+    isSecret: raw.isSecret === true,
+    options: normalizeUserInputOptions(raw.options),
+  };
+}
+
+export function normalizeSchemaObject(input: unknown): Record<string, unknown> | null {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    return null;
+  }
+  return input as Record<string, unknown>;
+}
+
+export function appendQuestionOption(
+  options: UserInputOption[],
+  seen: Set<string>,
+  label: string | null,
+  description: string | null = null,
+): void {
+  const normalizedLabel = (label || '').trim();
+  if (!normalizedLabel || seen.has(normalizedLabel)) {
+    return;
+  }
+  seen.add(normalizedLabel);
+  options.push({
+    label: normalizedLabel,
+    description: (description || '').trim(),
+  });
+}
+
+export function normalizeQuestionOptionsFromSchema(schema: Record<string, unknown> | null): UserInputOption[] | null {
+  if (!schema) {
+    return null;
+  }
+
+  const options: UserInputOption[] = [];
+  const seen = new Set<string>();
+  const schemaDescription = typeof schema.description === 'string' ? schema.description : null;
+
+  if (Array.isArray(schema.enum)) {
+    for (const value of schema.enum) {
+      appendQuestionOption(options, seen, String(value), schemaDescription);
+    }
+  }
+
+  for (const key of ['oneOf', 'anyOf']) {
+    const variants = schema[key];
+    if (!Array.isArray(variants)) {
+      continue;
+    }
+    for (const variant of variants) {
+      const raw = normalizeSchemaObject(variant);
+      if (!raw) {
+        continue;
+      }
+      const variantDescription = typeof raw.description === 'string' ? raw.description : schemaDescription;
+      if (Object.prototype.hasOwnProperty.call(raw, 'const')) {
+        appendQuestionOption(
+          options,
+          seen,
+          typeof raw.title === 'string' ? raw.title : String(raw.const),
+          variantDescription,
+        );
+        continue;
+      }
+      if (Array.isArray(raw.enum) && raw.enum.length === 1) {
+        const value = raw.enum[0];
+        appendQuestionOption(
+          options,
+          seen,
+          typeof raw.title === 'string' ? raw.title : String(value),
+          variantDescription,
+        );
+      }
+    }
+  }
+
+  return options.length > 0 ? options : null;
+}
+
+export function questionPromptFromSchema(message: string, schema: Record<string, unknown> | null): string {
+  const prompt = message.trim();
+  const description = typeof schema?.description === 'string' ? schema.description.trim() : '';
+  if (description && description !== prompt) {
+    return prompt + '\n' + description;
+  }
+  return prompt;
+}
+
+export function runtimeErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message || 'runtime request failed';
+  }
+  if (typeof error === 'string') {
+    return error.trim() || 'runtime request failed';
+  }
+  if (error && typeof error === 'object') {
+    const raw = error as { message?: unknown; code?: unknown; data?: unknown };
+    const message = typeof raw.message === 'string' ? raw.message.trim() : '';
+    const code = raw.code === undefined || raw.code === null || raw.code === '' ? '' : String(raw.code).trim();
+    if (message && code) {
+      return `${message} (code: ${code})`;
+    }
+    if (message) {
+      return message;
+    }
+    if (code) {
+      return `runtime request failed (code: ${code})`;
+    }
+    if (raw.data && typeof raw.data === 'object' && typeof (raw.data as { message?: unknown }).message === 'string') {
+      return String((raw.data as { message: string }).message).trim();
+    }
+  }
+  return 'runtime request failed';
+}
+
+export function normalizeRuntimeError(error: unknown): Error {
+  if (error instanceof Error) {
+    return error;
+  }
+  const normalized = new Error(runtimeErrorMessage(error)) as RuntimeErrorDetails;
+  if (error && typeof error === 'object') {
+    const raw = error as { code?: unknown; data?: unknown };
+    if (raw.code !== undefined && raw.code !== null && raw.code !== '') {
+      normalized.code = typeof raw.code === 'number' ? raw.code : String(raw.code).trim();
+    }
+    if (Object.prototype.hasOwnProperty.call(raw, 'data')) {
+      normalized.data = raw.data;
+    }
+  }
+  return normalized;
+}
+
+export function elicitationQuestionsFrom(params: Record<string, unknown>): UserInputQuestion[] {
+  const message = typeof params.message === 'string' ? params.message : '需要你确认后我才能继续。';
+  const mode = params.mode === 'url' ? 'url' : 'form';
+
+  if (mode === 'url') {
+    const url = typeof params.url === 'string' ? params.url : '';
+    const question = url ? message + '\n' + url : message;
+    return [
+      {
+        id: 'response',
+        header: 'MCP 确认',
+        question,
+        options: [
+          { label: '同意', description: '继续执行' },
+          { label: '拒绝', description: '拒绝本次请求' },
+          { label: '取消', description: '取消当前请求' },
+        ],
+      },
+    ];
+  }
+
+  const requestedSchema = normalizeSchemaObject(params.requestedSchema);
+  const properties = normalizeSchemaObject(requestedSchema?.properties);
+  const rootLooksLikeObject = requestedSchema?.type === 'object' || Boolean(properties && Object.keys(properties).length > 0);
+
+  if (rootLooksLikeObject && properties) {
+    const questions = Object.entries(properties)
+      .map(([id, value]) => {
+        const schema = normalizeSchemaObject(value);
+        return {
+          id,
+          header: typeof schema?.title === 'string' ? schema.title : id,
+          question: questionPromptFromSchema(message, schema),
+          isSecret: schema?.format === 'password',
+          options: normalizeQuestionOptionsFromSchema(schema),
+        } satisfies UserInputQuestion;
+      })
+      .filter((question) => Boolean(question.id));
+
+    if (questions.length > 0) {
+      return questions;
+    }
+  }
+
+  return [
+    {
+      id: 'response',
+      header: 'MCP 确认',
+      question: questionPromptFromSchema(message, requestedSchema),
+      options: normalizeQuestionOptionsFromSchema(requestedSchema),
+    },
+  ];
+}
+
+export function userInputRequestFrom(msg: JsonRpcMessage, messageId: string): UserInputRequest | null {
+  if (msg.method !== 'item/tool/requestUserInput' || msg.id == null) {
+    return null;
+  }
+  const params = msg.params || {};
+  if (typeof params.threadId !== 'string' || typeof params.turnId !== 'string' || !Array.isArray(params.questions)) {
+    return null;
+  }
+  const questions = params.questions
+    .map((question: unknown) => normalizeUserInputQuestion(question))
+    .filter((question: UserInputQuestion | null): question is UserInputQuestion => Boolean(question));
+  if (questions.length === 0) {
+    return null;
+  }
+  return {
+    requestId: msg.id,
+    threadId: params.threadId,
+    turnId: params.turnId,
+    itemId: typeof params.itemId === 'string' ? params.itemId : null,
+    messageId,
+    kind: 'questionnaire',
+    questions,
+    elicitation: null,
+  };
+}
+
+export function serverRequestResolvedEventFrom(msg: JsonRpcMessage): ServerRequestResolvedEvent | null {
+  if (msg.method !== 'serverRequest/resolved') {
+    return null;
+  }
+  const params = msg.params || {};
+  const requestId = params.requestId ?? params.id ?? params.serverRequestId ?? params.resolvedRequestId ?? null;
+  if (requestId == null) {
+    return null;
+  }
+  return {
+    requestId,
+    threadId: typeof params.threadId === 'string' ? params.threadId : null,
+    turnId: typeof params.turnId === 'string' ? params.turnId : null,
+  };
+}
+
+export function elicitationRequestFrom(msg: JsonRpcMessage, messageId: string): UserInputRequest | null {
+  if (msg.method !== 'mcpServer/elicitation/request' || msg.id == null) {
+    return null;
+  }
+  const params = msg.params || {};
+  if (typeof params.threadId !== 'string' || typeof params.serverName !== 'string' || typeof params.message !== 'string') {
+    return null;
+  }
+  const mode = params.mode === 'url' ? 'url' : params.mode === 'form' ? 'form' : null;
+  if (!mode) {
+    return null;
+  }
+  if (mode === 'url' && typeof params.url !== 'string') {
+    return null;
+  }
+
+  return {
+    requestId: msg.id,
+    threadId: params.threadId,
+    turnId: typeof params.turnId === 'string' ? params.turnId : '',
+    itemId: null,
+    messageId,
+    kind: 'mcp_elicitation',
+    questions: elicitationQuestionsFrom(params),
+    elicitation: {
+      serverName: params.serverName,
+      mode,
+      message: params.message,
+      requestedSchema: mode === 'form' ? params.requestedSchema : undefined,
+      url: mode === 'url' ? params.url : null,
+      elicitationId: mode === 'url' && typeof params.elicitationId === 'string' ? params.elicitationId : null,
+    },
+  };
+}

package/bridge/src/runtime-client-request-ops.ts

@@ -0,0 +1,56 @@
+import { logDebug } from './logger.ts';
+import type { PendingRuntimeRequest } from './runtime-client-message-dispatch.ts';
+
+const REQUEST_TIMEOUT_MS = Number(process.env.WORK_ALLY_CODEX_REQUEST_TIMEOUT_MS || '15000');
+const TURN_START_REQUEST_TIMEOUT_MS = Number(process.env.WORK_ALLY_CODEX_TURN_START_TIMEOUT_MS || '60000');
+const THREAD_REQUEST_TIMEOUT_MS = Number(process.env.WORK_ALLY_CODEX_THREAD_REQUEST_TIMEOUT_MS || '30000');
+
+interface RuntimeRequestDeps {
+  connect(): Promise<void>;
+  createId(): string;
+  pending: Map<string | number, PendingRuntimeRequest>;
+  sendRaw(payload: unknown): void;
+}
+
+function requestTimeoutForMethod(method: string): number {
+  switch (method) {
+    case 'thread/start':
+    case 'thread/resume':
+      return THREAD_REQUEST_TIMEOUT_MS;
+    case 'turn/start':
+      return TURN_START_REQUEST_TIMEOUT_MS;
+    default:
+      return REQUEST_TIMEOUT_MS;
+  }
+}
+
+export function rejectAllPendingRequests(
+  pending: Map<string | number, PendingRuntimeRequest>,
+  error: Error,
+): void {
+  for (const [id, request] of pending.entries()) {
+    clearTimeout(request.timer);
+    request.reject(error);
+    pending.delete(id);
+  }
+}
+
+export async function sendRuntimeRequest(
+  deps: RuntimeRequestDeps,
+  method: string,
+  params: unknown,
+): Promise<any> {
+  await deps.connect();
+  const id = deps.createId();
+  const timeoutMs = requestTimeoutForMethod(method);
+  const promise = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      deps.pending.delete(id);
+      reject(new Error(`runtime request timed out: ${method}`));
+    }, timeoutMs);
+    deps.pending.set(id, { resolve, reject, timer });
+  });
+  logDebug('runtime', 'request_sent', { id, method });
+  deps.sendRaw({ jsonrpc: '2.0', id, method, params });
+  return promise;
+}