@adcp/sdk 14.0.0-rc.42 → 14.0.0-rc.44

package/CONTRIBUTING.md

@@ -109,7 +109,13 @@ The Node test runner otherwise derives concurrency from the machine CPU count. T
 too aggressive on developer workstations because several test files launch their own
 TypeScript compiler or CLI subprocesses. The repository runner therefore caps local
 fast suites at two workers and runs the slow group serially. CI keeps its existing
-machine-derived concurrency and splits the fast suite into three shards.
+machine-derived concurrency and splits the fast suite into three shards. Those CI
+shards use per-file durations recorded by the latest successful `main` run and a
+deterministic longest-first assignment. A new or renamed test uses the median known
+duration; when no history is available, all files use an equal one-second weight.
+Pull requests may restore this history but cannot publish it, so untrusted or failed
+runs cannot poison future shard assignments. Each shard uploads its assignment
+manifest with the timing artifact for debugging.
 
 `npm test` and `npm run test:lib` build the library once before starting their test
 groups, then every test reads that completed `dist/` tree. Set `TEST_CONCURRENCY=1`

package/README.md

@@ -59,6 +59,19 @@ Large workspaces should keep the generated schema surface out of the default typ
 | Runtime Zod schemas and tool schema maps      | `@adcp/sdk/schemas`                                                                     |
 | Broad generated protocol type barrel          | `@adcp/sdk/types`                                                                       |
 
+### Focused client runtime (`@adcp/sdk/client/core`)
+
+Applications that only call AdCP agents can avoid evaluating the SDK's server,
+compliance, testing, and unrelated protocol surfaces:
+
+```ts
+import { ADCPMultiAgentClient, InMemoryWebhookRegistrationStore } from '@adcp/sdk/client/core';
+```
+
+The existing `@adcp/sdk/client` path remains an alias of the package root for
+compatibility. Use `/client/core` when cold import and test-worker startup time
+matter.
+
 For application monorepos, keep `skipLibCheck: true` unless you are intentionally auditing SDK declarations. If a package only needs request/response types for a few tools, prefer the per-tool slices over importing generated types through the root package or the broad `@adcp/sdk/types` barrel.
 
 ## Quick Start: AdCP 3.2

package/bin/adcp.js

@@ -57,7 +57,10 @@ const {
 } = require('./adcp-storyboard-summary.js');
 
 const { scheduleVersionCheck } = require('./adcp-version-check.js');
-const { formatStoryboardResultsAsJUnit } = require('../dist/lib/testing/storyboard/junit.js');
+const {
+  formatStoryboardResultsAsJUnit,
+  routedStoryboardResultGroup,
+} = require('../dist/lib/testing/storyboard/junit.js');
 const { ADCP_VERSION, LIBRARY_VERSION } = require('../dist/lib/version.js');
 const { isAdcpVersionSupported } = require('../dist/lib/utils/adcp-version-config.js');
 const { appendBuiltInVersionUnsupportedHint } = require('./adcp-version-unsupported-hint.js');
@@ -2917,7 +2920,7 @@ async function handleStoryboardRun(args) {
       'Usage: adcp storyboard run <agent> [storyboard_id|--file path] [options]\n' +
         '  Local agent: adcp storyboard run --local-agent <module> [storyboard_id|bundle_id]\n' +
         '  Multi-instance: adcp storyboard run --url <url1> --url <url2> <storyboard_id|bundle_id>\n' +
-        '  Multi-agent:   adcp storyboard run --agents-map ./agents.yaml <storyboard_id|bundle_id>'
+        '  Multi-agent:   adcp storyboard run --agents-map ./agents.yaml [storyboard_id|bundle_id]'
     );
     process.exit(2);
   }
@@ -4638,9 +4641,8 @@ async function handleMultiInstanceStoryboardRun(args, opts, urls) {
  * `get_adcp_capabilities`; tools without a unique claimant fall through to
  * `--default-agent`, or fail-fast with `unroutable_task`.
  *
- * Capability-driven full assessment is intentionally not supported here —
- * the assessment dispatches via `comply()` which expects a single agent.
- * Storyboard ID, bundle ID, or `--file` is required.
+ * With no storyboard or file, every tenant is discovered first and the
+ * topology runs the union of capability-applicable storyboards.
  */
 async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   const { authToken, authScheme, protocolFlag, jsonOutput, dryRun, positionalArgs, file: filePath, format } = opts;
@@ -4669,17 +4671,11 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   }
 
   const storyboardId = firstPositional;
+  const capabilityDriven = !filePath && !storyboardId;
   if (filePath && storyboardId) {
     console.error('ERROR: Cannot combine a storyboard ID with --file. Use one or the other.');
     process.exit(2);
   }
-  if (!filePath && !storyboardId) {
-    console.error(
-      'ERROR: Multi-agent routing requires a storyboard ID, bundle ID, or --file. ' +
-        'Capability-driven full assessment is not yet routing-aware.'
-    );
-    process.exit(2);
-  }
 
   const { loadStoryboardFile, runStoryboard, getComplianceStoryboardById, loadBundleStoryboards, findBundleById } =
     await import('../dist/lib/testing/storyboard/index.js');
@@ -4692,7 +4688,7 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
       console.error(`Failed to load storyboard from ${filePath}: ${err.message}`);
       process.exit(2);
     }
-  } else {
+  } else if (storyboardId) {
     const bundle = findBundleById(storyboardId, resolveOptions);
     if (bundle) {
       const bundleStoryboards = loadBundleStoryboards(bundle);
@@ -4748,6 +4744,49 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
 
   await loadInvariantModules(args);
 
+  let routedSelection;
+  let routedSelectionSummary;
+  let routingProfiles;
+  if (capabilityDriven) {
+    const { discoverAgentRouting } = await import('../dist/lib/testing/storyboard/agent-routing.js');
+    const { resolveRoutedAssessment } = await import('../dist/lib/testing/compliance/comply.js');
+    const discoveryOptions = {
+      protocol,
+      ...buildResolvedAuthOption({ resolvedAuth: authToken, resolvedAuthScheme: authScheme || 'bearer' }),
+      ...(opts.allowHttp && { allow_http: true }),
+      agents: routing.agents,
+      ...(routing.default_agent ? { default_agent: routing.default_agent } : {}),
+      ...(runComplianceDir && { complianceDir: runComplianceDir }),
+      ...(runAdcpVersion && { adcpVersion: runAdcpVersion }),
+      ...(runSchemaRoot && { schemaRoot: runSchemaRoot }),
+      ...sandboxRunOptions(opts),
+      ...(requestSigningOpts ?? {}),
+    };
+    const restoreDiscoveryLogs = jsonOutput ? captureStdoutLogs() : null;
+    try {
+      if (!jsonOutput) console.error('Discovering routed agent capabilities...');
+      const routingContext = await discoverAgentRouting(discoveryOptions);
+      routingProfiles = routingContext.profiles;
+      routedSelection = resolveRoutedAssessment(routingProfiles, resolveOptions);
+      routedSelectionSummary = {
+        agents: routedSelection.agents,
+        not_applicable: routedSelection.not_applicable,
+        missing_tools: routedSelection.missing_tools,
+        storyboard_ids: routedSelection.storyboards.map(storyboard => storyboard.id),
+      };
+      storyboards.push(...routedSelection.storyboards);
+    } catch (err) {
+      console.error(`ERROR: Failed to resolve routed assessment: ${err.message}`);
+      process.exit(1);
+    } finally {
+      if (restoreDiscoveryLogs) restoreDiscoveryLogs();
+    }
+    if (storyboards.length === 0) {
+      console.error('ERROR: Routed capability discovery selected no runnable storyboards.');
+      process.exit(1);
+    }
+  }
+
   const totalSteps = storyboards.reduce(
     (sum, sb) => sum + sb.phases.reduce((phaseSum, p) => phaseSum + p.steps.length, 0),
     0
@@ -4777,6 +4816,10 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
         default_agent: routing.default_agent,
         protocol,
         preview: true,
+        ...(capabilityDriven && {
+          assessment_mode: 'capability-driven',
+          selection: routedSelectionSummary,
+        }),
         storyboards: storyboards.map(sb => ({
           storyboard_id: sb.id,
           storyboard_title: sb.title,
@@ -4799,6 +4842,10 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
       }
       console.log(`\n${totalSteps} step(s) would be routed at run time. Use without --dry-run to execute.`);
     }
+    if (capabilityDriven) {
+      const { closeConnections } = await import('../dist/lib/protocols/index.js');
+      await closeConnections(protocol);
+    }
     return;
   }
 
@@ -4825,6 +4872,7 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
     }),
     ...(opts.loadedTestKit !== undefined && { test_kit: opts.loadedTestKit }),
     ...(requestSigningOpts ?? {}),
+    ...(routingProfiles && { _routingProfiles: routingProfiles }),
   };
 
   const restoreLogs = jsonOutput ? captureStdoutLogs() : null;
@@ -4842,7 +4890,12 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   }
 
   if (format === 'junit') {
-    process.stdout.write(formatStoryboardResultsAsJUnit(results));
+    const suiteGroups = capabilityDriven
+      ? Object.fromEntries(results.map(result => [result.storyboard_id, routedStoryboardResultGroup(result)]))
+      : undefined;
+    process.stdout.write(
+      formatStoryboardResultsAsJUnit(results, suiteGroups ? { suite_groups: suiteGroups } : undefined)
+    );
     if (opts.softFail && hadFailure) {
       printSoftFailBlock(
         results.filter(r => !r.overall_passed).map(r => r.storyboard_id),
@@ -4853,13 +4906,25 @@ async function handleAgentsRoutedStoryboardRun(args, opts, routing) {
   }
 
   if (jsonOutput) {
+    const reports = {};
+    if (capabilityDriven) {
+      for (const result of results) {
+        const group = routedStoryboardResultGroup(result);
+        (reports[group] ??= []).push(result);
+      }
+    }
     await writeJsonOutput(
-      results.length === 1
+      !capabilityDriven && results.length === 1
         ? results[0]
         : {
             agents: routing.agents,
             default_agent: routing.default_agent,
-            storyboards: results,
+            ...(capabilityDriven && {
+              assessment_mode: 'capability-driven',
+              selection: routedSelectionSummary,
+              reports,
+            }),
+            ...(!capabilityDriven && { storyboards: results }),
             overall_passed: !hadFailure,
           }
     );

package/dist/lib/acceptance-policy/evaluator.d.mts

@@ -0,0 +1,46 @@
+/** Conservative, advisory evaluation of already-verified acceptance profiles. */
+import type { AcceptanceContext } from '../types/core.generated.mjs';
+import type { AcceptancePolicyProfileResolution, AcceptancePolicyRequirement, AcceptancePolicyRule, AcceptancePolicySurface } from './index.mjs';
+export type AcceptancePolicyOutcome = 'allowed' | 'prohibited' | 'requires_disclosure' | 'requires_setup' | 'requires_review' | 'unknown';
+export type AcceptancePolicyAssessmentDiagnosticCode = 'profile_unresolved' | 'profile_conflict' | 'invalid_profile' | 'assessment_limit_exceeded' | 'partial_coverage' | 'incomplete_context' | 'invalid_context' | 'invalid_evaluation_time' | 'schema_unavailable';
+export interface AcceptancePolicyAssessmentDiagnostic {
+    code: AcceptancePolicyAssessmentDiagnosticCode;
+    profileId?: string;
+    ruleId?: string;
+}
+export interface AssessAcceptancePolicyInput {
+    /** Seller-default and product profiles to compose. Unresolved entries fail closed. */
+    profiles: readonly AcceptancePolicyProfileResolution[];
+    acceptanceContext: AcceptanceContext;
+    appliesTo: AcceptancePolicySurface;
+    /** Evaluation instant for rule windows. Defaults to the current time. */
+    evaluatedAt?: Date | string;
+    /** Schema bundle used to validate acceptanceContext and each resolved profile. Defaults to the SDK pin. */
+    adcpVersion?: string;
+}
+export interface AcceptancePolicyAssessment {
+    /** Advisory only. The seller's response to an exact request remains authoritative. */
+    advisory: true;
+    outcome: AcceptancePolicyOutcome;
+    profileIds: string[];
+    matchingRuleIds: string[];
+    matchedRules: AcceptancePolicyMatchedRule[];
+    requirements: AcceptancePolicyRequirement[];
+    diagnostics: AcceptancePolicyAssessmentDiagnostic[];
+}
+export interface AcceptancePolicyMatchedRule {
+    profileId: string;
+    ruleId: string;
+    disposition: AcceptancePolicyRule['disposition'];
+    policyIds: string[];
+    requirements: AcceptancePolicyRequirement[];
+}
+/**
+ * Compose verified seller-default and product acceptance profiles
+ * restrictively for one decision surface.
+ *
+ * The result is preflight guidance, not authorization. Missing profiles,
+ * partial coverage, out-of-scope complete profiles, and omitted buyer facts
+ * remain `unknown`; an explicit matching prohibition still wins.
+ */
+export declare function assessAcceptancePolicy(input: AssessAcceptancePolicyInput): AcceptancePolicyAssessment;

package/dist/lib/acceptance-policy/evaluator.d.ts

@@ -0,0 +1,46 @@
+/** Conservative, advisory evaluation of already-verified acceptance profiles. */
+import type { AcceptanceContext } from '../types/core.generated';
+import type { AcceptancePolicyProfileResolution, AcceptancePolicyRequirement, AcceptancePolicyRule, AcceptancePolicySurface } from './index';
+export type AcceptancePolicyOutcome = 'allowed' | 'prohibited' | 'requires_disclosure' | 'requires_setup' | 'requires_review' | 'unknown';
+export type AcceptancePolicyAssessmentDiagnosticCode = 'profile_unresolved' | 'profile_conflict' | 'invalid_profile' | 'assessment_limit_exceeded' | 'partial_coverage' | 'incomplete_context' | 'invalid_context' | 'invalid_evaluation_time' | 'schema_unavailable';
+export interface AcceptancePolicyAssessmentDiagnostic {
+    code: AcceptancePolicyAssessmentDiagnosticCode;
+    profileId?: string;
+    ruleId?: string;
+}
+export interface AssessAcceptancePolicyInput {
+    /** Seller-default and product profiles to compose. Unresolved entries fail closed. */
+    profiles: readonly AcceptancePolicyProfileResolution[];
+    acceptanceContext: AcceptanceContext;
+    appliesTo: AcceptancePolicySurface;
+    /** Evaluation instant for rule windows. Defaults to the current time. */
+    evaluatedAt?: Date | string;
+    /** Schema bundle used to validate acceptanceContext and each resolved profile. Defaults to the SDK pin. */
+    adcpVersion?: string;
+}
+export interface AcceptancePolicyAssessment {
+    /** Advisory only. The seller's response to an exact request remains authoritative. */
+    advisory: true;
+    outcome: AcceptancePolicyOutcome;
+    profileIds: string[];
+    matchingRuleIds: string[];
+    matchedRules: AcceptancePolicyMatchedRule[];
+    requirements: AcceptancePolicyRequirement[];
+    diagnostics: AcceptancePolicyAssessmentDiagnostic[];
+}
+export interface AcceptancePolicyMatchedRule {
+    profileId: string;
+    ruleId: string;
+    disposition: AcceptancePolicyRule['disposition'];
+    policyIds: string[];
+    requirements: AcceptancePolicyRequirement[];
+}
+/**
+ * Compose verified seller-default and product acceptance profiles
+ * restrictively for one decision surface.
+ *
+ * The result is preflight guidance, not authorization. Missing profiles,
+ * partial coverage, out-of-scope complete profiles, and omitted buyer facts
+ * remain `unknown`; an explicit matching prohibition still wins.
+ */
+export declare function assessAcceptancePolicy(input: AssessAcceptancePolicyInput): AcceptancePolicyAssessment;