@nodetool-ai/node-sdk 0.8.4-a24.3 → 0.8.4

package/dist/_sandbox/sandbox-flow/sandbox/generated/openai.audio.js

@@ -0,0 +1,16 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function textToSpeech(inputs) {
+  return callNode("openai.audio.TextToSpeech", inputs);
+}
+function translate(inputs) {
+  return callNode("openai.audio.Translate", inputs);
+}
+function transcribe(inputs) {
+  return callNode("openai.audio.Transcribe", inputs);
+}
+export {
+  textToSpeech,
+  transcribe,
+  translate
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/openai.image.js

@@ -0,0 +1,16 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function createImage(inputs) {
+  return callNode("openai.image.CreateImage", inputs);
+}
+function editImage(inputs) {
+  return callNode("openai.image.EditImage", inputs);
+}
+function imageVariation(inputs) {
+  return callNode("openai.image.ImageVariation", inputs);
+}
+export {
+  createImage,
+  editImage,
+  imageVariation
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/openai.text.js

@@ -0,0 +1,16 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function embedding(inputs) {
+  return callNode("openai.text.Embedding", inputs);
+}
+function webSearch(inputs) {
+  return callNode("openai.text.WebSearch", inputs);
+}
+function moderation(inputs) {
+  return callNode("openai.text.Moderation", inputs);
+}
+export {
+  embedding,
+  moderation,
+  webSearch
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/vector.js

@@ -0,0 +1,56 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function collection(inputs) {
+  return callNode("vector.Collection", inputs);
+}
+function count(inputs) {
+  return callNode("vector.Count", inputs);
+}
+function getDocuments(inputs) {
+  return callNode("vector.GetDocuments", inputs);
+}
+function peek(inputs) {
+  return callNode("vector.Peek", inputs);
+}
+function indexImage(inputs) {
+  return callNode("vector.IndexImage", inputs);
+}
+function indexEmbedding(inputs) {
+  return callNode("vector.IndexEmbedding", inputs);
+}
+function indexTextChunk(inputs) {
+  return callNode("vector.IndexTextChunk", inputs);
+}
+function indexAggregatedText(inputs) {
+  return callNode("vector.IndexAggregatedText", inputs);
+}
+function indexString(inputs) {
+  return callNode("vector.IndexString", inputs);
+}
+function queryImage(inputs) {
+  return callNode("vector.QueryImage", inputs);
+}
+function queryText(inputs) {
+  return callNode("vector.QueryText", inputs);
+}
+function removeOverlap(inputs) {
+  return callNode("vector.RemoveOverlap", inputs);
+}
+function hybridSearch(inputs) {
+  return callNode("vector.HybridSearch", inputs);
+}
+export {
+  collection,
+  count,
+  getDocuments,
+  hybridSearch,
+  indexAggregatedText,
+  indexEmbedding,
+  indexImage,
+  indexString,
+  indexTextChunk,
+  peek,
+  queryImage,
+  queryText,
+  removeOverlap
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/whisper_cpp.js

@@ -0,0 +1,11 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode, streamNode } from "../guest-core.js";
+function liveTranscription(inputs) {
+  return callNode("whisper_cpp.LiveTranscription", inputs);
+}
+liveTranscription.stream = function(inputs) {
+  return streamNode("whisper_cpp.LiveTranscription", inputs);
+};
+export {
+  liveTranscription
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/xai.image.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function generateImage(inputs) {
+  return callNode("xai.image.GenerateImage", inputs);
+}
+export {
+  generateImage
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/xai.text.js

@@ -0,0 +1,12 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function chatComplete(inputs) {
+  return callNode("xai.text.ChatComplete", inputs);
+}
+function webSearch(inputs) {
+  return callNode("xai.text.WebSearch", inputs);
+}
+export {
+  chatComplete,
+  webSearch
+};

package/dist/_sandbox/sandbox-flow/sandbox/generated/xai.vision.js

@@ -0,0 +1,8 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import { callNode } from "../guest-core.js";
+function imageToText(inputs) {
+  return callNode("xai.vision.ImageToText", inputs);
+}
+export {
+  imageToText
+};

package/dist/_sandbox/sandbox-flow/sandbox/guest-core.js

@@ -0,0 +1,35 @@
+// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit
+import {
+  invoke_node,
+  open_node_stream,
+  take_node_stream,
+  close_node_stream
+} from "@nodetool-ai/sandbox-nodetool/flow";
+async function callNode(type, inputs) {
+  const outputs = await invoke_node({ type, inputs });
+  return outputs;
+}
+function streamNode(type, inputs) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      const { stream_id } = await open_node_stream({ type, inputs });
+      let exhausted = false;
+      try {
+        while (true) {
+          const next = await take_node_stream({ stream_id });
+          if (next.done) {
+            exhausted = true;
+            return;
+          }
+          yield next.value;
+        }
+      } finally {
+        if (!exhausted) await close_node_stream({ stream_id });
+      }
+    }
+  };
+}
+export {
+  callNode,
+  streamNode
+};

package/dist/_sandbox/sandbox-flow/sandbox/index.js

@@ -0,0 +1,10 @@
+/**
+ * The pack's root module: the untyped call bridge.
+ *
+ * The typed surface is the per-namespace modules — `callNode(type, inputs)` is
+ * what they are built on, and takes a node type as a string, so it checks
+ * nothing until the host answers. Import it when the type is decided at run
+ * time; otherwise import the namespace and let the missing export be the error.
+ */
+
+export { callNode, streamNode } from "./guest-core.js";

package/dist/_sandbox/sandbox-flow/scripts/build.mjs

@@ -0,0 +1,120 @@
+/**
+ * Build the pack's guest modules from `packages/dsl/src/flow`.
+ *
+ * The flow surface is TypeScript whose only runtime import is
+ * `../guest-core.js`; every type in a signature is erased. So the build is a
+ * per-file transform, not a bundle: one guest module per namespace, all of them
+ * sharing the one `guest-core.js` this build ships from
+ * `packages/dsl/src/flow/guest-core.ts`. Bundling instead would inline that
+ * core — and the capability import behind it — into all 69 entries.
+ *
+ * The manifest's `sandboxModules` list is written from the same pass, so the
+ * pack cannot declare a module it did not build.
+ *
+ *   node packages/sandbox-packs/sandbox-flow/scripts/build.mjs
+ *   node packages/sandbox-packs/sandbox-flow/scripts/build.mjs --check
+ *
+ * `--check` writes nothing and exits non-zero when the built output differs
+ * from what is committed. The pack carries its own copy of the flow surface, so
+ * it can rot against `packages/dsl` — and this copy is what agents author
+ * against.
+ */
+
+import { createRequire } from "node:module";
+import { readdirSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+/** @type {import("esbuild")} */
+const esbuild = require("esbuild");
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packDir = join(here, "..");
+const flowSource = join(packDir, "..", "..", "dsl", "src", "flow");
+const generatedSource = join(flowSource, "generated");
+const generatedOut = join(packDir, "sandbox", "generated");
+
+const banner = "// Built from @nodetool-ai/dsl by scripts/build.mjs — do not edit\n";
+
+const check = process.argv.includes("--check");
+
+/** Built files, path → contents. Written at the end, or compared under --check. */
+const outputs = new Map();
+/** Paths that differ from what is on disk. */
+const stale = [];
+
+function emit(path, contents) {
+  outputs.set(path, contents);
+  if (!check) return;
+  let current = null;
+  try {
+    current = readFileSync(path, "utf8");
+  } catch {
+    // Missing counts as stale, reported by the null comparison below.
+  }
+  if (current !== contents) stale.push(path);
+}
+
+async function transform(file, sourcefile) {
+  const built = await esbuild.transform(readFileSync(file, "utf8"), {
+    loader: "ts",
+    format: "esm",
+    target: "es2022",
+    sourcefile
+  });
+  return `${banner}${built.code}`;
+}
+
+if (!check) {
+  rmSync(generatedOut, { recursive: true, force: true });
+  mkdirSync(generatedOut, { recursive: true });
+}
+
+const core = await transform(join(flowSource, "guest-core.ts"), "guest-core.ts");
+emit(join(packDir, "sandbox", "guest-core.js"), core);
+
+const sources = readdirSync(generatedSource)
+  .filter((file) => file.endsWith(".ts"))
+  .sort();
+
+const modules = [];
+let bytes = 0;
+for (const file of sources) {
+  const stem = file.replace(/\.ts$/, "");
+  const code = await transform(join(generatedSource, file), file);
+  emit(join(generatedOut, `${stem}.js`), code);
+  bytes += Buffer.byteLength(code, "utf8");
+  modules.push({ name: stem, kind: "js", file: `sandbox/generated/${stem}.js` });
+}
+
+modules.sort((left, right) => (left.name < right.name ? -1 : 1));
+// The root is hand-written: it re-exports the core's untyped `callNode` under
+// the pack's own name, which no generated namespace can do.
+modules.unshift({ name: ".", kind: "js", file: "sandbox/index.js" });
+
+const manifestPath = join(packDir, "package.json");
+const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+manifest.nodetool.sandboxModules = modules;
+// The core is a sibling every namespace imports, not a module anyone declares.
+manifest.nodetool.internal = ["sandbox/guest-core.js"];
+emit(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+
+if (check) {
+  if (stale.length > 0) {
+    console.error(
+      `sandbox-flow is stale — ${stale.length === 1 ? "1 file differs" : `${stale.length} files differ`} from @nodetool-ai/dsl:`
+    );
+    for (const path of stale.slice(0, 10)) console.error(`  ${path}`);
+    if (stale.length > 10) console.error(`  … and ${stale.length - 10} more`);
+    console.error("Run `npm run build:sandbox-flow` and commit the result.");
+    process.exit(1);
+  }
+  console.log(`sandbox-flow is up to date (${modules.length} modules).`);
+} else {
+  for (const [path, contents] of outputs) writeFileSync(path, contents);
+}
+
+console.log(
+  `${modules.length} modules, ${bytes} bytes of generated JavaScript, ${Buffer.byteLength(core, "utf8")} bytes of core`
+);

package/dist/_sandbox/sandbox-game/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: sandbox-game
+description: Build a complete native game document with entities, scripts and level geometry, then save the draft in one edit
+---
+
+# Games as code
+
+Import `@nodetool-ai/sandbox-game` in a game chat, CodeAct action or JS script.
+It creates plain game documents for `nodetool.games`. Build geometry in local
+loops and save the entire draft with one `set_document` edit. The server
+validates the schema and references before writing. It retains the game's
+stored ID and revision. Publishing requires a separate request.
+
+The helpers follow the shipped game document schema. Position, size and
+gravity use world units. Simulation runs at 60 ticks per second. Assets must
+already be installed or use the built-in asset bindings.
+
+## Build and save a level
+
+```js
+import { game, entity, script, registerAssets, fill, plank, arc, saveGame }
+  from "@nodetool-ai/sandbox-game";
+
+const document = game({ pixelsPerUnit: 48 });
+registerAssets(document, {
+  stone: { assetId: "builtin:wall", digest: "builtin:wall-v1", width: 32, height: 32 },
+  gem: { assetId: "builtin:gem", digest: "builtin:gem-v1", width: 32, height: 32 }
+});
+const tiles = [];
+fill(tiles, 0, -2, 80, 2);
+plank(tiles, 4, 2, 8, { oneWay: true });
+const level = document.scenes[0];
+level.entities.push(entity("terrain", 0, 0, {
+  tilemap: { assetId: "stone", tiles, solid: true, layer: 0 }
+}));
+for (const [index, point] of arc(8, 3, 3, 2, 7).entries()) {
+  level.entities.push(entity(`gem-${index}`, point.x, point.y, {
+    sprite: { assetId: "gem", width: 0.5, height: 0.5 },
+    collider2d: { width: 0.5, height: 0.5, sensor: true },
+    behaviors: [{ kind: "collectible", score: 1 }]
+  }));
+}
+level.entities.push(entity("camera", 8, 2, { camera2d: { width: 16, height: 9 } }));
+level.entities.push(entity("logic", 0, 0, {
+  behaviors: [script(({ tick }) => ({ state: {}, commands: tick === 600 ? [{ kind: "emit", event: "ready" }] : [] }))]
+}));
+const saved = await saveGame({ name: "Arc study", document }, {
+  games: nodetool.games, project_id: "<owned-project-id>"
+});
+await output("game_id", saved.game_id);
+```
+
+Add a player and its controller before calling a level playable. Read
+`nodetool.games.getExample("kindle")` for a complete platformer document and
+load the `native-game` and `game-direction` skills for the runtime contract
+and craft requirements.
+
+## Helpers
+
+| Export | Contract |
+|---|---|
+| `game(options = {})` | Creates a schema version 2 document. Defaults to one empty `level` scene, 32 pixels per unit and left/right/up/down/space actions. Pass scenes, assets, collision layers and render effects directly. |
+| `entity(id, x = 0, y = 0, options = {})` | Creates an entity with a complete transform and behavior list. Pass sprite, body, collider, animator, camera, light and prefab settings in options. |
+| `script(source, options = {})` | Creates a script behavior from a source string or function. Defaults to 16 commands and 8 ms per tick. Functions cannot close over the builder's variables. |
+| `registerAssets(document, bindings)` | Copies slot bindings into the document. Sets pivot and sampling defaults. Audio and font dimensions default to 1×1. Images require their actual dimensions. This does not install files. |
+| `fill(tiles, x, y, cols, rows, options = {})` | Appends tile centres to an array. The first centre is `(x,y)`. Spacing is `width` and `height`, which default to `size` or 1. Options also carry frame, solid and oneWay fields. |
+| `plank(tiles, x, y, cols, options = {})` | Appends one horizontal row using `fill`. |
+| `arc(x, y, radiusX, radiusY, points, from = 0, to = Math.PI)` | Returns evenly spaced elliptical arc positions including both endpoints. Angles use radians. One point uses `from`. |
+| `saveGame({name, document}, options)` | Pass `{games: nodetool.games, project_id}` to create a game and save its draft. Pass `{games, game_id, base_updated_at}` to replace an existing draft. Returns game_id, revision and draft_updated_at. Refused writes and conflicts throw. |
+| `constructGame({inputs, seed}, build)` | Runs an explicit callback with `inputs` and `builder`, returning `{document, program}` plus retained parameters, prefabs and instance relationships. Preparation results must be literal JSON inputs. Use stable scene and entity IDs. |
+
+For an existing draft, read its `draft_updated_at` and pass it as
+`base_updated_at`. Save all scene references and bindings together. Invalid
+asset references, duplicate entities or script budget violations reject the
+whole edit. A failed replacement leaves the previous draft intact.
+
+## Retained construction
+
+Use an explicit callback for construction that can run again without preparation.
+The callback receives `inputs` and `builder` and returns a native document. It
+cannot close over variables in the authoring session. Keep runtime script
+behavior source separate from this construction body.
+
+```js
+import { constructGame, saveGame } from "@nodetool-ai/sandbox-game";
+const bundle = constructGame({ seed: 17, inputs: { speed: 4 } }, (inputs, builder) => {
+  const speed = builder.parameter("speed", {type: "number", default: 4, min: 1, max: 10});
+  const document = builder.game();
+  builder.prefab("marker", builder.entity("definition", 0, 0));
+  builder.instance(document.scenes[0], "north-marker", "marker", {
+    transform2d: {x: speed, y: 0, rotation: 0, scaleX: 1, scaleY: 1}
+  });
+  return document;
+});
+await saveGame({ name: "Retained study", ...bundle }, {
+  games: nodetool.games, project_id: "<owned-project-id>"
+});
+```
+
+`builder` includes the ordinary document helpers plus `parameter`, `prefab`,
+`instance`, and seeded `random`. Parameter types are number, string and
+boolean, enum, vector2 and vector3. Numeric parameters accept min and max.
+Enum parameters declare `values`. Vector parameters use arrays of two or
+three finite numbers. Prefabs are retained in the
+construction source and emit native entities through stable instance keys.
+Instance component overrides merge individual object fields with the prefab.
+Arrays replace the complete inherited array. Preparation inputs are copied
+before the callback runs, so mutating a template does not alter retained inputs.
+Duplicate scene, entity and prefab keys reject the build.
+
+Saving a bundle with `program` first previews a hermetic rebuild and checks
+that it reproduces `document`. Applying the candidate checks the draft has
+not changed since preview. Rebuilds cannot fetch, install assets, generate
+resources, access secrets or read the workspace. Pass accepted asset
+bindings through `inputs`. Use `builder.random()` for authoring randomness.
+The construction seed is independent of the play session seed.

package/dist/_sandbox/sandbox-game/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@nodetool-ai/sandbox-game",
+  "version": "0.8.4",
+  "description": "Build a complete native game document with entities, scripts and level geometry, then save the draft in one edit",
+  "license": "MIT",
+  "nodetool": {
+    "apiVersion": 1,
+    "recommended": true,
+    "sandboxModules": [
+      {
+        "name": ".",
+        "kind": "js",
+        "file": "sandbox/index.js"
+      }
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nodetool-ai/nodetool.git",
+    "directory": "packages/sandbox-packs/sandbox-game"
+  },
+  "homepage": "https://nodetool.ai",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "SKILL.md",
+    "sandbox"
+  ],
+  "keywords": [
+    "nodetool",
+    "nodetool-sandbox-pack",
+    "sandbox",
+    "game"
+  ]
+}