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

package/dist/chunk-NTMBOESX.js

@@ -0,0 +1,152 @@
+// ../../lib/terminals-tech/core/base/retry.ts
+function calculateDelay(attempt, baseDelayMs, maxDelayMs, jitter = 0) {
+  let delay = baseDelayMs * Math.pow(2, attempt);
+  delay = Math.min(delay, maxDelayMs);
+  if (jitter > 0) {
+    const jitterAmount = delay * jitter * Math.random();
+    delay = delay + jitterAmount - jitter * delay / 2;
+    delay = Math.max(baseDelayMs, delay);
+  }
+  return Math.floor(delay);
+}
+function exponentialBackoff(options = {}) {
+  return {
+    maxAttempts: options.maxAttempts ?? 3,
+    baseDelayMs: options.baseDelayMs ?? 100,
+    maxDelayMs: options.maxDelayMs ?? 1e4,
+    jitter: options.jitter ?? 0.1,
+    shouldRetry: options.shouldRetry ?? defaultShouldRetry
+  };
+}
+function defaultShouldRetry(error, _attempt) {
+  if (error.name === "TypeError" && error.message.includes("fetch")) {
+    return true;
+  }
+  if (error.name === "AbortError") {
+    return false;
+  }
+  if ("status" in error) {
+    const status = error.status;
+    return status >= 500 || status === 429;
+  }
+  return true;
+}
+async function withRetry(fn, strategyOrOptions = {}) {
+  const strategy = "maxAttempts" in strategyOrOptions && "shouldRetry" in strategyOrOptions ? strategyOrOptions : exponentialBackoff(strategyOrOptions);
+  const options = strategyOrOptions;
+  let lastError = null;
+  for (let attempt = 0; attempt < strategy.maxAttempts; attempt++) {
+    if (options.signal?.aborted) {
+      throw new DOMException("Operation was aborted", "AbortError");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const isLastAttempt = attempt >= strategy.maxAttempts - 1;
+      if (isLastAttempt || !strategy.shouldRetry(lastError, attempt)) {
+        throw lastError;
+      }
+      const delay = calculateDelay(
+        attempt,
+        strategy.baseDelayMs,
+        strategy.maxDelayMs,
+        strategy.jitter
+      );
+      options.onRetry?.(lastError, attempt + 1, delay);
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(resolve, delay);
+        if (options.signal) {
+          const abortHandler = () => {
+            clearTimeout(timeoutId);
+            reject(new DOMException("Operation was aborted", "AbortError"));
+          };
+          options.signal.addEventListener("abort", abortHandler, {
+            once: true
+          });
+        }
+      });
+    }
+  }
+  throw lastError ?? new Error("Retry failed");
+}
+function createCircuitBreaker(options) {
+  const state = {
+    failures: 0,
+    lastFailure: null,
+    isOpen: false,
+    nextAttempt: null
+  };
+  let halfOpenInFlight = 0;
+  return {
+    /**
+     * Execute function with circuit breaker protection.
+     *
+     * States:
+     *   CLOSED  — failures < threshold, all requests pass through
+     *   OPEN    — failures >= threshold, fast-fails until resetTimeoutMs elapses
+     *   HALF_OPEN — resetTimeoutMs elapsed, allows `halfOpenRequests` concurrent probes
+     *
+     * Transitions:
+     *   T1: CLOSED → CLOSED (success resets failures)
+     *   T2: CLOSED → OPEN   (failure hits threshold)
+     *   T3: OPEN   → OPEN   (fast-fail, time not elapsed)
+     *   T4: OPEN   → HALF_OPEN (time elapsed, probe allowed)
+     *   T5: HALF_OPEN → CLOSED (probe succeeds)
+     *   T6: HALF_OPEN → OPEN   (probe fails)
+     */
+    async execute(fn) {
+      if (state.isOpen) {
+        const now = Date.now();
+        if (state.nextAttempt && now < state.nextAttempt) {
+          throw new Error("Circuit breaker is open");
+        }
+        if (options.halfOpenRequests != null && halfOpenInFlight >= options.halfOpenRequests) {
+          throw new Error("Circuit breaker half-open \u2014 probe limit reached");
+        }
+        halfOpenInFlight++;
+      }
+      try {
+        const result = await fn();
+        state.failures = 0;
+        state.isOpen = false;
+        state.nextAttempt = null;
+        halfOpenInFlight = 0;
+        return result;
+      } catch (error) {
+        if (state.isOpen) {
+          halfOpenInFlight = Math.max(0, halfOpenInFlight - 1);
+        }
+        state.failures++;
+        state.lastFailure = Date.now();
+        if (state.failures >= options.failureThreshold) {
+          state.isOpen = true;
+          state.nextAttempt = Date.now() + options.resetTimeoutMs;
+          halfOpenInFlight = 0;
+        }
+        throw error;
+      }
+    },
+    /**
+     * Get current state
+     */
+    getState() {
+      return { ...state };
+    },
+    /**
+     * Manually reset the circuit breaker
+     */
+    reset() {
+      state.failures = 0;
+      state.lastFailure = null;
+      state.isOpen = false;
+      state.nextAttempt = null;
+      halfOpenInFlight = 0;
+    }
+  };
+}
+
+export {
+  withRetry,
+  createCircuitBreaker
+};

package/dist/chunk-OCLSAUCD.js

@@ -0,0 +1,474 @@
+// ../../lib/terminals-tech/machines/core/catalog.ts
+var inMemoryCatalog = /* @__PURE__ */ new Map();
+var nodesInitialized = false;
+async function ensureNodesLoaded() {
+  if (!nodesInitialized) {
+    await import("./nodes-K6GKI2FM.js");
+    nodesInitialized = true;
+  }
+}
+var manifestProviders = /* @__PURE__ */ new Map();
+function registerNode(manifest) {
+  inMemoryCatalog.set(manifest.id, manifest);
+}
+function registerManifestProvider(name, provider) {
+  manifestProviders.set(name, provider);
+}
+async function resolveNode(ref) {
+  await ensureNodesLoaded();
+  const staticNode = inMemoryCatalog.get(ref);
+  if (staticNode) return staticNode;
+  for (const provider of manifestProviders.values()) {
+    try {
+      const manifest = await provider(ref);
+      if (manifest) return manifest;
+    } catch (err) {
+      console.warn(`[resolveNode] Provider failed for ${ref}:`, err);
+    }
+  }
+  return null;
+}
+registerNode({
+  id: "demo.echo.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Echo",
+  description: "Returns input as output",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { message: { type: "string" } },
+    required: ["message"]
+  },
+  outputsSchema: { type: "object", properties: { echoed: { type: "object" } } }
+});
+registerNode({
+  id: "demo.webhook.post.v1",
+  version: "0.1.0",
+  kind: "webhook",
+  label: "Webhook POST",
+  description: "POST JSON to a URL",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { url: { type: "string" }, body: { type: "object" } },
+    required: ["url", "body"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: {
+      status: { type: "number" },
+      ok: { type: "boolean" },
+      body: { type: "string" }
+    }
+  },
+  policies: {
+    network: { egress: "allow:list", allowList: ["https://httpbin.org"] }
+  },
+  secrets: [
+    {
+      name: "DEMO_BEARER_TOKEN",
+      scope: "node",
+      env: "AUTH_TOKEN",
+      required: false
+    }
+  ]
+});
+registerNode({
+  id: "demo.mcp.echo.v1",
+  version: "0.1.0",
+  kind: "mcp",
+  label: "MCP Echo",
+  description: "Demonstrates MCP policy gate and echo",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { service: { type: "string" }, model: { type: "string" } },
+    required: ["service", "model"]
+  },
+  outputsSchema: { type: "object" },
+  mcp: { server: "https://example.com/mcp", tools: [] }
+});
+registerNode({
+  id: "demo.webcontainer.echo.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "WC Echo",
+  description: "Runs a trivial command in WebContainer and echoes inputs",
+  runtimes: ["webcontainer"],
+  entrypoints: {
+    webcontainer: { command: "node", args: ["-e", 'console.log("wc-node")'] }
+  },
+  inputsSchema: {
+    type: "object",
+    properties: { payload: { type: "object" } },
+    required: ["payload"]
+  },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "system.input.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Stack Input",
+  description: "Defines the inputs for a stack.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object" },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "system.output.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Stack Output",
+  description: "Defines the outputs of a stack.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object" },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "base.time.timeline.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Timeline",
+  description: "Event clock, windows and scheduling for temporal flows.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { events: { type: "array" }, window: { type: "string" } }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { windowEvents: { type: "array" }, ticks: { type: "array" } }
+  }
+});
+registerNode({
+  id: "base.time.memory.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Temporal Memory",
+  description: "Time-indexed key-value store with TTL and query windows.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { put: { type: "object" }, get: { type: "object" } }
+  },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "base.field.store3d.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Field Store 3D",
+  description: "Stores/queries radiance, SDF, or gaussian splat parameters.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { upsert: { type: "array" }, query: { type: "object" } }
+  },
+  outputsSchema: { type: "object" },
+  capabilities: ["fields:xyzt"]
+});
+registerNode({
+  id: "base.field.projector.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Cross\u2011Modal Projector",
+  description: "Maps field points (xyzt) to semantic embeddings/entities.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { points: { type: "array" }, model: { type: "string" } }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { embeddings: { type: "array" } }
+  }
+});
+registerNode({
+  id: "base.semantic.zero-agent.v1",
+  version: "0.1.0",
+  kind: "prompt",
+  label: "Zero Agent",
+  description: "LLM tool-using node with context shaping and routing.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      prompt: { type: "string" },
+      tools: { type: "array" },
+      memory: { type: "object" }
+    }
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { messages: { type: "array" }, artifacts: { type: "array" } }
+  }
+});
+registerNode({
+  id: "base.semantic.entity-graph.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Entity Graph",
+  description: "Typed nodes/edges with uncertainty; updates by deltas.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { upsert: { type: "array" }, query: { type: "object" } }
+  },
+  outputsSchema: { type: "object" }
+});
+registerNode({
+  id: "base.interface.oracle-adapter.v1",
+  version: "0.1.0",
+  kind: "webhook",
+  label: "Oracle Adapter",
+  description: "Bridges external web apps/APIs into the composition.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: { type: "object", properties: { request: { type: "object" } } },
+  outputsSchema: {
+    type: "object",
+    properties: { response: { type: "object" } }
+  },
+  policies: { network: { egress: "ask" } }
+});
+registerNode({
+  id: "astro.transform.buildAgentPrompt.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Build Agent Prompt",
+  description: "Constructs an astronomer assistant prompt from a user question and product/record context.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      question: { type: "string" },
+      product: { type: "object" },
+      record: { type: "object" }
+    },
+    required: ["question"]
+  },
+  outputsSchema: { type: "object", properties: { prompt: { type: "string" } } }
+});
+registerNode({
+  id: "transform.object.pickPath.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Pick Path",
+  description: "Extracts a nested value from an object using a dot path.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { object: { type: "object" }, path: { type: "string" } },
+    required: ["object", "path"]
+  },
+  outputsSchema: { type: "object", properties: { value: { type: "object" } } }
+});
+registerNode({
+  id: "intel.llm.http.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "HTTP LLM (OpenRouter)",
+  description: "Calls an LLM provider over HTTP (default OpenRouter). Inputs: prompt, model, apiKey.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      prompt: { type: "string" },
+      model: { type: "string" },
+      apiKey: { type: "string" }
+    },
+    required: ["prompt"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { text: { type: "string" }, messages: { type: "array" } }
+  },
+  policies: {
+    network: { egress: "allow:list", allowList: ["https://openrouter.ai"] }
+  }
+});
+registerNode({
+  id: "provider.http.invoke.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "HTTP Invoke",
+  description: "Calls an HTTP endpoint with method/headers/body; returns JSON or text.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string" },
+      method: { type: "string" },
+      headers: { type: "object" },
+      body: { type: "object" },
+      parse: { type: "string" }
+    },
+    required: ["url"]
+  },
+  outputsSchema: { type: "object" },
+  policies: { network: { egress: "ask" } }
+});
+registerNode({
+  id: "provider.tap.query.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "TAP Query",
+  description: "Executes ADQL via TAP sync endpoint and returns rows as JSON.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      tapUrl: { type: "string" },
+      adql: { type: "string" },
+      format: { type: "string" },
+      maxRows: { type: "number" },
+      token: { type: "string" }
+    },
+    required: ["tapUrl", "adql"]
+  },
+  outputsSchema: { type: "object" },
+  policies: { network: { egress: "ask" } }
+});
+registerNode({
+  id: "table.firstRow.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "First Row",
+  description: "Selects the first record from a table of rows.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { rows: { type: "array" } },
+    required: ["rows"]
+  },
+  outputsSchema: { type: "object", properties: { record: { type: "object" } } }
+});
+registerNode({
+  id: "items.pickPreferred.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Pick Preferred Items",
+  description: "Picks preferred items by ordered type keys; returns selected array.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      items: { type: "array" },
+      prefer: { type: "array" },
+      typeKey: { type: "string" },
+      groupKey: { type: "string" }
+    },
+    required: ["items"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { selected: { type: "array" } }
+  }
+});
+registerNode({
+  id: "transform.buildPrompt.v1",
+  version: "0.1.0",
+  kind: "transform",
+  label: "Build Prompt",
+  description: "Constructs an assistant prompt from question + context (record or object).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { question: { type: "string" }, context: { type: "object" } },
+    required: ["question"]
+  },
+  outputsSchema: { type: "object", properties: { prompt: { type: "string" } } }
+});
+registerNode({
+  id: "intel.embedText.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Embed Text",
+  description: "Computes an embedding vector from text.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: { text: { type: "string" } },
+    required: ["text"]
+  },
+  outputsSchema: { type: "object", properties: { vector: { type: "array" } } }
+});
+registerNode({
+  id: "integration.source.poll.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Integration Source (Poll)",
+  description: "Polls a provider resource with cursoring and returns normalized events.",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: { type: "string" },
+      resource: { type: "string" },
+      config: { type: "object" },
+      cursorKey: { type: "string" }
+    },
+    required: ["provider", "resource"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { items: { type: "array" }, cursor: { type: "string" } }
+  },
+  policies: { network: { egress: "ask" } },
+  secrets: [{ name: "DISCORD_BOT_TOKEN", scope: "stack", required: false }]
+});
+registerNode({
+  id: "integration.sink.post.v1",
+  version: "0.1.0",
+  kind: "task",
+  label: "Integration Sink (Post)",
+  description: "Posts items to a provider resource (supports webhooks or REST).",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: { type: "string" },
+      resource: { type: "string" },
+      config: { type: "object" },
+      item: { type: "object" },
+      items: { type: "array" }
+    },
+    required: ["provider", "resource"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { ok: { type: "boolean" }, status: { type: "number" } }
+  },
+  policies: { network: { egress: "ask" } },
+  secrets: [{ name: "DISCORD_BOT_TOKEN", scope: "stack", required: false }]
+});
+
+export {
+  registerNode,
+  registerManifestProvider,
+  resolveNode
+};