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

package/dist/chunk-Q4B7YS7T.js

@@ -0,0 +1,557 @@
+import {
+  BASE_PHASE_LOCKING_VALUE_NODE_ID,
+  BASE_RESONANCE_IQ_ENCODE_NODE_ID,
+  BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID,
+  BASE_RESONANCE_METRICS_NODE_ID,
+  COMPUTE_BEND_NODE_ID,
+  HVM_PROOF_EDGE_CHECK_NODE_ID,
+  SYSTEM_SCHEDULE_NODE_ID,
+  SYSTEM_SIGNAL_EMIT_NODE_ID,
+  executeBendCompute,
+  executeHvmProofEdgeCheck,
+  executeIqEncode,
+  executeIqPhaseShift,
+  executePhaseLockingValueNode,
+  executeResonanceMetrics,
+  executeSystemSchedule,
+  executeSystemSignalEmit
+} from "./chunk-BKB3MD5Y.js";
+import {
+  getProvider
+} from "./chunk-H3POJCFA.js";
+import {
+  registerNode
+} from "./chunk-3CEM77QZ.js";
+
+// ../../lib/types/safe-types.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+
+// ../../lib/terminals-tech/machines/core/nodes/provider.chat.ts
+var PROVIDER_CHAT_NODE_ID = "provider.chat.v1";
+var manifest = {
+  id: PROVIDER_CHAT_NODE_ID,
+  version: "0.1.0",
+  kind: "task",
+  label: "Provider Chat",
+  description: "Calls a chat model on a selected provider",
+  runtimes: ["worker"],
+  entrypoints: { worker: { module: "local" } },
+  inputsSchema: {
+    type: "object",
+    properties: {
+      provider: {
+        type: "string",
+        description: "provider id (openai, nous, prime, ...)"
+      },
+      model: { type: "string" },
+      messages: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: { role: { type: "string" }, content: { type: "string" } },
+          required: ["role", "content"]
+        }
+      },
+      temperature: { type: "number" },
+      secretRef: {
+        type: "string",
+        description: "reference key in Secrets store"
+      },
+      baseUrl: { type: "string", description: "override baseUrl for vendor" }
+    },
+    required: ["provider", "model", "messages"]
+  },
+  outputsSchema: {
+    type: "object",
+    properties: { message: { type: "string" }, usage: { type: "object" } }
+  }
+};
+registerNode(manifest);
+async function executeProviderChat(inputs, context) {
+  const adapter = getProvider(inputs.provider);
+  if (!adapter?.chat?.generate) throw new Error(`provider not found: ${inputs.provider}`);
+  const secrets = inputs.secretRef && context.getSecret ? await context.getSecret(inputs.secretRef) : {};
+  const out = await adapter.chat.generate(
+    {
+      model: inputs.model,
+      messages: inputs.messages,
+      temperature: inputs.temperature
+    },
+    secrets
+  );
+  return { message: out.message, usage: out.usage };
+}
+
+// ../../lib/terminals-tech/machines/core/runners/registry.ts
+var RunnerRegistry = class {
+  workerRunners = /* @__PURE__ */ new Map();
+  // key: manifest id
+  tierRunners = /* @__PURE__ */ new Map();
+  // key: tier name
+  /**
+   * Register a worker runner for a specific node manifest ID.
+   *
+   * @param manifestId - Node manifest ID (e.g., 'http-fetch')
+   * @param fn - Worker runner function
+   */
+  registerWorker(manifestId, fn) {
+    this.workerRunners.set(manifestId, fn);
+  }
+  /**
+   * Retrieve a registered worker runner by manifest ID.
+   *
+   * @param manifestId - Node manifest ID
+   * @returns Worker runner function or null if not found
+   */
+  getWorker(manifestId) {
+    return this.workerRunners.get(manifestId) || null;
+  }
+  /**
+   * Register a generic runner for a runtime tier.
+   *
+   * @param tier - Runtime tier name (e.g., 'stack', 'webcontainer')
+   * @param fn - Runner function for that tier
+   */
+  registerRunner(tier, fn) {
+    this.tierRunners.set(tier, fn);
+  }
+  /**
+   * Retrieve a registered runner for a runtime tier.
+   *
+   * @param tier - Runtime tier name
+   * @returns Runner function or null if not found
+   */
+  getRunner(tier) {
+    return this.tierRunners.get(tier) || null;
+  }
+};
+var runners = new RunnerRegistry();
+import("./demo-VXMGMJNK.js").catch((err) => console.warn("[RunnerRegistry] demo runner import failed", err));
+import("./stack-CHDAFU2S.js").catch((err) => console.warn("[RunnerRegistry] stack runner import failed", err));
+runners.registerWorker(PROVIDER_CHAT_NODE_ID, async (_m, input, ctx) => {
+  const typedInput = input;
+  const secrets = typedInput.__secrets || {};
+  try {
+    const { decrypt } = await import("./crypto-D4LMI2RN.js");
+    const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+    const outSecrets = {};
+    for (const [k, v] of Object.entries(secrets)) {
+      try {
+        const parsed = JSON.parse(String(v));
+        if (isObject(parsed) && "iv" in parsed && "ct" in parsed) {
+          outSecrets[k] = decrypt(parsed);
+        } else {
+          outSecrets[k] = String(v);
+        }
+      } catch {
+        outSecrets[k] = String(v);
+      }
+    }
+    const { __secrets: _secrets, ...clean } = typedInput;
+    const out = await executeProviderChat(
+      clean,
+      {
+        getSecret: async (ref) => {
+          if (ref) {
+            const value = await resolveSecretValue(ref, {
+              ownerId: ctx.userId || "anonymous",
+              stackId: ctx.stackId,
+              nodeId: ctx.nodeId,
+              appletId: ctx.appletId,
+              worldId: ctx.worldId,
+              terminalId: ctx.terminalId
+            });
+            if (value) {
+              const resolved = typeof value === "string" ? value : "";
+              return { ...outSecrets, [ref]: resolved, apiKey: resolved };
+            }
+          }
+          return outSecrets;
+        }
+      }
+    );
+    return out;
+  } catch {
+    const { __secrets: _secrets, ...clean } = typedInput;
+    const out = await executeProviderChat(
+      clean,
+      {
+        getSecret: async (ref) => {
+          const secretsRecord = {};
+          if (isObject(secrets)) {
+            for (const [key, val] of Object.entries(secrets)) {
+              secretsRecord[key] = isString(val) ? val : String(val ?? "");
+            }
+          }
+          if (ref) {
+            const secretValue = isObject(secrets) ? secrets[ref] : void 0;
+            return {
+              ...secretsRecord,
+              [ref]: isString(secretValue) ? secretValue : String(secretValue ?? "")
+            };
+          }
+          return secretsRecord;
+        }
+      }
+    );
+    return out;
+  }
+});
+runners.registerWorker("base.time.timeline.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  const windowVal = isObject(input) && "window" in input && isString(input.window) ? input.window : void 0;
+  const tl = mod.makeTimeline(windowVal);
+  const eventsVal = isObject(input) && "events" in input ? input.events : void 0;
+  const events = isArray(eventsVal) ? eventsVal : [];
+  return tl.process(events);
+});
+runners.registerWorker(SYSTEM_SCHEDULE_NODE_ID, async (_m, input, ctx) => {
+  return await executeSystemSchedule(input, { stackId: ctx.stackId });
+});
+runners.registerWorker(HVM_PROOF_EDGE_CHECK_NODE_ID, async (_m, input, ctx) => {
+  return await executeHvmProofEdgeCheck(input, {
+    stackId: ctx.stackId,
+    nodeId: ctx.nodeId
+  });
+});
+runners.registerWorker(COMPUTE_BEND_NODE_ID, async (_m, input, ctx) => {
+  return await executeBendCompute(input, {
+    stackId: ctx.stackId,
+    nodeId: ctx.nodeId
+  });
+});
+runners.registerWorker(SYSTEM_SIGNAL_EMIT_NODE_ID, async (_m, input, ctx) => {
+  return await executeSystemSignalEmit(input, {
+    stackId: ctx.stackId,
+    nodeId: ctx.nodeId
+  });
+});
+runners.registerWorker(BASE_RESONANCE_IQ_ENCODE_NODE_ID, async (_m, input) => {
+  return await executeIqEncode(input);
+});
+runners.registerWorker(BASE_RESONANCE_IQ_PHASE_SHIFT_NODE_ID, async (_m, input) => {
+  return await executeIqPhaseShift(input);
+});
+runners.registerWorker(BASE_RESONANCE_METRICS_NODE_ID, async (_m, input) => {
+  return await executeResonanceMetrics(input);
+});
+runners.registerWorker(BASE_PHASE_LOCKING_VALUE_NODE_ID, async (_m, input) => {
+  return await executePhaseLockingValueNode(input);
+});
+runners.registerWorker("base.time.memory.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.temporalKV().handle(input);
+});
+runners.registerWorker("base.field.store3d.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.fieldStore3d().handle(input);
+});
+runners.registerWorker("base.field.projector.v1", async (_m, input) => {
+  const emb = await import("./embeddings-MAEWWUHW.js");
+  const pointsVal = isObject(input) && "points" in input ? input.points : void 0;
+  const points = isArray(pointsVal) ? pointsVal.filter(
+    (point) => isObject(point) && typeof point.x === "number" && typeof point.y === "number" && typeof point.z === "number"
+  ) : [];
+  const modelVal = isObject(input) && "model" in input ? input.model : void 0;
+  const model = isString(modelVal) ? modelVal : "default";
+  const embeddings = await emb.encodePoints(points, { model });
+  return { embeddings };
+});
+runners.registerWorker("base.semantic.zero-agent.v1", async (_m, input) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.zeroAgent().handle(input);
+});
+runners.registerWorker("base.semantic.entity-graph.v1", async (_m, input) => {
+  const g = await import("./graph-RKMNE2X5.js");
+  return g.entityGraph().handle(input);
+});
+runners.registerWorker("base.interface.oracle-adapter.v1", async (_m, input, ctx) => {
+  const mod = await import("./core-H2UUDATO.js");
+  return mod.httpOracle(ctx?.policies).handle(input);
+});
+runners.registerWorker("astro.transform.buildAgentPrompt.v1", async (_m, input) => {
+  const questionVal = isObject(input) && "question" in input ? input.question : void 0;
+  const q = String(questionVal || "");
+  const product = isObject(input) && "product" in input ? input.product : null;
+  const record = isObject(input) && "record" in input ? input.record : null;
+  const lines = [];
+  if (product) lines.push(`Context (product): ${JSON.stringify(product).slice(0, 2e3)}`);
+  if (record) lines.push(`Context (record): ${JSON.stringify(record).slice(0, 2e3)}`);
+  const prompt = `${lines.join("\n")}
+
+Question: ${q}
+Answer with observed facts first, then suggested follow-ups and uncertainties.`;
+  return { prompt };
+});
+runners.registerWorker("transform.object.pickPath.v1", async (_m, input) => {
+  const objVal = isObject(input) && "object" in input ? input.object : void 0;
+  const obj = isObject(objVal) ? objVal : {};
+  const pathVal = isObject(input) && "path" in input ? input.path : void 0;
+  const path = String(pathVal || "");
+  const segs = path.split(".").filter(Boolean);
+  let cur = obj;
+  for (const s of segs) {
+    if (isObject(cur) && s in cur) {
+      cur = cur[s];
+    } else {
+      cur = void 0;
+      break;
+    }
+  }
+  return { value: cur };
+});
+if (!runners.getWorker("provider.http.invoke.v1")) {
+  runners.registerWorker("provider.http.invoke.v1", async (_m, input, ctx) => {
+    const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+    const urlVal = isObject(input) && "url" in input ? input.url : void 0;
+    const url = String(urlVal || "");
+    const methodVal = isObject(input) && "method" in input ? input.method : void 0;
+    const method = String(methodVal || "GET").toUpperCase();
+    const headersVal = isObject(input) && "headers" in input ? input.headers : void 0;
+    const headers = isObject(headersVal) ? headersVal : {};
+    const body = isObject(input) && "body" in input ? input.body : void 0;
+    const parseVal = isObject(input) && "parse" in input ? input.parse : void 0;
+    const parse = String(parseVal || "json");
+    if (!(isNetworkAllowed(ctx?.policies, url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, url))) {
+      throw new Error("egress not allowed (approval required)");
+    }
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const text = await res.text();
+    if (!res.ok) throw new Error(`http ${res.status}: ${text.slice(0, 256)}`);
+    try {
+      return parse === "json" ? JSON.parse(text) : { text };
+    } catch {
+      return { text };
+    }
+  });
+}
+if (!runners.getWorker("items.pickPreferred.v1")) {
+  runners.registerWorker("items.pickPreferred.v1", async (_m, input) => {
+    const itemsVal = isObject(input) && "items" in input ? input.items : void 0;
+    const items = isArray(itemsVal) ? itemsVal : [];
+    const preferVal = isObject(input) && "prefer" in input ? input.prefer : void 0;
+    const prefer = isArray(preferVal) ? preferVal : [];
+    const typeKeyVal = isObject(input) && "typeKey" in input ? input.typeKey : void 0;
+    const typeKey = String(typeKeyVal || "type");
+    const groupKeyVal = isObject(input) && "groupKey" in input ? input.groupKey : void 0;
+    const groupKey = String(groupKeyVal || "group");
+    const key = (p) => {
+      if (isObject(p) && typeKey in p) {
+        return String(p[typeKey] || "").toLowerCase();
+      }
+      return "";
+    };
+    const groups = /* @__PURE__ */ new Map();
+    for (const p of items) {
+      const id = isObject(p) && groupKey in p ? String(p[groupKey] ?? "group") : "group";
+      const arr = groups.get(id) || [];
+      arr.push(p);
+      groups.set(id, arr);
+    }
+    const selected = [];
+    for (const [, arr] of groups.entries()) {
+      let pick = null;
+      for (const t of prefer) {
+        pick = arr.find((p) => key(p).includes(String(t).toLowerCase()));
+        if (pick) break;
+      }
+      pick = pick || arr[0];
+      if (pick) selected.push(pick);
+    }
+    return { selected };
+  });
+}
+if (!runners.getWorker("transform.buildPrompt.v1")) {
+  runners.registerWorker("transform.buildPrompt.v1", async (_m, input) => {
+    const questionVal = isObject(input) && "question" in input ? input.question : void 0;
+    const q = String(questionVal || "");
+    const ctxVal = isObject(input) && "context" in input ? input.context : void 0;
+    const ctx = isObject(ctxVal) ? ctxVal : {};
+    const preview = JSON.stringify(ctx).slice(0, 2e3);
+    const prompt = `Context: ${preview}
+
+Question: ${q}
+Answer with observed facts first, then follow-ups and uncertainties.`;
+    return { prompt };
+  });
+}
+if (!runners.getWorker("intel.embedText.v1")) {
+  runners.registerWorker("intel.embedText.v1", async (_m, input) => {
+    const { encodeTextBatch } = await import("./embeddings-MAEWWUHW.js");
+    const textVal = isObject(input) && "text" in input ? input.text : void 0;
+    const text = String(textVal || "");
+    const [vec] = await encodeTextBatch([text]);
+    return { vector: vec };
+  });
+}
+runners.registerWorker("intel.llm.http.v1", async (_m, input, ctx) => {
+  const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+  const typedInput = input;
+  const promptVal = isObject(input) && "prompt" in input ? input.prompt : void 0;
+  const prompt = String(promptVal || "");
+  const modelVal = isObject(input) && "model" in input ? input.model : void 0;
+  const model = String(modelVal || "openrouter/auto");
+  const apiKeyVal = isObject(input) && "apiKey" in input ? input.apiKey : void 0;
+  const secretsApiKey = isObject(typedInput.__secrets) ? typedInput.__secrets.OPENROUTER_API_KEY : void 0;
+  let apiKey = String(apiKeyVal || (isString(secretsApiKey) ? secretsApiKey : "") || "");
+  if (!apiKey) {
+    try {
+      const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+      const value = await resolveSecretValue("OPENROUTER_API_KEY", {
+        ownerId: ctx.userId || "anonymous",
+        stackId: ctx.stackId,
+        nodeId: ctx.nodeId,
+        appletId: ctx.appletId,
+        worldId: ctx.worldId,
+        terminalId: ctx.terminalId
+      });
+      if (value) apiKey = value;
+    } catch {
+    }
+  }
+  const url = "https://openrouter.ai/api/v1/chat/completions";
+  if (!(isNetworkAllowed(ctx?.policies, url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, url))) {
+    throw new Error("egress not allowed (approval required)");
+  }
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "user", content: prompt }],
+      stream: false
+    })
+  });
+  const json = await res.json().catch(() => ({ error: "failed to parse" }));
+  if (!res.ok) throw new Error(json?.error || `llm http ${res.status}`);
+  const text = json?.choices?.[0]?.message?.content || "";
+  return {
+    text,
+    messages: json?.choices?.[0]?.messages || [{ role: "assistant", content: text }]
+  };
+});
+runners.registerWorker("integration.source.poll.v1", async (_m, input, ctx) => {
+  const { getProvider: getProvider2 } = await import("./registry-FW63E7FE.js");
+  const providerIdVal = isObject(input) && "provider" in input ? input.provider : void 0;
+  const providerId = String(providerIdVal || "");
+  const resourceVal = isObject(input) && "resource" in input ? input.resource : void 0;
+  const resource = String(resourceVal || "");
+  const configVal = isObject(input) && "config" in input ? input.config : void 0;
+  const config = isObject(configVal) ? configVal : {};
+  const cursorKeyVal = isObject(input) && "cursorKey" in input ? input.cursorKey : void 0;
+  const cursorKey = String(cursorKeyVal || `${providerId}:${resource}`);
+  const prov = getProvider2(providerId);
+  if (!prov?.integration) throw new Error(`provider not found: ${providerId}`);
+  const secrets = {};
+  try {
+    const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+    const names = ["DISCORD_BOT_TOKEN"];
+    for (const n of names) {
+      const value = await resolveSecretValue(n, {
+        ownerId: ctx.userId || "anonymous",
+        stackId: ctx.stackId,
+        nodeId: ctx.nodeId,
+        appletId: ctx.appletId,
+        worldId: ctx.worldId,
+        terminalId: ctx.terminalId
+      });
+      if (value) secrets[n] = value;
+    }
+  } catch {
+  }
+  const mem = (await import("./core-H2UUDATO.js")).temporalKV();
+  const cur = await mem.handle({ get: { key: cursorKey } });
+  const cursor = cur?.value ? String(cur.value) : void 0;
+  const req = prov.integration.buildRequest("poll", { resource, config, cursor }, secrets);
+  const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+  if (!(isNetworkAllowed(ctx?.policies, req.url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, req.url))) {
+    throw new Error("egress not allowed (approval required)");
+  }
+  const res = await fetch(req.url, {
+    method: req.method,
+    headers: req.headers
+  });
+  const text = await res.text();
+  const raw = req.parse === "json" ? JSON.parse(text) : text;
+  const items = prov.integration.toEnvelope(raw, resource);
+  const nextCursor = prov.integration.extractCursor && prov.integration.extractCursor(raw, cursor) || cursor || null;
+  if (nextCursor && nextCursor !== cursor)
+    await mem.handle({ put: { key: cursorKey, value: nextCursor } });
+  return { items, cursor: nextCursor };
+});
+runners.registerWorker("integration.sink.post.v1", async (_m, input, ctx) => {
+  const { getProvider: getProvider2 } = await import("./registry-FW63E7FE.js");
+  const providerIdVal = isObject(input) && "provider" in input ? input.provider : void 0;
+  const providerId = String(providerIdVal || "");
+  const resourceVal = isObject(input) && "resource" in input ? input.resource : void 0;
+  const resource = String(resourceVal || "");
+  const configVal = isObject(input) && "config" in input ? input.config : void 0;
+  const config = isObject(configVal) ? configVal : {};
+  const singleItem = isObject(input) && "item" in input ? input.item : void 0;
+  const itemsVal = isObject(input) && "items" in input ? input.items : void 0;
+  const itemsArray = isArray(itemsVal) ? itemsVal : void 0;
+  const items = itemsArray || (singleItem !== void 0 ? [singleItem] : []);
+  const prov = getProvider2(providerId);
+  if (!prov?.integration) throw new Error(`provider not found: ${providerId}`);
+  const secrets = {};
+  try {
+    const { resolveSecretValue } = await import("./secret-store-H7273UIT.js");
+    const names = ["DISCORD_BOT_TOKEN"];
+    for (const n of names) {
+      const value = await resolveSecretValue(n, {
+        ownerId: ctx.userId || "anonymous",
+        stackId: ctx.stackId,
+        nodeId: ctx.nodeId,
+        appletId: ctx.appletId,
+        worldId: ctx.worldId,
+        terminalId: ctx.terminalId
+      });
+      if (value) secrets[n] = value;
+    }
+  } catch {
+  }
+  const { isNetworkAllowed, requireNetworkApproval } = await import("./policy-IRJCM6FS.js");
+  let lastStatus = 0;
+  let allOk = true;
+  for (const it of items) {
+    const itemPayload = isObject(it) ? it : { value: it };
+    const req = prov.integration.buildRequest(
+      "post",
+      { resource, config, item: itemPayload },
+      secrets
+    );
+    if (!(isNetworkAllowed(ctx?.policies, req.url) || await requireNetworkApproval(ctx.stackId, ctx.nodeId, ctx?.policies, req.url))) {
+      throw new Error("egress not allowed (approval required)");
+    }
+    const res = await fetch(req.url, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body ? JSON.stringify(req.body) : void 0
+    });
+    lastStatus = res.status;
+    allOk = allOk && res.ok;
+  }
+  if (items.length === 0) {
+    return { ok: true, status: 204 };
+  }
+  return { ok: allOk, status: lastStatus };
+});
+
+export {
+  runners
+};