@rong/agentscript 0.1.0

package/tutorials/cli.as

@@ -0,0 +1,22 @@
+import llm Qwen from "ollama://localhost:11434/qwen3.6"
+
+main agent {
+    model Qwen
+    role "CLI Assistant"
+    description "Answer a short request from a command-line user."
+
+    main func(input {
+        name string
+        request string
+    }) {
+        use input.name
+        use input.request
+
+        return generate({ input: "Reply to the CLI user by name", limit: 300 }) {
+            return {
+                ok boolean
+                message string
+            }
+        }
+    }
+}

package/tutorials/helloworld.as

@@ -0,0 +1,14 @@
+import llm Qwen from "ollama://localhost:11434/qwen3.6"
+
+main agent {
+    model Qwen
+    role "Assistant"
+    description "Return a simple hello world response."
+
+    main func(input {}) {
+        return {
+            ok: true,
+            message: "Hello, AgentScript!"
+        }
+    }
+}

package/tutorials/memory.as

@@ -0,0 +1,19 @@
+import memory Notes from "file://./.agentscript/tutorial-memory.jsonl"
+
+main agent MemoryDemo {
+    main func(input {
+        topic string
+    }) {
+        Notes.add({
+            kind: "note"
+            text: input.topic
+            topic: input.topic
+        })
+
+        return Notes.query({
+            kind: "note"
+            text: input.topic
+            limit: 3
+        })
+    }
+}

package/tutorials/plan-execute.as

@@ -0,0 +1,155 @@
+import llm Qwen from "ollama://localhost:11434/qwen3.6"
+import tool Search from "mcp://tools/search"
+
+main agent PlanAndExecute {
+    model Qwen
+    role "Controller"
+    description "Coordinate planning, execution, verification, and final synthesis."
+
+    main func(input {
+        goal string
+    }) {
+        plan = Planner({
+            goal: input.goal,
+            problem: "",
+            previous: []
+        })
+        results = []
+
+        steps = [
+            {
+                id: "step-1",
+                task: plan.step1
+            },
+            {
+                id: "step-2",
+                task: plan.step2
+            },
+            {
+                id: "step-3",
+                task: plan.step3
+            }
+        ]
+
+        for step in steps < 6 {
+            outcome = run_step(input.goal, step, results)
+            results.add(outcome.result)
+
+            if not outcome.ok {
+                plan = Planner({
+                    goal: input.goal,
+                    problem: outcome.reason,
+                    previous: results.summary
+                })
+            }
+        }
+
+        return finish(input.goal, results)
+    }
+
+    func run_step(goal, step, previous) {
+        result = Executor({
+            goal: goal,
+            step: step,
+            previous: previous.summary
+        })
+
+        verdict = Verifier({
+            goal: goal,
+            step: step,
+            result: result
+        })
+
+        return {
+            ok: verdict.ok,
+            reason: verdict.reason,
+            result: {
+                step: step.id,
+                task: step.task,
+                output: result.output
+            }
+        }
+    }
+
+    func finish(goal, results) {
+        use goal
+        use results.summary < 2k
+
+        return generate({ input: "Create the final answer from executed steps", limit: 800 }) {
+            return {
+                ok boolean
+                text string
+                error string
+            }
+        }
+    }
+}
+
+agent Planner {
+    model Qwen
+    role "Planner"
+    description "Create or revise a short executable plan."
+
+    main func(input) {
+        use input.goal
+        use input.problem
+        use input.previous < 1k
+
+        return generate({ input: "Create a three step plan", limit: 600 }) {
+            return {
+                step1 string
+                step2 string
+                step3 string
+            }
+        }
+    }
+}
+
+agent Executor {
+    model Qwen
+    role "Executor"
+    description "Execute one plan step with available tools."
+
+    main func(input) {
+        use input.goal
+        use input.step
+        use input.previous < 1k
+
+        query = Search.query(input.goal, input.step, input.previous)
+        raw = Search.search(query)
+
+        observation = {
+            summary: raw.summary,
+            source: raw.source
+        }
+
+        use observation
+
+        return generate({ input: "Report the result of this step", limit: 500 }) {
+            return {
+                ok boolean
+                output json
+                error string
+            }
+        }
+    }
+}
+
+agent Verifier {
+    model Qwen
+    role "Verifier"
+    description "Check whether one executed step satisfies the plan."
+
+    main func(input) {
+        use input.goal
+        use input.step
+        use input.result
+
+        return generate({ input: "Verify this step result", limit: 300 }) {
+            return {
+                ok boolean
+                reason string
+            }
+        }
+    }
+}

package/tutorials/react.as

@@ -0,0 +1,98 @@
+import llm Qwen from "ollama://localhost:11434/qwen3.6"
+import tool Search from "mcp://tools/search"
+
+main agent ResearchAgent {
+    model Qwen
+    role "Researcher"
+    description "Answer questions with a small reason-act-observe loop."
+
+    main func(input {
+        question string
+    }) {
+        use input.question
+
+        scratch = []
+        use scratch.summary < 2k
+
+        done = false
+
+        loop until done < 4 {
+            thought = reason(input.question, scratch)
+            action = act(input.question, thought)
+            observation = observe(action)
+
+            scratch.add(observation)
+            done = enough(input.question, scratch)
+        }
+
+        return answer(input.question, scratch)
+    }
+
+    func reason(question, scratch) {
+        use question
+        use scratch.summary < 1k
+
+        return generate({ input: "Choose the next search focus", limit: 300 }) {
+            return {
+                focus string
+                why string
+            }
+        }
+    }
+
+    func act(question, thought) {
+        raw_query = Search.query(question, thought)
+        raw_result = Search.search(raw_query)
+
+        return {
+            query: raw_query.summary,
+            result: {
+                summary: raw_result.summary,
+                source: raw_result.source
+            }
+        }
+    }
+
+    func observe(action) {
+        raw = {
+            query: action.query,
+            summary: action.result.summary,
+            source: action.result.source
+        }
+
+        use raw
+
+        return generate({ input: "Summarize the useful observation", limit: 400 }) {
+            return {
+                facts list[string]
+                source string
+            }
+        }
+    }
+
+    func enough(question, scratch) {
+        use question
+        use scratch.summary < 1k
+
+        verdict = generate({ input: "Decide whether the observations are enough", limit: 200 }) {
+            return {
+                done boolean
+            }
+        }
+
+        return verdict.done
+    }
+
+    func answer(question, scratch) {
+        use question
+        use scratch.summary < 2k
+
+        return generate({ input: "Answer using only the observations", limit: 800 }) {
+            return {
+                ok boolean
+                text string
+                error string
+            }
+        }
+    }
+}

package/tutorials/repl.as

@@ -0,0 +1,31 @@
+main agent ReplGuide {
+    role "REPL Guide"
+    description "Show a small AgentScript program that can be loaded and run in the REPL."
+
+    main func(input {}) {
+        commands = [
+            {
+                command: ":load examples/repl.as",
+                purpose: "Load this teaching agent into the REPL session."
+            },
+            {
+                command: ":check",
+                purpose: "Parse and semantically check the current REPL program."
+            },
+            {
+                command: ":run {}",
+                purpose: "Run the main agent with an empty JSON input."
+            },
+            {
+                command: ":trace pretty",
+                purpose: "Print the latest run trace in a readable form."
+            }
+        ]
+
+        return {
+            ok: true,
+            title: "AgentScript REPL quick start",
+            commands: commands
+        }
+    }
+}

package/tutorials/self-improve.as

@@ -0,0 +1,60 @@
+import llm Qwen from "ollama://localhost:11434/qwen3.6"
+import memory Lessons from "file://./.agentscript/self-improve-lessons.jsonl"
+
+main agent SelfImprover {
+    model Qwen
+    role "Self-improving assistant"
+    description "Read relevant lessons, answer the goal, then store a new lesson."
+
+    main func(input {
+        goal string
+    }) {
+        past = Lessons.query({
+            kind: "lesson"
+            text: input.goal
+            limit: 5
+        })
+
+        use input.goal
+        use past < 2k
+
+        result = generate({
+            input: "Answer the goal using any relevant lessons.",
+            attempts: 3
+        }) {
+            return {
+                ok boolean
+                answer string
+                reason string
+            }
+        }
+
+        lesson = reflect({
+            goal: input.goal
+            result: result
+            past: past
+        })
+
+        Lessons.add({
+            kind: "lesson"
+            text: lesson.insight
+            goal: input.goal
+            ok: result.ok
+        })
+
+        return result
+    }
+
+    func reflect(run) {
+        use run
+
+        return generate({
+            input: "Extract one durable lesson that could improve a future run.",
+            attempts: 3
+        }) {
+            return {
+                insight string
+            }
+        }
+    }
+}