@claude-flow/plugin-agent-federation 1.0.4 → 1.0.5

package/dist/mcp-tools.d.ts

@@ -0,0 +1,10 @@
+import type { MCPToolDefinition } from '@claude-flow/shared/src/plugin-interface.js';
+import type { PluginContext } from '@claude-flow/shared/src/plugin-interface.js';
+import type { FederationCoordinator } from './application/federation-coordinator.js';
+import type { WgMeshService } from './domain/services/wg-mesh-service.js';
+type CoordinatorGetter = () => FederationCoordinator | null;
+type ContextGetter = () => PluginContext | null;
+type WgMeshGetter = () => WgMeshService | null;
+export declare function createMcpTools(getCoordinator: CoordinatorGetter, getContext: ContextGetter, getWgMesh?: WgMeshGetter): MCPToolDefinition[];
+export {};
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/plugin.d.ts

@@ -0,0 +1,19 @@
+import type { ClaudeFlowPlugin, PluginContext, MCPToolDefinition, CLICommandDefinition, AgentTypeDefinition } from '@claude-flow/shared/src/plugin-interface.js';
+export declare class AgentFederationPlugin implements ClaudeFlowPlugin {
+    readonly name = "@claude-flow/plugin-agent-federation";
+    readonly version: "1.0.0-alpha.18";
+    readonly description = "Cross-installation agent federation with PII protection and AI defence";
+    readonly author = "Claude Flow Team";
+    readonly dependencies: string[];
+    private coordinator;
+    private context;
+    private transport;
+    private agentCardServer;
+    initialize(context: PluginContext): Promise<void>;
+    shutdown(): Promise<void>;
+    registerMCPTools(): MCPToolDefinition[];
+    registerCLICommands(): CLICommandDefinition[];
+    registerAgentTypes(): AgentTypeDefinition[];
+    healthCheck(): Promise<boolean>;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/transport/midstream-aware-loader.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Midstream-aware federation transport loader (ADR-120, Step 2).
+ *
+ * Extends the agentic-flow `loadQuicTransport` loader pattern with a
+ * preferred branch that probes `midstreamer` first. When `midstreamer`
+ * ships real QUIC (currently the WASM build is a counter-tracking
+ * stub per ADR-119), this loader picks it up automatically without
+ * any change to consumer plugins.
+ *
+ * Resolution order:
+ *
+ *   1. If `MIDSTREAMER_QUIC_NATIVE=1` AND the `midstreamer` module
+ *      exposes a real `QuicMultistream`-derived `AgentTransport`,
+ *      use it. (Today: probes fail closed and we fall through.)
+ *
+ *   2. Otherwise: defer to agentic-flow's existing loader, which
+ *      itself respects `AGENTIC_FLOW_QUIC_NATIVE=1` (ADR-108) and
+ *      falls back to WebSocket (ADR-104) otherwise.
+ *
+ * The loader is opt-in: callers must explicitly invoke
+ * `loadFederationTransport()` instead of `loadQuicTransport()`.
+ * Behavior is identical to `loadQuicTransport()` until upstream
+ * `midstreamer` ships its real QUIC build AND the operator sets the
+ * env flag — so this change is safe to land before any of that
+ * happens.
+ *
+ * Re-exports the `AgentTransport` / `AgentMessage` / `QuicTransportConfig`
+ * surface from agentic-flow so consumers only import from one place.
+ */
+export interface AgentMessage {
+    id: string;
+    type: 'task' | 'result' | 'status' | 'coordination' | 'heartbeat' | string;
+    payload: unknown;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface AgentTransport {
+    send: (address: string, message: AgentMessage) => Promise<void>;
+    onMessage: (handler: (address: string, message: AgentMessage) => void) => void;
+    listen?: (port: number, host?: string) => Promise<void>;
+    close?: () => Promise<void> | void;
+    [key: string]: unknown;
+}
+export interface QuicTransportConfig {
+    port?: number;
+    host?: string;
+    serverName?: string;
+    [key: string]: unknown;
+}
+/** Result envelope describing which backend the loader picked. */
+export interface LoadedFederationTransport {
+    /** The live transport. Send/receive against this. */
+    transport: AgentTransport;
+    /** Which loader branch resolved. Useful for logs/metrics. */
+    source: 'midstreamer-native' | 'agentic-flow-loader' | 'websocket-fallback';
+    /** Free-form note when a probe failed (helps explain a fallback). */
+    fallbackReason?: string;
+}
+/**
+ * Top-level loader for federation transport. Identical signature to
+ * agentic-flow's `loadQuicTransport`, but with the midstreamer-first
+ * preference. Use this from `plugins/ruflo-federation` in place of
+ * the bare `loadQuicTransport`.
+ *
+ * Failure mode: if midstreamer is requested but rejects (stub, init
+ * error, missing package), this function falls through to the
+ * agentic-flow loader. If current agentic-flow does not export its
+ * historical loader subpath, the plugin-owned WebSocket fallback is
+ * used directly (ADR-104, #2618).
+ */
+export declare function loadFederationTransport(config?: QuicTransportConfig): Promise<LoadedFederationTransport>;
+//# sourceMappingURL=midstream-aware-loader.d.ts.map

package/dist/version.d.ts

@@ -0,0 +1,3 @@
+/** Single source of truth for runtime, manifest, CLI, and MCP version metadata. */
+export declare const FEDERATION_PLUGIN_VERSION: "1.0.0-alpha.18";
+//# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/plugin-agent-federation",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Cross-installation agent federation with zero-trust security, PII-gated data flow, and compliance-grade audit trails.",
   "homepage": "https://github.com/ruvnet/ruflo",
   "type": "module",