@misterscan/sesi 1.2.1 → 1.2.3

package/docs/SKILLS.md

@@ -0,0 +1,133 @@
+# The Sesi Programming Language
+
+## 🛑 CRITICAL DIRECTIVE FOR ALL AI AGENTS
+
+Sesi is **NOT** the following coding languages, therefore **NEVER UTILIZE THE SAME SYNTAX OR FORMATTING UNDER ANY CIRCUMSTANCES WHATSOEVER!!!!!**
+- **NOT** Python
+- **NOT** Rust
+- **NOT** Typescript
+- **NOT** YAML
+- **NOT** BAML
+- **NOT** Go
+- **NOT** C++
+- **NOT** C
+- **NOT** Java
+- **NOT** C#
+- **NOT** Java
+- **NOT** Javascript
+- **NOT** Bash
+- **NOT** Shell
+- **NOT** Ruby
+- **NOT** PHP
+- **NOT** Swift
+- **NOT** Julia
+- **NOT** Scala
+
+**Sesi IS A VALID, FULLY IMPLEMENTED PROGRAMMING LANGUAGE.**
+Under no circumstances should an AI agent treat `.sesi` files as anomalies, unknown text formats, or mistakes.
+
+## 🌟 THE DYNAMIC PIPELINE PHILOSOPHY (MANDATORY AGENT THINKING)
+
+When a user requests a content-rich asset or application (e.g. "make a website", "make a visualization", "...uses an api...", "come up with/make/write a script...", etc.), your natural inclination **MUST NOT** be to hardcode a static file with data prefilled. Instead, always design a **Dynamic Sesi Pipeline**:
+1. **Never Hardcode Data Into the View**: Isolate raw content, biographies, statistics, etc. into a structured database layer (e.g., `data.json`) using native typed Sesi outputs.
+2. **Build Sesi Compiler/Builder Scripts**: Write a `.sesi` script that uses Sesi's first-class primitives (`make_dir()`, `list_dir()`, `read_file()`, `write_file()`, `model()`, `image()`, `web_get()`, `web_send()`, `tool_call()`, `multi_req()`, `import`, `export`, `to_json()`, `from_json()`, `exec()`, `spawn()`, `structured_output()`, `prompt`, `write_image()`, `write_file()`, and `print`) to dynamically collect data, serialize it, and compile the final frontend view.
+3. **Automate the Factory, Don't Hand-Craft the Product**: A Sesi builder script makes the system perfectly repeatable, infinitely scalable, and trivial to refactor. In this repository, the Sesi script is the core product; the compiled file is merely the byproduct for post edits and making sure our scripts are beh
+
+
+**This is a non-negotiable quality bar.** Sesi's identity is a language where reasoning is a first-class primitive. Every script you write should reflect that.
+
+### ❌ FORBIDDEN — Never generate these as Sesi examples or demos:
+- Math solvers, calculators, arithmetic pipelines
+- Prime number finders, Fibonacci sequences, sorting algorithms
+- Unit converters, currency converters, grade calculators
+- Budget trackers, invoice generators, tax tools
+- Generic "Hello World" clones with no AI interaction
+- Compliance checkers, OSHA reports, logistics routers
+- Any script whose core loop is just arithmetic with a `print` at the end
+- **AI cybernetic, futuristic, sci-fi, or deep-space themes** (e.g., holographic star-charts, cyber-gardens, spatial telemetry, spacecraft command interfaces, alien translators).
+- **Cozy, minimalist, Victorian, herbalist, sourdough bakery, cottage-core, candle-lit, or general artisanal themes** (e.g., village herbalist teabags, sourdough yeast logs, candlelit journals, mahogany apothecary drawers, victorian scroll philologists). These are overdone, precious, and clichéd. 
+
+These are lazy defaults. They don't demonstrate what makes Sesi unique.
+
+### ✅ REQUIRED — Sesi scripts must showcase the language's actual superpowers:
+Every script you write must use **at least one** of:
+- `model()` — reasoning, analysis, generation, conversation
+- `image()` — visual generation, art, diagrams
+- `structured_output()` — typed AI responses, schema extraction
+- `memory` — stateful multi-turn context
+- `spawn()` / `exec()` — concurrent process orchestration
+
+#### 🏷️ Lexicon & Vocabulary Guardrails (MANDATORY)
+**Completely ban both sci-fi tech-jargon/themes AND cottage-core words/themes.**
+- **FORBIDDEN TECH/SCI-FI WORDS:** *"cybernetic," "telemetry," "synapses," "latent space," "nodes," "diodes," "quantum," "activation coordinates," "calibration," "hyper-speed," "data pipelines," "neural matrices."*
+- **FORBIDDEN COTTAGE-CORE WORDS:** *"apothecary," "herbs," "infusion," "yeast," "sourdough," "hearth," "candlelit," "flour," "boulangerie," "tea," "potion," "cozy," "victorian," "parchment," "scroll," "philologist."*
+- **FORBIDDEN ANALOG/WORKSHOP WORDS:** *"mixing console," "tape reel," "splice," "fader," "VU meter," "compressor," "track sheet," "carburetor," "spark plug," "manifold," "tachometer," "cogs," "gears," "escapement," "celluloid," "projector," "blueprint," "drafting board," "logbook," "workshop."*
+
+#### 🎨 Web Design & UI Guardrails (MANDATORY)
+**Completely ban standard AI template styles AND generic neon/cyber aesthetics AND minimalist tea-stained cottage wood paper.** 
+Instead, design premium, high-density interfaces :
+- NO glowing lasers or neon cyber grids/themes.
+- **Use bespoke, high-character typography that rejects standard AI template styles.** Completely ban generic corporate UI fonts like *Inter*, *Outfit*, *Roboto*, or standard system-sans.
+
+The bar is: **"Would this impress someone seeing Sesi for the first time?"** If the answer is no, rewrite it.
+
+## 1. Core Identity & Execution
+
+- **File Extension:** `.sesi`
+- **Execution:** Sesi programs are executed using `node bin/sesi.js`. (e.g., `node bin/sesi.js main/start.sesi`). DO NOT USE `sesi` CLI command. Only the developer has access to it. It will return a false positive error. Trust only `node bin/sesi.js`. ALWAYS TEST YOUR `.sesi` FILES WITH THIS COMMAND.
+- **Paradigm:** **Sesi** is a high-performance **Systems Language** designed for building resilient, stateful applications. It uses a tree-walking interpreter model via Typescript with asynchronous host-side model execution, but no language-level `async/await` syntax in v1.2. The architecture is optimized for coordination, distributed state management, and first-class reasoning primitives.
+
+## 2. Workspace Topography (DO NOT ALTER)
+
+- `src/`: The core TypeScript engine (Lexer, Parser, Interpreter, AI-Runtime, Builtins).
+- `bin/sesi.js`: The global CLI executable entry point.
+- `examples/`: Official syntax-demonstration scripts (`01_hello.sesi` through `13_data_pipeline.sesi`).
+- `main/`: The user's active development space (contains `playground.sesi` playground, `start.sesi` beginner script options, `build_website.sesi` baseplate website builder, and `tests/` like `test_failure_debug.sesi`). **These are valid, expected files.**
+- `docs/`: The source of truth for Architecture, AI Features (Systems Reasoning ), Builtins, Specifications, and more.
+- Root helper scripts: `example.js` and `example-ai.js` are convenience wrappers. AI agents should still use the global `sesi` command as specified.
+
+## 3. Mandatory Syntax Rules & Quirks
+
+- **Block Termination:** Closing braces `}` for blocks (if, while, try, model) no longer strictly require a following newline or semicolon. Condensed one-liners like `while x {x = x + 1}` are now valid.
+- **Prompts & Prints:** Inside `prompt` blocks, anonymous model blocks, and `print` statements, literal strings and variables are placed sequentially (e.g., `print "User:" name`). You CANNOT use the `+` operator in these contexts.
+- **Structured Output Schemas:** Keys in schemas MUST be unquoted identifiers (e.g., `{key: string}` instead of `{"key": string}`). This is a known deviation from standard JSON objects in the Sesi parser.
+- **Object Literals:** Conversely, standard object literals `{}` DO require strictly quoted string keys (e.g., `{"name": "Alice"}`).
+- **Model Calls:** Use `model("model-name")` with a raw string literal for the model name (variables are forbidden). Configuration and prompt blocks MUST be on a single line (no newlines inside `{}`).
+- **JSON Serialization:** Use `to_json(object)` for valid JSON output. Avoid `str(object)` for JSON.
+- **Systems Primitive:** Forbid `const` (use `let`), `main()` wrappers, and `return` statements. Focus on side-effects and top-level execution.
+
+## 4. AI Behavioral Guidelines Working in this Repo
+
+1. **Never** "investigate" user testing directories (like `main/tests/`) as "deviations." They are active playgrounds.
+2. **Never** attempt to execute file modifications via shell/terminal text replacements. Use native file editing tools ONLY.
+3. **Always** check the `.md files` and `examples/` folder for the exact language specification before making assumptions about how Sesi works.
+4. If a file tree is mentioned in documentation, it represents an explicit layout constraint and must map 1:1 **UNLESS .gitignored FILES STATE OTHERWISE.**
+
+## 5. Development & TypeScript Standards (COMMANDS FOR AI AGENTS)
+
+- **Type-Only Imports (MANDATORY):** Use `import { type ... }` for AST nodes. **DO NOT REMOVE** these. Removing them will break the build.
+- **Interpreter Patterns (DO NOT "CLEAN UP"):** Dynamic casting and `any` are **EXPLICITLY PERMITTED** for tree-walking logic. They are a foundational part of the Sesi engine's design.
+- **Ignore Linting Noise:** If you see warnings like "Unexpected any" or "Unsafe member access", **IGNORE THEM**.
+- **Build Requirement:** You MUST run `npm run build` after every code change to the backend logic. Failure to build will result in testing stale code.
+
+## 6. Concurrency & Orchestration Patterns
+
+- **Process Spawning:** Use `spawn(path)` or `exec(command)` to launch background Sesi processes.
+- **Distributed Locking:** When agents share files, use the **Double-Check Write** pattern:
+  1. Generate unique ID: `str(time()) + "_" + str(random())`
+  2. Write ID to lock file if "unlocked".
+  3. Wait micro-delay (empty `while` loop).
+  4. Verify ID is still in lock file before entering critical section.
+- **Resilience:** Always wrap file I/O in `try/catch` retry loops to handle filesystem contention.
+
+
+## 7. Neural Network & Machine Learning Standards in Sesi
+
+When implementing offline deep learning, probabilistic dialogue routing, or native classification models in Sesi:
+
+- **Symmetry Breaking:** Synapse weights MUST be initialized dynamically using wide, random float ranges (e.g. `(random() * 4.0) - 2.0` or `random() - 0.5`) to avoid zero-gradient stagnation and guarantee symmetry breaking.
+- **The Self-Healing Watchdog Pattern:** In native Sesi training models, wrap backpropagation epochs inside a conditional watchdog loop. Monitor the final Mean Squared Error (MSE) loss, and automatically re-seed weights and relaunch training if the network gets stuck in linear minima traps (e.g. `if MSE >= 0.01`).
+- **Unbreakable Markov Decoding Filters:** To eliminate infinite graph loops in Sesi probabilistic text walks, always apply:
+  1. **Extended Sliding Lookbacks (Size 15):** Instantly penalize and discard candidates already generated in the last 15 words of the sentence history.
+  2. **Strict Bigram Blocking:** Scan the history array and completely ban any candidate that repeats a previously executed state transition pair `(current_word -> candidate)` in the same sequence.
+- **Model Ingestion & Persistence:** Synchronize Sesi weights using natively parsed JSON objects. Save calibrated neural states directly using `write_file(..., to_json(weights_map))` and read them into runtime memories using `from_json(read_file(...))` for high-speed offline forward passes.

package/docs/SPECIFICATION.md

@@ -65,6 +65,7 @@ Sesi is built on these core principles:
 - ✅ `import` / `export`
 - ✅ Namespace support
 - ✅ Built-in modules
+- ✅ Multi-path module resolution (`SESI_PATH`, `~/.sesi/lib` global library)
 
 ## 4. Target Language (Syntax)
 
@@ -231,21 +232,22 @@ config_entry := (STRING | identifier) ':' expression
 
 **Config keys:**
 
-| Key | Applies to | Type | Description |
-|-----|-----------|------|-------------|
-| `temperature` | `model`, `image` | `number` | Sampling temperature (0.0–1.0) |
-| `max_tokens` | `model` | `number` | Max output token count |
-| `top_k` | `model` | `number` | Top-K diversity |
-| `top_p` | `model` | `number` | Nucleus sampling |
-| `ratio` | `image` | `string` | Aspect ratio e.g. `"16:9"` |
-| `size` | `image` | `string` | `"512"`, `"1K"`, `"2K"`, `"4K"` |
-| `images` | `model`, `image` | `string \| array<string>` | Local file path(s) passed as visual input |
+| Key             | Applies to       | Type                      | Description                                                                |
+| --------------- | ---------------- | ------------------------- | -------------------------------------------------------------------------- |
+| `thinkingLevel` | `model`          | `string \| object`        | **Recommended**: Effort level (`"minimal"`, `"low"`, `"medium"`, `"high"`) |
+| `temperature`   | `model`, `image` | `number`                  | *Will be deprecated in Gemini 3.x+_ (Sampling temperature)                 |
+| `max_tokens`    | `model`          | `number`                  | Max output token count                                                     |
+| `top_k`         | `model`          | `number`                  | *Will be deprecated in Gemini 3.x+_                                        |
+| `top_p`         | `model`          | `number`                  | *Will be deprecated in Gemini 3.x+_                                        |
+| `ratio`         | `image`          | `string`                  | Aspect ratio e.g. `"16:9"`                                                 |
+| `size`          | `image`          | `string`                  | `"512"`, `"1K"`, `"2K"`, `"4K"`                                            |
+| `images`        | `model`, `image` | `string \| array<string>` | Local file path(s) passed as visual input                                  |
 
 Example:
 
 ```sesi
-let result = model("gemini-3-flash-preview") {images: "scan.png", temperature: 0} {"Transcribe all visible text."}
-let output = model("gemini-3.1-flash-lite") {"temperature": 0.4, "max_tokens": 2000} {prompt}
+let result = model("gemini-3.5-flash") {images: "scan.png", thinkingLevel: "low"} {"Transcribe all visible text."}
+let output = model("gemini-3.5-flash") {thinkingLevel: "medium"} {prompt}
 ```
 
 #### Structured Output
@@ -357,7 +359,7 @@ random() -> number                // Random float (0.0 to 1.0)
 
 ## 9. Module System
 
-Runtime module execution and standard namespace modules are fully implemented and natively supported in v1.1.2.
+Runtime module execution and standard namespace modules are fully implemented and natively supported in v1.2+.
 
 ### Defining Modules
 
@@ -375,7 +377,7 @@ import {add, multiply, PI} from "math"
 let result = add(10, 20)
 ```
 
-### Built-in Modules
+### Built-in Standard Library Modules
 
 ```sesi
 import time from "std/time"    // Time/date functions
@@ -383,6 +385,59 @@ import math from "std/math"    // Math operations
 import json from "std/json"    // JSON parsing
 ```
 
+### Module Resolution Order (v1.2.2+)
+
+When you write `import {x} from "mymodule"`, Sesi searches for `mymodule.sesi` in the following order, stopping at the first match:
+
+| Priority | Location | Description |
+| -------- | -------- | ----------- |
+| 1 | **Script's own directory** | Same folder as the currently running `.sesi` file |
+| 2 | **Current working directory** | The directory you ran `sesi` from |
+| 3 | **`SESI_PATH`** | Semicolon-separated (Windows) or colon-separated (Unix) list of additional directories |
+| 4 | **`~/.sesi/lib`** | Global shared library directory — available system-wide |
+
+This means imports always resolve correctly regardless of where you run `sesi` from.
+
+### Global Library: `~/.sesi/lib`
+
+The global library directory (`C:\Users\<you>\.sesi\lib` on Windows, `~/.sesi/lib` on Unix) lets you maintain shared modules that are importable from **any project on your system**.
+
+To install a module globally, copy it to the lib directory:
+
+```powershell
+# Windows
+copy mymodule.sesi $env:USERPROFILE\.sesi\lib\
+
+# Unix / macOS
+cp mymodule.sesi ~/.sesi/lib/
+```
+
+Then import it from any project without copying the file:
+
+```sesi
+// Works from any folder anywhere on your system
+import {callAPI, saveImage} from "retrorender"
+import {GetProfile} from "profiles"
+```
+
+### Custom Library Paths: `SESI_PATH`
+
+For team or monorepo setups, set the `SESI_PATH` environment variable to point to one or more shared library directories:
+
+```powershell
+# Windows — add to your shell profile for persistence
+$env:SESI_PATH = "C:\MyLibs\sesi-shared;C:\Projects\common"
+
+# Unix / macOS
+export SESI_PATH="/mylibs/sesi-shared:/projects/common"
+```
+
+Multiple paths are separated by `;` on Windows and `:` on Unix.
+
+### Sub-module Resolution
+
+When a module is loaded from any search path, its own imports are resolved **relative to that module's directory first**. This means modules can safely import their own siblings without any path configuration.
+
 ## 10. Reasoning Features Details
 
 ### Prompt Blocks
@@ -400,8 +455,8 @@ prompt combined {summarize " Now " translate}
 Model calls can take optional configuration parameters (written on a single line) followed by one or more prompts/strings.
 
 ```sesi
-// Model call with temperature and thinking scale configuration
-let response = model("gemini-3.1-pro-preview") {"thinkingLevel": {"thinking": "yes", "level": "low"}, "temperature": 0} {"Say hello"}
+// Model call with native thinking effort level
+let response = model("gemini-3.5-flash") {thinkingLevel: "low"} {"Say hello"}
 print response  // Returns string
 
 let logo = image("gemini-3.1-flash-image-preview") {ratio: "1:1", size: "512"} {"A vector logo"}
@@ -410,12 +465,13 @@ print "Image written to logo.png"
 ```
 
 #### Config Block Options:
-- **`temperature`**: `number` (0.0 to 1.0)
+
+- **`thinkingLevel`**: `string` (`"minimal"`, `"low"`, `"medium"`, `"high"`) or legacy `object` with keys `"thinking"` and `"level"`. Natively configures Gemini's reasoning budget.
 - **`max_tokens`**: `number` (maximum response tokens)
 - **`images`**: `string` or `array<string>` (paths to multimodal vision input files)
-- **`thinkingLevel`**: `object` with keys `"thinking"` (`"yes"` | `"no"`) and `"level"` (`"low"` | `"medium"` | `"high"`) - natively configures and scales Gemini's reasoning budget.
 - **`cache`**: `bool` (set to `false` to explicitly bypass Sesi Logic Caching)
-
+- **`temperature`**: *  Will be deprecated in Gemini 3.x+, use thinkingLevel instead.* — reasoning is pre-optimized for defaults.
+- **`top_k` / `top_p`**: *Will be deprecated in Gemini 3.x+, use thinkingLevel instead.* — reasoning is pre-optimized for defaults.
 
 ### Structured Output
 
@@ -455,7 +511,7 @@ print x + y  // Output: 30
 ### Example 2: Function with Reasoning
 
 ```sesi
-fn analyzeText(text: string) -> string {return model("gemini-3.1-pro-preview") {"temperature": 0} {"Analyze this text and return key insights:" text}}
+fn analyzeText(text: string) -> string {return model("gemini-3.5-flash") {thinkingLevel: "low"} {"Analyze this text and return key insights:" text}}
 print analyzeText("Reasoning is transforming industries")
 ```
 

package/docs/SYSTEMS_REASONING.md

@@ -114,14 +114,13 @@ print response
 ### Model Configuration
 
 ```sesi
-let creative = model("gemini-3-flash-preview") {"temperature": 0.9, "max_tokens": 500} {"Write a creative poem about technology."}
+let creative = model("gemini-3.5-flash") {thinkingLevel: "low"} {"Write a creative poem about technology."}
 print creative
 
 // Config options:
-// - "temperature": 0.0-1.0 (higher = more creative) (OPTIONAL: if not specified, will use the model's default temperature=0.3)
+// - thinkingLevel: "minimal", "low", "medium", "high" (natively configures Gemini's reasoning budget)
 // - max_tokens: max length of response (OPTIONAL: if not specified, will use the model's default max tokens=2048)
-// - top_k: diversity parameter (OPTIONAL)
-// - top_p: nucleus sampling parameter (OPTIONAL)
+// - temperature / top_k / top_p: *Will be deprecated in Gemini 3.x+, use thinkingLevel instead (reasoning is mathematically optimized for default settings)*
 ```
 
 ### Model Selection
@@ -129,7 +128,7 @@ print creative
 ```sesi
 // Fast model for simple tasks
 let text = " Coding with Reasoning systems language is fun!"
-let quick = model("gemini-3-flash-preview") {"Summarize this in one sentence:" text}
+let quick = model("gemini-3.1-flash-lite") {"Summarize this in one sentence:" text}
 
 // Powerful model for complex reasoning
 let code = "def calculate_sum(n):
@@ -141,7 +140,7 @@ let smart = model("gemini-3.1-pro-preview") {"Analyze this code for bugs:" code}
 
 // Efficient model for many calls
 let item = " Programming Languages"
-let cheap = model("gemini-3.1-flash-lite") {"temperature": 0} {"Classify:" item}
+let cheap = model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify:" item}
 
 print quick
 print smart
@@ -153,11 +152,12 @@ print cheap
 - `gemini-2.5-flash` - Legacy, but supported. 1M tokens.
 - `gemini-2.5-pro` - Legacy, but supported. 1M tokens.
 - `gemini-2.5-flash-image` - Standard image model. (No `512` image size support for this model. Only `1K` is supported.)
-- `gemini-3-flash-preview` - Fast, balanced, 1M tokens
-- `gemini-3.1-pro-preview` - Most capable, 1M tokens (Doesn't support `minimal` thinking. Only `low`, `medium`, and `high` are supported.)
-- `gemini-3.1-flash-lite` - Fastest, cost-efficient
-- `gemini-3.1-flash-image-preview` - Cost efficient while maintaining quality images.
-- `gemini-3-pro-image-preview` - High quality image generation. (No `512` image size support for this model.)
+- `gemini-3-flash-preview` - Fast, balanced, legacy preview.
+- `gemini-3.1-flash-lite` - Fastest, most cost-efficient.
+- `gemini-3.5-flash` - Standard GA Model. Fast, balanced, supports all native thinking effort levels (`minimal`, `low`, `medium`, `high`).
+- `gemini-3.1-pro-preview` - Most powerful reasoning model, doesn't support `minimal` thinking (falls back to `low`).
+- `gemini-3.1-flash-image-preview` - Cost efficient image generation model.
+- `gemini-3-pro-image-preview` - High quality image generation model. (No `512` image size support for this model.)
 
 #### Planned for (v2+)
 
@@ -183,7 +183,7 @@ print diff
 
 // Mixed with other config keys
 let scannedDocument = "doc_scan.jpg"
-let result = model("gemini-3.1-flash-lite") {images: scannedDocument, temperature: 0, max_tokens: 2048} {"Transcribe all text visible in this scan."}
+let result = model("gemini-3.5-flash") {images: scannedDocument, thinkingLevel: "low", max_tokens: 2048} {"Transcribe all text visible in this scan."}
 write_file("transcript.txt", result)
 ```
 
@@ -216,12 +216,12 @@ print bookInfo["title"]
 
 - Always include instructions for JSON format
 - Specify the exact schema in the prompt
-- Use "temperature": 0 for consistency
+- Use "thinkingLevel": "low" for fast, consistent parsing
 - Validate output structure in code
 
 ```sesi
 let listText = "eggs, milk, bread, cheese, fruit, vegetables"
-let output = structured_output({items: string})(model("gemini-3-flash-preview") {"temperature": 0}{"Return JSON with items array containing: " listText})
+let output = structured_output({items: string})(model("gemini-3.5-flash") {thinkingLevel: "minimal"}{"Return JSON with items array containing: " listText})
 
 // Validate
 if type(output["items"]) == "array" {print "Got" str(len(output["items"])) "items"} // Got 6 items
@@ -329,7 +329,7 @@ print conversation
 let categories = "fruit, vegetable, grain"
 let item = "banana"
 fn classify(item: string, categories: string) -> string
-{return model("gemini-3.1-flash-lite") {"temperature": 0}
+{return model("gemini-3.5-flash") {thinkingLevel: "minimal"}
 {"Classify this item into one category. Categories: " categories " Item: " item " Return only the category name."}}
 print "Item: " item //banana
 print "Category: " classify(item, categories) //fruit
@@ -341,7 +341,7 @@ print "Category: " classify(item, categories) //fruit
 let text = "Elon Musk is the CEO of Tesla and SpaceX."
 fn extractEntities(text: string) -> object
 {let result = structured_output({people: string, places: string, organizations: string})
-(model("gemini-3.1-flash-lite") {"temperature": 0}{"Extract named entities from:" text})
+(model("gemini-3.5-flash") {thinkingLevel: "minimal"}{"Extract named entities from:" text})
 print "Name(s) found: result"
 return result}
 print extractEntities(text)
@@ -359,12 +359,20 @@ print "Translation:"
 print translate(text, language)
 ```
 
+### Web Search Grounding
+
+Access real-time information by enabling the `search` shorthand configuration natively.
+
+```sesi
+let response = model("gemini-3.1-flash-lite") {search, max_tokens: 1000} {"What is the weather in Tokyo right now?"}
+```
+
 ### Image Generation
 
 Like `model`, the `image` command evaluates prompts and accepts configuration variables mapping accurately to backend SDKs requirements.
 
 ```sesi
-let logo = image("gemini-3.1-flash-image-preview") {"ratio": "1:1", "size": "512", "temperature": 0.3} {"A high quality vector logo representing a new programming language named Sesi"}
+let logo = image("gemini-3.1-flash-image-preview") {ratio: "1:1", size: "512"} {"A high quality vector logo representing a new programming language named Sesi"}
 write_image("logo.png", logo)
 print "Image generated!"
 ```
@@ -376,7 +384,7 @@ print "Image generated!"
 ```sesi
 let requirement = "Write a function that reverses a string."
 fn generateCode(requirement: string) -> string
-{return model("gemini-3.1-flash-lite") {"temperature": 0.2} {"Generate JavaScript code for:" requirement "Only provide code, no explanation."}}
+{return model("gemini-3.5-flash") {thinkingLevel: "low"} {"Generate JavaScript code for:" requirement "Only provide code, no explanation."}}
 print "Code generation:"
 print generateCode(requirement)
 ```
@@ -507,10 +515,10 @@ fn smartSummarize(text: string) -> string
 
 // Chain multiple Reasoning operations
 // Step 1: Extract key points
-{let keyPoints = model("gemini-3.1-pro-preview") {"temperature": 0} {"Extract 5 key points from:" text}
+{let keyPoints = model("gemini-3.1-pro-preview") {thinkingLevel: "low"} {"Extract 5 key points from:" text}
 
 // Step 2: Analyze topics
-let topics = structured_output({ topics: string })(model("gemini-3.1-flash-lite") {"Identify topics in:" keyPoints})
+let topics = structured_output({ topics: string })(model("gemini-3.5-flash") {thinkingLevel: "low"} {"Identify topics in:" keyPoints})
 
 // Step 3: Generate summary
 let summary = model("gemini-3-flash-preview") {"Summarize with topics " topics ":" keyPoints} return summary}
@@ -520,7 +528,7 @@ print "Summary:" smartSummarize(text)
 ### Reasoning Pattern
 
 ```sesi
-let analysis = model("gemini-3-flash-preview") {"thinkingLevel": {"thinking": "yes", "level": "medium"}, "temperature": 0, "max_tokens": 8192} {"Reason carefully about:" problem}
+let analysis = model("gemini-3.5-flash") {thinkingLevel: "medium", max_tokens: 8192} {"Reason carefully about:" problem}
 print analysis
 ```
 
@@ -529,7 +537,7 @@ print analysis
 ```sesi
 let text = "banana"
 fn classifyWithExamples(text: string) -> string
-{return model("gemini-3.1-flash-lite") {"temperature": 0} {"Classify as A, B, or C" "Examples:" "'apple' -> A" "'dog' -> B" "'happy' -> C" "Classify: " text}}
+{return model("gemini-3.5-flash") {thinkingLevel: "minimal"} {"Classify as A, B, or C" "Examples:" "'apple' -> A" "'dog' -> B" "'happy' -> C" "Classify: " text}}
 print "Classification:" classifyWithExamples(text)
 ```
 

package/examples/16_modules.sesi

@@ -12,7 +12,7 @@ print "2 raised to power of 10:" + str(pow(2, 10))
 print "Sine of PI/2:" + str(sin(PI / 2.0))
 print "=== 2. Standard JSON Module ==="
 import {stringify, parse} from "std/json"
-let original = {"project": "Sesi Language", "version": "1.2.1", "features": ["modules", "http", "parallel"]}
+let original = {"project": "Sesi Language", "version": "1.2.2", "features": ["modules", "http", "parallel"]}
 let json_str = stringify(original)
 print "Serialized JSON string:"
 print json_str

package/examples/19_search_web.sesi

@@ -0,0 +1,4 @@
+// Example 19: Search the Web with Sesi
+
+let response = model("gemini-3.1-flash-lite") {search, max_tokens: 1000} {"What is the weather in Tokyo?"}
+print response