@ai-sdk/harness-acp 0.0.0 → 1.0.1

package/src/v1/bridge/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "harness-acp-bridge",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.2.1",
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "ws": "8.21.0",
+    "zod": "4.4.3"
+  }
+}

package/src/v1/bridge/permission-controller.ts

@@ -0,0 +1,152 @@
+import type { HarnessV1PermissionMode } from '@ai-sdk/harness';
+import type { BridgeTurn } from '@ai-sdk/harness/bridge';
+import type {
+  RequestPermissionRequest,
+  RequestPermissionResponse,
+  ToolCallUpdate,
+} from '@agentclientprotocol/sdk';
+
+type PendingPermission = {
+  cancel(): void;
+};
+
+let permissionRequestCounter = 0;
+
+export function createACPPermissionController({
+  turn,
+  sessionId,
+  permissionMode,
+  hasPermissionModeMapping,
+  emitToolCall,
+  claimHostToolPermission,
+}: {
+  turn: BridgeTurn;
+  sessionId: string;
+  permissionMode: HarnessV1PermissionMode;
+  hasPermissionModeMapping: boolean;
+  emitToolCall: (options: { toolCall: ToolCallUpdate }) => void;
+  claimHostToolPermission: (options: { toolCall: ToolCallUpdate }) => boolean;
+}): {
+  requestPermission(
+    request: RequestPermissionRequest,
+  ): Promise<RequestPermissionResponse>;
+  cancelAll(): void;
+} {
+  const pendingPermissions = new Map<string, PendingPermission>();
+
+  return {
+    async requestPermission(request) {
+      if (request.sessionId !== sessionId) {
+        turn.emitWarning({
+          message:
+            `ACP permission request for session ${JSON.stringify(request.sessionId)} was cancelled ` +
+            `because the active session is ${JSON.stringify(sessionId)}.`,
+        });
+        return cancelled();
+      }
+      const allowOnce = request.options.find(
+        option => option.kind === 'allow_once',
+      );
+      const rejectOnce = request.options.find(
+        option => option.kind === 'reject_once',
+      );
+      if (allowOnce == null || rejectOnce == null) {
+        const missing = [
+          ...(allowOnce == null ? ['allow_once'] : []),
+          ...(rejectOnce == null ? ['reject_once'] : []),
+        ];
+        turn.emitWarning({
+          message:
+            `ACP permission request for tool call ${JSON.stringify(request.toolCall.toolCallId)} ` +
+            `was cancelled because it did not advertise ${missing.join(' and ')}.`,
+        });
+        return cancelled();
+      }
+      if (claimHostToolPermission({ toolCall: request.toolCall })) {
+        return {
+          outcome: {
+            outcome: 'selected',
+            optionId: allowOnce.optionId,
+          },
+        };
+      }
+      if (
+        !hasPermissionModeMapping &&
+        shouldAutoApprove({
+          permissionMode,
+          kind: request.toolCall.kind,
+        })
+      ) {
+        return {
+          outcome: {
+            outcome: 'selected',
+            optionId: allowOnce.optionId,
+          },
+        };
+      }
+
+      const approvalId = `acp-permission-${++permissionRequestCounter}`;
+      let cancelPermission!: () => void;
+      const cancellation = new Promise<undefined>(resolve => {
+        cancelPermission = () => resolve(undefined);
+      });
+      pendingPermissions.set(approvalId, {
+        cancel: cancelPermission,
+      });
+      const approval = turn.requestToolApproval(approvalId);
+      emitToolCall({ toolCall: request.toolCall });
+      turn.emit({
+        type: 'tool-approval-request',
+        approvalId,
+        toolCallId: request.toolCall.toolCallId,
+      });
+
+      try {
+        const response = await Promise.race([approval, cancellation]);
+        if (response == null) return cancelled();
+        return {
+          outcome: {
+            outcome: 'selected',
+            optionId: response.approved
+              ? allowOnce.optionId
+              : rejectOnce.optionId,
+          },
+        };
+      } finally {
+        pendingPermissions.delete(approvalId);
+      }
+    },
+    cancelAll() {
+      for (const pending of pendingPermissions.values()) {
+        pending.cancel();
+      }
+      pendingPermissions.clear();
+    },
+  };
+}
+
+function shouldAutoApprove({
+  permissionMode,
+  kind,
+}: {
+  permissionMode: HarnessV1PermissionMode;
+  kind: ToolCallUpdate['kind'];
+}): boolean {
+  if (permissionMode === 'allow-all') return true;
+  if (
+    kind === 'read' ||
+    kind === 'search' ||
+    kind === 'think' ||
+    kind === 'fetch'
+  ) {
+    return true;
+  }
+  return (
+    permissionMode === 'allow-edits' &&
+    (kind === 'edit' || kind === 'delete' || kind === 'move')
+  );
+}
+
+function cancelled(): RequestPermissionResponse {
+  return { outcome: { outcome: 'cancelled' } };
+}

package/src/v1/bridge/permission-mode.ts

@@ -0,0 +1,163 @@
+import type { HarnessV1PermissionMode } from '@ai-sdk/harness';
+import { HarnessBridgeCapabilityUnsupportedError } from '@ai-sdk/harness/bridge';
+import * as acp from '@agentclientprotocol/sdk';
+import type {
+  ACPPermissionModeMapping,
+  ACPPermissionModeTarget,
+} from '../acp-v1-settings';
+
+const PERMISSION_MODES = [
+  'allow-reads',
+  'allow-edits',
+  'allow-all',
+] as const satisfies ReadonlyArray<HarnessV1PermissionMode>;
+
+type ACPSessionConfiguration = Pick<
+  acp.NewSessionResponse,
+  'modes' | 'configOptions'
+>;
+
+export async function configureACPPermissionMode({
+  agent,
+  sessionId,
+  sessionConfiguration,
+  permissionModeMapping,
+  permissionMode,
+  harnessId,
+}: {
+  agent: acp.ClientContext;
+  sessionId: string;
+  sessionConfiguration: ACPSessionConfiguration;
+  permissionModeMapping: ACPPermissionModeMapping;
+  permissionMode: HarnessV1PermissionMode;
+  harnessId: string;
+}): Promise<void> {
+  const target = permissionModeMapping[permissionMode];
+  if (target == null) {
+    throw unsupported({
+      harnessId,
+      message:
+        `Permission mode ${JSON.stringify(permissionMode)} is not supported by this ACP harness.` +
+        (permissionModeMapping['allow-all'] == null
+          ? ''
+          : ` Use permissionMode: 'allow-all'.`),
+    });
+  }
+
+  for (const mappedPermissionMode of PERMISSION_MODES) {
+    const mappedTarget = permissionModeMapping[mappedPermissionMode];
+    if (mappedTarget != null) {
+      validateTarget({
+        target: mappedTarget,
+        permissionMode: mappedPermissionMode,
+        sessionConfiguration,
+        harnessId,
+      });
+    }
+  }
+
+  if (target.type === 'session-mode') {
+    await agent.request(acp.methods.agent.session.setMode, {
+      sessionId,
+      modeId: target.modeId,
+    });
+    return;
+  }
+  await agent.request(acp.methods.agent.session.setConfigOption, {
+    sessionId,
+    configId: target.configId,
+    value: target.value,
+    ...(typeof target.value === 'boolean' ? { type: 'boolean' as const } : {}),
+  });
+}
+
+function validateTarget({
+  target,
+  permissionMode,
+  sessionConfiguration,
+  harnessId,
+}: {
+  target: ACPPermissionModeTarget;
+  permissionMode: HarnessV1PermissionMode;
+  sessionConfiguration: ACPSessionConfiguration;
+  harnessId: string;
+}): void {
+  if (target.type === 'session-mode') {
+    const availableModeIds =
+      sessionConfiguration.modes?.availableModes.map(mode => mode.id) ?? [];
+    if (!availableModeIds.includes(target.modeId)) {
+      throw unsupported({
+        harnessId,
+        message:
+          `ACP permission mapping for ${JSON.stringify(permissionMode)} requires session mode ` +
+          `${JSON.stringify(target.modeId)}, but the agent advertised ` +
+          `${formatChoices({ values: availableModeIds })}.`,
+      });
+    }
+    return;
+  }
+
+  const configOption = sessionConfiguration.configOptions?.find(
+    option => option.id === target.configId,
+  );
+  if (configOption == null) {
+    const availableConfigIds =
+      sessionConfiguration.configOptions?.map(option => option.id) ?? [];
+    throw unsupported({
+      harnessId,
+      message:
+        `ACP permission mapping for ${JSON.stringify(permissionMode)} requires session configuration ` +
+        `${JSON.stringify(target.configId)}, but the agent advertised ` +
+        `${formatChoices({ values: availableConfigIds })}.`,
+    });
+  }
+  if (configOption.type === 'boolean') {
+    if (typeof target.value !== 'boolean') {
+      throw unsupported({
+        harnessId,
+        message:
+          `ACP permission mapping for ${JSON.stringify(permissionMode)} assigns string value ` +
+          `${JSON.stringify(target.value)} to boolean session configuration ${JSON.stringify(target.configId)}.`,
+      });
+    }
+    return;
+  }
+  if (typeof target.value !== 'string') {
+    throw unsupported({
+      harnessId,
+      message:
+        `ACP permission mapping for ${JSON.stringify(permissionMode)} assigns boolean value ` +
+        `${JSON.stringify(target.value)} to select session configuration ${JSON.stringify(target.configId)}.`,
+    });
+  }
+  const availableValues = configOption.options.flatMap(option =>
+    'options' in option
+      ? option.options.map(value => value.value)
+      : [option.value],
+  );
+  if (!availableValues.includes(target.value)) {
+    throw unsupported({
+      harnessId,
+      message:
+        `ACP permission mapping for ${JSON.stringify(permissionMode)} requires value ` +
+        `${JSON.stringify(target.value)} for session configuration ${JSON.stringify(target.configId)}, ` +
+        `but the agent advertised ${formatChoices({ values: availableValues })}.`,
+    });
+  }
+}
+
+function formatChoices({ values }: { values: ReadonlyArray<string> }): string {
+  return values.length === 0
+    ? 'no matching choices'
+    : values.map(value => JSON.stringify(value)).join(', ');
+}
+
+function unsupported({
+  harnessId,
+  message,
+}: {
+  harnessId: string;
+  message: string;
+}): HarnessBridgeCapabilityUnsupportedError {
+  return new HarnessBridgeCapabilityUnsupportedError({ harnessId, message });
+}