@ductape/mcp 0.2.6 → 0.2.8

package/README.md

@@ -55,7 +55,7 @@ Use an absolute path for `args[0]`.
 
 ## Tools
 
-The server exposes **three tools**:
+The server exposes runtime, schema, documentation, CLI, discovery, migration, and setup tools. Core tools include:
 
 1. **`ductape_execute`**:
    - It runs any allowed SDK module method via the backend proxy.
@@ -82,6 +82,13 @@ The server exposes **three tools**:
      - ready-to-copy SDK snippet in `typescript` or `python`
    - Intended for engineers and copilots that need executable examples quickly.
 
+4. **`ductape_function_setup`**:
+   - Produces the secure local and remote setup for application functions referenced by portable Features.
+   - Requires an externally reachable HTTPS base URL (HTTP only for localhost development).
+   - Returns deterministic well-known routes, framework raw-body requirements, HMAC-SHA256 headers,
+     runtime verification steps, and fail-closed conditions.
+   - Agents must implement and verify the route; they must not claim remote availability from local registration alone.
+
 The `ductape_cli` MCP tool also exposes public app discovery:
 `marketplace search <capability>`, `marketplace categories`, and
 `marketplace get <app_tag>`. Inspect the app before generating or executing an action payload.

package/dist/events-capabilities.d.ts

@@ -0,0 +1,133 @@
+export declare const EVENTS_IMPLEMENTATION_WARNING = "Ductape manages consumer delivery retries and dead-letter queues. Do not create a parallel application transport DLQ. Use an application transactional outbox only to bridge canonical database commits to Ductape publication. Consumers must remain idempotent and replay-safe.";
+export declare const EVENTS_RECOVERY_SEARCH_TERMS: string[];
+export declare const EVENTS_DELIVERY_SEMANTICS: {
+    publisherAcceptance: string;
+    consumerRetriesManagedBy: string;
+    deadLetterQueueManagedBy: string;
+    applicationDlqRequired: boolean;
+    applicationOutboxRecommended: boolean;
+    applicationOutboxPurpose: string;
+    orderingGuarantees: string;
+    deliveryGuarantee: string;
+    deduplicationGuidance: string;
+    idempotentConsumerRequired: boolean;
+    responsibilities: {
+        applicationTransactionalOutbox: string;
+        brokerDeliveryRetries: string;
+        exhaustedDeliveryDlq: string;
+        replayAndReprocessing: string;
+        domainRejectedOrInvalidCommands: string;
+        consumerMutationIdempotency: string;
+    };
+};
+export declare const EVENTS_PROVIDER_CAPABILITIES: Record<string, Record<string, unknown>>;
+type Operation = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, string>;
+    outputSchema: Record<string, string>;
+    requiredIdentifiers: string[];
+    environmentRequirements: string;
+    connectionRequirements: string;
+    permissions: string;
+    idempotency: string;
+    pagination: string;
+    applicableStates: string[];
+    commonErrors: Array<{
+        error: string;
+        remediation: string;
+    }>;
+    mutatesState: boolean;
+    mayIncurProviderCost: boolean;
+};
+export declare const EVENTS_OPERATION_REGISTRY: Operation[];
+export declare function eventsCapabilityOverview(): {
+    capability: string;
+    aliases: string[];
+    implementationWarning: string;
+    deliverySemantics: {
+        publisherAcceptance: string;
+        consumerRetriesManagedBy: string;
+        deadLetterQueueManagedBy: string;
+        applicationDlqRequired: boolean;
+        applicationOutboxRecommended: boolean;
+        applicationOutboxPurpose: string;
+        orderingGuarantees: string;
+        deliveryGuarantee: string;
+        deduplicationGuidance: string;
+        idempotentConsumerRequired: boolean;
+        responsibilities: {
+            applicationTransactionalOutbox: string;
+            brokerDeliveryRetries: string;
+            exhaustedDeliveryDlq: string;
+            replayAndReprocessing: string;
+            domainRejectedOrInvalidCommands: string;
+            consumerMutationIdempotency: string;
+        };
+    };
+    recoverySearchTerms: string[];
+    documentationTopics: string[];
+    providerCapabilities: Record<string, Record<string, unknown>>;
+    operations: Operation[];
+};
+export declare function searchEventsCapabilities(query: string): {
+    query: string;
+    canonicalTopic: string;
+    recoveryMatch: boolean;
+    deliverySemantics: {
+        publisherAcceptance: string;
+        consumerRetriesManagedBy: string;
+        deadLetterQueueManagedBy: string;
+        applicationDlqRequired: boolean;
+        applicationOutboxRecommended: boolean;
+        applicationOutboxPurpose: string;
+        orderingGuarantees: string;
+        deliveryGuarantee: string;
+        deduplicationGuidance: string;
+        idempotentConsumerRequired: boolean;
+        responsibilities: {
+            applicationTransactionalOutbox: string;
+            brokerDeliveryRetries: string;
+            exhaustedDeliveryDlq: string;
+            replayAndReprocessing: string;
+            domainRejectedOrInvalidCommands: string;
+            consumerMutationIdempotency: string;
+        };
+    };
+    operations: Operation[];
+};
+export declare function inspectEventsComponent(component: any): {
+    component: any;
+    provider: any;
+    environments: any;
+    topics: any;
+    subscriptions: any;
+    consumerBindings: any;
+    messageStatistics: string;
+    availableOperationalActions: Operation[];
+    deliverySemantics: {
+        publisherAcceptance: string;
+        consumerRetriesManagedBy: string;
+        deadLetterQueueManagedBy: string;
+        applicationDlqRequired: boolean;
+        applicationOutboxRecommended: boolean;
+        applicationOutboxPurpose: string;
+        orderingGuarantees: string;
+        deliveryGuarantee: string;
+        deduplicationGuidance: string;
+        idempotentConsumerRequired: boolean;
+        responsibilities: {
+            applicationTransactionalOutbox: string;
+            brokerDeliveryRetries: string;
+            exhaustedDeliveryDlq: string;
+            replayAndReprocessing: string;
+            domainRejectedOrInvalidCommands: string;
+            consumerMutationIdempotency: string;
+        };
+    };
+    implementationWarning: string;
+    configurationWarnings: any;
+    documentationTopics: string[];
+};
+export {};
+//# sourceMappingURL=events-capabilities.d.ts.map

package/dist/events-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-capabilities.d.ts","sourceRoot":"","sources":["../src/events-capabilities.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,sRAC2O,CAAC;AAEtR,eAAO,MAAM,4BAA4B,UAWxC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;CAmBrC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkDhF,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,uBAAuB,EAAE,MAAM,CAAC;IAChC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5D,YAAY,EAAE,OAAO,CAAC;IACtB,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAyCF,eAAO,MAAM,yBAAyB,EAAE,SAAS,EA8IhD,CAAC;AAEF,wBAAgB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWvC;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;EASrD;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCpD"}

package/dist/events-capabilities.js

@@ -0,0 +1,311 @@
+export const EVENTS_IMPLEMENTATION_WARNING = 'Ductape manages consumer delivery retries and dead-letter queues. Do not create a parallel application transport DLQ. Use an application transactional outbox only to bridge canonical database commits to Ductape publication. Consumers must remain idempotent and replay-safe.';
+export const EVENTS_RECOVERY_SEARCH_TERMS = [
+    'dlq',
+    'dead letter',
+    'dead letters',
+    'failed messages',
+    'retry',
+    'retries',
+    'poison message',
+    'replay',
+    'reprocess',
+    'consumer failure',
+];
+export const EVENTS_DELIVERY_SEMANTICS = {
+    publisherAcceptance: 'Ductape acknowledges events accepted for publication; acceptance is not proof of consumer-side mutation.',
+    consumerRetriesManagedBy: 'ductape',
+    deadLetterQueueManagedBy: 'ductape',
+    applicationDlqRequired: false,
+    applicationOutboxRecommended: true,
+    applicationOutboxPurpose: 'Protect the canonical database transaction-to-Ductape publication boundary.',
+    orderingGuarantees: 'Provider and configuration dependent; inspect each environment. Never infer global ordering.',
+    deliveryGuarantee: 'At-least-once processing should be assumed unless the inspected provider/configuration explicitly proves otherwise.',
+    deduplicationGuidance: 'Use publishIdempotent with a stable logical-operation key where appropriate and deduplicate consumer mutations.',
+    idempotentConsumerRequired: true,
+    responsibilities: {
+        applicationTransactionalOutbox: 'application',
+        brokerDeliveryRetries: 'ductape',
+        exhaustedDeliveryDlq: 'ductape',
+        replayAndReprocessing: 'ductape',
+        domainRejectedOrInvalidCommands: 'application (not a transport DLQ)',
+        consumerMutationIdempotency: 'application',
+    },
+};
+export const EVENTS_PROVIDER_CAPABILITIES = {
+    google_pubsub: {
+        ordering: 'supported only when provider ordering keys/configuration are enabled; not inferred by Ductape',
+        acknowledgement: 'provider subscription acknowledgement deadline',
+        retriesAndBackoff: 'provider subscription policy; inspect the deployed subscription',
+        dlq: 'Ductape recovery operations are available, but provider dead-letter policy must be verified before claiming a provider DLQ exists',
+        retention: 'provider topic/subscription retention; inspect live provider configuration',
+    },
+    aws_sqs: {
+        ordering: 'FIFO only for FIFO queues; standard queues do not guarantee strict ordering',
+        acknowledgement: 'visibility timeout',
+        retriesAndBackoff: 'receive count and visibility timeout/provider redrive policy',
+        dlq: 'provider redrive/DLQ must be configured and verified; Ductape exposes tracked dead letters and reprocessing',
+        retention: 'provider queue retention',
+    },
+    azure_servicebus: {
+        ordering: 'sessions can provide ordered handling when configured; otherwise provider-controlled',
+        acknowledgement: 'message lock duration',
+        retriesAndBackoff: 'max delivery count and lock/redelivery behavior',
+        dlq: 'provider entity DLQ exists, but its configured state and access must be verified',
+        retention: 'provider entity configuration',
+    },
+    kafka: {
+        ordering: 'within a partition only',
+        acknowledgement: 'consumer offset commit',
+        retriesAndBackoff: 'Ductape consumer failure tracking plus application/provider configuration',
+        dlq: 'do not assume a native broker DLQ topic exists unless it is configured and verified',
+        retention: 'topic retention configuration',
+    },
+    rabbitmq: {
+        ordering: 'queue ordering can be affected by redelivery and multiple consumers',
+        acknowledgement: 'broker acknowledgement/nack',
+        retriesAndBackoff: 'redelivery and configured exchange/queue policies',
+        dlq: 'dead-letter exchange/queue must be configured and verified before claiming provider DLQ availability',
+        retention: 'queue/message TTL configuration',
+    },
+    redis: {
+        ordering: 'provider/mode dependent',
+        acknowledgement: 'not uniformly supported across Redis pub/sub and stream modes',
+        retriesAndBackoff: 'Ductape tracking; provider-native retry semantics may be unsupported',
+        dlq: 'no provider DLQ should be implied without a verified stream/consumer-group recovery configuration',
+        retention: 'provider/mode dependent',
+    },
+    nats: {
+        ordering: 'subject/stream configuration dependent',
+        acknowledgement: 'JetStream configuration dependent; core NATS has different semantics',
+        retriesAndBackoff: 'provider mode/configuration dependent',
+        dlq: 'do not imply a provider DLQ without verified JetStream/recovery configuration',
+        retention: 'stream configuration dependent',
+    },
+};
+const runtimeRead = {
+    environmentRequirements: 'product environment must exist and the Events component must be configured for it',
+    connectionRequirements: 'configured provider connection for the selected Events environment',
+    permissions: 'publishable-key runtime access plus product/environment access',
+    applicableStates: ['active', 'provider-ready'],
+    commonErrors: [
+        { error: 'broker/topic not found', remediation: 'inspect the Events component and use its exact broker/topic tags' },
+        { error: 'environment not configured', remediation: 'configure that environment on the Events component' },
+        { error: 'authentication/permission denied', remediation: 'verify publishable key, workspace, product, and environment access' },
+    ],
+};
+function adminOperation(name, description, inputSchema, requiredIdentifiers, mutatesState) {
+    return {
+        name, description, inputSchema,
+        outputSchema: mutatesState ? { resource: 'persisted Events component/topic' } : { resource: 'Events component/topic or array' },
+        requiredIdentifiers,
+        environmentRequirements: 'administrative product access; create/update must cover every product environment where required',
+        connectionRequirements: 'provider-specific credentials or a verified cloud connection for every configured environment',
+        permissions: 'authenticated access-key CLI session with workspace/product administration permission',
+        idempotency: mutatesState ? 'not guaranteed; fetch first and use update rather than duplicate create' : 'read-only',
+        pagination: name.endsWith('.list') ? 'provider/component list; pagination is not currently exposed by this admin method' : 'none',
+        applicableStates: ['draft', 'active', 'provider-ready'],
+        commonErrors: [
+            { error: 'missing environment/provider fields', remediation: 'read the targeted live events.create/events.update schema and cover every product environment' },
+            { error: 'unsupported provider configuration', remediation: 'use the selected env type’s live config branch; do not copy fields between providers' },
+            { error: 'permission denied', remediation: 'authenticate the CLI and select the correct workspace; do not use ductape_execute for admin writes' },
+        ],
+        mutatesState,
+        mayIncurProviderCost: mutatesState,
+    };
+}
+export const EVENTS_OPERATION_REGISTRY = [
+    adminOperation('events.create', 'Register an Events component and its per-environment provider connections.', { product: 'string', tag: 'string', name: 'string', description: 'string?', envs: 'provider-specific env[]' }, ['product', 'tag', 'name', 'envs'], true),
+    adminOperation('events.update', 'Update an Events component/provider configuration.', { product: 'string', brokerTag: 'string', data: 'targeted live events.update schema' }, ['product', 'brokerTag'], true),
+    adminOperation('events.fetch', 'Fetch one Events component.', { product: 'string', brokerTag: 'string' }, ['product', 'brokerTag'], false),
+    adminOperation('events.list', 'List Events components for a product.', { product: 'string' }, ['product'], false),
+    adminOperation('events.delete', 'Delete or retire an Events component.', { product: 'string', brokerTag: 'string' }, ['product', 'brokerTag'], true),
+    adminOperation('events.topics.create', 'Create a topic definition on a registered Events component.', { product: 'string', tag: 'broker:topic', name: 'string', sample: 'object?', idempotent: 'boolean?', queueUrls: 'array?' }, ['product', 'tag', 'name'], true),
+    adminOperation('events.topics.update', 'Update an Events topic definition.', { product: 'string', topicTag: 'broker:topic', data: 'topic patch' }, ['product', 'topicTag'], true),
+    adminOperation('events.topics.fetch', 'Fetch one Events topic definition.', { product: 'string', topicTag: 'broker:topic' }, ['product', 'topicTag'], false),
+    adminOperation('events.topics.list', 'List topic definitions for an Events component.', { product: 'string', brokerTag: 'string' }, ['product', 'brokerTag'], false),
+    {
+        name: 'events.produce', description: 'Publish an event immediately.',
+        inputSchema: { product: 'string', env: 'string', event: 'broker:topic', message: 'object', session: 'string?' },
+        outputSchema: { accepted: 'boolean', messageId: 'string?' }, requiredIdentifiers: ['product', 'env', 'event'],
+        ...runtimeRead, idempotency: 'not inherently idempotent; use events.publishIdempotent when duplicate publication matters',
+        pagination: 'none', mutatesState: true, mayIncurProviderCost: true,
+    },
+    {
+        name: 'events.publishIdempotent', description: 'Publish with a stable deduplication key.',
+        inputSchema: { product: 'string', env: 'string', event: 'broker:topic', message: 'object', idempotencyKey: 'string', idempotencyTtl: 'number?' },
+        outputSchema: { accepted: 'boolean', duplicate: 'boolean?', messageId: 'string?' }, requiredIdentifiers: ['product', 'env', 'event', 'idempotencyKey'],
+        ...runtimeRead, idempotency: 'deduplicates the logical publication for the configured TTL',
+        pagination: 'none', mutatesState: true, mayIncurProviderCost: true,
+    },
+    {
+        name: 'events.consume', description: 'Register a server-side consumer; successful return acknowledges and thrown errors trigger managed failure handling.',
+        inputSchema: { product: 'string', env: 'string', event: 'broker:topic', callback: 'function' },
+        outputSchema: { subscribed: 'boolean', consumerTag: 'string?' }, requiredIdentifiers: ['product', 'env', 'event'],
+        ...runtimeRead, permissions: 'server-side SDK access; browser clients cannot consume',
+        idempotency: 'consumer mutations must be idempotent and replay-safe', pagination: 'none',
+        mutatesState: true, mayIncurProviderCost: true,
+    },
+    {
+        name: 'events.dispatch', description: 'Queue or schedule an Events publication.',
+        inputSchema: { product: 'string', env: 'string', event: 'broker:topic', input: '{message: object}', retries: 'number?', schedule: 'object?' },
+        outputSchema: { job_id: 'string', status: 'scheduled|queued', scheduled_at: 'string?', recurring: 'boolean' },
+        requiredIdentifiers: ['product', 'env', 'event'], ...runtimeRead,
+        connectionRequirements: 'Events provider connection plus redis_url for dispatch scheduling',
+        idempotency: 'job/publication idempotency depends on stable job and message keys; consumers remain idempotent',
+        pagination: 'none', mutatesState: true, mayIncurProviderCost: true,
+    },
+    {
+        name: 'events.messages.query', description: 'Query tracked broker messages and delivery state.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string', topicTag: 'string?', producerTag: 'string?', consumerTag: 'string?', status: 'string?', startDate: 'ISO date?', endDate: 'ISO date?', page: 'number?', limit: 'number?' },
+        outputSchema: { messages: 'array', total: 'number', page: 'number', limit: 'number', hasMore: 'boolean' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'page/limit with total and hasMore', mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.getEvents', description: 'Query tracked Events records by broker, topic, category, status, idempotency, and date range.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string', topic: 'string?', category: 'string?', status: 'string?', idempotent: 'boolean?', startDate: 'Date?', endDate: 'Date?', page: 'number?', limit: 'number?' },
+        outputSchema: { events: 'array', total: 'number', page: 'number', limit: 'number', hasMore: 'boolean' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'page/limit with total and hasMore',
+        mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.getEvent', description: 'Fetch one tracked Events record by ID.',
+        inputSchema: { product: 'string', eventId: 'string' },
+        outputSchema: { event: 'tracked event or null' },
+        requiredIdentifiers: ['product', 'eventId'], ...runtimeRead,
+        environmentRequirements: 'the event ID must belong to the selected product',
+        idempotency: 'read-only', pagination: 'none',
+        mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.getEventStats', description: 'Fetch aggregate tracked event statistics.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string' },
+        outputSchema: { total_events: 'number', failed_count: 'number', success_count: 'number', status_breakdown: 'object?' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'none',
+        mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.messages.getDeadLetters', description: 'List messages whose managed consumer delivery attempts were exhausted.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string', topicTag: 'string?', consumerTag: 'string?', startDate: 'ISO date?', endDate: 'ISO date?', page: 'number?', limit: 'number?' },
+        outputSchema: { deadLetters: 'array', total: 'number', page: 'number', limit: 'number', hasMore: 'boolean' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'page/limit with total and hasMore', mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.reprocessDLQ', description: 'Requeue selected or bounded dead-lettered messages for Ductape-managed delivery.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string', topicTag: 'string?', messageIds: 'string[]?', limit: 'number?' },
+        outputSchema: { reprocessed: 'number', failed: 'number', messageIds: 'string[]?' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        permissions: 'publishable-key runtime mutation access plus product/environment access',
+        idempotency: 'may redeliver; consumer mutation must be idempotent', pagination: 'bounded by messageIds or limit, not page-based',
+        applicableStates: ['dead-lettered', 'provider-ready'], mutatesState: true, mayIncurProviderCost: true,
+    },
+    {
+        name: 'events.replayEvent', description: 'Replay one tracked event by event identifier.',
+        inputSchema: { product: 'string', env: 'string', eventId: 'string', force: 'boolean?' },
+        outputSchema: { replayed: 'boolean', eventId: 'string', messageId: 'string?' },
+        requiredIdentifiers: ['product', 'env', 'eventId'], ...runtimeRead,
+        permissions: 'publishable-key runtime mutation access plus product/environment access',
+        idempotency: 'replay intentionally redelivers; force may bypass replay guards; consumer mutation must be idempotent',
+        pagination: 'none', applicableStates: ['tracked', 'failed', 'dead-lettered'],
+        mutatesState: true, mayIncurProviderCost: true,
+    },
+    {
+        name: 'events.messages.getStats', description: 'Return aggregate delivery and failure statistics.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string' },
+        outputSchema: { totals: 'object', delivery: 'object', failures: 'object' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'none', mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.messages.getDashboard', description: 'Return operational overview, recent messages, and recovery indicators.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string' },
+        outputSchema: { overview: 'object', recent_messages: 'array', health: 'object?' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'fixed dashboard window', mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.messages.getProducers', description: 'List observed producers.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string', topicTag: 'string?', page: 'number?', limit: 'number?' },
+        outputSchema: { producers: 'array', total: 'number', page: 'number', limit: 'number', hasMore: 'boolean' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'page/limit', mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.messages.getConsumers', description: 'List observed consumers and bindings.',
+        inputSchema: { product: 'string', env: 'string', brokerTag: 'string', topicTag: 'string?', page: 'number?', limit: 'number?' },
+        outputSchema: { consumers: 'array', total: 'number', page: 'number', limit: 'number', hasMore: 'boolean' },
+        requiredIdentifiers: ['product', 'env', 'brokerTag'], ...runtimeRead,
+        idempotency: 'read-only', pagination: 'page/limit', mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.checkIdempotency', description: 'Check whether a publication idempotency key has already been accepted.',
+        inputSchema: { product: 'string', env: 'string', idempotencyKey: 'string' },
+        outputSchema: { exists: 'boolean', event_id: 'string?' }, requiredIdentifiers: ['product', 'env', 'idempotencyKey'],
+        ...runtimeRead, idempotency: 'read-only idempotency lookup', pagination: 'none',
+        mutatesState: false, mayIncurProviderCost: false,
+    },
+    {
+        name: 'events.testConnection', description: 'Test the configured provider connection for one Events environment.',
+        inputSchema: { product: 'string', env: 'string', broker: 'string' },
+        outputSchema: { connected: 'boolean', latency: 'number?', error: 'string?' },
+        requiredIdentifiers: ['product', 'env', 'broker'], ...runtimeRead,
+        idempotency: 'read-only connection probe', pagination: 'none',
+        mutatesState: false, mayIncurProviderCost: false,
+    },
+];
+export function eventsCapabilityOverview() {
+    return {
+        capability: 'events',
+        aliases: ['messageBrokers', 'brokers', 'messaging'],
+        implementationWarning: EVENTS_IMPLEMENTATION_WARNING,
+        deliverySemantics: EVENTS_DELIVERY_SEMANTICS,
+        recoverySearchTerms: EVENTS_RECOVERY_SEARCH_TERMS,
+        documentationTopics: ['events', 'resilience'],
+        providerCapabilities: EVENTS_PROVIDER_CAPABILITIES,
+        operations: EVENTS_OPERATION_REGISTRY,
+    };
+}
+export function searchEventsCapabilities(query) {
+    const normalized = query.toLowerCase();
+    const recoveryMatch = EVENTS_RECOVERY_SEARCH_TERMS.some(term => normalized.includes(term));
+    const operations = EVENTS_OPERATION_REGISTRY.filter(operation => recoveryMatch
+        ? /deadletter|reprocess|replay|query|getstats|getdashboard/i.test(operation.name)
+        : `${operation.name} ${operation.description}`.toLowerCase().includes(normalized));
+    return { query, canonicalTopic: 'events', recoveryMatch, deliverySemantics: EVENTS_DELIVERY_SEMANTICS, operations };
+}
+export function inspectEventsComponent(component) {
+    const environments = (component?.envs || []).map((env) => ({
+        slug: env.slug ?? env.env_slug ?? null,
+        provider: env.type ?? component.type ?? null,
+        connection: env.cloud ?? env.instance ?? (env.config ? 'configured' : null),
+        retryPolicy: env.retryPolicy ?? component.retryPolicy ?? 'provider-default',
+        maximumDeliveryAttempts: env.maxDeliveryAttempts ?? component.maxDeliveryAttempts ?? 'provider-controlled-or-unverified',
+        acknowledgementDeadline: env.acknowledgementDeadline ?? component.acknowledgementDeadline ?? 'provider-controlled-or-unverified',
+        backoff: env.backoff ?? component.backoff ?? 'provider-controlled-or-unverified',
+        dlq: env.dlq ?? component.dlq ?? { configured: 'unverified', managedBy: 'ductape' },
+        retention: env.retention ?? component.retention ?? 'provider-controlled-or-unverified',
+        ordering: env.ordering ?? component.ordering ?? 'provider-controlled-or-unverified',
+        filters: env.filters ?? component.filters ?? 'none-configured-or-unverified',
+        providerCapabilities: EVENTS_PROVIDER_CAPABILITIES[env.type ?? component.type] ??
+            { status: 'unsupported-or-unknown-provider; inspect live provider configuration' },
+    }));
+    return {
+        component,
+        provider: component?.type ?? 'environment-specific',
+        environments,
+        topics: component?.topics ?? [],
+        subscriptions: component?.subscriptions ?? 'provider-controlled-or-unverified',
+        consumerBindings: component?.consumers ?? [],
+        messageStatistics: 'Call events.messages.getStats or events.messages.getDashboard with product, env, and brokerTag.',
+        availableOperationalActions: EVENTS_OPERATION_REGISTRY,
+        deliverySemantics: EVENTS_DELIVERY_SEMANTICS,
+        implementationWarning: EVENTS_IMPLEMENTATION_WARNING,
+        configurationWarnings: environments
+            .filter((env) => env.retryPolicy === 'provider-default' || env.dlq?.configured === 'unverified')
+            .map((env) => `${env.slug ?? 'unknown env'}: retry/DLQ configuration is not verified; provider defaults may apply.`),
+        documentationTopics: ['events', 'resilience'],
+    };
+}

package/dist/index.js

@@ -15,6 +15,7 @@ import { homedir } from 'os';
 import { delimiter, join } from 'path';
 import { z } from 'zod';
 import { executeViaProxy, generateExecutablePayload, getAssetSchemas, } from './proxy-client.js';
+import { EVENTS_DELIVERY_SEMANTICS, EVENTS_IMPLEMENTATION_WARNING, eventsCapabilityOverview, inspectEventsComponent, searchEventsCapabilities, } from './events-capabilities.js';
 const MODULES = [
     'product', 'app', 'databases', 'graph', 'webhooks', 'notifications',
     'events', 'messageBrokers', 'storage', 'vector', 'caches', 'sessions', 'quotas',
@@ -556,6 +557,14 @@ ALL params are passed as a JSON array in positional order matching the SDK signa
   events.messages.getDeadLetters [{ product, env, brokerTag, topicTag?, consumerTag?, startDate?, endDate?, page?, limit? }]
   events.messages.getStats      [{ product, env, brokerTag }]
   events.messages.getDashboard  [{ product, env, brokerTag }]
+  events.getEvents              [{ product, env, brokerTag, topic?, category?, status?, idempotent?, startDate?, endDate?, page?, limit? }]
+  events.getEvent               [{ product, eventId }]
+  events.getEventStats          [{ product, env, brokerTag }]
+  events.replayEvent            [{ product, env, eventId, force? }]
+  events.reprocessDLQ           [{ product, env, brokerTag, topicTag?, messageIds?, limit? }]
+  events.publishIdempotent      [{ product, env, event, message, idempotencyKey, idempotencyTtl? }]
+  events.checkIdempotency       [{ product, env, idempotencyKey }]
+  events.testConnection         [{ product, env, broker }]
 
 ━━━ MODULE: storage ━━━
   storage.create   [{ product: string, tag: string, name: string, description?: string, envs: [{ slug: string, type: "aws"|"azure"|"gcp", config: { bucket?: string, region?: string, accessKeyId?: string, secretAccessKey?: string, containerName?: string, connectionString?: string, projectId?: string, keyFilename?: string } }] }]
@@ -1340,7 +1349,19 @@ const docsInputSchema = z.object({
     topic: z.string().describe('Feature topic to look up. Supported: ' +
         'transactions, presave, triggers, aggregations, migrations, indexes, performance, actions, ' +
         'graphs, storage, cloud, vector, warehouse, secrets, apps, products, sessions, caches, ' +
-        'notifications, resilience, features, events, logs, migration, frontend, frontend-analytics, client, react, vue'),
+        'notifications, resilience, features, portable-functions, events, logs, migration, frontend, frontend-analytics, client, react, vue'),
+});
+const eventsDiscoveryInputSchema = z.object({
+    query: z.string().optional().describe('Capability or recovery search, including DLQ, dead letter, failed messages, retry, poison message, replay, or consumer failure.'),
+    product: z.string().optional().describe('Product tag used for live component inspection.'),
+    component: z.string().optional().describe('Events component/broker tag used for live inspection.'),
+});
+const portableFunctionSetupInputSchema = z.object({
+    framework: z.enum(['express', 'nestjs', 'fastify', 'other']).describe('Application HTTP framework.'),
+    base_url: z.string().url().describe('Externally reachable HTTPS origin. HTTP is accepted only for localhost development.'),
+    namespace: z.string().min(1).describe('Portable function namespace.'),
+    version: z.string().min(1).describe('Contract version.'),
+    operations: z.array(z.string().min(1)).min(1).describe('Operation names that must be registered and exposed.'),
 });
 const migrationInputSchema = z.object({
     source: z.string().describe('Absolute path to the existing codebase.'),
@@ -1357,6 +1378,65 @@ const migrationInputSchema = z.object({
     write: z.boolean().optional().default(false).describe('Write redacted advisory artifacts only. This never writes application code or executable Ductape assets.'),
 });
 const DOCS = {
+    'portable-functions': `
+PORTABLE APPLICATION FUNCTIONS
+
+Use portable functions when a Feature needs application-owned logic that cannot be expressed with
+database, action, Event, storage, graph, vector, session, quota, fallback, or transform primitives.
+
+Non-negotiable rule: arbitrary JavaScript/TypeScript callbacks are not serializable. Never write
+ctx.step('x', () => applicationService.method()) and assume the method will run elsewhere. The
+Feature compiler must reject a step that records no portable operation.
+
+Canonical TypeScript pattern:
+  const AuthFunctions = defineFunctions({
+    namespace: 'statecraft-auth', version: '1',
+    operations: {
+      register: {
+        input: { type: 'object', required: ['email', 'password'], properties: {
+          email: { type: 'string' }, password: { type: 'string', minLength: 12 }
+        }, additionalProperties: false },
+        output: { type: 'object', required: ['token', 'player'], properties: {
+          token: { type: 'string' }, player: { type: 'object' }
+        } },
+        transports: [{ type: 'local' }],
+        handler: (input, context) => authService.register(input.email, input.password)
+      }
+    }
+  });
+  ductape.functions.register(AuthFunctions);
+  await ductape.feature.define({
+    tag: 'register-player', name: 'Register Player',
+    input: { email: { type: 'string', required: true }, password: { type: 'string', required: true } },
+    handler: async ctx => {
+      const auth = ctx.functions.use(AuthFunctions);
+      return ctx.step('register', () => auth.register({ email: ctx.input.email, password: ctx.input.password }));
+    }
+  });
+
+The compiled step stores namespace, operation, version, input/output JSON Schemas, timeout,
+idempotency declaration, and permitted transports. It never stores the handler or a sample result.
+
+Resolution order is local registered handler, then a contract-declared signed HTTP transport.
+HTTP function calls use Ductape HMAC-SHA256 headers. Raw arbitrary URLs and unsigned invocation are
+not supported. Application endpoints should use handlePortableFunctionHttpRequest and must receive
+the raw request body so signature verification covers exactly the bytes sent.
+
+The feature session is inherited automatically in invocation.context.session, not mixed into the
+business input. Invocation context also includes product, env, workspace_id, feature_id,
+feature_tag, step_tag, invocation_id, and deadline_at.
+
+Failure behavior is strict:
+  FUNCTION_UNAVAILABLE                 no local handler or configured HTTP transport
+  FUNCTION_SCHEMA_VALIDATION_FAILED    input or output violates the contract
+  FUNCTION_SIGNATURE_INVALID           HTTP signature is absent, invalid, or expired
+  FUNCTION_CORRELATION_MISMATCH         response invocation_id differs from request
+  FUNCTION_TIMEOUT                     operation exceeded its declared deadline
+
+Do not invent a function contract. Inspect the application's defineFunctions declarations and use
+the exact namespace, operation, version, schemas, and transports. If no contract exists, add one in
+application code and explicitly register its runtime implementation.
+`.trim(),
     migration: `
 DUCTAPE CODEBASE MIGRATION GUIDE
 
@@ -2807,6 +2887,13 @@ DUCTAPE RESILIENCE
 Resilience covers three mechanisms: quotas (rate-limited provider pools), fallbacks (automatic
 provider switching), and healthchecks (continuous probe monitoring with failure actions).
 
+EVENTS DELIVERY BOUNDARY
+  Events transport retries, exhausted-delivery DLQs, replay, and reprocessing are Ductape
+  responsibilities. Applications own transactional outboxes at the database-to-publication
+  boundary, domain rejection records, and idempotent/replay-safe consumer mutations. Never advise
+  a parallel application transport DLQ. See ductape_docs({ topic: "events" }) and
+  ductape_events_discover({ query: "consumer failure" }).
+
 CONFIGURATION BOUNDARY
   Quotas, fallbacks, and health checks are administrative product configuration. Manage them with
   the authenticated CLI:
@@ -3263,7 +3350,8 @@ STEP 2 — INVENTORY existing Ductape components
 STEP 3 — PLAN each step
   For every logical step:
     a. Identify whether it is local domain logic, a child Feature, or an existing Ductape component.
-       Local typed domain logic may run inside ctx.step; it does not require an Event or App.
+       Application-owned logic must be a registered portable function called through ctx.functions.
+       A plain callback that calls an application service is not serializable and must fail compilation.
        If a step calls an external service, it MUST go through a registered Ductape App.
        If no App for that service exists in the product → mark it "App to create: <service name>".
        DO NOT plan a raw HTTP call, a direct dispatch to a URL, or any workaround in place of a missing App.
@@ -3271,6 +3359,14 @@ STEP 3 — PLAN each step
     c. Decide if a rollback handler is needed (e.g. charge → refund on later failure).
        Rollback is optional and is not a Feature qualification requirement.
     d. Decide allow_fail: true for non-critical steps (email, analytics, audit logs)
+    e. If the step needs application-owned code, search the repository for an existing
+       defineFunctions contract and runtime registration. If none exists, design the exact contract.
+       Then ALWAYS call ductape_function_setup with the detected framework, namespace, version,
+       operations, and intended external base URL. Proactively inspect deployment configuration to
+       discover that URL and implement both local registration and the signed HTTPS adapter. If no
+       deployable HTTPS origin exists, report that explicit blocker instead of stopping at a local-only
+       setup. Do not mark the function remotely available until the
+       well-known route is reachable and rejects an invalid signature with HTTP 401.
 
 STEP 4 — PRESENT the plan and get approval BEFORE writing any code or creating anything
   Show the user:
@@ -3323,7 +3419,7 @@ STEP 8 — SET rollbacks for reversible steps
       async (result) => ctx.api.run({ app: 'stripe', event: 'refund', input: { chargeId: result.id } })
     );
 
-Step types: local_domain | action | database | graph | notification | storage | produce | quota |
+Step types: function | action | database | graph | notification | storage | produce | quota |
   fallback | vector | child_feature | sleep | wait_for_signal | checkpoint
 
 Valid synchronous Feature candidates include generate-world, resolve-nation-turn,
@@ -3429,10 +3525,12 @@ When you call features.define({ handler }), the handler runs TWICE:
   outer handler body. Code in the outer body runs during recording with proxy values and
   may behave unexpectedly (e.g. typeof proxy === 'object' is true but .someField is a proxy).
 
-  A ctx.step callback may call ordinary local domain functions and injected/application services
-  available to the registration scope. This is the normal shape for a synchronous capability such
-  as pricing, entitlement evaluation, route-capacity calculation, or turn resolution. Keep the
-  meaningful work inside ctx.step callbacks so recording does not execute it.
+  A ctx.step callback MUST NOT close over ordinary local domain functions or injected/application
+  services. Closures are not portable and compilation fails closed. Define application-owned logic
+  with defineFunctions, register its local runtime handler, and invoke it through ctx.functions.
+  The MCP workflow must also attempt secure remote availability: detect the framework and deployment
+  origin, install the signed well-known HTTPS adapter, and verify it. Local registration alone is
+  insufficient for a Feature intended to execute outside the application process.
 
   Use an Event when the operation genuinely crosses an asynchronous process/service boundary,
   needs broker delivery semantics, or must be consumed independently. Do not produce an Event merely
@@ -3471,6 +3569,19 @@ When you call features.define({ handler }), the handler runs TWICE:
     events: `
 DUCTAPE EVENTS (MESSAGE BROKERS)
 
+RELIABILITY OWNERSHIP — DO NOT DUPLICATE THE TRANSPORT DLQ
+  Ductape owns broker delivery retries, exhausted-delivery dead-letter handling, replay,
+  reprocessing, and message observability. Do not build a parallel MongoDB/application transport
+  DLQ. The application may use a transactional outbox only to bridge its canonical database commit
+  to Ductape publication. Domain-invalid or rejected commands remain application records and are
+  not transport dead letters. Every consumer mutation must be idempotent and replay-safe.
+  Recovery operations: events.messages.getDeadLetters, events.reprocessDLQ, events.replayEvent,
+  events.messages.query, events.messages.getStats, and events.messages.getDashboard.
+  Structured contracts and live component inspection:
+    ductape_events_discover({ query: "DLQ" })
+    ductape_events_discover({ product: "<product-tag>", component: "<events-tag>" })
+  Resilience boundary reference: ductape_docs({ topic: "resilience" }).
+
 ARCHITECTURE — always two separate steps:
   Step 1: Register the BROKER COMPONENT (establishes the connection to the broker service).
           The broker's envs[] holds connection credentials and host/project info, NOT topics.
@@ -3775,6 +3886,9 @@ Import (register an EXISTING cloud resource):
   events.messages.getDeadLetters [{ product, env, brokerTag, topicTag?, consumerTag?, limit? }]
   events.messages.getProducers [{ product, env, brokerTag, topicTag?, page?, limit? }]
   events.messages.getConsumers [{ product, env, brokerTag, topicTag?, page?, limit? }]
+  events.getEvents              [{ product, env, brokerTag, topic?, category?, status?, idempotent?, startDate?, endDate?, page?, limit? }]
+  events.getEvent               [{ product, eventId }]
+  events.getEventStats          [{ product, env, brokerTag }]
   events.replayEvent           [{ product, env, eventId, force? }]
   events.reprocessDLQ         [{ product, env, brokerTag, topicTag?, messageIds?, limit? }]
   events.checkIdempotency      [{ product, env, brokerTag, idempotency_key }]
@@ -4371,7 +4485,9 @@ DEPRECATED ALIASES
 `.trim(),
 };
 const docsHandler = async (args) => {
-    const key = args.topic.toLowerCase().trim();
+    const requested = args.topic.toLowerCase().trim();
+    const recoveryAliases = /^(dlq|dead[- ]?letters?|failed messages?|retry|retries|poison messages?|replay|reprocess|consumer failures?)$/;
+    const key = recoveryAliases.test(requested) ? 'events' : requested;
     const doc = DOCS[key];
     if (!doc) {
         const available = Object.keys(DOCS).join(', ');
@@ -4379,7 +4495,67 @@ const docsHandler = async (args) => {
             content: [{ type: 'text', text: `Unknown topic "${args.topic}". Available topics: ${available}` }],
         };
     }
-    return { content: [{ type: 'text', text: doc }] };
+    const structured = key === 'events'
+        ? `\n\nSTRUCTURED EVENTS CAPABILITY INDEX\n${JSON.stringify(eventsCapabilityOverview(), null, 2)}`
+        : key === 'resilience'
+            ? `\n\nEVENTS DELIVERY RESPONSIBILITY BOUNDARY\n${JSON.stringify({
+                implementationWarning: EVENTS_IMPLEMENTATION_WARNING,
+                deliverySemantics: EVENTS_DELIVERY_SEMANTICS,
+                canonicalDocumentationTopic: 'events',
+            }, null, 2)}`
+            : '';
+    return { content: [{ type: 'text', text: doc + structured }] };
+};
+const portableFunctionSetupHandler = async (args) => {
+    const parsed = new URL(args.base_url);
+    const local = parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1' || parsed.hostname === '::1';
+    if (parsed.protocol !== 'https:' && !(local && parsed.protocol === 'http:')) {
+        return { content: [{ type: 'text', text: JSON.stringify({
+                        ok: false,
+                        error: 'FUNCTION_INSECURE_TRANSPORT',
+                        message: 'Use HTTPS for portable function endpoints. HTTP is allowed only for localhost development.',
+                    }, null, 2) }], isError: true };
+    }
+    const base = args.base_url.replace(/\/$/, '');
+    const routes = args.operations.map(operation => ({
+        operation,
+        url: `${base}/.well-known/ductape/functions/${encodeURIComponent(args.namespace)}/${encodeURIComponent(args.version)}/${encodeURIComponent(operation)}`,
+    }));
+    const adapter = args.framework === 'nestjs'
+        ? `Configure rawBody: true in NestFactory.create, then add a POST controller route at\n` +
+            `/.well-known/ductape/functions/:namespace/:version/:operation. Pass request.rawBody, headers,\n` +
+            `and params to handlePortableFunctionHttpRequest(..., process.env.DUCTAPE_ACCESS_KEY!).`
+        : args.framework === 'fastify'
+            ? `Register a raw-body plugin for only the well-known function route, then pass rawBody, headers,\nparams to handlePortableFunctionHttpRequest(..., process.env.DUCTAPE_ACCESS_KEY!).`
+            : args.framework === 'express'
+                ? `Mount express.raw({ type: 'application/json' }) before JSON parsing on the well-known function route,\nthen pass request.body, headers, and params to handlePortableFunctionHttpRequest(..., process.env.DUCTAPE_ACCESS_KEY!).`
+                : `Preserve the exact raw JSON request bytes and pass body, headers, and route params to\nhandlePortableFunctionHttpRequest(..., process.env.DUCTAPE_ACCESS_KEY!).`;
+    return { content: [{ type: 'text', text: JSON.stringify({
+                    ok: true,
+                    requiredActions: [
+                        'Create or locate one defineFunctions contract with exact input/output JSON Schemas.',
+                        'Register handlers with ductape.functions.register during application startup.',
+                        `Set DUCTAPE_FUNCTION_BASE_URL=${JSON.stringify(base)} in the application runtime.`,
+                        'Mount the signed well-known HTTP adapter and preserve the exact raw body.',
+                        'Do not add bearer keys, access keys, static headers, or unsigned routes to Feature JSON.',
+                        'Verify invalid signatures receive HTTP 401 and missing handlers receive HTTP 503.',
+                        'Execute each operation and verify actual business state plus Feature/step processor records.',
+                    ],
+                    routes,
+                    adapter,
+                    security: {
+                        scheme: 'HMAC-SHA256',
+                        signedValue: '<timestamp>.<raw-request-body>',
+                        headers: ['X-Ductape-Invocation-Id', 'X-Ductape-Timestamp', 'X-Ductape-Signature', 'X-Ductape-Function'],
+                        replayToleranceMs: 300000,
+                        httpsRequired: !local,
+                    },
+                    stopConditions: [
+                        'Do not claim remote availability until the route is reachable from the intended executor.',
+                        'Do not compile a closure-only ctx.step; use ctx.functions.',
+                        'Do not fall back to sample output when a runtime is unavailable.',
+                    ],
+                }, null, 2) }] };
 };
 const cliInputSchema = z.object({
     command: z.string().describe('The ductape CLI command to run, without the leading "ductape" word. ' +
@@ -4528,6 +4704,74 @@ async function main() {
             ...(result.success ? {} : { isError: true }),
         };
     };
+    const eventsDiscoveryHandler = async (args) => {
+        try {
+            if (args.product || args.component) {
+                if (!args.product || !args.component) {
+                    throw new Error('Both product and component are required for live Events inspection.');
+                }
+                const result = await cliHandler({
+                    command: `products components get --product-tag ${shellArgument(args.product)} --type events --json`,
+                });
+                if (result.isError)
+                    return result;
+                const raw = result.content?.[0]?.text ?? '';
+                let parsed;
+                try {
+                    parsed = JSON.parse(raw);
+                }
+                catch {
+                    throw new Error(`Events inspection did not return JSON. ${raw}`);
+                }
+                const candidates = Array.isArray(parsed)
+                    ? parsed
+                    : Array.isArray(parsed?.events)
+                        ? parsed.events
+                        : Array.isArray(parsed?.messageBrokers)
+                            ? parsed.messageBrokers
+                            : [parsed];
+                const component = candidates.find((item) => item?.tag === args.component || item?._id === args.component);
+                if (!component) {
+                    throw new Error(`Events component "${args.component}" was not found in product "${args.product}". ` +
+                        'Use the exact component tag or ID returned by products components get --type events.');
+                }
+                const inspection = inspectEventsComponent(component);
+                const key = process.env.DUCTAPE_PUBLISHABLE_KEY;
+                if (key) {
+                    inspection.messageStatistics = {};
+                    for (const environment of inspection.environments) {
+                        if (!environment.slug)
+                            continue;
+                        try {
+                            inspection.messageStatistics[environment.slug] = await executeViaProxy(key, 'events', 'messages.getStats', [{ product: args.product, env: environment.slug, brokerTag: component.tag }]);
+                        }
+                        catch (error) {
+                            inspection.messageStatistics[environment.slug] = {
+                                status: 'unavailable',
+                                error: error instanceof Error ? error.message : String(error),
+                                remediation: 'Verify publishable-key permission, environment configuration, provider readiness, and the exact broker tag.',
+                            };
+                        }
+                    }
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(inspection, null, 2) }],
+                };
+            }
+            const data = args.query ? searchEventsCapabilities(args.query) : eventsCapabilityOverview();
+            return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: ${message}\nRemediation: verify product/component identifiers, CLI authentication, workspace selection, and environment/provider configuration.`,
+                    }],
+                isError: true,
+            };
+        }
+    };
     const migrationHandler = async (args) => {
         if (args.mode === 'new-codebase' && !args.destination) {
             return {
@@ -4687,7 +4931,13 @@ async function main() {
             if (args.method && !args.module) {
                 throw new Error('module is required when method is provided');
             }
-            const data = await getAssetSchemas(args.module, args.method);
+            const requestedMethod = args.method;
+            const schemaMethod = requestedMethod === 'events.create'
+                ? 'messageBrokers.create'
+                : requestedMethod === 'events.update'
+                    ? 'messageBrokers.update'
+                    : requestedMethod;
+            const data = await getAssetSchemas(args.module, schemaMethod);
             const compactData = args.module &&
                 !args.method &&
                 data &&
@@ -4700,7 +4950,36 @@ async function main() {
                     hint: `Call ductape_schema with module="${args.module}" and one method for its complete field schema`,
                 }
                 : data;
-            return { content: [{ type: 'text', text: JSON.stringify(compactData ?? null, null, 2) }] };
+            const isEventsSchema = args.module === 'product' &&
+                Boolean(requestedMethod && /^(events|messageBrokers)\.(create|update)$/.test(requestedMethod));
+            const enrichedData = isEventsSchema
+                ? {
+                    ...compactData,
+                    method: requestedMethod,
+                    eventsCapability: {
+                        implementationWarning: EVENTS_IMPLEMENTATION_WARNING,
+                        deliverySemantics: EVENTS_DELIVERY_SEMANTICS,
+                        operations: eventsCapabilityOverview().operations,
+                        configurationValidation: {
+                            retryOrDlqUnspecified: 'Warn that provider defaults apply and inspect the deployed provider asset before claiming DLQ availability.',
+                            unsupportedFields: 'The live Joi schema rejects provider settings not supported by the selected env type; use the reported field path and provider matrix for remediation.',
+                            costSensitive: 'Azure Service Bus tier must be confirmed; provider operations may incur usage charges.',
+                        },
+                        documentationTopics: ['events', 'resilience'],
+                    },
+                }
+                : args.module === 'product' && !requestedMethod
+                    ? {
+                        ...compactData,
+                        eventsOwnership: {
+                            implementationWarning: EVENTS_IMPLEMENTATION_WARNING,
+                            deliverySemantics: EVENTS_DELIVERY_SEMANTICS,
+                            schemaMethods: ['events.create', 'events.update', 'messageBrokers.create', 'messageBrokers.update'],
+                            discoveryTool: 'ductape_events_discover',
+                        },
+                    }
+                    : compactData;
+            return { content: [{ type: 'text', text: JSON.stringify(enrichedData ?? null, null, 2) }] };
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
@@ -4759,9 +5038,24 @@ async function main() {
                 'index strategy, operation types) that should be confirmed with the user first.\n\n' +
                 'Available topics: transactions, presave, triggers, aggregations, migrations, indexes, performance, actions, ' +
                 'graphs, storage, cloud, vector, warehouse, secrets, apps, products, sessions, caches, ' +
-                'notifications, resilience, features, events, logs, migration, frontend, frontend-analytics, client, react, vue',
+                'notifications, resilience, features, portable-functions, events, logs, migration, frontend, frontend-analytics, client, react, vue',
             inputSchema: docsInputSchema,
         }, docsHandler);
+        server.registerTool('ductape_events_discover', {
+            title: 'Ductape Events Capability Discovery',
+            description: 'Discover Ductape Events delivery ownership, retries, dead-letter queues, replay/reprocessing, observability operations, ' +
+                'live input/output contracts, and provider-aware component configuration. Search recovery synonyms with query, or pass ' +
+                'product and component together for live inspection. Ductape owns transport retries and exhausted-delivery DLQs; ' +
+                'applications own transactional outboxes, domain rejection handling, and idempotent consumer mutations.',
+            inputSchema: eventsDiscoveryInputSchema,
+        }, eventsDiscoveryHandler);
+        server.registerTool('ductape_function_setup', {
+            title: 'Ductape Portable Function Setup',
+            description: 'Generate the mandatory secure local + remote runtime setup for application functions used by Features. ' +
+                'Use this whenever feature code calls application-owned logic. The result requires a registered local handler, ' +
+                'a deterministic HTTPS endpoint, raw-body HMAC verification, runtime checks, and fail-closed behavior.',
+            inputSchema: portableFunctionSetupInputSchema,
+        }, portableFunctionSetupHandler);
         server.registerTool('ductape_migration_plan', {
             title: 'Ductape AI Migration Guidance',
             description: 'Inspect a TypeScript, Go, Java, or .NET repository without exposing secret values. ' +
@@ -4886,6 +5180,8 @@ async function main() {
         server.tool('ductape_generate_snippet', snippetGenerateInputSchema.shape, snippetGenerateHandler);
         server.tool('ductape_schema', schemaInputSchema.shape, schemaHandler);
         server.tool('ductape_docs', docsInputSchema.shape, docsHandler);
+        server.tool('ductape_events_discover', eventsDiscoveryInputSchema.shape, eventsDiscoveryHandler);
+        server.tool('ductape_function_setup', portableFunctionSetupInputSchema.shape, portableFunctionSetupHandler);
         server.tool('ductape_migration_plan', migrationInputSchema.shape, migrationHandler);
         server.tool('ductape_cli', cliInputSchema.shape, cliHandler);
     }

package/dist/proxy-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxy-client.d.ts","sourceRoot":"","sources":["../src/proxy-client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,YAAY,4BAA4B,CAAC;AAEtD,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,KAAK,GACL,WAAW,GACX,OAAO,GACP,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,SAAS,GACT,UAAU,GACV,MAAM,GACN,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,SAAS,CAAC;AAUd;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,GAAG,OAAO,EAC/C,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,OAAO,EAAO,GACrB,OAAO,CAAC,CAAC,CAAC,CAuBZ;AAED,MAAM,WAAW,iCAAiC;IAChD,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,kCAAkC;IACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AASD,wBAAsB,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAuBxF;AA4BD,wBAAsB,yBAAyB,CAAC,CAAC,GAAG,kCAAkC,EACpF,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,CAAC,CAAC,CAiCZ"}
+{"version":3,"file":"proxy-client.d.ts","sourceRoot":"","sources":["../src/proxy-client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,YAAY,4BAA4B,CAAC;AAEtD,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,KAAK,GACL,WAAW,GACX,OAAO,GACP,UAAU,GACV,eAAe,GACf,gBAAgB,GAChB,QAAQ,GACR,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,SAAS,GACT,UAAU,GACV,MAAM,GACN,MAAM,GACN,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,SAAS,CAAC;AAUd;;GAEG;AACH,wBAAsB,eAAe,CAAC,CAAC,GAAG,OAAO,EAC/C,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,OAAO,EAAO,GACrB,OAAO,CAAC,CAAC,CAAC,CAuBZ;AAED,MAAM,WAAW,iCAAiC;IAChD,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,CAAC;IACpD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,kCAAkC;IACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AA4BD,wBAAsB,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAoGxF;AA4BD,wBAAsB,yBAAyB,CAAC,CAAC,GAAG,kCAAkC,EACpF,OAAO,EAAE,iCAAiC,GACzC,OAAO,CAAC,CAAC,CAAC,CAiCZ"}

package/dist/proxy-client.js

@@ -28,28 +28,113 @@ export async function executeViaProxy(publishable_key, module, method, params =
     }
     return body.data?.data;
 }
+async function readJsonResponse(res, label) {
+    const contentType = res.headers.get('content-type')?.toLowerCase() ?? '';
+    if (!contentType.includes('json')) {
+        const responseText = await res.text();
+        const preview = responseText.replace(/\s+/g, ' ').trim().slice(0, 160);
+        throw new Error(`${label}: HTTP ${res.status} returned ${contentType || 'an unknown content type'}` +
+            (preview ? ` (${preview})` : ''));
+    }
+    try {
+        return await res.json();
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new Error(`${label}: HTTP ${res.status} returned invalid JSON (${detail})`);
+    }
+}
 export async function getAssetSchemas(module, method) {
     const path = module
         ? `/proxy/v1/schema/${encodeURIComponent(module)}${method ? `/${encodeURIComponent(method)}` : ''}`
         : '/proxy/v1/schema';
     const url = `${API_BASE_URL.replace(/\/$/, '')}${path}`;
     const res = await fetch(url);
-    const body = (await res.json());
     if (res.status === 404 && module && method) {
         const fallbackUrl = `${API_BASE_URL.replace(/\/$/, '')}/proxy/v1/schema/${encodeURIComponent(module)}`;
         const fallbackRes = await fetch(fallbackUrl);
-        const fallbackBody = (await fallbackRes.json());
-        const methodSchema = fallbackBody.data?.methods?.[method];
-        if (fallbackRes.ok && methodSchema) {
-            return { module, method, schema: methodSchema };
+        const fallbackBody = await readJsonResponse(fallbackRes, `Module schema fallback for ${module}.${method}`);
+        if (!fallbackRes.ok) {
+            throw new Error(fallbackBody.message ?? `Schema fallback request failed: ${fallbackRes.status}`);
+        }
+        if (typeof fallbackBody.status === 'boolean' && !fallbackBody.status) {
+            throw new Error(fallbackBody.message ?? 'Schema fallback fetch failed');
         }
+        const methods = fallbackBody.data?.method_schemas ?? fallbackBody.data?.methods;
+        const hasExactMethod = methods !== null && typeof methods === 'object' &&
+            !Array.isArray(methods) &&
+            Object.prototype.hasOwnProperty.call(methods, method);
+        const methodSchema = hasExactMethod ? methods[method] : undefined;
+        if (methodSchema !== null && typeof methodSchema === 'object') {
+            return {
+                module,
+                method,
+                schema: methodSchema,
+                resolution: {
+                    exact: true,
+                    source: fallbackBody.data?.method_schemas ? 'module.method_schemas' : 'module.methods',
+                    targeted_route_status: res.status,
+                    lookup_path: fallbackBody.data?.method_schemas
+                        ? `data.method_schemas[${JSON.stringify(method)}]`
+                        : `data.methods[${JSON.stringify(method)}]`,
+                },
+            };
+        }
+        if (Array.isArray(fallbackBody.data?.methods)) {
+            const rootUrl = `${API_BASE_URL.replace(/\/$/, '')}/proxy/v1/schema`;
+            const rootRes = await fetch(rootUrl);
+            const rootBody = await readJsonResponse(rootRes, `Root schema fallback for ${module}.${method}`);
+            if (!rootRes.ok) {
+                throw new Error(rootBody.message ?? `Root schema fallback request failed: ${rootRes.status}`);
+            }
+            if (typeof rootBody.status === 'boolean' && !rootBody.status) {
+                throw new Error(rootBody.message ?? 'Root schema fallback fetch failed');
+            }
+            const moduleSchemas = rootBody.data?.modules?.[module];
+            const hasRootMethod = moduleSchemas !== null && typeof moduleSchemas === 'object' &&
+                !Array.isArray(moduleSchemas) &&
+                Object.prototype.hasOwnProperty.call(moduleSchemas, method);
+            const rootMethodSchema = hasRootMethod ? moduleSchemas[method] : undefined;
+            if (rootMethodSchema !== null && typeof rootMethodSchema === 'object') {
+                return {
+                    module,
+                    method,
+                    schema: rootMethodSchema,
+                    resolution: {
+                        exact: true,
+                        source: 'root.modules',
+                        targeted_route_status: res.status,
+                        lookup_path: `data.modules[${JSON.stringify(module)}][${JSON.stringify(method)}]`,
+                    },
+                };
+            }
+        }
+        throw new Error(hasExactMethod
+            ? `Schema method "${method}" in the ${module} module schema is malformed`
+            : `Schema method "${method}" was not found in the ${module} module schema`);
     }
+    const body = await readJsonResponse(res, 'Schema request');
     if (!res.ok) {
         throw new Error(body.message ?? `Schema request failed: ${res.status}`);
     }
     if (typeof body.status === 'boolean' && !body.status) {
         throw new Error(body.message ?? 'Schema fetch failed');
     }
+    if (module && method) {
+        if (body.data === null || typeof body.data !== 'object') {
+            throw new Error(`Targeted schema response for ${module}.${method} is malformed`);
+        }
+        return {
+            module,
+            method,
+            schema: body.data,
+            resolution: {
+                exact: true,
+                source: 'targeted-route',
+                targeted_route_status: res.status,
+            },
+        };
+    }
     return body.data;
 }
 function normalizeTargets(targets) {

package/docs/TOOLS.md

@@ -1,6 +1,12 @@
 # MCP Tools Reference
 
-The Ductape MCP server exposes **one tool**. All operations go through the backend proxy; the list of allowed modules and methods is enforced by the proxy
+The Ductape MCP server exposes proxy, CLI, discovery, documentation, migration, and portable-function setup tools.
+
+## Tool: `ductape_function_setup`
+
+Produces the mandatory local registry and signed HTTPS exposure plan for portable application
+functions referenced by Features. The route is
+`/.well-known/ductape/functions/:namespace/:version/:operation` and requests use HMAC-SHA256.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/mcp",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "MCP server that exposes Ductape SDK operations via the backend proxy",
   "type": "module",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "node scripts/check-frontend-analytics-guidance.mjs",
+    "test": "npm run build && node scripts/check-frontend-analytics-guidance.mjs && node scripts/check-events-discovery.mjs && node scripts/check-schema-fallback.mjs && node scripts/check-portable-functions.mjs",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts"
   },