@rong/agentscript 0.1.0

package/dist/runtime/shape.js

@@ -0,0 +1,132 @@
+import { RuntimeError } from "./errors.js";
+import { isObject, isRuntimeResource } from "./guards.js";
+export function buildValueFromShape(shape) {
+    const result = {};
+    for (const field of shape.fields) {
+        result[field.name] = buildValueFromShapeType(field.type);
+    }
+    return result;
+}
+export function validateValueAgainstShape(value, shape, range) {
+    if (!isObject(value)) {
+        throw new RuntimeError("LLM result must be an object matching the generate return shape", range);
+    }
+    const allowedFields = new Set(shape.fields.map((field) => field.name));
+    for (const key of Object.keys(value)) {
+        if (!allowedFields.has(key)) {
+            throw new RuntimeError(`LLM result contains unexpected field '${key}'`, range);
+        }
+    }
+    for (const field of shape.fields) {
+        if (!(field.name in value)) {
+            throw new RuntimeError(`LLM result is missing required field '${field.name}'`, field.range);
+        }
+        validateValueAgainstShapeType(value[field.name], field.type, field.range);
+    }
+}
+export function coerceValueToShape(value, shape) {
+    if (!isObject(value)) {
+        return value;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        const field = shape.fields.find((candidate) => candidate.name === key);
+        result[key] = field ? coerceValueToShapeType(item, field.type) : item;
+    }
+    return result;
+}
+const SHAPE_TYPE_CONFIG = {
+    string: {
+        default: "",
+        validate: (value, range, errorPrefix = "LLM result field") => {
+            if (typeof value !== "string")
+                throw new RuntimeError(`${errorPrefix} must be a string`, range);
+        }
+    },
+    number: {
+        default: 0,
+        validate: (value, range, errorPrefix = "LLM result field") => {
+            if (typeof value !== "number")
+                throw new RuntimeError(`${errorPrefix} must be a number`, range);
+        },
+        coerce: coerceStringToNumber
+    },
+    boolean: {
+        default: true,
+        validate: (value, range, errorPrefix = "LLM result field") => {
+            if (typeof value !== "boolean")
+                throw new RuntimeError(`${errorPrefix} must be a boolean`, range);
+        },
+        coerce: coerceStringToBoolean
+    },
+    json: {
+        default: {},
+        validate: (value, range, errorPrefix = "LLM result json field") => {
+            if (isRuntimeResource(value)) {
+                throw new RuntimeError(`${errorPrefix} cannot contain runtime resource bindings`, range);
+            }
+        },
+    },
+    list: {
+        default: [],
+        validate: (value, range, errorPrefix = "LLM result field") => {
+            if (!Array.isArray(value))
+                throw new RuntimeError(`${errorPrefix} must be a list`, range);
+        },
+    },
+};
+function coerceValueToShapeType(value, type) {
+    if (type.kind === "ListShapeType") {
+        if (!Array.isArray(value)) {
+            return value;
+        }
+        return value.map((item) => coerceValueToShapeType(item, type.itemType));
+    }
+    const config = SHAPE_TYPE_CONFIG[type.name];
+    return config?.coerce ? config.coerce(value) : value;
+}
+function coerceStringToNumber(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (!/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(trimmed)) {
+        return value;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : value;
+}
+function coerceStringToBoolean(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") {
+        return true;
+    }
+    if (normalized === "false") {
+        return false;
+    }
+    return value;
+}
+export function validateValueAgainstShapeType(value, type, range, errorPrefix = "LLM result field") {
+    if (type.kind === "ListShapeType") {
+        if (!Array.isArray(value)) {
+            throw new RuntimeError(`${errorPrefix} must be a list`, range);
+        }
+        for (const item of value) {
+            validateValueAgainstShapeType(item, type.itemType, range, errorPrefix);
+        }
+        return;
+    }
+    const config = SHAPE_TYPE_CONFIG[type.name];
+    if (config) {
+        config.validate(value, range, errorPrefix);
+    }
+}
+function buildValueFromShapeType(type) {
+    if (type.kind === "ListShapeType") {
+        return [buildValueFromShapeType(type.itemType)];
+    }
+    return SHAPE_TYPE_CONFIG[type.name]?.default ?? {};
+}

package/dist/runtime/trace.js

@@ -0,0 +1,54 @@
+import { assertNever } from "../utils/assert.js";
+export function formatTrace(trace) {
+    if (trace.length === 0) {
+        return "(empty trace)";
+    }
+    return trace.map((event) => formatEvent(event, 0)).join("\n");
+}
+function formatEvent(event, depth) {
+    const indent = "  ".repeat(depth);
+    switch (event.kind) {
+        case "agent": {
+            const agent = readString(event.data.agent);
+            const fn = readString(event.data.function);
+            const nested = Array.isArray(event.data.trace) ? event.data.trace : [];
+            const header = `${indent}- agent ${agent}.${fn}`;
+            if (nested.length === 0)
+                return header;
+            return [header, ...nested.map((child) => formatEvent(child, depth + 1))].join("\n");
+        }
+        case "generate":
+            return `${indent}- generate ${summarize(event.data.instruction)}`;
+        case "tool": {
+            const tool = readString(event.data.tool);
+            const method = readString(event.data.method);
+            return `${indent}- tool ${tool}.${method}`;
+        }
+        case "memory": {
+            const memory = readString(event.data.memory);
+            const operation = readString(event.data.operation);
+            return `${indent}- memory ${memory}.${operation}`;
+        }
+        case "input":
+            return `${indent}- input ${readString(event.data.path)}`;
+        case "for":
+            return `${indent}- for ${readString(event.data.item)}[${summarize(event.data.index)}]`;
+        case "use":
+            return `${indent}- use ${summarize(event.data.source)}`;
+        default:
+            assertNever(event.kind);
+    }
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : "?";
+}
+function summarize(value) {
+    if (typeof value === "string") {
+        return value.length > 72 ? `${value.slice(0, 69)}...` : value;
+    }
+    if (value === undefined) {
+        return "";
+    }
+    const json = JSON.stringify(value);
+    return json.length > 72 ? `${json.slice(0, 69)}...` : json;
+}

package/dist/runtime/truth.js

@@ -0,0 +1,13 @@
+export function isTruthy(value) {
+    if (value === null)
+        return false;
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return value !== 0;
+    if (typeof value === "string")
+        return value.length > 0;
+    if (Array.isArray(value))
+        return value.length > 0;
+    return true;
+}

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/uri.js

@@ -0,0 +1,10 @@
+export function uriScheme(uri) {
+    try {
+        const parsed = new URL(uri);
+        return parsed.protocol.endsWith(":") ? parsed.protocol.slice(0, -1) : parsed.protocol;
+    }
+    catch {
+        const match = /^([A-Za-z][A-Za-z0-9+.-]*):/.exec(uri);
+        return match?.[1] ?? "";
+    }
+}