Configure automatic saving of conversation histories

Reference for Pinocchio chatapp protobuf contracts, segment-aware message entities, and shared reasoning/tool-call plugins.

Engine-only profile registries for resolving `InferenceSettings` in Geppetto.

Engine-first event publishing with EventSink, Watermill routing, and context-carried sinks for streaming AI.

Task-based index for Geppetto docs and example programs.

Reference for the native `require("geppetto")` API exposed through goja.

Practical guide for writing scripts against the hard-cut Geppetto JavaScript API.

Extract and process different types of blocks from markdown files

App-facing `pkg/inference/runner` package for building simple and event-driven inference programs from resolved runtime input.

Build terminal chat UIs with the unified ChatBuilder/ChatSession API and Watermill event routing.

How Pinocchio builds hidden base settings and merges engine profiles without contaminating the underlying baseline.

Upgrade third-party integrations from legacy runtime symbol names to canonical names after alias removal.

Operational checklist and debugging playbook for Pinocchio terminal TUI integrations using Bobatea timeline entities and Watermill event routing.

Use `--rpc` or `--output jsonl` to stream protobuf-defined Pinocchio chat frames for scripts and subprocess clients.

Using temporizer for managing temporary context files

Choosing between local estimates and provider-native token counting

Process and analyze source code for LLM context preparation and token analysis

Operational procedures for diagnosing and troubleshooting webchat issues.

Frontend architecture for the sessionstream-backed webchat application.

How frontend clients integrate with the sessionstream-backed chat API, WebSocket transport, and snapshot hydration.

Migrate and validate per-turn runtime truth with conversation current-runtime semantics.

Step-by-step guide to implement a custom event handler, subscribe it to the router, and parse incoming events.

Step-by-step guide to define a tool, register it, attach the registry to context, and configure tool calling on a Turn.

Applications now bootstrap StepSettings from defaults/config/env/flags only; profiles no longer patch them.

Step-by-step tutorial to build a Cobra command that streams model output and supports tool calling using Geppetto.

Step-by-step tutorial for building a small Glazed CLI that streams events, runs a tool loop, and keeps engine settings hidden in app bootstrap.

Intern-friendly developer guide to designing, wiring, and debugging `eval_xxx` tools with `pkg/inference/tools/scopedjs`.

Step-by-step guide to creating a Geppetto middleware that emits UI events and a Bubble Tea renderer to display them in the Pinocchio timeline.

Step-by-step playbook for building a sessionstream-backed React chat app with Go handlers, Geppetto inference, hydration, websockets, and custom widgets.

Step-by-step guide to migrate a Cobra command to the current Glazed + bootstrap path with profile resolution and shared inference-debug output.

Build applications using embeddings for semantic search, with single/batch generation and caching strategies.

Build an application that routes inference events to multiple handlers and produces structured JSON/YAML logs.

Build and run a session-centered Geppetto JavaScript script.

How Geppetto runs linting, how to add custom go/analysis analyzers, and how turnsdatalint works

A practical guide to writing, composing, and using middlewares with Turn-based engines.

Hard-cut migration guide from old Geppetto layer/parameter symbols to the new section/value facade API.

Step-by-step migration guide from legacy Pinocchio config keys to the unified app/profile/profiles document model.

Legacy profile-map migration has been removed after the StepSettingsPatch hard cut.

Step-by-step guide to migrate from the legacy inference lifecycle APIs to geppetto/pkg/inference/session.

Log into a profile with PKCE and keep renewable OAuth state in one owner-only registry.

Runbook for operating, inspecting, backing up, and recovering SQLite-backed profile registry storage.

Pinocchio-specific companion to the generic Geppetto CLI bootstrap migration tutorial.

Step-by-step guide to embed Pinocchio’s Bubble Tea + Bobatea terminal chat UI with the extracted tool-loop backend and agent forwarder.

Step-by-step guide to extract structured data from streaming LLM output using filtering sinks and custom extractors.

Use `pinocchio js` to run JavaScript scripts with Pinocchio config defaults and Geppetto's session-centered JS API.

Managing multi-turn interactions with session.Session — turn history, inference lifecycle, and async execution.

Build an application that extracts structured data from streaming LLM output in real-time.

Extracting structured data from LLM text streams using tagged blocks and the FilteringSink.

A complete guide to defining, attaching, and executing tools with Turns. Tool registries are carried via `context.Context` (Turn state stays serializable).

Understanding the Run/Turn/Block data model and how engines and middleware use it

A guide to the embeddings package in Geppetto, covering embedding generation, caching, and integrating with applications.

A comprehensive guide to the Turn-based inference engine architecture, covering engines, streaming, and provider implementations.

A guide to the rerank package in Geppetto, covering cross-encoder reranking, the llama.cpp adapter, profile integration, and the JavaScript API.

Inject host-owned renewable bearer credentials without placing refresh state in inference settings.

Build a read-only scoped SQLite tool with `geppetto/pkg/inference/tools/scopeddb`, choose prebuilt or lazy registration, and keep queries safe.

Quick start for running the Pinocchio webchat backend and React UI locally.

Resolve provider credentials through Geppetto/Pinocchio profiles and pass final settings to engines.