@rong/agentscript 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to AgentScript will be documented in this file.
 
+## 0.1.5 - 2026-05-09
+
+### Changed
+
+- Switched context budgets from `use expr < budget` to `use expr max budget`.
+- Switched loop and for-in iteration limits to `max` syntax.
+- Restored `<` as an ordinary numeric comparison operator.
+- Required comma separators between object literal fields.
+- Updated current docs, examples, tutorials, fixtures, and tests for the new syntax.
+
+## 0.1.4 - 2026-05-08
+
+### Added
+
+- Added `max_output` as the explicit `generate` output budget.
+- Added `temperature`, `think`, and `strict` generate options.
+- Added provider request mapping for generate provider hints.
+
+### Changed
+
+- Replaced generate `limit` usage with `max_output` in current docs, examples, tutorials, and fixtures.
+- Expanded English and Chinese `generate` design docs with configuration semantics.
+- Updated shape validation so `strict: true` disables coercion and rejects extra fields.
+
 ## 0.1.3 - 2026-05-08
 
 ### Added

package/README.md

@@ -6,8 +6,10 @@
 > Zero runtime dependencies. TypeScript-powered.
 
 ```agentscript
-use scratch.summary < 2k as observations
-generate({ input: "Answer from observations" }) -> {
+use scratch.summary max 2k as observations
+generate({
+    input: "Answer from observations"
+}) -> {
     ok boolean
     text string
 }
@@ -60,13 +62,15 @@ main agent FileSummarizer {
     description "Read one local file and produce a useful structured summary."
 
     main func(input { path string }) {
-        content = File.read({ path: input.path })
+        content = File.read({
+            path: input.path
+        })
         use input.path as source path
-        use content < 8k as file content
+        use content max 8k as file content
 
         generate({
-            input: "Summarize the file for a busy teammate"
-            limit: 1000
+            input: "Summarize the file for a busy teammate",
+            max_output: 1000
         }) -> {
             title string
             summary string
@@ -181,10 +185,10 @@ main agent ResearchAgent {
         use input.question as user question
 
         scratch = []
-        use scratch.summary < 2k as observations
+        use scratch.summary max 2k as observations
 
         done = false
-        loop until done < 6 {
+        loop until done max 6 {
             thought = reason(input.question, scratch)
             obs = Search.search(thought.focus)
             scratch.add(obs)
@@ -196,8 +200,10 @@ main agent ResearchAgent {
 
     func answer(question, scratch) {
         use question as user question
-        use scratch.summary < 2k as observations
-        generate({ input: "Answer using only the observations" }) -> {
+        use scratch.summary max 2k as observations
+        generate({
+            input: "Answer using only the observations"
+        }) -> {
             ok boolean
             text string
             error string
@@ -254,8 +260,8 @@ agentscript examples/review.as --quiet               # value only, no trace
 
 | Language | Links |
 |----------|-------|
-| English | [Language Reference](docs/en/language.md) · [Context Engineering](docs/en/context-engineering.md) · [Design History](docs/design-history/) |
-| 中文 | [README-CN](./README-CN.md) · [语言参考](docs/cn/language.md) · [Context Engineering](docs/cn/context-engineering.md) |
+| English | [Language Reference](docs/en/language.md) · [Context Engineering](docs/en/context-engineering.md) · [`use ... as ...`](docs/en/use-as.md) · [`generate`](docs/en/generate.md) · [Design History](docs/design-history/) |
+| 中文 | [README-CN](./README-CN.md) · [语言参考](docs/cn/language.md) · [Context Engineering](docs/cn/context-engineering.md) · [`use ... as ...`](docs/cn/use-as.md) · [`generate`](docs/cn/generate.md) |
 
 ### Design principles
 
@@ -281,4 +287,4 @@ Zero runtime dependencies. Built with TypeScript.
 
 ## License
 
-MIT
+MIT

package/dist/parser/parser.js

@@ -175,7 +175,7 @@ class Parser {
     parseUse() {
         const start = this.consume("use").range.start;
         const value = this.parseLogicalOr();
-        const budget = this.match("<") ? this.parseBudget() : undefined;
+        const budget = this.match("max") ? this.parseBudget() : undefined;
         const label = this.match("as") ? this.parseUseLabel() : undefined;
         return {
             kind: "UseStmt",
@@ -228,7 +228,7 @@ class Parser {
         const item = this.consumeIdentifier("Expected for item name");
         this.consume("in");
         const iterable = this.parseLogicalOr();
-        this.consume("<");
+        this.consume("max");
         const maxIterations = this.parsePositiveInteger("Expected for iteration count");
         const body = this.parseBlock();
         return {
@@ -245,7 +245,7 @@ class Parser {
         const start = this.consume("loop").range.start;
         this.consume("until");
         const condition = this.parseLogicalOr();
-        this.consume("<");
+        this.consume("max");
         const maxIterations = this.parsePositiveInteger("Expected loop iteration count");
         const body = this.parseBlock();
         return {
@@ -299,7 +299,10 @@ class Parser {
         return this.parseBinaryExpression(() => this.parseEquality(), "and");
     }
     parseEquality() {
-        return this.parseBinaryExpression(() => this.parseUnary(), "==", "!=");
+        return this.parseBinaryExpression(() => this.parseComparison(), "==", "!=");
+    }
+    parseComparison() {
+        return this.parseBinaryExpression(() => this.parseUnary(), "<");
     }
     parseBinaryExpression(parseOperand, ...operators) {
         let expr = parseOperand();
@@ -434,16 +437,19 @@ class Parser {
         const properties = [];
         let input;
         let attempts;
-        let limit;
+        let maxOutput;
+        let temperature;
+        let think;
+        let strict;
         let debug;
         while (!this.check("}") && !this.isAtEnd()) {
             const propStart = this.peek().range.start;
             const key = this.consumeObjectKey();
             this.consume(":");
             let value;
-            if (key === "limit") {
-                const token = this.consumeKind("number", "Expected generate limit");
-                limit = this.parseBudgetToken(token);
+            if (key === "max_output") {
+                const token = this.consumeKind("number", "Expected generate max_output");
+                maxOutput = this.parseBudgetToken(token);
                 value = {
                     kind: "NumberExpr",
                     value: Number.parseFloat(token.value),
@@ -466,10 +472,19 @@ class Parser {
             else if (key === "attempts" && value.kind === "NumberExpr") {
                 attempts = value;
             }
+            else if (key === "temperature" && value.kind === "NumberExpr") {
+                temperature = value;
+            }
+            else if (key === "think" && (value.kind === "BooleanExpr" || value.kind === "StringExpr")) {
+                think = value;
+            }
+            else if (key === "strict" && value.kind === "BooleanExpr") {
+                strict = value;
+            }
             else if (key === "debug" && value.kind === "BooleanExpr") {
                 debug = value;
             }
-            this.match(",");
+            this.consumePropertySeparator("}");
         }
         this.consume("}");
         return {
@@ -477,7 +492,10 @@ class Parser {
             properties,
             input,
             attempts,
-            limit,
+            maxOutput,
+            temperature,
+            think,
+            strict,
             debug,
             range: { start, end: this.previous().range.end }
         };
@@ -496,7 +514,7 @@ class Parser {
                 value,
                 range: { start: propStart, end: value.range.end }
             });
-            this.match(",");
+            this.consumePropertySeparator("}");
         }
         this.consume("}");
         return {
@@ -505,6 +523,11 @@ class Parser {
             range: { start, end: this.previous().range.end }
         };
     }
+    consumePropertySeparator(terminator) {
+        if (this.check(terminator))
+            return;
+        this.consume(",");
+    }
     parseList() {
         const start = this.consume("[").range.start;
         const items = this.parseCommaSeparatedUntil("]", () => this.parseExpression());

package/dist/parser/tokenizer.js

@@ -25,7 +25,8 @@ const KEYWORDS = new Set([
     "number",
     "boolean",
     "json",
-    "list"
+    "list",
+    "max"
 ]);
 const SYMBOLS = new Set([
     "{",

package/dist/providers/llm/anthropic.js

@@ -5,7 +5,7 @@ export async function callAnthropic(request, parsed, options, fetchImpl, timeout
     if (!apiKey) {
         throw new RuntimeError("ANTHROPIC_API_KEY is required for anthropic:// models");
     }
-    const response = await postJson(fetchImpl, `${baseUrl}/messages`, {
+    const body = {
         model: parsed.model,
         max_tokens: budgetToTokenLimit(request) ?? 1024,
         system: request.builtContext.system,
@@ -15,7 +15,11 @@ export async function callAnthropic(request, parsed, options, fetchImpl, timeout
                 content: request.builtContext.finalUserMessage,
             },
         ],
-    }, timeoutMs, {
+    };
+    if (request.temperature !== undefined) {
+        body.temperature = request.temperature;
+    }
+    const response = await postJson(fetchImpl, `${baseUrl}/messages`, body, timeoutMs, {
         "x-api-key": apiKey,
         "anthropic-version": "2023-06-01",
     });

package/dist/providers/llm/ollama.js

@@ -3,7 +3,7 @@ export async function callOllama(request, parsed, fetchImpl, timeoutMs, baseUrl)
     const body = {
         model: parsed.model,
         stream: false,
-        think: false,
+        think: request.think ?? false,
         messages: [
             { role: "system", content: request.builtContext.system },
             { role: "user", content: request.builtContext.finalUserMessage },
@@ -13,8 +13,15 @@ export async function callOllama(request, parsed, fetchImpl, timeoutMs, baseUrl)
         body.format = request.builtContext.returnSchema;
     }
     const maxTokens = budgetToTokenLimit(request);
+    const options = {};
     if (maxTokens) {
-        body.options = { num_predict: maxTokens };
+        options.num_predict = maxTokens;
+    }
+    if (request.temperature !== undefined) {
+        options.temperature = request.temperature;
+    }
+    if (Object.keys(options).length > 0) {
+        body.options = options;
     }
     const response = await postJson(fetchImpl, `${baseUrl}/api/chat`, body, timeoutMs);
     const text = readPath(response, ["message", "content"]);

package/dist/providers/llm/openai.js

@@ -17,11 +17,18 @@ export async function callOpenAI(request, parsed, options, fetchImpl, timeoutMs,
             type: "json_schema",
             json_schema: {
                 name: "agentscript_generate",
-                strict: true,
+                strict: request.strict,
                 schema: request.builtContext.returnSchema,
             },
         };
     }
+    if (request.temperature !== undefined) {
+        body.temperature = request.temperature;
+    }
+    const reasoningEffort = openAIReasoningEffort(request.think);
+    if (reasoningEffort) {
+        body.reasoning_effort = reasoningEffort;
+    }
     const maxTokens = budgetToTokenLimit(request);
     if (maxTokens) {
         body.max_completion_tokens = maxTokens;
@@ -32,3 +39,10 @@ export async function callOpenAI(request, parsed, options, fetchImpl, timeoutMs,
     const text = readPath(response, ["choices", 0, "message", "content"]);
     return request.returnShape ? parseJsonText(text) : text;
 }
+function openAIReasoningEffort(think) {
+    if (think === true)
+        return "medium";
+    if (think === "low" || think === "medium" || think === "high")
+        return think;
+    return undefined;
+}

package/dist/providers/llm/shared.js

@@ -1,12 +1,12 @@
 import { RuntimeError } from "../../runtime/errors.js";
 export function budgetToTokenLimit(request) {
-    if (!request.budget) {
+    if (!request.maxOutput) {
         return undefined;
     }
-    if (request.budget.unit === "k") {
-        return Math.max(1, Math.floor(request.budget.amount * 1000));
+    if (request.maxOutput.unit === "k") {
+        return Math.max(1, Math.floor(request.maxOutput.amount * 1000));
     }
-    return Math.max(1, Math.floor(request.budget.amount));
+    return Math.max(1, Math.floor(request.maxOutput.amount));
 }
 export async function postJson(fetchImpl, url, body, timeoutMs, headers = {}) {
     const controller = new AbortController();

package/dist/runtime/context.js

@@ -14,7 +14,7 @@ export function buildContext(input) {
         instruction,
         instructionText,
         returnSchema,
-        budget: input.budget,
+        maxOutput: input.maxOutput,
         finalUserMessage: buildFinalUserMessage(context, instructionText, returnSchema),
     };
 }
@@ -166,7 +166,7 @@ export function builtContextToJson(context) {
         })),
         instruction: context.instruction,
         returnSchema: context.returnSchema ?? null,
-        budget: budgetToJson(context.budget),
+        maxOutput: budgetToJson(context.maxOutput),
         finalUserMessage: context.finalUserMessage,
     };
 }

package/dist/runtime/evaluator.js

@@ -97,8 +97,16 @@ export class Evaluator {
                 return this.valuesEqual(await this.evaluate(expr.left, scope), await this.evaluate(expr.right, scope));
             case "!=":
                 return !this.valuesEqual(await this.evaluate(expr.left, scope), await this.evaluate(expr.right, scope));
+            case "<":
+                return this.evaluateLessThan(await this.evaluate(expr.left, scope), await this.evaluate(expr.right, scope), expr.range);
         }
     }
+    evaluateLessThan(left, right, range) {
+        if (typeof left !== "number" || typeof right !== "number") {
+            throw new RuntimeError("operator '<' requires number operands", range);
+        }
+        return left < right;
+    }
     valuesEqual(left, right) {
         return runtimeValuesEqual(left, right);
     }

package/dist/runtime/generate.js

@@ -29,7 +29,7 @@ export class GenerateRuntime {
                 instruction,
                 returnShape: expr.returnShape,
                 uses: context,
-                budget: options.limit,
+                maxOutput: options.maxOutput,
             });
             if (options.debug) {
                 writeDebugPrompt(agent.name, attempt, builtContext);
@@ -44,7 +44,11 @@ export class GenerateRuntime {
                     returnShape: expr.returnShape,
                     context,
                     builtContext,
-                    budget: options.limit,
+                    maxOutput: options.maxOutput,
+                    temperature: options.temperature,
+                    think: options.think,
+                    strict: options.strict,
+                    debug: options.debug,
                 });
             }
             catch (error) {
@@ -58,18 +62,27 @@ export class GenerateRuntime {
                 continue;
             }
             try {
-                const result = expr.returnShape ? coerceValueToShape(rawResult, expr.returnShape) : rawResult;
+                const result = expr.returnShape && !options.strict ? coerceValueToShape(rawResult, expr.returnShape) : rawResult;
                 if (expr.returnShape) {
-                    validateValueAgainstShape(result, expr.returnShape, expr.range);
+                    validateValueAgainstShape(result, expr.returnShape, expr.range, { rejectExtraFields: options.strict });
                 }
                 this.trace.push({
                     kind: "generate",
                     data: {
                         instruction: sanitizeForJson(options.input),
+                        config: {
+                            maxOutput: budgetToJson(options.maxOutput),
+                            attempts: options.attempts,
+                            temperature: options.temperature ?? null,
+                            think: options.think ?? false,
+                            strict: options.strict,
+                            debug: options.debug,
+                        },
                         attempts: attempt,
-                        budget: budgetToJson(options.limit),
+                        maxOutput: budgetToJson(options.maxOutput),
                         debug: options.debug,
                         context: builtContextToJson(builtContext),
+                        validation: expr.returnShape ? { ok: true, strict: options.strict } : null,
                         result: sanitizeForJson(result),
                     },
                 });
@@ -99,7 +112,10 @@ export class GenerateRuntime {
         return {
             input: await this.host.evaluate(expr.options.input, scope),
             attempts,
-            limit: expr.options.limit,
+            maxOutput: expr.options.maxOutput,
+            temperature: expr.options.temperature?.value,
+            think: expr.options.think?.value,
+            strict: expr.options.strict?.value ?? false,
             debug: expr.options.debug?.value ?? false,
         };
     }

package/dist/runtime/shape.js

@@ -7,14 +7,16 @@ export function buildValueFromShape(shape) {
     }
     return result;
 }
-export function validateValueAgainstShape(value, shape, range) {
+export function validateValueAgainstShape(value, shape, range, options = {}) {
     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);
+    if (options.rejectExtraFields) {
+        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) {

package/dist/semantic/analyzer.js

@@ -395,9 +395,26 @@ class Analyzer {
                     this.error("INVALID_GENERATE_ATTEMPTS", "generate attempts must be a positive integer", property.value.range);
                 }
             }
-            else if (property.key === "limit") {
-                if (!expr.options.limit || expr.options.limit.amount <= 0) {
-                    this.error("INVALID_GENERATE_LIMIT", "generate limit must be a positive budget", property.value.range);
+            else if (property.key === "max_output") {
+                if (!expr.options.maxOutput || expr.options.maxOutput.amount <= 0) {
+                    this.error("INVALID_GENERATE_MAX_OUTPUT", "generate max_output must be a positive budget", property.value.range);
+                }
+            }
+            else if (property.key === "temperature") {
+                if (property.value.kind !== "NumberExpr") {
+                    this.error("INVALID_GENERATE_TEMPERATURE", "generate temperature must be a number", property.value.range);
+                }
+            }
+            else if (property.key === "think") {
+                const validThinkString = property.value.kind === "StringExpr" &&
+                    ["auto", "low", "medium", "high"].includes(property.value.value);
+                if (property.value.kind !== "BooleanExpr" && !validThinkString) {
+                    this.error("INVALID_GENERATE_THINK", "generate think must be a boolean or one of auto, low, medium, high", property.value.range);
+                }
+            }
+            else if (property.key === "strict") {
+                if (property.value.kind !== "BooleanExpr") {
+                    this.error("INVALID_GENERATE_STRICT", "generate strict must be a boolean", property.value.range);
                 }
             }
             else if (property.key === "debug") {