@gigaai/newton 0.3.0

package/dist/schema.js

@@ -0,0 +1,184 @@
+/**
+ * Minimal JSON Schema validation — just the subset workflow authors actually
+ * use for structured output (type/properties/required/items/enum/anyOf).
+ * Deliberately not a full validator; swap for ajv if this ever falls short.
+ */
+export function validateAgainstSchema(value, schema, path = "$") {
+    const errors = [];
+    if (schema.const !== undefined && JSON.stringify(value) !== JSON.stringify(schema.const)) {
+        return [`${path}: expected const ${JSON.stringify(schema.const)}`];
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(value))) {
+        return [`${path}: expected one of ${JSON.stringify(schema.enum)}`];
+    }
+    const variants = (schema.anyOf ?? schema.oneOf);
+    if (Array.isArray(variants)) {
+        const matches = variants.some((v) => validateAgainstSchema(value, v, path).length === 0);
+        if (!matches)
+            errors.push(`${path}: matched no variant of anyOf/oneOf`);
+        return errors;
+    }
+    const type = schema.type;
+    if (type) {
+        const types = Array.isArray(type) ? type : [type];
+        if (!types.some((t) => matchesType(value, t))) {
+            return [`${path}: expected ${types.join("|")}, got ${describe(value)}`];
+        }
+    }
+    if (isObject(value)) {
+        const required = schema.required ?? [];
+        for (const key of required) {
+            if (!(key in value))
+                errors.push(`${path}: missing required property "${key}"`);
+        }
+        const properties = schema.properties ?? {};
+        for (const [key, propSchema] of Object.entries(properties)) {
+            if (key in value)
+                errors.push(...validateAgainstSchema(value[key], propSchema, `${path}.${key}`));
+        }
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(value)) {
+                if (!(key in properties))
+                    errors.push(`${path}: unexpected property "${key}"`);
+            }
+        }
+    }
+    if (Array.isArray(value)) {
+        if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+            errors.push(`${path}: expected at least ${schema.minItems} items`);
+        }
+        if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+            errors.push(`${path}: expected at most ${schema.maxItems} items`);
+        }
+        if (isObject(schema.items)) {
+            value.forEach((item, i) => {
+                errors.push(...validateAgainstSchema(item, schema.items, `${path}[${i}]`));
+            });
+        }
+    }
+    if (typeof value === "number") {
+        if (typeof schema.minimum === "number" && value < schema.minimum) {
+            errors.push(`${path}: ${value} < minimum ${schema.minimum}`);
+        }
+        if (typeof schema.maximum === "number" && value > schema.maximum) {
+            errors.push(`${path}: ${value} > maximum ${schema.maximum}`);
+        }
+    }
+    if (typeof value === "string" && typeof schema.pattern === "string") {
+        if (!new RegExp(schema.pattern).test(value)) {
+            errors.push(`${path}: does not match pattern ${schema.pattern}`);
+        }
+    }
+    return errors;
+}
+function matchesType(value, type) {
+    switch (type) {
+        case "string":
+            return typeof value === "string";
+        case "number":
+            return typeof value === "number";
+        case "integer":
+            return typeof value === "number" && Number.isInteger(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "array":
+            return Array.isArray(value);
+        case "object":
+            return isObject(value);
+        case "null":
+            return value === null;
+        default:
+            return true;
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describe(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+/**
+ * Pull a JSON value out of agent prose. Tries the whole text, then fenced
+ * blocks, then the last balanced {...} or [...] span — agents often preface
+ * the payload with commentary despite instructions not to.
+ */
+export function extractJson(text) {
+    const trimmed = text.trim();
+    const direct = tryParse(trimmed);
+    if (direct !== INVALID)
+        return direct;
+    const fences = [...trimmed.matchAll(/```(?:json)?\s*\n?([\s\S]*?)```/g)];
+    for (const fence of fences.reverse()) {
+        const parsed = tryParse(fence[1].trim());
+        if (parsed !== INVALID)
+            return parsed;
+    }
+    for (const open of ["{", "["]) {
+        const start = trimmed.lastIndexOf(open);
+        if (start === -1)
+            continue;
+        const candidate = balancedSlice(trimmed, start);
+        if (candidate) {
+            const parsed = tryParse(candidate);
+            if (parsed !== INVALID)
+                return parsed;
+        }
+    }
+    return INVALID;
+}
+export const INVALID = Symbol("invalid-json");
+function tryParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return INVALID;
+    }
+}
+export function balancedSlice(text, start) {
+    const open = text[start];
+    const close = open === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (escaped) {
+            escaped = false;
+        }
+        else if (ch === "\\") {
+            escaped = inString;
+        }
+        else if (ch === '"') {
+            inString = !inString;
+        }
+        else if (!inString) {
+            if (ch === open)
+                depth++;
+            else if (ch === close && --depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return undefined;
+}
+export function structuredOutputInstruction(schema) {
+    return [
+        "",
+        "## Output format (mandatory)",
+        "Your final message must be ONLY a single JSON value matching this JSON Schema — no prose, no markdown fences:",
+        JSON.stringify(schema, null, 2),
+    ].join("\n");
+}
+export function structuredOutputRetryPrompt(errors, schema) {
+    return [
+        "Your previous response was not valid against the required JSON Schema:",
+        ...errors.slice(0, 10).map((e) => `- ${e}`),
+        "",
+        "Respond again with ONLY a single JSON value matching this schema — no prose, no fences:",
+        JSON.stringify(schema, null, 2),
+    ].join("\n");
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const VERSION = "0.3.0";

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@gigaai/newton",
+  "version": "0.3.0",
+  "description": "Deterministic multi-agent workflow executor. Write workflows in plain JavaScript; Newton drives coding agents over the Agent Client Protocol.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GigaML/newton.git"
+  },
+  "homepage": "https://github.com/GigaML/newton#readme",
+  "keywords": [
+    "acp",
+    "agent-client-protocol",
+    "agents",
+    "workflow",
+    "orchestration",
+    "codex",
+    "claude",
+    "cli"
+  ],
+  "type": "module",
+  "bin": {
+    "newton": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"require('fs').chmodSync('dist/cli.js', 0o755)\"",
+    "check": "npm run build && node dist/cli.js validate examples/hello.js && node dist/cli.js doctor --json",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@agentclientprotocol/codex-acp": "^1.1.0",
+    "@agentclientprotocol/sdk": "^1.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.3"
+  }
+}