@terminals-tech/sdk 1.0.0-rc.1 → 1.0.0

package/dist/mcp-NK34ZNM5.js

@@ -0,0 +1,101 @@
+import {
+  isNetworkAllowed,
+  requireNetworkApproval
+} from "./chunk-UJDUQNE2.js";
+import "./chunk-WGBCRNMB.js";
+import "./chunk-3LFMIVJM.js";
+import "./chunk-AFDUOYHD.js";
+import "./chunk-NTMBOESX.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/machines/core/runners/mcp.ts
+function extractUrls(input) {
+  const urls = [];
+  const extract = (obj) => {
+    if (typeof obj === "string") {
+      try {
+        const url = new URL(obj);
+        if (url.protocol === "http:" || url.protocol === "https:") {
+          urls.push(obj);
+        }
+      } catch {
+      }
+    } else if (Array.isArray(obj)) {
+      obj.forEach(extract);
+    } else if (obj && typeof obj === "object") {
+      Object.values(obj).forEach(extract);
+    }
+  };
+  extract(input);
+  return urls;
+}
+async function runMcpNode(manifest, input, ctx) {
+  const mcpConfig = manifest.mcp;
+  const server = mcpConfig?.server;
+  if (server) {
+    const allowed = isNetworkAllowed(ctx.policies, server) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx.policies, server);
+    if (!allowed) {
+      return {
+        input,
+        runtime: "mcp:policy-denied",
+        error: `MCP server egress denied: ${server}`
+      };
+    }
+  }
+  const inputUrls = extractUrls(input);
+  for (const url of inputUrls) {
+    const allowed = isNetworkAllowed(ctx.policies, url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx.policies, url);
+    if (!allowed) {
+      return {
+        input,
+        runtime: "mcp:policy-denied",
+        error: `Network egress denied for URL in input: ${url}`
+      };
+    }
+  }
+  const { MCPClientServiceBrowser } = await import("./mcp-client-service-browser-SGB2K3VZ.js");
+  const mcpClient = MCPClientServiceBrowser.getInstance();
+  const servers = mcpClient.getServers();
+  const targetServer = servers.find(
+    (s) => s.id === mcpConfig?.provider || s.name === mcpConfig?.provider || s.process?.serverUrl === server
+  );
+  if (!targetServer) {
+    return {
+      input,
+      runtime: "mcp:error",
+      error: `No MCP server available for provider: ${mcpConfig?.provider || "unknown"}`
+    };
+  }
+  const toolName = mcpConfig?.tool || input.tool;
+  if (toolName) {
+    try {
+      const result = await mcpClient.executeTool(targetServer.id, toolName, input);
+      return {
+        input,
+        runtime: "mcp",
+        serverId: targetServer.id,
+        tool: toolName,
+        result
+      };
+    } catch (error) {
+      return {
+        input,
+        runtime: "mcp:error",
+        serverId: targetServer.id,
+        tool: toolName,
+        error: error.message
+      };
+    }
+  }
+  return {
+    input,
+    runtime: "mcp",
+    serverId: targetServer.id,
+    serverName: targetServer.name,
+    status: targetServer.status,
+    availableTools: targetServer.tools?.map((t) => t.name) || []
+  };
+}
+export {
+  runMcpNode
+};

package/dist/mcp-client-service-browser-SGB2K3VZ.js

@@ -0,0 +1,14 @@
+import {
+  KNOWN_MCP_SERVERS,
+  MCPClientServiceBrowser,
+  mcp_client_service_browser_default
+} from "./chunk-DKFJIILR.js";
+import "./chunk-KHR7ZYCX.js";
+import "./chunk-OSSRZOGC.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  KNOWN_MCP_SERVERS,
+  MCPClientServiceBrowser,
+  mcp_client_service_browser_default as default
+};

package/dist/neuro-state-XHRGIRVO.js

@@ -0,0 +1,498 @@
+import {
+  onOrchestratorEvent
+} from "./chunk-Q2VI6ICE.js";
+import "./chunk-PWAHFID5.js";
+import "./chunk-Y2EULKA2.js";
+import "./chunk-BCOQMFKT.js";
+import {
+  getSignalBus
+} from "./chunk-2WTYE4SW.js";
+import "./chunk-FOXUEYWK.js";
+import "./chunk-EXI3LJVJ.js";
+import "./chunk-QJFKEQHF.js";
+import "./chunk-ZVO47SQV.js";
+import "./chunk-WGBCRNMB.js";
+import "./chunk-3LFMIVJM.js";
+import "./chunk-AFDUOYHD.js";
+import "./chunk-NTMBOESX.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../../lib/terminals-tech/brains/neuro-state.ts
+import { BehaviorSubject as BehaviorSubject2, combineLatest as combineLatest2, interval, map as map2 } from "rxjs";
+
+// ../../lib/terminals-tech/brains/core/coherence-streams.ts
+import { BehaviorSubject, combineLatest, distinctUntilChanged, map } from "rxjs";
+var DEFAULT_WEIGHTS = {
+  grounding: 0.4,
+  internal: 0.3,
+  crystallization: 0.3
+};
+var CoherenceStreams = class {
+  // ========== Internal State Subjects ==========
+  loadLevel$ = new BehaviorSubject("normal");
+  groundingFactors$ = new BehaviorSubject([]);
+  internalFactors$ = new BehaviorSubject([]);
+  crystallizationFactors$ = new BehaviorSubject([]);
+  // ========== Public Observable Streams ==========
+  /**
+   * Grounding score stream (0-1).
+   * Computed from weighted average of grounding factors.
+   */
+  grounding$;
+  /**
+   * Internal consistency score stream (0-1).
+   * Computed from weighted average of internal factors.
+   */
+  internal$;
+  /**
+   * Crystallization score stream (0-1).
+   * Computed from weighted average of crystallization factors.
+   */
+  crystallization$;
+  /**
+   * Overall coherence score stream (0-1).
+   * Weighted combination of grounding, internal, and crystallization.
+   */
+  overall$;
+  /**
+   * Complete coherence snapshot stream.
+   * Emits full metrics object with all dimensions and factors.
+   */
+  snapshot$;
+  constructor() {
+    this.grounding$ = this.groundingFactors$.pipe(
+      map((factors) => this.computeWeightedAverage(factors)),
+      distinctUntilChanged()
+    );
+    this.internal$ = this.internalFactors$.pipe(
+      map((factors) => this.computeWeightedAverage(factors)),
+      distinctUntilChanged()
+    );
+    this.crystallization$ = this.crystallizationFactors$.pipe(
+      map((factors) => this.computeWeightedAverage(factors)),
+      distinctUntilChanged()
+    );
+    this.overall$ = combineLatest([this.grounding$, this.internal$, this.crystallization$]).pipe(
+      map(
+        ([grounding, internal, crystallization]) => grounding * DEFAULT_WEIGHTS.grounding + internal * DEFAULT_WEIGHTS.internal + crystallization * DEFAULT_WEIGHTS.crystallization
+      ),
+      distinctUntilChanged()
+    );
+    this.snapshot$ = combineLatest([
+      this.grounding$,
+      this.internal$,
+      this.crystallization$,
+      this.overall$,
+      this.loadLevel$,
+      this.groundingFactors$,
+      this.internalFactors$,
+      this.crystallizationFactors$
+    ]).pipe(
+      map(
+        ([
+          grounding,
+          internal,
+          crystallization,
+          overall,
+          loadLevel,
+          gFactors,
+          iFactors,
+          cFactors
+        ]) => ({
+          grounding,
+          internal,
+          crystallization,
+          overall,
+          timestamp: Date.now(),
+          loadLevel,
+          groundingFactors: gFactors,
+          internalFactors: iFactors,
+          crystallizationFactors: cFactors
+        })
+      )
+    );
+  }
+  // ========== Public API: State Updates ==========
+  /**
+   * Update the system load level.
+   * Affects coherence calculation strategies.
+   *
+   * @param level - New load level
+   */
+  updateLoadLevel(level) {
+    this.loadLevel$.next(level);
+  }
+  /**
+   * Add or update a grounding factor.
+   * If factor with same ID exists, it is replaced.
+   *
+   * @param factor - Grounding factor to add/update
+   */
+  addGroundingFactor(factor) {
+    const factors = this.groundingFactors$.value;
+    const index = factors.findIndex((f) => f.id === factor.id);
+    if (index >= 0) {
+      factors[index] = factor;
+      this.groundingFactors$.next([...factors]);
+    } else {
+      this.groundingFactors$.next([...factors, factor]);
+    }
+  }
+  /**
+   * Remove a grounding factor by ID.
+   *
+   * @param id - Factor ID to remove
+   */
+  removeGroundingFactor(id) {
+    const factors = this.groundingFactors$.value.filter((f) => f.id !== id);
+    this.groundingFactors$.next(factors);
+  }
+  /**
+   * Add or update an internal consistency factor.
+   *
+   * @param factor - Internal factor to add/update
+   */
+  addInternalFactor(factor) {
+    const factors = this.internalFactors$.value;
+    const index = factors.findIndex((f) => f.id === factor.id);
+    if (index >= 0) {
+      factors[index] = factor;
+      this.internalFactors$.next([...factors]);
+    } else {
+      this.internalFactors$.next([...factors, factor]);
+    }
+  }
+  /**
+   * Remove an internal consistency factor by ID.
+   *
+   * @param id - Factor ID to remove
+   */
+  removeInternalFactor(id) {
+    const factors = this.internalFactors$.value.filter((f) => f.id !== id);
+    this.internalFactors$.next(factors);
+  }
+  /**
+   * Add or update a crystallization factor.
+   *
+   * @param factor - Crystallization factor to add/update
+   */
+  addCrystallizationFactor(factor) {
+    const factors = this.crystallizationFactors$.value;
+    const index = factors.findIndex((f) => f.id === factor.id);
+    if (index >= 0) {
+      factors[index] = factor;
+      this.crystallizationFactors$.next([...factors]);
+    } else {
+      this.crystallizationFactors$.next([...factors, factor]);
+    }
+  }
+  /**
+   * Remove a crystallization factor by ID.
+   *
+   * @param id - Factor ID to remove
+   */
+  removeCrystallizationFactor(id) {
+    const factors = this.crystallizationFactors$.value.filter((f) => f.id !== id);
+    this.crystallizationFactors$.next(factors);
+  }
+  /**
+   * Clear all factors and reset to defaults.
+   */
+  reset() {
+    this.groundingFactors$.next([]);
+    this.internalFactors$.next([]);
+    this.crystallizationFactors$.next([]);
+    this.loadLevel$.next("normal");
+  }
+  // ========== Public API: Snapshot Accessors ==========
+  /**
+   * Get current coherence metrics (synchronous snapshot).
+   *
+   * @returns Current coherence metrics
+   */
+  getCurrentMetrics() {
+    const grounding = this.computeWeightedAverage(this.groundingFactors$.value);
+    const internal = this.computeWeightedAverage(this.internalFactors$.value);
+    const crystallization = this.computeWeightedAverage(this.crystallizationFactors$.value);
+    const overall = grounding * DEFAULT_WEIGHTS.grounding + internal * DEFAULT_WEIGHTS.internal + crystallization * DEFAULT_WEIGHTS.crystallization;
+    return {
+      grounding,
+      internal,
+      crystallization,
+      overall,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get current load level.
+   *
+   * @returns Current load level
+   */
+  getCurrentLoadLevel() {
+    return this.loadLevel$.value;
+  }
+  /**
+   * Get current grounding factors.
+   *
+   * @returns Array of current grounding factors
+   */
+  getGroundingFactors() {
+    return [...this.groundingFactors$.value];
+  }
+  /**
+   * Get current internal factors.
+   *
+   * @returns Array of current internal factors
+   */
+  getInternalFactors() {
+    return [...this.internalFactors$.value];
+  }
+  /**
+   * Get current crystallization factors.
+   *
+   * @returns Array of current crystallization factors
+   */
+  getCrystallizationFactors() {
+    return [...this.crystallizationFactors$.value];
+  }
+  // ========== Private Helpers ==========
+  /**
+   * Compute weighted average of factors.
+   * Returns 0 if no factors present.
+   *
+   * @param factors - Array of factors with weight and value
+   * @returns Weighted average (0-1)
+   */
+  computeWeightedAverage(factors) {
+    if (factors.length === 0) {
+      return 0;
+    }
+    const totalWeight = factors.reduce((sum, f) => sum + f.weight, 0);
+    if (totalWeight === 0) {
+      return 0;
+    }
+    const weightedSum = factors.reduce((sum, f) => sum + f.weight * f.value, 0);
+    return Math.max(0, Math.min(1, weightedSum / totalWeight));
+  }
+};
+var globalCoherenceStreams = new CoherenceStreams();
+
+// ../../lib/terminals-tech/mesh/convergence.ts
+var DEFAULT_CONFIG = {
+  staleThresholdMs: 6e4,
+  // 1 minute
+  healthDecayRate: 0.1,
+  maxRetries: 3,
+  alertThreshold: 0.5
+};
+var taskStates = /* @__PURE__ */ new Map();
+var agentStates = /* @__PURE__ */ new Map();
+var metricsHistory = [];
+function registerTask(id, status) {
+  const existing = taskStates.get(id);
+  const now = Date.now();
+  const task = existing ? {
+    ...existing,
+    status,
+    ...status === "running" && !existing.startedAt ? { startedAt: now } : {},
+    ...status === "completed" || status === "failed" ? { completedAt: now } : {}
+  } : {
+    id,
+    status,
+    createdAt: now,
+    retries: 0
+  };
+  taskStates.set(id, task);
+  return task;
+}
+function recordTaskCompletion(taskId, agentId, success) {
+  const task = taskStates.get(taskId);
+  if (task) {
+    task.status = success ? "completed" : "failed";
+    task.completedAt = Date.now();
+    if (!success) {
+      task.retries++;
+    }
+  }
+  const agent = agentStates.get(agentId);
+  if (agent) {
+    if (success) {
+      agent.completedTasks++;
+    } else {
+      agent.failedTasks++;
+    }
+    agent.status = "idle";
+    agent.currentTask = void 0;
+    agent.lastActivity = Date.now();
+  }
+}
+function calculateMetrics(config = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...config };
+  const now = Date.now();
+  const tasks = Array.from(taskStates.values());
+  const agents = Array.from(agentStates.values());
+  const pendingTasks = tasks.filter((t) => t.status === "pending" || t.status === "running");
+  const staleTasks = pendingTasks.filter((t) => now - t.createdAt > cfg.staleThresholdMs).length;
+  let agePressure = 0;
+  if (pendingTasks.length > 0) {
+    const totalAge = pendingTasks.reduce((sum, t) => sum + (now - t.createdAt), 0);
+    const avgAge = totalAge / pendingTasks.length;
+    agePressure = Math.min(1, avgAge / (cfg.staleThresholdMs * 2));
+  }
+  const fiveMinutesAgo = now - 3e5;
+  const recentCompleted = tasks.filter(
+    (t) => (t.status === "completed" || t.status === "failed") && t.completedAt && t.completedAt >= fiveMinutesAgo
+  ).length;
+  const throughput = recentCompleted / 5;
+  const completedTasks = tasks.filter((t) => t.status === "completed" || t.status === "failed");
+  const failedTasks = tasks.filter((t) => t.status === "failed");
+  const errorRate = completedTasks.length > 0 ? failedTasks.length / completedTasks.length : 0;
+  const activeAgents = agents.filter((a) => a.status === "working").length;
+  const idleAgents = agents.filter((a) => a.status === "idle").length;
+  let healthScore = 1;
+  healthScore -= agePressure * 0.3;
+  healthScore -= errorRate * 0.3;
+  healthScore -= staleTasks / Math.max(pendingTasks.length, 1) * 0.2;
+  if (idleAgents > 0 && pendingTasks.length > 0) {
+    healthScore -= 0.1;
+  }
+  healthScore = Math.max(0, Math.min(1, healthScore));
+  const metrics = {
+    healthScore,
+    agePressure,
+    staleTasks,
+    activeAgents,
+    throughput,
+    errorRate,
+    timestamp: now
+  };
+  metricsHistory.push(metrics);
+  if (metricsHistory.length > 100) {
+    metricsHistory.shift();
+  }
+  return metrics;
+}
+
+// ../../lib/terminals-tech/brains/neuro-state.ts
+var POLL_INTERVAL_MS = 2e3;
+var K_ADAPT_THRESHOLD = 0.1;
+var NeuroState = class {
+  // Observable for convergence metrics (polled)
+  convergence$ = new BehaviorSubject2(calculateMetrics());
+  // Subscription for cleanup
+  pollSubscription = null;
+  // Last K emitted (for hysteresis)
+  _lastEmittedK = null;
+  // Unified state stream
+  state$;
+  constructor() {
+    if (typeof window !== "undefined") {
+      this.pollSubscription = interval(POLL_INTERVAL_MS).subscribe(() => {
+        this.convergence$.next(calculateMetrics());
+      });
+      this.initBridgeListeners();
+    }
+    this.state$ = combineLatest2([globalCoherenceStreams.snapshot$, this.convergence$]).pipe(
+      map2(([coherence, convergence]) => {
+        const mood = this.deriveMood(coherence, convergence);
+        return {
+          coherence,
+          convergence,
+          load: coherence.loadLevel,
+          mood,
+          timestamp: Date.now()
+        };
+      })
+    );
+    if (typeof window !== "undefined") {
+      this.state$.subscribe(({ convergence }) => {
+        this._adaptCoupling(convergence.healthScore);
+      });
+    }
+  }
+  /**
+   * Emit adaptation_required signal to update Kuramoto coupling K in ReticulumNode.
+   *
+   * K formula: K = 0.5 + healthScore × 2.5 maps [0,1] → [0.5, 3.0]
+   *   - healthScore=0 → K=0.5 (minimal coupling, oscillators drift)
+   *   - healthScore=1 → K=3.0 (strong coupling, enforces synchrony)
+   *
+   * Hysteresis guard: only emits if |K - lastK| > K_ADAPT_THRESHOLD.
+   * This prevents signal storms from tiny healthScore micro-fluctuations.
+   */
+  _adaptCoupling(healthScore) {
+    const K = 0.5 + healthScore * 2.5;
+    if (this._lastEmittedK !== null && Math.abs(K - this._lastEmittedK) < K_ADAPT_THRESHOLD) {
+      return;
+    }
+    this._lastEmittedK = K;
+    getSignalBus().emit("adaptation_required", "L4", "L3", {
+      type: "kuramoto_coupling",
+      K,
+      healthScore
+    });
+  }
+  /**
+   * Derives the high-level "Mood" of the system based on
+   * internal coherence and external convergence health.
+   */
+  deriveMood(coherence, convergence) {
+    if (coherence.loadLevel === "critical" || convergence.healthScore < 0.3) {
+      return "overloaded";
+    }
+    if (coherence.overall > 0.8 && convergence.throughput > 10) {
+      return "flow";
+    }
+    if (coherence.overall > 0.7) {
+      return "focused";
+    }
+    if (coherence.overall < 0.4 && (convergence.activeAgents || 0) > 0) {
+      return "chaotic";
+    }
+    return "dormant";
+  }
+  /**
+   * Manual refresh of convergence metrics
+   */
+  refreshConvergence() {
+    this.convergence$.next(calculateMetrics());
+  }
+  /**
+   * Cleanup subscriptions to prevent memory leaks
+   */
+  dispose() {
+    this.pollSubscription?.unsubscribe();
+    this.pollSubscription = null;
+  }
+  /**
+   * Initialize listeners for L2->L3 bridge events to update convergence state.
+   * This ensures the "Brain" is aware of "Body" (Orchestrator) actions.
+   */
+  initBridgeListeners() {
+    onOrchestratorEvent((data) => {
+      switch (data.type) {
+        case "run_start":
+          registerTask(data.event.runId, "running");
+          break;
+        case "run_complete":
+          recordTaskCompletion(
+            data.event.runId,
+            "orchestrator-agent",
+            // Default agent ID for L2
+            data.event.success
+          );
+          this.refreshConvergence();
+          break;
+        case "node_complete":
+          if (!data.event.success) {
+          }
+          break;
+      }
+    });
+  }
+};
+var neuroState = new NeuroState();
+export {
+  NeuroState,
+  neuroState
+};