@ai-sdk/harness-acp 1.0.24 → 1.0.28

package/src/v1/bridge/refresh-host-tool-catalog.ts

@@ -2,6 +2,34 @@ import type { HarnessV1BridgeToolWire } from '@ai-sdk/harness';
 import { HarnessBridgeCapabilityUnsupportedError } from '@ai-sdk/harness/bridge';
 import type { HostToolRelay } from './host-tool-relay';
 
+/*
+ * Some ACP agents start session MCP servers only after receiving the first
+ * prompt. Starting that prompt before waiting lets those agents discover the
+ * initial catalog, while the relay's revision checks still reject stale or
+ * unknown tool invocations.
+ */
+export async function promptAndRefreshInitialHostToolCatalog({
+  startPrompt,
+  relay,
+  tools,
+  harnessId,
+  timeoutMs,
+}: {
+  startPrompt: () => Promise<unknown>;
+  relay: Pick<HostToolRelay, 'updateCatalog' | 'waitForCatalogRefresh'>;
+  tools: ReadonlyArray<HarnessV1BridgeToolWire>;
+  harnessId: string;
+  timeoutMs: number;
+}): Promise<void> {
+  void startPrompt();
+  await refreshHostToolCatalog({
+    relay,
+    tools,
+    harnessId,
+    timeoutMs,
+  });
+}
+
 export async function refreshHostToolCatalog({
   relay,
   tools,

package/src/v1/bridge/stream-translator.ts

@@ -206,6 +206,11 @@ export function createACPStreamTranslator({
       const builtin = resolveBuiltinTool({
         programmaticName,
         metadata: state.values._meta,
+        title: getStringProperty({
+          value: state.values,
+          property: 'title',
+        }),
+        kind: isACPToolKind(state.values.kind) ? state.values.kind : undefined,
         rawInput: state.values.rawInput,
         builtinTools,
         builtinToolsByName,
@@ -478,12 +483,16 @@ function addBuiltinToolMatch({
 function resolveBuiltinTool({
   programmaticName,
   metadata,
+  title,
+  kind,
   rawInput,
   builtinTools,
   builtinToolsByName,
 }: {
   programmaticName: string | undefined;
   metadata: unknown;
+  title: string | undefined;
+  kind: ACPToolKind | undefined;
   rawInput: unknown;
   builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
   builtinToolsByName: ReadonlyMap<string, ACPBuiltinToolMapping>;
@@ -502,12 +511,68 @@ function resolveBuiltinTool({
       : undefined;
   }
 
+  const titleMatch = findBuiltinToolByTitle({
+    title,
+    kind,
+    builtinTools,
+  });
+  if (titleMatch != null) return titleMatch;
+
   const schemaMatches = builtinTools.filter(tool =>
     matchesBuiltinToolInput({ rawInput, inputSchema: tool.inputSchema }),
   );
   return schemaMatches.length === 1 ? schemaMatches[0] : undefined;
 }
 
+function findBuiltinToolByTitle({
+  title,
+  kind,
+  builtinTools,
+}: {
+  title: string | undefined;
+  kind: ACPToolKind | undefined;
+  builtinTools: ReadonlyArray<ACPBuiltinToolMapping>;
+}): ACPBuiltinToolMapping | undefined {
+  if (title == null) return undefined;
+  const matches = builtinTools.filter(
+    tool =>
+      tool.title != null &&
+      title.startsWith(tool.title) &&
+      isCompatibleToolKind({ toolUseKind: tool.toolUseKind, kind }),
+  );
+  if (matches.length === 0) return undefined;
+  const longestPrefixLength = Math.max(
+    ...matches.map(tool => tool.title!.length),
+  );
+  const longestMatches = matches.filter(
+    tool => tool.title!.length === longestPrefixLength,
+  );
+  return longestMatches.length === 1 ? longestMatches[0] : undefined;
+}
+
+function isCompatibleToolKind({
+  toolUseKind,
+  kind,
+}: {
+  toolUseKind: ACPBuiltinToolMapping['toolUseKind'];
+  kind: ACPToolKind | undefined;
+}): boolean {
+  if (toolUseKind == null || kind == null) return true;
+  switch (toolUseKind) {
+    case 'readonly':
+      return (
+        kind === 'read' ||
+        kind === 'search' ||
+        kind === 'fetch' ||
+        kind === 'think'
+      );
+    case 'edit':
+      return kind === 'edit' || kind === 'delete' || kind === 'move';
+    case 'bash':
+      return kind === 'execute';
+  }
+}
+
 function findBuiltinToolsInMetadata({
   metadata,
   builtinToolsByName,

package/src/v1/implementation.ts

@@ -60,6 +60,9 @@ export function validateACPV1Implementation(
     if (source.pnpmLockYaml.length === 0) {
       throw new Error('ACP source.pnpmLockYaml must not be empty.');
     }
+    if (source.pnpmWorkspaceYaml?.length === 0) {
+      throw new Error('ACP source.pnpmWorkspaceYaml must not be empty.');
+    }
   } else if (source.type === 'npm-simple') {
     validateNpmSimpleSource({ source });
   } else if (source.command.trim().length === 0) {
@@ -133,6 +136,15 @@ export function getImplementationLockfile({
   return source.type === 'npm-locked' ? source.pnpmLockYaml : undefined;
 }
 
+export function getImplementationWorkspaceFile({
+  implementation,
+}: {
+  implementation: ACPImplementation;
+}): string | undefined {
+  const { source } = implementation;
+  return source.type === 'npm-locked' ? source.pnpmWorkspaceYaml : undefined;
+}
+
 export function createImplementationDescriptor({
   implementation,
 }: {
@@ -177,6 +189,7 @@ export function createImplementationIdentity({
           type: source.type,
           packageJson: source.packageJson,
           pnpmLockYaml: source.pnpmLockYaml,
+          pnpmWorkspaceYaml: source.pnpmWorkspaceYaml,
         }
       : source.type === 'npm-simple'
         ? {