• v2.32.0 bcc0b082b2

    v2.32.0
    All checks were successful
    release / build-and-release (push) Successful in 1m19s
    Stable

    littleisland released this 2026-11-18 06:45:47 +00:00 | 1 commits to main since this release

    NOE v2.32.0

    Search the built-in API reference

    searchDocs(query) in noe:docs finds API entries by name or task keywords.
    It returns up to five matches with a topic, member ID, and short excerpt.
    Pass the topic and member to docs for the full entry. Search works in
    the main runtime and Workers.

    import { docs, searchDocs } from "noe:docs";
    
    const [match] = searchDocs("read part of a file");
    export default match ? docs(match.topic, match.member) : null;
    

    The built-in reference includes a FileHandle.readAt example for
    reading bytes at an offset.

    Run agent scripts with deadlines and progress

    Set timeoutMs in the initial // @noe: comment to limit one run_js
    call. An expired call returns a timeout result with the output it captured.
    Set saveData: true to save the complete default export when its JSON
    exceeds outputBytes. The result includes a dataFile reference a later
    call can read.

    --observe displays sampled stdout and stderr while a script runs. The
    same samples appear as run_js.progress events in JSONL. See
    execution results for the options and fields.

    Runtime, standard library, and agent

    • Runtime installations reuse compiled built-in programs. Text encoding,
      live Headers iteration, local storage writes, SQLite row conversion,
      and full FileHandle reads do less intermediate work.
    • The agent reuses conversation context analysis, image metadata, and
      queued history. It honors an accepted cancellation before publishing
      queued history and analyzes logs incrementally.
    • Chat requests are encoded in one pass. Managed Responses WebSocket
      requests reuse configuration during continuation and replay.

    Distribution

    Linux, macOS, and Windows binaries for amd64 and arm64 are included with
    SHA256SUMS. The Go module is
    forge.harakara.site/littleisland/noe/v2.

    Downloads
  • v2.31.1 bf7f68d27e

    v2.31.1
    All checks were successful
    release / build-and-release (push) Successful in 23s
    Stable

    littleisland released this 2026-11-18 02:10:26 +00:00 | 8 commits to main since this release

    NOE v2.31.1

    CLI timeout during startup

    If the CLI's --timeout expires while setting up filesystem watching,
    noe run and noe eval now report the execution timeout and exit with
    code 124. A caller's parent deadline retains the ordinary error exit code.

    The tests for timeouts after JavaScript starts use a virtual clock. A
    separate regression test checks an expired deadline during watcher setup.

    Distribution

    Linux, macOS, and Windows binaries for amd64 and arm64 are included with
    SHA256SUMS. The Go module is
    forge.harakara.site/littleisland/noe/v2.

    Downloads
  • v2.31.0 f059c06c57

    v2.31.0
    All checks were successful
    release / build-and-release (push) Successful in 1m16s
    Stable

    littleisland released this 2026-11-18 02:02:21 +00:00 | 11 commits to main since this release

    NOE v2.31.0

    Saved agent tool output

    Set NOE_AGENT_TOOL_OUTPUT_DIR to an existing directory for CLI runs, or set
    agent.HostConfig.ToolOutputDir when embedding the agent in Go. When
    run_js stdout or stderr exceeds its capture budget, NOE saves that stream
    in full and keeps the bounded head and tail preview. Saving is opt-in.

    The stdoutFile and stderrFile references include a path and byte count.
    A later tool can read the omitted range with noe:fs. The references also
    appear in live observation and execution logs. Saved files persist after
    the run, and the caller manages retention. See the
    saved stream contract.

    Provider retry and context estimates

    • Model requests honor bounded provider retry delays and distinguish
      transient usage lookups from quota exhaustion. Each logical request still
      allows up to three transport attempts.
    • The context estimate uses the provider's reported input tokens for an
      unchanged prefix and estimates subsequent additions. Display and automatic
      trim use the same total.

    See the retry and context design.

    Built-in model catalog

    GPT-6.2 Sol and GPT-6.2 Astra are listed for openai-chatgpt, openai-api,
    and openrouter. The entries include text and image input, tool support,
    reasoning effort, and context limits. See the
    catalog metadata.

    Distribution

    The release includes Linux, macOS, and Windows binaries for amd64 and arm64,
    plus SHA256SUMS. Go users can select the tag for the
    forge.harakara.site/littleisland/noe/v2 module.

    Downloads
  • v2.30.0 3a132e2817

    v2.30.0
    All checks were successful
    release / build-and-release (push) Successful in 1m8s
    Stable

    littleisland released this 2026-11-18 00:33:41 +00:00 | 16 commits to main since this release

    NOE v2.30.0

    Filesystem operations can now process large copies and directory listings
    without holding the complete input in memory. Web Crypto also supports
    generating HMAC keys and exchanging them as JWKs, including use by jose.

    Filesystem operations

    noe:fs.iterateDir(path, {batchSize = 128, signal} = {}) returns a lazy async
    iterator of Dirent values. Opening starts on the first next request. Entries
    arrive in filesystem order, one bounded batch at a time. Concurrent next
    requests are serialized. EOF, early break, explicit close, async disposal,
    abort, and owner cleanup release the descriptor. Abort delivers the exact
    signal reason. Existing readdir APIs retain their sorted-array behavior.

    copyFile and copyFileSync share a native copy path with a 32 KiB fallback
    buffer. Initial source failures preserve an existing destination, and
    same-file aliases leave contents intact. Existing permissions and
    Root/Cwd/ReadOnly policy remain in force. Copies remain non-atomic; an I/O
    failure during copying can leave partial output. Directory iteration is
    neither recursive nor a snapshot of concurrent changes.

    See the filesystem reference,
    example, and
    implementation record.

    HMAC generation and JWK

    crypto.subtle.generateKey supports HMAC with SHA-1, SHA-256, SHA-384, and
    SHA-512, using the selected host random reader. Omitted lengths use the
    hash block size; positive explicit bit lengths are supported. HMAC importKey
    and exportKey support raw bytes and JWK. JWK algorithm, usage, key_ops, and
    extractability restrictions are checked against the requested key policy.

    Private key snapshots govern operations. Mutating public metadata, import
    arguments, or exported dictionaries cannot change a key's authority or bytes.
    The same APIs are available through global crypto and node:crypto, in main
    and Worker runtimes. jose 6.2.15 can generate, export, import, sign, and verify
    HS256/HS384/HS512 keys and tokens across Node and NOE.

    The supported surface remains an explicit Web Crypto subset. AES/RSA/EC
    key generation, key wrapping, CryptoKey structured cloning, and byte
    streams/BYOB are outside this release. JWK key material uses unpadded
    base64url; padded or whitespace-containing values are rejected. See the
    Web Crypto contract
    and jose example.

    Verification and distribution

    Implementation checks cover whole-tree unit/E2E results, affected race checks,
    vet, public types, lint, main/Worker behavior, embedded references, and
    checkout/artifact Go consumers. An external-consumer fixture usage error in
    the broad run was corrected; the complete stdlib package passed afterward,
    and unchanged passing packages are reused. Unmodified jose interoperability
    checks pass in both directions for Node/main and Node/Worker.

    Dependencies and public Go function signatures remain unchanged, including
    go-quickjs v0.38.0 with JIT disabled. Release verification reuses completed
    source checks and exercises a clean native candidate and the published native
    asset. CI builds six binaries and SHA256SUMS from the immutable tag. Publication
    includes verified installation at both existing vm201 executable paths,
    retaining previous copies. See the release checkpoints.

    Downloads
  • v2.29.0 260c60a06f

    v2.29.0
    All checks were successful
    release / build-and-release (push) Successful in 1m12s
    Stable

    littleisland released this 2026-11-17 17:25:13 +00:00 | 19 commits to main since this release

    NOE v2.29.0

    Managed agent runs now reuse an OpenAI Responses WebSocket connection across
    model/tool turns. Both built-in OpenAI providers, openai-chatgpt with OAuth
    and openai-api with an API key, enable this transport by default.

    Continuation and lifetime

    An unchanged conversation sends only new input items with the last completed
    response ID. Trim, history/configuration replacement, reconnection, or a known
    server-side continuation cache miss starts from current complete history.
    Recovery preserves completed local tool work. Existing logical-request retry,
    observations, usage reporting, and provider error categories remain in use.

    Each managed run owns its connection. Completion, cancellation, operation
    closure, and Host closure release it. Queued runs and parent/child runs have
    separate connections. Borrowed model services and HTTP clients remain usable.

    Configuration and compatibility

    Built-in OpenAI providers use transport=auto: managed OpenAI Responses calls
    use WebSocket, while other API modes use HTTP/SSE. Set transport=sse in a
    provider override to retain the previous managed path. Explicit websocket
    requires sdk=openai and api=responses. Custom provider definitions default
    to SSE; enabling WebSocket requires endpoint support for HTTP upgrades.

    Injected Go clients support *http.Client, including custom RoundTrippers.
    A bespoke Do-only client must expose WebSocketHTTPClient() *http.Client to
    preserve its upgrade policy, or select SSE. Authentication and configured
    endpoint/header policy remain associated with the selected provider; errors
    do not automatically switch credentials or transports.

    Public Go/JavaScript function signatures are unchanged. Standalone
    model.Service.Generate() and independent noe:model calls retain HTTP/SSE.
    A standalone persistent-session API remains a future note only. See the
    provider configuration,
    Go embedding guide, and
    implementation record.

    Verification and distribution

    Whole-tree unit/E2E, affected race checks, vet, managed GoHost/JavaScript
    fixtures, and checkout/artifact Go consumers passed during implementation.
    Final handshake error-classification changes received focused race/vet and
    repeated external-consumer checks. Live functional checks completed one tool
    execution and two model calls over one WebSocket for each authentication
    route. Earlier synthetic transport measurements are recorded separately;
    reduced upload size does not reduce logical input-token counts or guarantee
    whole-run latency gains.

    Dependencies remain unchanged, including go-quickjs v0.38.0 with JIT disabled.
    Release verification reuses completed implementation checks and exercises
    the native binary against a local transport fixture without paid requests.
    CI builds six binaries and SHA256SUMS from the immutable tag. Publication
    includes verified installation at both existing vm201 executable paths,
    retaining previous copies. See the release checkpoints.

    Downloads
  • v2.28.0 4d72c30ce9

    v2.28.0
    All checks were successful
    release / build-and-release (push) Successful in 41s
    Stable

    littleisland released this 2026-11-17 10:37:30 +00:00 | 22 commits to main since this release

    NOE v2.28.0

    This release adds batched SQLite row iteration, improves binary-data contracts
    and context preparation, and corrects stream cleanup and reasoning observations.

    SQLite row iteration

    Database and transaction handles now expose
    iterate(sql, params, {batchSize, signal}); prepared statements expose
    iterate(params, options). These return lazy async iterators directly, fetching
    at most 128 rows per batch by default rather than collecting the whole result.
    Preparation and execution start on the first next call. Existing all/get/run
    callers need no migration.

    EOF, loop break, return, close, async disposal, cancellation, and owner shutdown
    release cursors. Transaction-local iterators close when their callback ends;
    caught SQL errors and iterator cancellations still cause rollback. Other SQL
    can run between batches. Reusing a prepared statement with an active native
    cursor rejects with ERR_SQLITE_BUSY until it is released.

    The batch bound counts rows, not bytes or SQLite query workspace. Early close
    does not undo writes from RETURNING; use a transaction for rollback. See the
    API reference,
    implementation record,
    and CSV export example.

    Blob, File, and FormData

    Binary data now uses private immutable backing storage. Derived Blobs, slices,
    and Files with new names share that storage, while author-visible reads and
    stream chunks receive independent bytes. Fetch, multipart, WebSocket, and
    structured cloning use the same private data path. FormData iteration observes
    live changes. The improvement reduces derived-data copying; slices can still
    retain their larger original allocation.

    Compatibility changes follow the supported Web contracts:

    • Replace new Blob(text) with new Blob([text]).
    • File requires parts and a filename. Text/name conversions, MIME types,
      lastModified, and native text endings follow their documented contracts.
    • A filename argument to FormData append/set requires a Blob, even when that
      third argument is undefined.
    • Internal-looking properties such as _bytes, _type, and _entries no
      longer supply native state.

    See the reference and
    implementation and measurement record.

    Stream cleanup and agent preparation

    ReadableStream async iterators release reader ownership on EOF and read errors.
    Early return releases the lock before source cleanup settles and propagates
    cleanup failure. Iterator calls are serialized. Callers should handle a failed
    return or loop break when source cancellation fails.

    Managed agent runs reuse context analysis for an unchanged owned snapshot and
    revision. Trim and run completion release obsolete references. Unmanaged input
    still receives full validation. Cache-hit preparation of the recorded
    256-message fixture improved from 4.69 ms to 1.35 ms, excluding model/network
    time; this is not a whole-run latency claim. See the
    analysis cache record.

    Chat observations respect the configured reasoningField, including
    reasoning_content and custom fields. A configured field no longer falls back
    to another top-level alias when absent. Opaque reasoning and request payloads
    are unchanged. See the provider guide.

    Verification and distribution

    Implementation verification includes whole-tree unit/E2E, focused SQLite and
    binary/context race checks, vet, TypeScript fixtures, JS lint, embedded API
    checks, and independent stdlib/agent Go consumers. The final transaction
    cleanup guard was checked by all SQLite tests with race detection and repeated
    external stdlib consumers; its regression fails without the guard and passes
    20 consecutive runs with it. Unchanged completed checks are reused.

    Dependencies remain unchanged, including go-quickjs v0.38.0 with JIT disabled.
    No paid provider request is needed for release verification. CI builds the
    six distribution binaries and SHA256SUMS from the immutable tag without
    repeating source suites. Publication includes verified installation at both
    existing vm201 executable paths, retaining the previous binaries. See the
    release checkpoints.

    Downloads
  • v2.27.0 0b2082ae71

    v2.27.0
    All checks were successful
    release / build-and-release (push) Successful in 1m26s
    Stable

    littleisland released this 2026-11-17 04:25:01 +00:00 | 27 commits to main since this release

    NOE v2.27.0

    This release updates go-quickjs from v0.37.1 to v0.38.0 and corrects the
    Windows line-ending value exposed by NOE's OS module.

    Engine update

    The engine incorporates upstream compiler and parser fixes for captured block
    bindings on loop exits, nested finally execution and completion values,
    computed object-rest keys, optional-chain deletion, loop labels, labelled-block
    breaks, and async functions after line breaks. It also includes interpreter
    improvements for object spread, sparse arrays, string concatenation and
    instanceof; NOE-specific performance gains were not measured.

    JIT remains disabled. Go remains 1.27.2, go-intl remains v0.9.0, and the public
    Go and JavaScript API signatures are unchanged. NOE continues to use its own
    standard library and module loader. See the
    integration record.

    Windows OS line endings

    os.EOL and node:os.EOL now return "\r\n" on Windows and "\n" elsewhere,
    through both named and default exports. Previously they returned LF on every
    platform. Windows callers requiring LF for a file format should use an explicit
    "\n". This does not automatically normalize file or stream output.

    The embedded API reference and TypeScript descriptions document the behavior.

    OpenAI Fast-mode documentation

    The OpenAI guide documents requesting Fast with the
    existing provider configuration: priority for the tested ChatGPT plan-sharing
    route, and fast or priority for API-key access according to OpenAI's API
    documentation. No new agent option or provider implementation is added.

    The investigation records the earlier
    v2.26.1 real-provider comparison and installed-agent check. A ChatGPT response
    reporting default alone does not establish that Fast was ignored. Its measured
    speed difference is a small-sample observation, not a universal speed or billing
    guarantee.

    Verification

    Eight compiler/parser regression cases fail against v0.37.1 and pass against
    v0.38.0 in main, Workers, and repeatedly executed node:vm Scripts, matching Node.
    Whole-tree unit/E2E, focused race, vet, module verification, independent stdlib
    and agent consumers, and all six distribution-target compilation checks pass.
    Windows and macOS are compile-only verification; Linux amd64 was run natively.

    Release preparation reuses this completed implementation evidence. CI builds
    the six distribution binaries and SHA256SUMS from the immutable tag without
    repeating source suites. Publication includes verified installation at both
    existing vm201 executable paths, retaining the previous binaries. See the
    release checkpoints.

    Downloads
  • v2.26.1 47710b9e07

    v2.26.1
    All checks were successful
    release / build-and-release (push) Successful in 22s
    Stable

    littleisland released this 2026-11-15 02:58:34 +00:00 | 32 commits to main since this release

    NOE v2.26.1

    NOE's built-in agent instructions now identify JavaScript as the primary
    programming language for task logic, data processing, and automation. The
    guidance is embedded in the executable and supplied to Go-hosted agents as
    well as CLI agents, including with --no-inst or no external instruction files.

    Agents can still use another language when requested by the user, required by
    the target project, or concretely beneficial for the task. Existing command-line
    tools remain available through the selected execution profile's APIs.

    The instruction guide, API guide, and CLI help describe the built-in guidance.
    Public Go/JavaScript APIs, runtime behavior, dependencies, and the remaining
    external behavioral preferences are unchanged.

    Focused implementation checks cover Go-host instruction composition, external
    instruction replacement/removal, parent/child snapshots, API-reference lookup,
    and CLI composition with external instructions disabled. Release verification
    checks the native binary and the built-in guidance in a loopback model request.
    Existing checks for unchanged source and dependencies are reused; CI builds the
    six distribution binaries and SHA256SUMS without repeating source suites.

    Publication includes verified local installation at both existing vm201
    executable paths, retaining the previous binaries. See the
    release checkpoints.

    Downloads
  • v2.26.0 72cc4c5e36

    v2.26.0
    All checks were successful
    release / build-and-release (push) Successful in 4m2s
    Stable

    littleisland released this 2026-11-10 02:12:53 +00:00 | 35 commits to main since this release

    NOE v2.26.0

    This release updates both provider Go SDKs and removes redundant JSON encoding
    when preparing Responses requests, incorporating implementation 33f5c39.

    Provider SDK updates

    • OpenAI Go SDK: v3.79.0 to v3.98.0.
    • OpenRouter Go SDK: v0.9.61 to v0.9.116.

    Existing OpenAI, OpenRouter and OpenCode Go HTTP/SSE routes, authentication,
    Chat/Responses, Decisions and image generation contracts are preserved.
    The update includes upstream API/type additions and fixes; NOE continues to
    construct its own request JSON and retain native tool/reasoning history.
    Go remains 1.27.2 and go-quickjs remains v0.37.1 with JIT disabled.

    Responses request construction

    Responses previously generated a complete Chat request solely to validate it,
    discarded that JSON, then constructed the actual Responses payload. Shared
    validation now runs without the discarded encoding and returns normalized
    effort to the request builder. Invalid model/cache-key UTF-8, invalid objects,
    duplicate JSON names, effort/token limits and error behavior remain checked.

    The optimization applies to both SDK adapters, including OpenCode Go's Responses
    route. Public Go/JavaScript APIs and provider configuration are unchanged.

    In a synthetic 256-message history with 4 KiB per message, median request
    construction time decreased from 9.22 ms to 7.93 ms and cumulative allocated
    bytes decreased from 14,927,254 to 10,928,036. Five alternating before/after
    process pairs use identical SDK versions. This is a 14.0% local time reduction
    and 26.8% allocation reduction; network, model and tool execution are excluded.
    See the implementation record
    for the other workloads, method and evidence.

    Verification and scope

    Implementation checks cover provider and agent/public/bridge/executor suites,
    focused CLI E2E, vet, module integrity and external Go consumers using both
    checkout and independent module artifacts. Valid source results are reused for
    release preparation. CI builds the six distribution binaries and SHA256SUMS
    from the immutable tag without repeating source suites.

    WebSocket continuation is retained as a
    deferred improvement idea;
    this release does not enable it. Publication includes verified installation
    at both existing vm201 executable paths, retaining the previous binaries.
    See the release checkpoints.

    Downloads
  • v2.25.0 f3ce20bce5

    v2.25.0
    All checks were successful
    release / build-and-release (push) Successful in 1m30s
    Stable

    littleisland released this 2026-11-08 15:31:56 +00:00 | 39 commits to main since this release

    NOE v2.25.0

    This release updates go-quickjs from v0.32.0 to v0.37.1 and go-intl from
    v0.8.0 to v0.9.0, incorporating the integration in c29d466.
    JIT remains disabled. The Go /v2 module path, host capabilities and existing
    native backends are unchanged.

    Engine corrections and improvements

    The update fixes a nested-loop error affecting ordinary execution without JIT:
    an inner loop with continue before a later break condition could stop early
    and silently omit results. Main runtimes, Workers and node:vm now produce the
    correct result. Upstream also improves object allocation, repeated Program and
    Realm memory retention, JSON processing, compilation and constant array literals.
    These are upstream improvements; no NOE performance benchmark is claimed.

    Standards behavior and migration

    Error and fresh DOMException instances inherit the stack accessor instead of
    having an own stack property. Stack strings remain readable and cloning retains
    the trace. Code that inspects own properties must allow this new structure.
    Iterator helpers validate closing operations. A DataView made out of bounds by
    shrinking its buffer reports byteLength and byteOffset as zero. Temporal adopts
    the newer annotation grammar and ISO PlainMonthDay overflow rules. NOE accepts
    these standards-mode changes without enabling WithNodeQuirks.

    Web Crypto subtle methods now reject resizable ArrayBuffer-backed inputs with
    TypeError, including views into those buffers. This follows Web IDL and prevents
    an out-of-bounds DataView from silently hashing empty data after the engine
    getter change. In-bounds resizable inputs previously accepted are rejected too.
    Copy the intended bytes into a fixed Uint8Array before passing them as data,
    raw key material or algorithm fields such as salt. Fixed-buffer view offsets,
    valid empty DataViews, input snapshots and rejected-Promise behavior remain.

    Verification and scope

    Implementation verification covers unit tests, CLI E2E, affected race checks,
    main/Worker/realm regressions, production interruption, standalone Go consumers,
    unmodified jose 6.2.15 and Node interoperability, and six compilation targets.
    Two outdated HTTP E2E fixtures were corrected to preserve lowercase patch, as
    the existing Request method contract requires; they pass on both engine versions.
    Completed source verification is reused for release preparation and lightweight
    CI builds six binaries and SHA256SUMS from the immutable tag.

    The existing Iterator.from wrapper closing divergence remains. Full
    BodyInit/BufferSource conversion, complete Web conformance, JIT enablement and
    other stdlib expansion are outside this release. Other target binaries are
    compiled but not executed natively. No live provider request is needed.

    Publication includes verified installation at both existing vm201 executable
    paths, with previous binaries retained. Other hosts, running services and
    noebot are excluded. See the integration record
    and release checkpoints.

    Downloads