Team B implements the handler in their own worker — using their own workflows internally.

// fraud-team/worker.ts (Team B's implementation)
import { NexusWorker, NewWorkflowRunOperation, NewSyncOperation } from '@temporalio/nexus';
import { fraudService } from '../shared/fraud-service';

const fraudHandler = fraudService.implement({
  // Async: delegate to internal Workflow
  checkTransaction: NewWorkflowRunOperation({
    async start(input, ctx) {
      const client = ctx.getClient();
      // Team B starts their OWN workflow internally
      return await client.workflow.start(FraudCheckWorkflow, {
        args: [input],
        taskQueue: 'fraud-task-queue',
        workflowId: `fraud-${input.transactionId}`,
      });
    }
  }),

  // Sync: fast lookup, no Workflow needed
  getQuickScore: NewSyncOperation({
    async handler(input) {
      const score = await scoreCache.get(input.userId);
      return { score };
    }
  }),
});

// Run a Worker that polls the Endpoint's task queue
const worker = await NexusWorker.create({
  taskQueue: 'fraud-task-queue',
  nexusServices: [fraudHandler],
});

Team A calls the Nexus Service from their Workflow — it looks just like calling any other activity.

// payments-team/workflow.ts (Team A's caller)
import { proxyActivities, executeNexusOperation } from '@temporalio/workflow';
import { fraudService } from '../shared/fraud-service'; // shared package

export async function PaymentWorkflow(payment: Payment): Promise<Result> {
  // 1. Call the Nexus Operation — fully durable, typed
  const fraudResult = await executeNexusOperation({
    endpoint: 'fraud-detection-prod', // Nexus Endpoint name
    service: fraudService,
    operation: fraudService.operations.checkTransaction,
    input: {
      transactionId: payment.id,
      amount: payment.amount,
      userId: payment.userId,
    },
    // Total duration caller will wait (up to 60 days)
    scheduleToCloseTimeout: '24h',
  });

  // 2. Caller workflow was suspended during the check
  // Now it has the result — fully typed!
  if (!fraudResult.approved) {
    throw new Error(`Fraud detected: ${fraudResult.reason}`);
  }

  return processApprovedPayment(payment);
}