Callbacks
+PromptWithCallbacks
+The PromptWithCallbacks method provides real-time visibility into tool calls and streaming output:
response, err := host.PromptWithCallbacks(
+ ctx,
+ "List files in current directory",
+ func(name, args string) {
+ // Called when the model invokes a tool
+ fmt.Println("Calling tool:", name)
+ },
+ func(name, args, result string, isError bool) {
+ // Called when a tool returns its result
+ if isError {
+ fmt.Println("Tool failed:", name)
+ }
+ },
+ func(chunk string) {
+ // Called for each streaming text chunk
+ fmt.Print(chunk)
+ },
+)Callback signatures
+| Callback | +Signature | +When | +
|---|---|---|
onToolCall |
+func(name, args string) |
+Model requests a tool call | +
onToolResult |
+func(name, args, result string, isError bool) |
+Tool execution completes | +
onStreaming |
+func(chunk string) |
+Streaming text chunk received | +
Any callback can be nil if you don't need it:
// Only care about streaming output
+response, err := host.PromptWithCallbacks(ctx, "Hello", nil, nil, func(chunk string) {
+ fmt.Print(chunk)
+})Event-based monitoring
+For more granular control, use the event subscription API:
+// Subscribe returns an unsubscribe function
+unsub := host.OnToolCall(func(event kit.ToolCallEvent) {
+ fmt.Printf("Tool: %s, Args: %s\\n", event.Name, event.Args)
+})
+defer unsub()
+
+unsub2 := host.OnToolResult(func(event kit.ToolResultEvent) {
+ fmt.Printf("Result: %s (error: %v)\\n", event.Name, event.IsError)
+})
+defer unsub2()
+
+unsub3 := host.OnStreaming(func(event kit.MessageUpdateEvent) {
+ fmt.Print(event.Chunk)
+})
+defer unsub3()
+
+unsub4 := host.OnResponse(func(event kit.ResponseEvent) {
+ fmt.Println("Final response received")
+})
+defer unsub4()
+
+unsub5 := host.OnTurnStart(func(event kit.TurnStartEvent) {
+ fmt.Println("Turn started")
+})
+defer unsub5()
+
+unsub6 := host.OnTurnEnd(func(event kit.TurnEndEvent) {
+ fmt.Println("Turn ended")
+})
+defer unsub6()Hook system
+Hooks allow you to intercept and modify behavior. Unlike events, hooks can modify or cancel operations:
+// Intercept tool calls before execution
+host.OnBeforeToolCall(0, func(ctx context.Context, name string, args string) (string, error) {
+ if name == "bash" {
+ log.Println("Bash command:", args)
+ }
+ return args, nil // return modified args or error to cancel
+})
+
+// Process results after tool execution
+host.OnAfterToolResult(0, func(ctx context.Context, name string, result string) (string, error) {
+ return result, nil
+})
+
+// Before/after each agent turn
+host.OnBeforeTurn(0, func(ctx context.Context) error {
+ return nil
+})
+
+host.OnAfterTurn(0, func(ctx context.Context) error {
+ return nil
+})The first argument is a priority (lower = runs first).
`,headings:[{depth:2,text:"PromptWithCallbacks",id:"promptwithcallbacks"},{depth:3,text:"Callback signatures",id:"callback-signatures"},{depth:2,text:"Event-based monitoring",id:"event-based-monitoring"},{depth:2,text:"Hook system",id:"hook-system"}],raw:` +# Callbacks + +## PromptWithCallbacks + +The \`PromptWithCallbacks\` method provides real-time visibility into tool calls and streaming output: + +\`\`\`go +response, err := host.PromptWithCallbacks( + ctx, + "List files in current directory", + func(name, args string) { + // Called when the model invokes a tool + fmt.Println("Calling tool:", name) + }, + func(name, args, result string, isError bool) { + // Called when a tool returns its result + if isError { + fmt.Println("Tool failed:", name) + } + }, + func(chunk string) { + // Called for each streaming text chunk + fmt.Print(chunk) + }, +) +\`\`\` + +### Callback signatures + +| Callback | Signature | When | +|----------|-----------|------| +| \`onToolCall\` | \`func(name, args string)\` | Model requests a tool call | +| \`onToolResult\` | \`func(name, args, result string, isError bool)\` | Tool execution completes | +| \`onStreaming\` | \`func(chunk string)\` | Streaming text chunk received | + +Any callback can be \`nil\` if you don't need it: + +\`\`\`go +// Only care about streaming output +response, err := host.PromptWithCallbacks(ctx, "Hello", nil, nil, func(chunk string) { + fmt.Print(chunk) +}) +\`\`\` + +## Event-based monitoring + +For more granular control, use the event subscription API: + +\`\`\`go +// Subscribe returns an unsubscribe function +unsub := host.OnToolCall(func(event kit.ToolCallEvent) { + fmt.Printf("Tool: %s, Args: %s\\n", event.Name, event.Args) +}) +defer unsub() + +unsub2 := host.OnToolResult(func(event kit.ToolResultEvent) { + fmt.Printf("Result: %s (error: %v)\\n", event.Name, event.IsError) +}) +defer unsub2() + +unsub3 := host.OnStreaming(func(event kit.MessageUpdateEvent) { + fmt.Print(event.Chunk) +}) +defer unsub3() + +unsub4 := host.OnResponse(func(event kit.ResponseEvent) { + fmt.Println("Final response received") +}) +defer unsub4() + +unsub5 := host.OnTurnStart(func(event kit.TurnStartEvent) { + fmt.Println("Turn started") +}) +defer unsub5() + +unsub6 := host.OnTurnEnd(func(event kit.TurnEndEvent) { + fmt.Println("Turn ended") +}) +defer unsub6() +\`\`\` + +## Hook system + +Hooks allow you to intercept and modify behavior. Unlike events, hooks can modify or cancel operations: + +\`\`\`go +// Intercept tool calls before execution +host.OnBeforeToolCall(0, func(ctx context.Context, name string, args string) (string, error) { + if name == "bash" { + log.Println("Bash command:", args) + } + return args, nil // return modified args or error to cancel +}) + +// Process results after tool execution +host.OnAfterToolResult(0, func(ctx context.Context, name string, result string) (string, error) { + return result, nil +}) + +// Before/after each agent turn +host.OnBeforeTurn(0, func(ctx context.Context) error { + return nil +}) + +host.OnAfterTurn(0, func(ctx context.Context) error { + return nil +}) +\`\`\` + +The first argument is a priority (lower = runs first). +`};export{s as default}; diff --git a/assets/capabilities-hnq2TbFu.js b/assets/capabilities-hnq2TbFu.js new file mode 100644 index 00000000..0ea7a85d --- /dev/null +++ b/assets/capabilities-hnq2TbFu.js @@ -0,0 +1,485 @@ +const s={frontmatter:{title:"Capabilities",description:"All extension capabilities — lifecycle events, tools, commands, widgets, and more.",hidden:!1,toc:!0,draft:!1},html:`Extension Capabilities
+Lifecycle events
+Extensions can hook into 18 lifecycle events:
+| Event | +Description | +
|---|---|
OnSessionStart |
+Session initialized | +
OnSessionShutdown |
+Session ending | +
OnBeforeAgentStart |
+Before the agent loop begins | +
OnAgentStart |
+Agent loop started | +
OnAgentEnd |
+Agent loop completed | +
OnToolCall |
+Tool call requested by the model | +
OnToolExecutionStart |
+Tool execution beginning | +
OnToolExecutionEnd |
+Tool execution completed | +
OnToolResult |
+Tool result returned | +
OnInput |
+User input received | +
OnMessageStart |
+Assistant message started | +
OnMessageUpdate |
+Streaming text chunk received | +
OnMessageEnd |
+Assistant message completed | +
OnModelChange |
+Model switched | +
OnContextPrepare |
+Context being assembled for the model | +
OnBeforeFork |
+Before forking a conversation branch | +
OnBeforeSessionSwitch |
+Before switching sessions | +
OnBeforeCompact |
+Before conversation compaction | +
Example
+api.OnToolCall(func(event ext.ToolCallEvent, ctx ext.Context) {
+ ctx.PrintInfo("Calling tool: " + event.Name)
+})
+
+api.OnAgentEnd(func(_ ext.AgentEndEvent, ctx ext.Context) {
+ ctx.PrintInfo("Agent finished")
+})Tools
+Register custom tools that the LLM can invoke:
+api.RegisterTool(ext.ToolDef{
+ Name: "weather",
+ Description: "Get current weather for a location",
+ Parameters: map[string]ext.ParameterDef{
+ "city": {Type: "string", Description: "City name", Required: true},
+ },
+ Handler: func(ctx ext.Context, params map[string]any) (string, error) {
+ city := params["city"].(string)
+ return "Sunny, 72°F in " + city, nil
+ },
+})Commands
+Register slash commands that users can invoke directly:
+api.RegisterCommand(ext.CommandDef{
+ Name: "stats",
+ Description: "Show context statistics",
+ Handler: func(ctx ext.Context, args string) {
+ stats := ctx.GetContextStats()
+ ctx.PrintInfo(fmt.Sprintf("Tokens: %d", stats.TotalTokens))
+ },
+})Widgets
+Add persistent status displays above or below the input area:
+ctx.SetWidget(ext.WidgetConfig{
+ ID: "token-count",
+ Position: "bottom",
+ Content: ext.WidgetContent{Text: "Tokens: 1,234"},
+})
+
+// Update later
+ctx.SetWidget(ext.WidgetConfig{
+ ID: "token-count",
+ Position: "bottom",
+ Content: ext.WidgetContent{Text: "Tokens: 2,456"},
+})
+
+// Remove
+ctx.RemoveWidget("token-count")Headers and footers
+Persistent content above and below the conversation:
+ctx.SetHeader(ext.HeaderFooterConfig{
+ Content: ext.WidgetContent{Text: "Project: my-app | Branch: main"},
+})
+
+ctx.SetFooter(ext.HeaderFooterConfig{
+ Content: ext.WidgetContent{Text: "Plan Mode (read-only)"},
+})Status bar
+Custom status bar entries:
+ctx.SetStatus("mode", "Planning")
+ctx.RemoveStatus("mode")Shortcuts
+Global keyboard shortcuts:
+api.RegisterShortcut(ext.ShortcutDef{
+ Key: "ctrl+t",
+ Description: "Toggle plan mode",
+}, func(ctx ext.Context) {
+ // handle shortcut
+})Overlays
+Modal dialogs with markdown content:
+ctx.ShowOverlay(ext.OverlayConfig{
+ Title: "Help",
+ Content: "# Keyboard Shortcuts\\n\\n- **ctrl+t** — Toggle plan mode\\n- **ctrl+s** — Save session",
+})Tool renderers
+Customize how specific tool calls are displayed in the TUI:
+api.RegisterToolRenderer(ext.ToolRenderConfig{
+ ToolName: "bash",
+ Render: func(name, args, result string, isError bool) string {
+ return "$ " + args + "\\n" + result
+ },
+})Message renderers
+Custom rendering for assistant messages:
+api.RegisterMessageRenderer(ext.MessageRendererConfig{
+ Name: "custom",
+ Render: func(content string) string {
+ return ">> " + content
+ },
+})Editor interceptors
+Handle key events and wrap the editor's rendering:
+ctx.SetEditor(ext.EditorConfig{
+ HandleKey: func(key, text string) ext.EditorKeyAction {
+ if key == "escape" {
+ return ext.EditorKeyAction{Handled: true}
+ }
+ return ext.EditorKeyAction{Handled: false}
+ },
+})Interactive prompts
+Select, confirm, input, and multi-select dialogs:
+// Single select
+response := ctx.PromptSelect(ext.PromptSelectConfig{
+ Title: "Choose a model",
+ Options: []string{"claude-sonnet", "gpt-4o", "llama3"},
+})
+
+// Confirm
+confirmed := ctx.PromptConfirm(ext.PromptConfirmConfig{
+ Title: "Delete this file?",
+})
+
+// Text input
+name := ctx.PromptInput(ext.PromptInputConfig{
+ Title: "Enter project name",
+ Placeholder: "my-project",
+})Options
+Register configurable extension options:
+api.RegisterOption(ext.OptionDef{
+ Name: "auto-commit",
+ Description: "Automatically commit on shutdown",
+ DefaultValue: "false",
+})Subagents
+Spawn in-process child Kit instances:
+result := ctx.SpawnSubagent(ext.SubagentConfig{
+ Task: "Analyze the test files and summarize coverage",
+ Model: "anthropic/claude-haiku-3-5-20241022",
+ SystemPrompt: "You are a test analysis expert.",
+})LLM completion
+Make direct model calls without going through the agent loop:
+response := ctx.Complete(ext.CompleteRequest{
+ Prompt: "Summarize this in one sentence: " + content,
+})Custom events
+Inter-extension communication:
+// Emit
+ctx.EmitCustomEvent("my-extension:data-ready", payload)
+
+// Listen
+api.OnCustomEvent("my-extension:data-ready", func(data any, ctx ext.Context) {
+ // handle event
+})Commands
+Authentication
+For OAuth-enabled providers like Anthropic.
+kit auth login [provider] # Start OAuth flow (e.g., anthropic)
+kit auth logout [provider] # Remove credentials for provider
+kit auth status # Check authentication statusModel database
+Manage the local model database that maps provider names to API configurations.
+kit models [provider] # List available models (optionally filter by provider)
+kit models --all # Show all providers (not just Fantasy-compatible)
+kit update-models [source] # Update model databaseThe update-models command accepts an optional source argument:
-
+
- (none) — update from models.dev +
- A URL — fetch from a custom endpoint +
- A file path — load from a local file +
embedded— reset to the bundled database
+
Extension management
+kit extensions list # List discovered extensions
+kit extensions validate # Validate extension files
+kit extensions init # Generate example extension templateInstalling extensions from git
+kit install <git-url> # Install extensions from git repositories
+kit install -l <git-url> # Install to project-local .kit/git/ directory
+kit install -u <git-url> # Update an already-installed package
+kit install --uninstall <pkg> # Remove an installed package
+kit install --all # Install all extensions without promptingSkills
+kit skill # Install the Kit extensions skill via skills.shACP server
+Run Kit as an ACP (Agent Client Protocol) agent server. ACP-compatible clients communicate with Kit over JSON-RPC 2.0 on stdin/stdout.
+kit acp # Start as ACP agent
+kit acp --debug # With debug logging to stderrConfiguration
+Kit looks for configuration in the following locations, in order of priority:
+-
+
- CLI flags +
- Environment variables (with
KIT_prefix)
+ ./.kit.yml/./.kit.yaml/./.kit.json(project-local)
+~/.kit.yml/~/.kit.yaml/~/.kit.json(global)
+
Basic configuration
+Create ~/.kit.yml:
model: anthropic/claude-sonnet-4-5-20250929
+max-tokens: 4096
+temperature: 0.7
+stream: trueAll configuration keys
+| Key | +Type | +Default | +Description | +
|---|---|---|---|
model |
+string | +anthropic/claude-sonnet-4-5-20250929 |
+Model to use (provider/model format) | +
max-tokens |
+int | +4096 |
+Maximum tokens in response | +
temperature |
+float | +0.7 |
+Randomness 0.0–1.0 | +
top-p |
+float | +0.95 |
+Nucleus sampling 0.0–1.0 | +
top-k |
+int | +40 |
+Limit top K tokens | +
stream |
+bool | +true |
+Enable streaming output | +
debug |
+bool | +false |
+Enable debug logging | +
compact |
+bool | +false |
+Enable compact output mode | +
system-prompt |
+string | +— | +System prompt text or file path | +
max-steps |
+int | +0 |
+Maximum agent steps (0 = unlimited) | +
thinking-level |
+string | +off |
+Extended thinking: off, minimal, low, medium, high | +
provider-api-key |
+string | +— | +API key for the provider | +
provider-url |
+string | +— | +Base URL for provider API | +
tls-skip-verify |
+bool | +false |
+Skip TLS certificate verification | +
stop-sequences |
+list | +— | +Custom stop sequences | +
theme |
+string | +— | +UI theme | +
markdown-theme |
+string | +— | +Markdown rendering theme | +
Environment variables
+Any configuration key can be set via environment variable with the KIT_ prefix. Hyphens become underscores:
export KIT_MODEL="openai/gpt-4o"
+export KIT_MAX_TOKENS="8192"
+export KIT_TEMPERATURE="0.5"Provider API keys use their own environment variables:
+export ANTHROPIC_API_KEY="sk-..."
+export OPENAI_API_KEY="sk-..."
+export GOOGLE_API_KEY="..."MCP server configuration
+Add external MCP servers to your .kit.yml:
mcpServers:
+ filesystem:
+ type: local
+ command: ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed"]
+ environment:
+ LOG_LEVEL: "info"
+ allowedTools: ["read_file", "write_file"]
+ excludedTools: ["delete_file"]
+
+ search:
+ type: remote
+ url: "https://mcp.example.com/search"MCP server fields
+| Field | +Type | +Description | +
|---|---|---|
type |
+string | +local (stdio) or remote (streamable HTTP) |
+
command |
+list | +Command and args for local servers | +
environment |
+map | +Environment variables for the server process | +
url |
+string | +URL for remote servers | +
allowedTools |
+list | +Whitelist of tool names to expose | +
excludedTools |
+list | +Blacklist of tool names to hide | +
A legacy format with transport, args, env, and headers fields is also supported.
Development
+Build and test
+# Build
+go build -o output/kit ./cmd/kit
+
+# Run all tests
+go test -race ./...
+
+# Run a specific test
+go test -race ./cmd -run TestScriptExecution
+
+# Lint
+go vet ./...
+
+# Format
+go fmt ./...Project structure
+cmd/kit/ - CLI entry point (main.go)
+cmd/ - CLI command implementations (root, auth, models, etc.)
+pkg/kit/ - Go SDK for embedding Kit
+internal/app/ - Application orchestrator (agent loop, message store, queue)
+internal/agent/ - Agent execution and tool dispatch
+internal/auth/ - OAuth authentication and credential storage
+internal/acpserver/ - ACP (Agent Client Protocol) server
+internal/clipboard/ - Cross-platform clipboard operations
+internal/compaction/ - Conversation compaction and summarization
+internal/config/ - Configuration management
+internal/core/ - Built-in tools (bash, read, write, edit, grep, find, ls)
+internal/extensions/ - Yaegi extension system
+internal/kitsetup/ - Initial setup wizard
+internal/message/ - Message content types and structured content blocks
+internal/models/ - Provider and model management
+internal/session/ - Session persistence (tree-based JSONL)
+internal/skills/ - Skill loading and system prompt composition
+internal/tools/ - MCP tool integration
+internal/ui/ - Bubble Tea TUI components
+examples/extensions/ - Example extension files
+npm/ - NPM package wrapper for distribution
+Architecture overview
+Kit is built around a few key architectural patterns:
+Multi-provider LLM support
+The llm.Provider interface abstracts different LLM providers. Each provider implements message formatting, tool calling, and streaming for its specific API.
MCP client-server model
+External tools are integrated via the Model Context Protocol (MCP). Kit acts as an MCP client, connecting to MCP servers configured in .kit.yml.
Extension system
+Extensions are Go source files interpreted at runtime by Yaegi. The internal/extensions/ package manages loading, symbol export, and lifecycle dispatch. See the Extension System docs for details.
TUI architecture
+The interactive terminal UI is built with Bubble Tea v2, using a parent-child model where AppModel manages child components (InputComponent, StreamComponent, etc.).
Decoupling pattern
+cmd/root.go contains converter functions (e.g., widgetProviderForUI()) that bridge internal/extensions/ types to internal/ui/ types. The UI never imports the extensions package directly.
Contributing
+Contributions are welcome! Please see the contribution guide for guidelines.
+Community
+-
+
- Discord +
- GitHub Issues +
Extension Examples
+Kit ships with a rich set of example extensions in the examples/extensions/ directory. These serve as both documentation and starting points for your own extensions.
UI and display
+| Extension | +Description | +
|---|---|
minimal.go |
+Clean UI with custom footer | +
branded-output.go |
+Branded output rendering | +
header-footer-demo.go |
+Custom headers and footers | +
widget-status.go |
+Persistent status widgets | +
overlay-demo.go |
+Modal dialogs | +
tool-renderer-demo.go |
+Custom tool call rendering | +
custom-editor-demo.go |
+Vim-like modal editor | +
pirate.go |
+Pirate-themed personality | +
Workflow and automation
+| Extension | +Description | +
|---|---|
auto-commit.go |
+Auto-commit changes on shutdown | +
plan-mode.go |
+Read-only planning mode | +
permission-gate.go |
+Permission gating for destructive tools | +
confirm-destructive.go |
+Confirm destructive operations | +
protected-paths.go |
+Path protection for sensitive files | +
project-rules.go |
+Project-specific rules injection | +
compact-notify.go |
+Notification on conversation compaction | +
Interactive features
+| Extension | +Description | +
|---|---|
prompt-demo.go |
+Interactive prompts (select/confirm/input) | +
bookmark.go |
+Bookmark conversations | +
inline-bash.go |
+Inline bash execution | +
interactive-shell.go |
+Interactive shell integration | +
notify.go |
+Desktop notifications | +
Agent and context
+| Extension | +Description | +
|---|---|
tool-logger.go |
+Log all tool calls | +
context-inject.go |
+Inject context into conversations | +
summarize.go |
+Conversation summarization | +
lsp-diagnostics.go |
+LSP diagnostic integration | +
Multi-agent
+| Extension | +Description | +
|---|---|
kit-kit.go |
+Kit-in-Kit sub-agent spawning | +
subagent-widget.go |
+Multi-agent orchestration with status widget | +
subagent-test.go |
+Subagent testing utilities | +
Development
+| Extension | +Description | +
|---|---|
dev-reload.go |
+Development live-reload | +
Subdirectory extensions
+| Directory | +Description | +
|---|---|
kit-kit-agents/ |
+Multi-agent orchestration example | +
kit-telegram/ |
+Telegram bot integration | +
status-tools/ |
+Status bar tool examples | +
Global Flags
+All flags can be passed to the root kit command.
Model and provider
+| Flag | +Short | +Default | +Description | +
|---|---|---|---|
--model |
+-m |
+anthropic/claude-sonnet-4-5-20250929 |
+Model to use (provider/model format) | +
--provider-api-key |
+— | +— | +API key for the provider | +
--provider-url |
+— | +— | +Base URL for provider API | +
--tls-skip-verify |
+— | +false |
+Skip TLS certificate verification | +
Session management
+| Flag | +Short | +Default | +Description | +
|---|---|---|---|
--session |
+-s |
+— | +Open specific JSONL session file | +
--continue |
+-c |
+false |
+Resume most recent session for current directory | +
--resume |
+-r |
+false |
+Interactive session picker | +
--no-session |
+— | +false |
+Ephemeral mode, no persistence | +
Behavior
+These flags control Kit's behavior. When a prompt is passed as a positional argument, Kit runs in non-interactive mode.
+| Flag | +Short | +Default | +Description | +
|---|---|---|---|
--quiet |
+— | +false |
+Suppress all output (non-interactive only) | +
--json |
+— | +false |
+Output response as JSON (non-interactive only) | +
--no-exit |
+— | +false |
+Enter interactive mode after prompt completes | +
--max-steps |
+— | +0 |
+Maximum agent steps (0 for unlimited) | +
--stream |
+— | +true |
+Enable streaming output | +
--compact |
+— | +false |
+Enable compact output mode | +
--auto-compact |
+— | +false |
+Auto-compact conversation near context limit | +
Extensions
+| Flag | +Short | +Default | +Description | +
|---|---|---|---|
--extension |
+-e |
+— | +Load additional extension file(s) (repeatable) | +
--no-extensions |
+— | +false |
+Disable all extensions | +
Generation parameters
+| Flag | +Short | +Default | +Description | +
|---|---|---|---|
--max-tokens |
+— | +4096 |
+Maximum tokens in response | +
--temperature |
+— | +0.7 |
+Randomness 0.0–1.0 | +
--top-p |
+— | +0.95 |
+Nucleus sampling 0.0–1.0 | +
--top-k |
+— | +40 |
+Limit top K tokens | +
--stop-sequences |
+— | +— | +Custom stop sequences (comma-separated) | +
--thinking-level |
+— | +off |
+Extended thinking level: off, minimal, low, medium, high | +
System
+| Flag | +Short | +Default | +Description | +
|---|---|---|---|
--config |
+— | +~/.kit.yml |
+Config file path | +
--system-prompt |
+— | +— | +System prompt text or file path | +
--debug |
+— | +false |
+Enable debug logging | +
+ 
+
+
+A powerful, extensible AI coding agent CLI with multi-provider support, built-in tools, and a rich extension system.
+
+## Features
+
+- **Multi-Provider LLM Support** — Anthropic, OpenAI, Google Gemini, Ollama, Azure OpenAI, AWS Bedrock, OpenRouter, and more
+- **Built-in Core Tools** — bash, read, write, edit, grep, find, ls, spawn_subagent with no MCP overhead
+- **MCP Integration** — Connect external MCP servers for expanded capabilities
+- **Extension System** — Write custom tools, commands, widgets, and UI modifications in Go
+- **Interactive TUI** — Rich terminal interface powered by Bubble Tea with streaming, syntax highlighting, and custom rendering
+- **Session Management** — Tree-based conversation history with branching support
+- **Non-Interactive Mode** — Script-friendly positional args with JSON output
+- **ACP Server** — Run Kit as an [Agent Client Protocol](https://agentclientprotocol.com) agent over stdio
+- **Go SDK** — Embed Kit in your own applications
+
+## Quick links
+
+| Resource | Description |
+|----------|-------------|
+| [Installation](/installation) | Get Kit up and running |
+| [Quick Start](/quick-start) | Your first Kit session |
+| [Configuration](/configuration) | Customize Kit for your workflow |
+| [Extensions](/extensions/overview) | Build custom tools and UI components |
+| [Go SDK](/sdk/overview) | Embed Kit in your applications |
+`},{id:"installation",title:"Installation",content:`
+# Installation
+
+## Using npm (recommended)
+
+\`\`\`bash
+npm install -g @mark3labs/kit
+\`\`\`
+
+## Using Go
+
+\`\`\`bash
+go install github.com/mark3labs/kit/cmd/kit@latest
+\`\`\`
+
+## Building from source
+
+\`\`\`bash
+git clone https://github.com/mark3labs/kit.git
+cd kit
+go build -o kit ./cmd/kit
+\`\`\`
+
+## Verifying the installation
+
+After installing, verify Kit is available:
+
+\`\`\`bash
+kit --help
+\`\`\`
+
+## Setting up a provider
+
+Kit needs at least one LLM provider configured. Set an API key for your preferred provider:
+
+\`\`\`bash
+# Anthropic (default provider)
+export ANTHROPIC_API_KEY="sk-..."
+
+# OpenAI
+export OPENAI_API_KEY="sk-..."
+
+# Google Gemini
+export GOOGLE_API_KEY="..."
+\`\`\`
+
+For OAuth-enabled providers like Anthropic, you can also authenticate interactively:
+
+\`\`\`bash
+kit auth login anthropic
+\`\`\`
+
+See [Providers](/providers) for the full list of supported providers and their configuration.
+`},{id:"providers",title:"Providers",content:`
+# Providers
+
+Kit supports a wide range of LLM providers through a unified \`provider/model\` string format.
+
+## Supported providers
+
+| Provider | Prefix | Description |
+|----------|--------|-------------|
+| **Anthropic** | \`anthropic/\` | Claude models (native, prompt caching, OAuth) |
+| **OpenAI** | \`openai/\` | GPT models |
+| **Google** | \`google/\` or \`gemini/\` | Gemini models |
+| **Ollama** | \`ollama/\` | Local models |
+| **Azure OpenAI** | \`azure/\` | Azure-hosted OpenAI |
+| **AWS Bedrock** | \`bedrock/\` | Bedrock models |
+| **Google Vertex** | \`google-vertex-anthropic/\` | Claude on Vertex AI |
+| **OpenRouter** | \`openrouter/\` | Multi-provider router |
+| **Vercel AI** | \`vercel/\` | Vercel AI SDK models |
+| **Auto-routed** | any | Any provider from the models.dev database |
+
+## Model string format
+
+\`\`\`bash
+provider/model # Standard format
+anthropic/claude-sonnet-4-5-20250929
+openai/gpt-4o
+ollama/llama3
+google/gemini-2.0-flash-exp
+\`\`\`
+
+## Model aliases
+
+Kit provides aliases for commonly used models:
+
+\`\`\`bash
+claude-opus-latest → claude-opus-4-20250514
+claude-sonnet-latest → claude-sonnet-4-5-20250929
+claude-4-opus-latest → claude-opus-4-20250514
+claude-4-sonnet-latest → claude-sonnet-4-5-20250929
+claude-3-7-sonnet-latest → claude-3-7-sonnet-20250219
+claude-3-5-sonnet-latest → claude-3-5-sonnet-20241022
+claude-3-5-haiku-latest → claude-3-5-haiku-20241022
+claude-3-opus-latest → claude-3-opus-20240229
+\`\`\`
+
+## Specifying a model
+
+Via CLI flag:
+
+\`\`\`bash
+kit --model openai/gpt-4o
+kit -m ollama/llama3
+\`\`\`
+
+Via config file:
+
+\`\`\`yaml
+model: anthropic/claude-sonnet-4-5-20250929
+\`\`\`
+
+Via environment variable:
+
+\`\`\`bash
+export KIT_MODEL="google/gemini-2.0-flash-exp"
+\`\`\`
+
+## Authentication
+
+### API keys
+
+Set the appropriate environment variable for your provider:
+
+\`\`\`bash
+export ANTHROPIC_API_KEY="sk-..."
+export OPENAI_API_KEY="sk-..."
+export GOOGLE_API_KEY="..."
+\`\`\`
+
+Or pass it directly:
+
+\`\`\`bash
+kit --provider-api-key "sk-..." --model openai/gpt-4o
+\`\`\`
+
+### OAuth
+
+For providers that support OAuth (e.g., Anthropic):
+
+\`\`\`bash
+kit auth login anthropic # Start OAuth flow
+kit auth status # Check authentication status
+kit auth logout anthropic # Remove credentials
+\`\`\`
+
+### Custom provider URL
+
+For self-hosted or proxy endpoints:
+
+\`\`\`bash
+kit --provider-url "https://my-proxy.example.com/v1" --model openai/gpt-4o
+\`\`\`
+
+## Model database
+
+Kit ships with a local model database that maps provider names to API configurations. You can manage it with:
+
+\`\`\`bash
+kit models # List available models
+kit models openai # Filter by provider
+kit models --all # Show all providers
+kit update-models # Update from models.dev
+kit update-models embedded # Reset to bundled database
+\`\`\`
+`},{id:"quick-start",title:"Quick Start",content:`
+# Quick Start
+
+## Basic usage
+
+Start an interactive session:
+
+\`\`\`bash
+kit
+\`\`\`
+
+Run a one-off prompt:
+
+\`\`\`bash
+kit "List files in src/"
+\`\`\`
+
+Attach files as context using the \`@\` prefix:
+
+\`\`\`bash
+kit @main.go @test.go "Review these files"
+\`\`\`
+
+Use a specific model:
+
+\`\`\`bash
+kit --model anthropic/claude-sonnet-4-5-20250929
+\`\`\`
+
+## Non-interactive mode
+
+Kit can run as a non-interactive tool for scripting and automation.
+
+Get JSON output:
+
+\`\`\`bash
+kit "Explain main.go" --json
+\`\`\`
+
+Quiet mode (final response only, no TUI):
+
+\`\`\`bash
+kit "Run tests" --quiet
+\`\`\`
+
+Ephemeral mode (no session file created):
+
+\`\`\`bash
+kit "Quick question" --no-session
+\`\`\`
+
+## Resuming sessions
+
+Continue the most recent session for the current directory:
+
+\`\`\`bash
+kit --continue
+# or
+kit -c
+\`\`\`
+
+Pick from previous sessions interactively:
+
+\`\`\`bash
+kit --resume
+# or
+kit -r
+\`\`\`
+
+## ACP server mode
+
+Kit can run as an [ACP (Agent Client Protocol)](https://agentclientprotocol.com) agent server, enabling ACP-compatible clients (such as [OpenCode](https://github.com/sst/opencode)) to drive Kit as a remote coding agent over stdio:
+
+\`\`\`bash
+# Start Kit as an ACP server (JSON-RPC 2.0 on stdin/stdout)
+kit acp
+
+# With debug logging to stderr
+kit acp --debug
+\`\`\`
+
+The ACP server exposes Kit's full capabilities — LLM execution, tool calls (bash, read, write, edit, grep, etc.), and session persistence — over the standard ACP protocol.
+`},{id:"sdk/callbacks",title:"Callbacks",content:`
+# Callbacks
+
+## PromptWithCallbacks
+
+The \`PromptWithCallbacks\` method provides real-time visibility into tool calls and streaming output:
+
+\`\`\`go
+response, err := host.PromptWithCallbacks(
+ ctx,
+ "List files in current directory",
+ func(name, args string) {
+ // Called when the model invokes a tool
+ fmt.Println("Calling tool:", name)
+ },
+ func(name, args, result string, isError bool) {
+ // Called when a tool returns its result
+ if isError {
+ fmt.Println("Tool failed:", name)
+ }
+ },
+ func(chunk string) {
+ // Called for each streaming text chunk
+ fmt.Print(chunk)
+ },
+)
+\`\`\`
+
+### Callback signatures
+
+| Callback | Signature | When |
+|----------|-----------|------|
+| \`onToolCall\` | \`func(name, args string)\` | Model requests a tool call |
+| \`onToolResult\` | \`func(name, args, result string, isError bool)\` | Tool execution completes |
+| \`onStreaming\` | \`func(chunk string)\` | Streaming text chunk received |
+
+Any callback can be \`nil\` if you don't need it:
+
+\`\`\`go
+// Only care about streaming output
+response, err := host.PromptWithCallbacks(ctx, "Hello", nil, nil, func(chunk string) {
+ fmt.Print(chunk)
+})
+\`\`\`
+
+## Event-based monitoring
+
+For more granular control, use the event subscription API:
+
+\`\`\`go
+// Subscribe returns an unsubscribe function
+unsub := host.OnToolCall(func(event kit.ToolCallEvent) {
+ fmt.Printf("Tool: %s, Args: %s\\n", event.Name, event.Args)
+})
+defer unsub()
+
+unsub2 := host.OnToolResult(func(event kit.ToolResultEvent) {
+ fmt.Printf("Result: %s (error: %v)\\n", event.Name, event.IsError)
+})
+defer unsub2()
+
+unsub3 := host.OnStreaming(func(event kit.MessageUpdateEvent) {
+ fmt.Print(event.Chunk)
+})
+defer unsub3()
+
+unsub4 := host.OnResponse(func(event kit.ResponseEvent) {
+ fmt.Println("Final response received")
+})
+defer unsub4()
+
+unsub5 := host.OnTurnStart(func(event kit.TurnStartEvent) {
+ fmt.Println("Turn started")
+})
+defer unsub5()
+
+unsub6 := host.OnTurnEnd(func(event kit.TurnEndEvent) {
+ fmt.Println("Turn ended")
+})
+defer unsub6()
+\`\`\`
+
+## Hook system
+
+Hooks allow you to intercept and modify behavior. Unlike events, hooks can modify or cancel operations:
+
+\`\`\`go
+// Intercept tool calls before execution
+host.OnBeforeToolCall(0, func(ctx context.Context, name string, args string) (string, error) {
+ if name == "bash" {
+ log.Println("Bash command:", args)
+ }
+ return args, nil // return modified args or error to cancel
+})
+
+// Process results after tool execution
+host.OnAfterToolResult(0, func(ctx context.Context, name string, result string) (string, error) {
+ return result, nil
+})
+
+// Before/after each agent turn
+host.OnBeforeTurn(0, func(ctx context.Context) error {
+ return nil
+})
+
+host.OnAfterTurn(0, func(ctx context.Context) error {
+ return nil
+})
+\`\`\`
+
+The first argument is a priority (lower = runs first).
+`},{id:"sdk/options",title:"SDK Options",content:'\n# SDK Options\n\nPass an `Options` struct to `kit.New()` to configure the Kit instance.\n\n## Full options reference\n\n```go\nhost, err := kit.New(ctx, &kit.Options{\n // Model\n Model: "ollama/llama3",\n SystemPrompt: "You are a helpful bot",\n ConfigFile: "/path/to/config.yml",\n\n // Behavior\n MaxSteps: 10,\n Streaming: true,\n Quiet: true,\n Debug: true,\n\n // Session\n SessionPath: "./session.jsonl",\n SessionDir: "/custom/sessions/",\n Continue: true,\n NoSession: true,\n\n // Tools\n Tools: []kit.Tool{...}, // Replace default tool set entirely\n ExtraTools: []kit.Tool{...}, // Add tools alongside defaults\n\n // Compaction\n AutoCompact: true,\n\n // Skills\n Skills: []string{"/path/to/skill.md"},\n SkillsDir: "/path/to/skills/",\n})\n```\n\n## Options fields\n\n| Field | Type | Default | Description |\n|-------|------|---------|-------------|\n| `Model` | `string` | config default | Model string (provider/model format) |\n| `SystemPrompt` | `string` | — | System prompt text or file path |\n| `ConfigFile` | `string` | `~/.kit.yml` | Path to config file |\n| `MaxSteps` | `int` | `0` | Max agent steps (0 = unlimited) |\n| `Streaming` | `bool` | `true` | Enable streaming output |\n| `Quiet` | `bool` | `false` | Suppress output |\n| `Debug` | `bool` | `false` | Enable debug logging |\n| `SessionPath` | `string` | — | Open a specific session file |\n| `SessionDir` | `string` | — | Base directory for session discovery |\n| `Continue` | `bool` | `false` | Resume most recent session |\n| `NoSession` | `bool` | `false` | Ephemeral mode (no persistence) |\n| `Tools` | `[]Tool` | — | Replace the entire default tool set |\n| `ExtraTools` | `[]Tool` | — | Additional tools alongside core/MCP/extension tools |\n| `AutoCompact` | `bool` | `false` | Auto-compact when near context limit |\n| `CompactionOptions` | `*CompactionOptions` | — | Configuration for auto-compaction |\n| `Skills` | `[]string` | — | Explicit skill files/dirs to load |\n| `SkillsDir` | `string` | — | Override default skills directory |\n'},{id:"sdk/overview",title:"Go SDK",content:`
+# Go SDK
+
+The \`pkg/kit\` package lets you embed Kit as a library in your Go applications.
+
+## Installation
+
+\`\`\`bash
+go get github.com/mark3labs/kit/pkg/kit
+\`\`\`
+
+## Basic usage
+
+\`\`\`go
+package main
+
+import (
+ "context"
+ "log"
+
+ kit "github.com/mark3labs/kit/pkg/kit"
+)
+
+func main() {
+ ctx := context.Background()
+
+ // Create Kit instance with default configuration
+ host, err := kit.New(ctx, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer host.Close()
+
+ // Send a prompt
+ response, err := host.Prompt(ctx, "What is 2+2?")
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ println(response)
+}
+\`\`\`
+
+## Multi-turn conversations
+
+Conversations retain context automatically across calls:
+
+\`\`\`go
+host.Prompt(ctx, "My name is Alice")
+response, _ := host.Prompt(ctx, "What's my name?")
+// response: "Your name is Alice"
+\`\`\`
+
+## Additional prompt methods
+
+The SDK provides several prompt variants:
+
+| Method | Description |
+|--------|-------------|
+| \`Prompt(ctx, message)\` | Simple prompt, returns response string |
+| \`PromptWithCallbacks(ctx, message, ...)\` | With tool call and streaming callbacks |
+| \`PromptWithOptions(ctx, message, opts)\` | With per-call options |
+| \`PromptResult(ctx, message)\` | Returns full \`TurnResult\` with usage stats |
+| \`PromptResultWithFiles(ctx, message, files)\` | Multimodal with file attachments |
+| \`Steer(ctx, instruction)\` | System-level steering without user message |
+| \`FollowUp(ctx, text)\` | Continue without new user input |
+
+## Event system
+
+Subscribe to events for monitoring:
+
+\`\`\`go
+unsubscribe := host.OnToolCall(func(event kit.ToolCallEvent) {
+ fmt.Println("Tool called:", event.Name)
+})
+defer unsubscribe()
+
+host.OnToolResult(func(event kit.ToolResultEvent) {
+ fmt.Println("Tool result:", event.Name)
+})
+
+host.OnStreaming(func(event kit.MessageUpdateEvent) {
+ fmt.Print(event.Chunk)
+})
+\`\`\`
+
+## Model management
+
+Switch models at runtime:
+
+\`\`\`go
+host.SetModel(ctx, "openai/gpt-4o")
+info := host.GetModelInfo()
+models := host.GetAvailableModels()
+\`\`\`
+
+## Context and compaction
+
+Monitor and manage context usage:
+
+\`\`\`go
+tokens := host.EstimateContextTokens()
+stats := host.GetContextStats()
+
+if host.ShouldCompact() {
+ result, err := host.Compact(ctx, nil, "")
+}
+\`\`\`
+
+See [Options](/sdk/options), [Callbacks](/sdk/callbacks), and [Sessions](/sdk/sessions) for more details.
+`},{id:"sdk/sessions",title:"SDK Sessions",content:`
+# SDK Sessions
+
+## Automatic persistence
+
+By default, Kit automatically persists sessions to JSONL files. Multi-turn conversations retain context across calls:
+
+\`\`\`go
+host.Prompt(ctx, "My name is Alice")
+response, _ := host.Prompt(ctx, "What's my name?")
+// response: "Your name is Alice"
+\`\`\`
+
+## Accessing session info
+
+\`\`\`go
+// Get the current session file path
+path := host.GetSessionPath()
+
+// Get the session ID
+id := host.GetSessionID()
+
+// Get the current model string
+model := host.GetModelString()
+\`\`\`
+
+## Configuring sessions via Options
+
+Session behavior is configured at initialization:
+
+\`\`\`go
+// Open a specific session file
+host, _ := kit.New(ctx, &kit.Options{
+ SessionPath: "./my-session.jsonl",
+})
+
+// Resume the most recent session for the current directory
+host, _ := kit.New(ctx, &kit.Options{
+ Continue: true,
+})
+
+// Ephemeral mode (no file persistence)
+host, _ := kit.New(ctx, &kit.Options{
+ NoSession: true,
+})
+
+// Custom session directory
+host, _ := kit.New(ctx, &kit.Options{
+ SessionDir: "/custom/sessions/",
+})
+\`\`\`
+
+## Clearing history
+
+Clear the in-memory conversation history (does not delete the session file):
+
+\`\`\`go
+host.ClearSession()
+\`\`\`
+
+## Tree-based sessions
+
+Kit's session model is tree-based, supporting branching. You can branch from any entry to explore alternate conversation paths:
+
+\`\`\`go
+// Access the tree session manager
+ts := host.GetTreeSession()
+
+// Branch from a specific entry
+err := host.Branch("entry-id-123")
+\`\`\`
+
+## Listing and managing sessions
+
+Package-level functions for session discovery:
+
+\`\`\`go
+// List sessions for a specific directory
+sessions := kit.ListSessions("/home/user/project")
+
+// List all sessions across all directories
+all := kit.ListAllSessions()
+
+// Delete a session file
+kit.DeleteSession("/path/to/session.jsonl")
+\`\`\`
+`},{id:"sessions",title:"Session Management",content:`
+# Session Management
+
+Kit uses a tree-based session model that supports branching and forking conversations.
+
+## Session storage
+
+Sessions are stored as JSONL (JSON Lines) files:
+
+\`\`\`
+~/.kit/sessions/
+Page not found
",pageComponent:d!=null&&d.isMdx?d.component:void 0,mdxComponents:eg,pageTitle:(d==null?void 0:d.frontmatter.title)||(v?"":"Not Found"),pageDescription:d==null?void 0:d.frontmatter.description,headings:(d==null?void 0:d.headings)||[],tocEnabled:(d==null?void 0:d.frontmatter.toc)!==!1,editUrl:bt,lastUpdated:K==null?void 0:K.lastUpdated,changelogEntries:d!=null&&d.isMdx||d==null?void 0:d.changelogEntries,apiManifest:!(d!=null&&d.isMdx)&&(d!=null&&d.isApiReference)?d.apiManifest:void 0,apiBaseUrl:(W=Jn.api)==null?void 0:W.baseUrl,apiPlayground:(I=Jn.api)==null?void 0:I.playground,apiAuth:(ct=Jn.api)==null?void 0:ct.auth,ApiReferenceComponent:N0,onNavigate:D,allPages:R,docContext:x0,versioning:void 0,currentVersion:nt,basePath:ko,isDraft:((Q=K==null?void 0:K.frontmatter)==null?void 0:Q.draft)===!0,dir:jt,i18n:void 0,currentLocale:Ot,overrides:b0})]})}const om=document.getElementById("tome-root");om&&wh.createRoot(om).render(s.jsx(ig,{})); diff --git a/assets/index-CGDazwHL.js b/assets/index-CGDazwHL.js new file mode 100644 index 00000000..355538b6 --- /dev/null +++ b/assets/index-CGDazwHL.js @@ -0,0 +1,75 @@ +const n={frontmatter:{title:"Kit",description:"Kit is a powerful, extensible AI coding agent CLI with multi-provider support, built-in tools, and a rich extension system.",hidden:!1,toc:!1,draft:!1},html:`
+
+
+
+A powerful, extensible AI coding agent CLI with multi-provider support, built-in tools, and a rich extension system.
+Features
+-
+
- Multi-Provider LLM Support — Anthropic, OpenAI, Google Gemini, Ollama, Azure OpenAI, AWS Bedrock, OpenRouter, and more +
- Built-in Core Tools — bash, read, write, edit, grep, find, ls, spawn_subagent with no MCP overhead +
- MCP Integration — Connect external MCP servers for expanded capabilities +
- Extension System — Write custom tools, commands, widgets, and UI modifications in Go +
- Interactive TUI — Rich terminal interface powered by Bubble Tea with streaming, syntax highlighting, and custom rendering +
- Session Management — Tree-based conversation history with branching support +
- Non-Interactive Mode — Script-friendly positional args with JSON output +
- ACP Server — Run Kit as an Agent Client Protocol agent over stdio +
- Go SDK — Embed Kit in your own applications +
Quick links
+| Resource | +Description | +
|---|---|
| Installation | +Get Kit up and running | +
| Quick Start | +Your first Kit session | +
| Configuration | +Customize Kit for your workflow | +
| Extensions | +Build custom tools and UI components | +
| Go SDK | +Embed Kit in your applications | +
+
+
+
+A powerful, extensible AI coding agent CLI with multi-provider support, built-in tools, and a rich extension system.
+
+## Features
+
+- **Multi-Provider LLM Support** — Anthropic, OpenAI, Google Gemini, Ollama, Azure OpenAI, AWS Bedrock, OpenRouter, and more
+- **Built-in Core Tools** — bash, read, write, edit, grep, find, ls, spawn_subagent with no MCP overhead
+- **MCP Integration** — Connect external MCP servers for expanded capabilities
+- **Extension System** — Write custom tools, commands, widgets, and UI modifications in Go
+- **Interactive TUI** — Rich terminal interface powered by Bubble Tea with streaming, syntax highlighting, and custom rendering
+- **Session Management** — Tree-based conversation history with branching support
+- **Non-Interactive Mode** — Script-friendly positional args with JSON output
+- **ACP Server** — Run Kit as an [Agent Client Protocol](https://agentclientprotocol.com) agent over stdio
+- **Go SDK** — Embed Kit in your own applications
+
+## Quick links
+
+| Resource | Description |
+|----------|-------------|
+| [Installation](/installation) | Get Kit up and running |
+| [Quick Start](/quick-start) | Your first Kit session |
+| [Configuration](/configuration) | Customize Kit for your workflow |
+| [Extensions](/extensions/overview) | Build custom tools and UI components |
+| [Go SDK](/sdk/overview) | Embed Kit in your applications |
+`};export{n as default};
diff --git a/assets/index-Di_r5hA0.css b/assets/index-Di_r5hA0.css
new file mode 100644
index 00000000..1baabe9f
--- /dev/null
+++ b/assets/index-Di_r5hA0.css
@@ -0,0 +1 @@
+:root,:root[data-theme=dark],:root[data-theme=light],html,html[data-theme=dark],#tome-root,#tome-root *,[data-theme],body,div{--bg: #08080a !important;--sf: #0e0e12 !important;--sfH: #141418 !important;--bd: #1a1a22 !important;--tx: #e8e0e0 !important;--tx2: #8a8090 !important;--txM: #6a6070 !important;--ac: #e03030 !important;--acD: rgba(224, 48, 48, .12) !important;--acT: #ff4444 !important;--cdBg: #0a0a0e !important;--cdTx: #c8a0a0 !important;--sbBg: #0a0a0d !important;--hdBg: rgba(8, 8, 10, .92) !important}h1,h2,h3,h4,h5,h6{color:#e8e0e0!important;font-style:normal!important}
diff --git a/assets/installation-DaBrcZPn.js b/assets/installation-DaBrcZPn.js
new file mode 100644
index 00000000..45e06904
--- /dev/null
+++ b/assets/installation-DaBrcZPn.js
@@ -0,0 +1,78 @@
+const n={frontmatter:{title:"Installation",description:"Install Kit using npm, Go, or build from source.",hidden:!1,toc:!0,draft:!1},html:`
+Installation
+Using npm (recommended)
+npm install -g @mark3labs/kitUsing Go
+go install github.com/mark3labs/kit/cmd/kit@latestBuilding from source
+git clone https://github.com/mark3labs/kit.git
+cd kit
+go build -o kit ./cmd/kitVerifying the installation
+After installing, verify Kit is available:
+kit --helpSetting up a provider
+Kit needs at least one LLM provider configured. Set an API key for your preferred provider:
+# Anthropic (default provider)
+export ANTHROPIC_API_KEY="sk-..."
+
+# OpenAI
+export OPENAI_API_KEY="sk-..."
+
+# Google Gemini
+export GOOGLE_API_KEY="..."For OAuth-enabled providers like Anthropic, you can also authenticate interactively:
+kit auth login anthropicSee Providers for the full list of supported providers and their configuration.
`,headings:[{depth:2,text:"Using npm (recommended)",id:"using-npm-recommended"},{depth:2,text:"Using Go",id:"using-go"},{depth:2,text:"Building from source",id:"building-from-source"},{depth:2,text:"Verifying the installation",id:"verifying-the-installation"},{depth:2,text:"Setting up a provider",id:"setting-up-a-provider"}],raw:` +# Installation + +## Using npm (recommended) + +\`\`\`bash +npm install -g @mark3labs/kit +\`\`\` + +## Using Go + +\`\`\`bash +go install github.com/mark3labs/kit/cmd/kit@latest +\`\`\` + +## Building from source + +\`\`\`bash +git clone https://github.com/mark3labs/kit.git +cd kit +go build -o kit ./cmd/kit +\`\`\` + +## Verifying the installation + +After installing, verify Kit is available: + +\`\`\`bash +kit --help +\`\`\` + +## Setting up a provider + +Kit needs at least one LLM provider configured. Set an API key for your preferred provider: + +\`\`\`bash +# Anthropic (default provider) +export ANTHROPIC_API_KEY="sk-..." + +# OpenAI +export OPENAI_API_KEY="sk-..." + +# Google Gemini +export GOOGLE_API_KEY="..." +\`\`\` + +For OAuth-enabled providers like Anthropic, you can also authenticate interactively: + +\`\`\`bash +kit auth login anthropic +\`\`\` + +See [Providers](/providers) for the full list of supported providers and their configuration. +`};export{n as default}; diff --git a/assets/json-output-B1QZabVS.js b/assets/json-output-B1QZabVS.js new file mode 100644 index 00000000..afb88fcf --- /dev/null +++ b/assets/json-output-B1QZabVS.js @@ -0,0 +1,240 @@ +const s={frontmatter:{title:"JSON Output",description:"Machine-readable JSON output for scripting and automation.",hidden:!1,toc:!0,draft:!1},html:`JSON Output
+Use the --json flag to get structured output for scripting and automation:
kit "Explain main.go" --json --quiet --no-sessionResponse format
+{
+ "response": "Final assistant response text",
+ "model": "anthropic/claude-haiku-3-5-20241022",
+ "stop_reason": "end_turn",
+ "session_id": "a1b2c3d4e5f6",
+ "usage": {
+ "input_tokens": 1024,
+ "output_tokens": 512,
+ "total_tokens": 1536,
+ "cache_read_tokens": 0,
+ "cache_creation_tokens": 0
+ },
+ "messages": [
+ {
+ "role": "assistant",
+ "parts": [
+ {"type": "text", "data": "..."},
+ {"type": "tool_call", "data": {"name": "...", "args": "..."}},
+ {"type": "tool_result", "data": {"name": "...", "result": "..."}}
+ ]
+ }
+ ]
+}Fields
+Top-level
+| Field | +Type | +Description | +
|---|---|---|
response |
+string | +The final assistant response text | +
model |
+string | +The model that was used | +
stop_reason |
+string | +Why the model stopped (e.g., end_turn) |
+
session_id |
+string | +Session identifier (omitted in --no-session mode) |
+
usage |
+object | +Token usage statistics | +
messages |
+array | +Full conversation history | +
Usage
+| Field | +Type | +Description | +
|---|---|---|
input_tokens |
+int | +Tokens sent to the model | +
output_tokens |
+int | +Tokens generated by the model | +
total_tokens |
+int | +Sum of input and output tokens | +
cache_read_tokens |
+int | +Tokens read from prompt cache | +
cache_creation_tokens |
+int | +Tokens written to prompt cache | +
Message parts
+Each message contains a parts array with typed entries:
| Type | +Description | +
|---|---|
text |
+Assistant text content | +
tool_call |
+Tool invocation with name and args | +
tool_result |
+Tool execution result | +
reasoning |
+Extended thinking content | +
finish |
+End-of-turn marker | +
Parsing in scripts
+bash + jq
+result=$(kit "Count files" --json --quiet --no-session)
+response=$(echo "$result" | jq -r '.response')
+tokens=$(echo "$result" | jq '.usage.total_tokens')Go SDK
+For Go programs, use the SDK's PromptResult method instead of parsing JSON:
result, err := host.PromptResult(ctx, "Count files")
+fmt.Println(result.Response)
+fmt.Println(result.Usage.TotalTokens)Loading Extensions
+Auto-discovery
+Kit automatically discovers and loads extensions from these paths, in order:
+| Path | +Scope | +
|---|---|
~/.config/kit/extensions/*.go |
+Global single files | +
~/.config/kit/extensions/*/main.go |
+Global subdirectory extensions | +
.kit/extensions/*.go |
+Project-local single files | +
.kit/extensions/*/main.go |
+Project-local subdirectory extensions | +
~/.local/share/kit/git/ |
+Global git-installed packages | +
.kit/git/ |
+Project-local git-installed packages | +
Explicit loading
+Load extensions by path using the -e flag:
kit -e path/to/extension.goLoad multiple extensions:
+kit -e ext1.go -e ext2.goDisabling extensions
+Disable all auto-discovered extensions:
+kit --no-extensionsYou can combine --no-extensions with -e to load only specific extensions:
kit --no-extensions -e my-extension.goInstalling from git
+Install extensions from git repositories using kit install:
# Install globally (to ~/.local/share/kit/git/)
+kit install https://github.com/user/my-kit-extension.git
+
+# Install project-locally (to .kit/git/)
+kit install -l https://github.com/user/my-kit-extension.git
+
+# Update an installed package
+kit install -u https://github.com/user/my-kit-extension.git
+
+# Remove
+kit install --uninstall my-kit-extensionExtension structure
+Single-file extensions
+A single .go file with an Init function:
//go:build ignore
+
+package main
+
+import "kit/ext"
+
+func Init(api ext.API) {
+ // register handlers, tools, commands, etc.
+}The //go:build ignore directive prevents the Go toolchain from trying to compile the file as part of a normal build.
Subdirectory extensions
+For more complex extensions, create a directory with a main.go entry point:
.kit/extensions/my-extension/
+├── main.go # Must contain Init(api ext.API)
+├── helpers.go # Additional source files
+└── config.go
+Package-level state
+Yaegi supports package-level variables captured in closures. This is the standard way to maintain state across event callbacks:
+package main
+
+import "kit/ext"
+
+var callCount int
+
+func Init(api ext.API) {
+ api.OnToolCall(func(_ ext.ToolCallEvent, ctx ext.Context) {
+ callCount++
+ ctx.SetFooter(ext.HeaderFooterConfig{
+ Content: ext.WidgetContent{
+ Text: fmt.Sprintf("Tools called: %d", callCount),
+ },
+ })
+ })
+}SDK Options
+Pass an Options struct to kit.New() to configure the Kit instance.
Full options reference
+host, err := kit.New(ctx, &kit.Options{
+ // Model
+ Model: "ollama/llama3",
+ SystemPrompt: "You are a helpful bot",
+ ConfigFile: "/path/to/config.yml",
+
+ // Behavior
+ MaxSteps: 10,
+ Streaming: true,
+ Quiet: true,
+ Debug: true,
+
+ // Session
+ SessionPath: "./session.jsonl",
+ SessionDir: "/custom/sessions/",
+ Continue: true,
+ NoSession: true,
+
+ // Tools
+ Tools: []kit.Tool{...}, // Replace default tool set entirely
+ ExtraTools: []kit.Tool{...}, // Add tools alongside defaults
+
+ // Compaction
+ AutoCompact: true,
+
+ // Skills
+ Skills: []string{"/path/to/skill.md"},
+ SkillsDir: "/path/to/skills/",
+})Options fields
+| Field | +Type | +Default | +Description | +
|---|---|---|---|
Model |
+string |
+config default | +Model string (provider/model format) | +
SystemPrompt |
+string |
+— | +System prompt text or file path | +
ConfigFile |
+string |
+~/.kit.yml |
+Path to config file | +
MaxSteps |
+int |
+0 |
+Max agent steps (0 = unlimited) | +
Streaming |
+bool |
+true |
+Enable streaming output | +
Quiet |
+bool |
+false |
+Suppress output | +
Debug |
+bool |
+false |
+Enable debug logging | +
SessionPath |
+string |
+— | +Open a specific session file | +
SessionDir |
+string |
+— | +Base directory for session discovery | +
Continue |
+bool |
+false |
+Resume most recent session | +
NoSession |
+bool |
+false |
+Ephemeral mode (no persistence) | +
Tools |
+[]Tool |
+— | +Replace the entire default tool set | +
ExtraTools |
+[]Tool |
+— | +Additional tools alongside core/MCP/extension tools | +
AutoCompact |
+bool |
+false |
+Auto-compact when near context limit | +
CompactionOptions |
+*CompactionOptions |
+— | +Configuration for auto-compaction | +
Skills |
+[]string |
+— | +Explicit skill files/dirs to load | +
SkillsDir |
+string |
+— | +Override default skills directory | +
Extension System
+Extensions are Go source files interpreted at runtime via Yaegi. They can add custom tools, slash commands, widgets, keyboard shortcuts, and intercept lifecycle events — all without recompiling Kit.
+Minimal extension
+//go:build ignore
+
+package main
+
+import "kit/ext"
+
+func Init(api ext.API) {
+ api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {
+ ctx.SetFooter(ext.HeaderFooterConfig{
+ Content: ext.WidgetContent{Text: "Custom Footer"},
+ })
+ })
+}Run it with:
+kit -e examples/extensions/minimal.goHow extensions work
+-
+
- Kit discovers extension files from auto-discovery paths or explicit
-eflags
+ - Each
.gofile is loaded into a Yaegi interpreter with access to thekit/extpackage
+ - Kit calls the
Init(api ext.API)function in each extension
+ - The extension registers callbacks, tools, commands, and UI components via the
apiandctxobjects
+
Key concepts
+The API object
+Passed to Init(), the API object is used to register lifecycle event handlers and static components:
-
+
- Lifecycle handlers —
api.OnSessionStart(...),api.OnToolCall(...), etc.
+ - Tools —
api.RegisterTool(ext.ToolDef{...})
+ - Commands —
api.RegisterCommand(ext.CommandDef{...})
+ - Shortcuts —
api.RegisterShortcut(ext.ShortcutDef{...}, handler)
+ - Tool renderers —
api.RegisterToolRenderer(ext.ToolRenderConfig{...})
+ - Message renderers —
api.RegisterMessageRenderer(ext.MessageRendererConfig{...})
+ - Options —
api.RegisterOption(ext.OptionDef{...})
+
The Context object
+Passed to event handlers, the Context object provides runtime access to Kit's state and UI:
-
+
- Output —
ctx.Print(...),ctx.PrintInfo(...),ctx.PrintError(...)
+ - UI components —
ctx.SetWidget(...),ctx.SetHeader(...),ctx.SetFooter(...),ctx.SetStatus(...)
+ - Editor —
ctx.SetEditor(...),ctx.ResetEditor()
+ - Prompts —
ctx.PromptSelect(...),ctx.PromptConfirm(...),ctx.PromptInput(...)
+ - Overlays —
ctx.ShowOverlay(...)
+ - Messages —
ctx.SendMessage(...),ctx.GetMessages()
+ - Model —
ctx.SetModel(...),ctx.GetAvailableModels()
+ - Tools —
ctx.GetAllTools(),ctx.SetActiveTools(...)
+ - Context stats —
ctx.GetContextStats()
+ - Session data —
ctx.AppendEntry(...),ctx.GetEntries(...)
+ - Subagents —
ctx.SpawnSubagent(...)
+ - LLM completion —
ctx.Complete(...)
+ - Custom events —
ctx.EmitCustomEvent(...)
+ - App control —
ctx.Exit(),ctx.ReloadExtensions()
+
See Capabilities for full details on each component type.
`,headings:[{depth:2,text:"Minimal extension",id:"minimal-extension"},{depth:2,text:"How extensions work",id:"how-extensions-work"},{depth:2,text:"Key concepts",id:"key-concepts"},{depth:3,text:"The API object",id:"the-api-object"},{depth:3,text:"The Context object",id:"the-context-object"}],raw:'\n# Extension System\n\nExtensions are Go source files interpreted at runtime via [Yaegi](https://github.com/traefik/yaegi). They can add custom tools, slash commands, widgets, keyboard shortcuts, and intercept lifecycle events — all without recompiling Kit.\n\n## Minimal extension\n\n```go\n//go:build ignore\n\npackage main\n\nimport "kit/ext"\n\nfunc Init(api ext.API) {\n api.OnSessionStart(func(_ ext.SessionStartEvent, ctx ext.Context) {\n ctx.SetFooter(ext.HeaderFooterConfig{\n Content: ext.WidgetContent{Text: "Custom Footer"},\n })\n })\n}\n```\n\nRun it with:\n\n```bash\nkit -e examples/extensions/minimal.go\n```\n\n## How extensions work\n\n1. Kit discovers extension files from [auto-discovery paths](/extensions/loading) or explicit `-e` flags\n2. Each `.go` file is loaded into a Yaegi interpreter with access to the `kit/ext` package\n3. Kit calls the `Init(api ext.API)` function in each extension\n4. The extension registers callbacks, tools, commands, and UI components via the `api` and `ctx` objects\n\n## Key concepts\n\n### The `API` object\n\nPassed to `Init()`, the `API` object is used to register lifecycle event handlers and static components:\n\n- **Lifecycle handlers** — `api.OnSessionStart(...)`, `api.OnToolCall(...)`, etc.\n- **Tools** — `api.RegisterTool(ext.ToolDef{...})`\n- **Commands** — `api.RegisterCommand(ext.CommandDef{...})`\n- **Shortcuts** — `api.RegisterShortcut(ext.ShortcutDef{...}, handler)`\n- **Tool renderers** — `api.RegisterToolRenderer(ext.ToolRenderConfig{...})`\n- **Message renderers** — `api.RegisterMessageRenderer(ext.MessageRendererConfig{...})`\n- **Options** — `api.RegisterOption(ext.OptionDef{...})`\n\n### The `Context` object\n\nPassed to event handlers, the `Context` object provides runtime access to Kit\'s state and UI:\n\n- **Output** — `ctx.Print(...)`, `ctx.PrintInfo(...)`, `ctx.PrintError(...)`\n- **UI components** — `ctx.SetWidget(...)`, `ctx.SetHeader(...)`, `ctx.SetFooter(...)`, `ctx.SetStatus(...)`\n- **Editor** — `ctx.SetEditor(...)`, `ctx.ResetEditor()`\n- **Prompts** — `ctx.PromptSelect(...)`, `ctx.PromptConfirm(...)`, `ctx.PromptInput(...)`\n- **Overlays** — `ctx.ShowOverlay(...)`\n- **Messages** — `ctx.SendMessage(...)`, `ctx.GetMessages()`\n- **Model** — `ctx.SetModel(...)`, `ctx.GetAvailableModels()`\n- **Tools** — `ctx.GetAllTools()`, `ctx.SetActiveTools(...)`\n- **Context stats** — `ctx.GetContextStats()`\n- **Session data** — `ctx.AppendEntry(...)`, `ctx.GetEntries(...)`\n- **Subagents** — `ctx.SpawnSubagent(...)`\n- **LLM completion** — `ctx.Complete(...)`\n- **Custom events** — `ctx.EmitCustomEvent(...)`\n- **App control** — `ctx.Exit()`, `ctx.ReloadExtensions()`\n\nSee [Capabilities](/extensions/capabilities) for full details on each component type.\n'};export{e as default}; diff --git a/assets/overview-DbvqPNef.js b/assets/overview-DbvqPNef.js new file mode 100644 index 00000000..2e1889ad --- /dev/null +++ b/assets/overview-DbvqPNef.js @@ -0,0 +1,215 @@ +const s={frontmatter:{title:"Go SDK",description:"Embed Kit in your Go applications.",hidden:!1,toc:!0,draft:!1},html:`Go SDK
+The pkg/kit package lets you embed Kit as a library in your Go applications.
Installation
+go get github.com/mark3labs/kit/pkg/kitBasic usage
+package main
+
+import (
+ "context"
+ "log"
+
+ kit "github.com/mark3labs/kit/pkg/kit"
+)
+
+func main() {
+ ctx := context.Background()
+
+ // Create Kit instance with default configuration
+ host, err := kit.New(ctx, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer host.Close()
+
+ // Send a prompt
+ response, err := host.Prompt(ctx, "What is 2+2?")
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ println(response)
+}Multi-turn conversations
+Conversations retain context automatically across calls:
+host.Prompt(ctx, "My name is Alice")
+response, _ := host.Prompt(ctx, "What's my name?")
+// response: "Your name is Alice"Additional prompt methods
+The SDK provides several prompt variants:
+| Method | +Description | +
|---|---|
Prompt(ctx, message) |
+Simple prompt, returns response string | +
PromptWithCallbacks(ctx, message, ...) |
+With tool call and streaming callbacks | +
PromptWithOptions(ctx, message, opts) |
+With per-call options | +
PromptResult(ctx, message) |
+Returns full TurnResult with usage stats |
+
PromptResultWithFiles(ctx, message, files) |
+Multimodal with file attachments | +
Steer(ctx, instruction) |
+System-level steering without user message | +
FollowUp(ctx, text) |
+Continue without new user input | +
Event system
+Subscribe to events for monitoring:
+unsubscribe := host.OnToolCall(func(event kit.ToolCallEvent) {
+ fmt.Println("Tool called:", event.Name)
+})
+defer unsubscribe()
+
+host.OnToolResult(func(event kit.ToolResultEvent) {
+ fmt.Println("Tool result:", event.Name)
+})
+
+host.OnStreaming(func(event kit.MessageUpdateEvent) {
+ fmt.Print(event.Chunk)
+})Model management
+Switch models at runtime:
+host.SetModel(ctx, "openai/gpt-4o")
+info := host.GetModelInfo()
+models := host.GetAvailableModels()Context and compaction
+Monitor and manage context usage:
+tokens := host.EstimateContextTokens()
+stats := host.GetContextStats()
+
+if host.ShouldCompact() {
+ result, err := host.Compact(ctx, nil, "")
+}See Options, Callbacks, and Sessions for more details.
`,headings:[{depth:2,text:"Installation",id:"installation"},{depth:2,text:"Basic usage",id:"basic-usage"},{depth:2,text:"Multi-turn conversations",id:"multi-turn-conversations"},{depth:2,text:"Additional prompt methods",id:"additional-prompt-methods"},{depth:2,text:"Event system",id:"event-system"},{depth:2,text:"Model management",id:"model-management"},{depth:2,text:"Context and compaction",id:"context-and-compaction"}],raw:` +# Go SDK + +The \`pkg/kit\` package lets you embed Kit as a library in your Go applications. + +## Installation + +\`\`\`bash +go get github.com/mark3labs/kit/pkg/kit +\`\`\` + +## Basic usage + +\`\`\`go +package main + +import ( + "context" + "log" + + kit "github.com/mark3labs/kit/pkg/kit" +) + +func main() { + ctx := context.Background() + + // Create Kit instance with default configuration + host, err := kit.New(ctx, nil) + if err != nil { + log.Fatal(err) + } + defer host.Close() + + // Send a prompt + response, err := host.Prompt(ctx, "What is 2+2?") + if err != nil { + log.Fatal(err) + } + + println(response) +} +\`\`\` + +## Multi-turn conversations + +Conversations retain context automatically across calls: + +\`\`\`go +host.Prompt(ctx, "My name is Alice") +response, _ := host.Prompt(ctx, "What's my name?") +// response: "Your name is Alice" +\`\`\` + +## Additional prompt methods + +The SDK provides several prompt variants: + +| Method | Description | +|--------|-------------| +| \`Prompt(ctx, message)\` | Simple prompt, returns response string | +| \`PromptWithCallbacks(ctx, message, ...)\` | With tool call and streaming callbacks | +| \`PromptWithOptions(ctx, message, opts)\` | With per-call options | +| \`PromptResult(ctx, message)\` | Returns full \`TurnResult\` with usage stats | +| \`PromptResultWithFiles(ctx, message, files)\` | Multimodal with file attachments | +| \`Steer(ctx, instruction)\` | System-level steering without user message | +| \`FollowUp(ctx, text)\` | Continue without new user input | + +## Event system + +Subscribe to events for monitoring: + +\`\`\`go +unsubscribe := host.OnToolCall(func(event kit.ToolCallEvent) { + fmt.Println("Tool called:", event.Name) +}) +defer unsubscribe() + +host.OnToolResult(func(event kit.ToolResultEvent) { + fmt.Println("Tool result:", event.Name) +}) + +host.OnStreaming(func(event kit.MessageUpdateEvent) { + fmt.Print(event.Chunk) +}) +\`\`\` + +## Model management + +Switch models at runtime: + +\`\`\`go +host.SetModel(ctx, "openai/gpt-4o") +info := host.GetModelInfo() +models := host.GetAvailableModels() +\`\`\` + +## Context and compaction + +Monitor and manage context usage: + +\`\`\`go +tokens := host.EstimateContextTokens() +stats := host.GetContextStats() + +if host.ShouldCompact() { + result, err := host.Compact(ctx, nil, "") +} +\`\`\` + +See [Options](/sdk/options), [Callbacks](/sdk/callbacks), and [Sessions](/sdk/sessions) for more details. +`};export{s as default}; diff --git a/assets/providers-B05lw6S_.js b/assets/providers-B05lw6S_.js new file mode 100644 index 00000000..36fccfcb --- /dev/null +++ b/assets/providers-B05lw6S_.js @@ -0,0 +1,224 @@ +const s={frontmatter:{title:"Providers",description:"Supported LLM providers and model configuration.",hidden:!1,toc:!0,draft:!1},html:`Providers
+Kit supports a wide range of LLM providers through a unified provider/model string format.
Supported providers
+| Provider | +Prefix | +Description | +
|---|---|---|
| Anthropic | +anthropic/ |
+Claude models (native, prompt caching, OAuth) | +
| OpenAI | +openai/ |
+GPT models | +
google/ or gemini/ |
+Gemini models | +|
| Ollama | +ollama/ |
+Local models | +
| Azure OpenAI | +azure/ |
+Azure-hosted OpenAI | +
| AWS Bedrock | +bedrock/ |
+Bedrock models | +
| Google Vertex | +google-vertex-anthropic/ |
+Claude on Vertex AI | +
| OpenRouter | +openrouter/ |
+Multi-provider router | +
| Vercel AI | +vercel/ |
+Vercel AI SDK models | +
| Auto-routed | +any | +Any provider from the models.dev database | +
Model string format
+provider/model # Standard format
+anthropic/claude-sonnet-4-5-20250929
+openai/gpt-4o
+ollama/llama3
+google/gemini-2.0-flash-expModel aliases
+Kit provides aliases for commonly used models:
+claude-opus-latest → claude-opus-4-20250514
+claude-sonnet-latest → claude-sonnet-4-5-20250929
+claude-4-opus-latest → claude-opus-4-20250514
+claude-4-sonnet-latest → claude-sonnet-4-5-20250929
+claude-3-7-sonnet-latest → claude-3-7-sonnet-20250219
+claude-3-5-sonnet-latest → claude-3-5-sonnet-20241022
+claude-3-5-haiku-latest → claude-3-5-haiku-20241022
+claude-3-opus-latest → claude-3-opus-20240229Specifying a model
+Via CLI flag:
+kit --model openai/gpt-4o
+kit -m ollama/llama3Via config file:
+model: anthropic/claude-sonnet-4-5-20250929Via environment variable:
+export KIT_MODEL="google/gemini-2.0-flash-exp"Authentication
+API keys
+Set the appropriate environment variable for your provider:
+export ANTHROPIC_API_KEY="sk-..."
+export OPENAI_API_KEY="sk-..."
+export GOOGLE_API_KEY="..."Or pass it directly:
+kit --provider-api-key "sk-..." --model openai/gpt-4oOAuth
+For providers that support OAuth (e.g., Anthropic):
+kit auth login anthropic # Start OAuth flow
+kit auth status # Check authentication status
+kit auth logout anthropic # Remove credentialsCustom provider URL
+For self-hosted or proxy endpoints:
+kit --provider-url "https://my-proxy.example.com/v1" --model openai/gpt-4oModel database
+Kit ships with a local model database that maps provider names to API configurations. You can manage it with:
+kit models # List available models
+kit models openai # Filter by provider
+kit models --all # Show all providers
+kit update-models # Update from models.dev
+kit update-models embedded # Reset to bundled databaseQuick Start
+Basic usage
+Start an interactive session:
+kitRun a one-off prompt:
+kit "List files in src/"Attach files as context using the @ prefix:
kit @main.go @test.go "Review these files"Use a specific model:
+kit --model anthropic/claude-sonnet-4-5-20250929Non-interactive mode
+Kit can run as a non-interactive tool for scripting and automation.
+Get JSON output:
+kit "Explain main.go" --jsonQuiet mode (final response only, no TUI):
+kit "Run tests" --quietEphemeral mode (no session file created):
+kit "Quick question" --no-sessionResuming sessions
+Continue the most recent session for the current directory:
+kit --continue
+# or
+kit -cPick from previous sessions interactively:
+kit --resume
+# or
+kit -rACP server mode
+Kit can run as an ACP (Agent Client Protocol) agent server, enabling ACP-compatible clients (such as OpenCode) to drive Kit as a remote coding agent over stdio:
+# Start Kit as an ACP server (JSON-RPC 2.0 on stdin/stdout)
+kit acp
+
+# With debug logging to stderr
+kit acp --debugThe ACP server exposes Kit's full capabilities — LLM execution, tool calls (bash, read, write, edit, grep, etc.), and session persistence — over the standard ACP protocol.
`,headings:[{depth:2,text:"Basic usage",id:"basic-usage"},{depth:2,text:"Non-interactive mode",id:"non-interactive-mode"},{depth:2,text:"Resuming sessions",id:"resuming-sessions"},{depth:2,text:"ACP server mode",id:"acp-server-mode"}],raw:` +# Quick Start + +## Basic usage + +Start an interactive session: + +\`\`\`bash +kit +\`\`\` + +Run a one-off prompt: + +\`\`\`bash +kit "List files in src/" +\`\`\` + +Attach files as context using the \`@\` prefix: + +\`\`\`bash +kit @main.go @test.go "Review these files" +\`\`\` + +Use a specific model: + +\`\`\`bash +kit --model anthropic/claude-sonnet-4-5-20250929 +\`\`\` + +## Non-interactive mode + +Kit can run as a non-interactive tool for scripting and automation. + +Get JSON output: + +\`\`\`bash +kit "Explain main.go" --json +\`\`\` + +Quiet mode (final response only, no TUI): + +\`\`\`bash +kit "Run tests" --quiet +\`\`\` + +Ephemeral mode (no session file created): + +\`\`\`bash +kit "Quick question" --no-session +\`\`\` + +## Resuming sessions + +Continue the most recent session for the current directory: + +\`\`\`bash +kit --continue +# or +kit -c +\`\`\` + +Pick from previous sessions interactively: + +\`\`\`bash +kit --resume +# or +kit -r +\`\`\` + +## ACP server mode + +Kit can run as an [ACP (Agent Client Protocol)](https://agentclientprotocol.com) agent server, enabling ACP-compatible clients (such as [OpenCode](https://github.com/sst/opencode)) to drive Kit as a remote coding agent over stdio: + +\`\`\`bash +# Start Kit as an ACP server (JSON-RPC 2.0 on stdin/stdout) +kit acp + +# With debug logging to stderr +kit acp --debug +\`\`\` + +The ACP server exposes Kit's full capabilities — LLM execution, tool calls (bash, read, write, edit, grep, etc.), and session persistence — over the standard ACP protocol. +`};export{s as default}; diff --git a/assets/sessions-BM7WkgkF.js b/assets/sessions-BM7WkgkF.js new file mode 100644 index 00000000..c7562295 --- /dev/null +++ b/assets/sessions-BM7WkgkF.js @@ -0,0 +1,77 @@ +const s={frontmatter:{title:"Session Management",description:"How Kit persists and manages conversation sessions.",hidden:!1,toc:!0,draft:!1},html:`Session Management
+Kit uses a tree-based session model that supports branching and forking conversations.
+Session storage
+Sessions are stored as JSONL (JSON Lines) files:
+~/.kit/sessions/<cwd-path>/<timestamp>_<id>.jsonl
+Path separators in the working directory are replaced with --. For example, /home/user/project becomes home--user--project.
Each line in the session file is a JSON entry representing a message, tool call, model change, or extension data. The tree structure allows branching from any message to explore alternate paths.
+Resuming sessions
+Continue most recent
+Resume the most recent session for the current directory:
+kit --continue
+kit -cInteractive picker
+Choose from previous sessions interactively:
+kit --resume
+kit -rOpen a specific session
+kit --session path/to/session.jsonl
+kit -s path/to/session.jsonlEphemeral mode
+Run without creating a session file:
+kit --no-sessionThis is useful for one-off prompts, scripting, and subagent patterns where persistence isn't needed.
`,headings:[{depth:2,text:"Session storage",id:"session-storage"},{depth:2,text:"Resuming sessions",id:"resuming-sessions"},{depth:3,text:"Continue most recent",id:"continue-most-recent"},{depth:3,text:"Interactive picker",id:"interactive-picker"},{depth:3,text:"Open a specific session",id:"open-a-specific-session"},{depth:2,text:"Ephemeral mode",id:"ephemeral-mode"}],raw:` +# Session Management + +Kit uses a tree-based session model that supports branching and forking conversations. + +## Session storage + +Sessions are stored as JSONL (JSON Lines) files: + +\`\`\` +~/.kit/sessions/SDK Sessions
+Automatic persistence
+By default, Kit automatically persists sessions to JSONL files. Multi-turn conversations retain context across calls:
+host.Prompt(ctx, "My name is Alice")
+response, _ := host.Prompt(ctx, "What's my name?")
+// response: "Your name is Alice"Accessing session info
+// Get the current session file path
+path := host.GetSessionPath()
+
+// Get the session ID
+id := host.GetSessionID()
+
+// Get the current model string
+model := host.GetModelString()Configuring sessions via Options
+Session behavior is configured at initialization:
+// Open a specific session file
+host, _ := kit.New(ctx, &kit.Options{
+ SessionPath: "./my-session.jsonl",
+})
+
+// Resume the most recent session for the current directory
+host, _ := kit.New(ctx, &kit.Options{
+ Continue: true,
+})
+
+// Ephemeral mode (no file persistence)
+host, _ := kit.New(ctx, &kit.Options{
+ NoSession: true,
+})
+
+// Custom session directory
+host, _ := kit.New(ctx, &kit.Options{
+ SessionDir: "/custom/sessions/",
+})Clearing history
+Clear the in-memory conversation history (does not delete the session file):
+host.ClearSession()Tree-based sessions
+Kit's session model is tree-based, supporting branching. You can branch from any entry to explore alternate conversation paths:
+// Access the tree session manager
+ts := host.GetTreeSession()
+
+// Branch from a specific entry
+err := host.Branch("entry-id-123")Listing and managing sessions
+Package-level functions for session discovery:
+// List sessions for a specific directory
+sessions := kit.ListSessions("/home/user/project")
+
+// List all sessions across all directories
+all := kit.ListAllSessions()
+
+// Delete a session file
+kit.DeleteSession("/path/to/session.jsonl")Subagents
+Kit supports multi-agent orchestration through both subprocess spawning and in-process subagents.
+Subprocess pattern
+Spawn Kit as a subprocess for isolated agent execution:
+kit "Analyze codebase" \\
+ --json \\
+ --no-session \\
+ --no-extensions \\
+ --quiet \\
+ --model anthropic/claude-haiku-3-5-20241022Key flags for subprocess usage:
+| Flag | +Purpose | +
|---|---|
--quiet |
+Stdout only, no TUI | +
--no-session |
+Ephemeral, no persistence | +
--no-extensions |
+Prevent recursive extension loading | +
--json |
+Machine-readable output | +
--system-prompt |
+Custom system prompt (string or file path) | +
Positional arguments are the prompt. @file arguments attach file content as context.
Built-in spawn_subagent tool
+Kit includes a built-in spawn_subagent tool that the LLM can use to delegate tasks to independent child agents:
spawn_subagent(
+ task: "Analyze the test files and summarize coverage",
+ model: "anthropic/claude-haiku-3-5-20241022", // optional
+ system_prompt: "You are a test analysis expert.", // optional
+ timeout_seconds: 300 // optional, max 1800
+)
+Subagents run as separate in-process Kit instances with full tool access (except spawning further subagents, to prevent infinite recursion). They can run in parallel.
+Extension subagents
+Extensions can spawn subagents programmatically:
+result := ctx.SpawnSubagent(ext.SubagentConfig{
+ Task: "Review this code for security issues",
+ Model: "anthropic/claude-sonnet-4-5-20250929",
+ SystemPrompt: "You are a security auditor.",
+})Go SDK subagents
+The SDK provides in-process subagent spawning:
+result, err := host.Subagent(ctx, kit.SubagentConfig{
+ Task: "Summarize the changes in this PR",
+ Model: "anthropic/claude-haiku-3-5-20241022",
+ SystemPrompt: "You are a code reviewer.",
+ Timeout: 5 * time.Minute,
+})Testing with tmux
+Kit's interactive TUI can be tested non-interactively using tmux. This is useful for automated testing, CI pipelines, and extension development.
+Basic pattern
+# Start Kit in a detached tmux session
+tmux new-session -d -s kittest -x 120 -y 40 \\
+ "output/kit -e ext.go --no-session 2>kit_stderr.log"
+
+# Wait for startup
+sleep 3
+
+# Capture the current screen
+tmux capture-pane -t kittest -p
+
+# Send input
+tmux send-keys -t kittest '/command' Enter
+
+# Wait for response
+sleep 2
+
+# Capture updated screen
+tmux capture-pane -t kittest -p
+
+# Cleanup
+tmux kill-session -t kittestTesting extensions
+When testing extensions, the pattern is:
+-
+
- Build Kit with your changes +
- Start Kit in tmux with the extension loaded +
- Send slash commands or prompts +
- Capture and verify the screen output +
- Check stderr logs for errors +
# Build first
+go build -o output/kit ./cmd/kit
+
+# Start with extension
+tmux new-session -d -s kittest -x 120 -y 40 \\
+ "output/kit -e examples/extensions/widget-status.go --no-session 2>kit_stderr.log"
+
+sleep 3
+
+# Verify widget appears in screen
+tmux capture-pane -t kittest -p | grep "Status"
+
+# Send a slash command
+tmux send-keys -t kittest '/stats' Enter
+sleep 1
+tmux capture-pane -t kittest -p
+
+# Cleanup
+tmux kill-session -t kittestTips
+-
+
- Use
-xand-yto set consistent terminal dimensions
+ - Redirect stderr to a log file (
2>kit.log) for debugging
+ - Use
--no-sessionto avoid creating session files during tests
+ - Add sufficient
sleepbetween commands for the TUI to render
+ - Use
grepon captured pane output to verify specific content
+
+
+
+
+A powerful, extensible AI coding agent CLI with multi-provider support, built-in tools, and a rich extension system.
+
+## Features
+
+- **Multi-Provider LLM Support** — Anthropic, OpenAI, Google Gemini, Ollama, Azure OpenAI, AWS Bedrock, OpenRouter, and more
+- **Built-in Core Tools** — bash, read, write, edit, grep, find, ls, spawn_subagent with no MCP overhead
+- **MCP Integration** — Connect external MCP servers for expanded capabilities
+- **Extension System** — Write custom tools, commands, widgets, and UI modifications in Go
+- **Interactive TUI** — Rich terminal interface powered by Bubble Tea with streaming, syntax highlighting, and custom rendering
+- **Session Management** — Tree-based conversation history with branching support
+- **Non-Interactive Mode** — Script-friendly positional args with JSON output
+- **ACP Server** — Run Kit as an [Agent Client Protocol](https://agentclientprotocol.com) agent over stdio
+- **Go SDK** — Embed Kit in your own applications
+
+## Quick links
+
+| Resource | Description |
+|----------|-------------|
+| [Installation](/installation) | Get Kit up and running |
+| [Quick Start](/quick-start) | Your first Kit session |
+| [Configuration](/configuration) | Customize Kit for your workflow |
+| [Extensions](/extensions/overview) | Build custom tools and UI components |
+| [Go SDK](/sdk/overview) | Embed Kit in your applications |
+
+---
+
+## Installation
+
+# Installation
+
+## Using npm (recommended)
+
+```bash
+npm install -g @mark3labs/kit
+```
+
+## Using Go
+
+```bash
+go install github.com/mark3labs/kit/cmd/kit@latest
+```
+
+## Building from source
+
+```bash
+git clone https://github.com/mark3labs/kit.git
+cd kit
+go build -o kit ./cmd/kit
+```
+
+## Verifying the installation
+
+After installing, verify Kit is available:
+
+```bash
+kit --help
+```
+
+## Setting up a provider
+
+Kit needs at least one LLM provider configured. Set an API key for your preferred provider:
+
+```bash
+# Anthropic (default provider)
+export ANTHROPIC_API_KEY="sk-..."
+
+# OpenAI
+export OPENAI_API_KEY="sk-..."
+
+# Google Gemini
+export GOOGLE_API_KEY="..."
+```
+
+For OAuth-enabled providers like Anthropic, you can also authenticate interactively:
+
+```bash
+kit auth login anthropic
+```
+
+See [Providers](/providers) for the full list of supported providers and their configuration.
+
+---
+
+## Providers
+
+# Providers
+
+Kit supports a wide range of LLM providers through a unified `provider/model` string format.
+
+## Supported providers
+
+| Provider | Prefix | Description |
+|----------|--------|-------------|
+| **Anthropic** | `anthropic/` | Claude models (native, prompt caching, OAuth) |
+| **OpenAI** | `openai/` | GPT models |
+| **Google** | `google/` or `gemini/` | Gemini models |
+| **Ollama** | `ollama/` | Local models |
+| **Azure OpenAI** | `azure/` | Azure-hosted OpenAI |
+| **AWS Bedrock** | `bedrock/` | Bedrock models |
+| **Google Vertex** | `google-vertex-anthropic/` | Claude on Vertex AI |
+| **OpenRouter** | `openrouter/` | Multi-provider router |
+| **Vercel AI** | `vercel/` | Vercel AI SDK models |
+| **Auto-routed** | any | Any provider from the models.dev database |
+
+## Model string format
+
+```bash
+provider/model # Standard format
+anthropic/claude-sonnet-4-5-20250929
+openai/gpt-4o
+ollama/llama3
+google/gemini-2.0-flash-exp
+```
+
+## Model aliases
+
+Kit provides aliases for commonly used models:
+
+```bash
+claude-opus-latest → claude-opus-4-20250514
+claude-sonnet-latest → claude-sonnet-4-5-20250929
+claude-4-opus-latest → claude-opus-4-20250514
+claude-4-sonnet-latest → claude-sonnet-4-5-20250929
+claude-3-7-sonnet-latest → claude-3-7-sonnet-20250219
+claude-3-5-sonnet-latest → claude-3-5-sonnet-20241022
+claude-3-5-haiku-latest → claude-3-5-haiku-20241022
+claude-3-opus-latest → claude-3-opus-20240229
+```
+
+## Specifying a model
+
+Via CLI flag:
+
+```bash
+kit --model openai/gpt-4o
+kit -m ollama/llama3
+```
+
+Via config file:
+
+```yaml
+model: anthropic/claude-sonnet-4-5-20250929
+```
+
+Via environment variable:
+
+```bash
+export KIT_MODEL="google/gemini-2.0-flash-exp"
+```
+
+## Authentication
+
+### API keys
+
+Set the appropriate environment variable for your provider:
+
+```bash
+export ANTHROPIC_API_KEY="sk-..."
+export OPENAI_API_KEY="sk-..."
+export GOOGLE_API_KEY="..."
+```
+
+Or pass it directly:
+
+```bash
+kit --provider-api-key "sk-..." --model openai/gpt-4o
+```
+
+### OAuth
+
+For providers that support OAuth (e.g., Anthropic):
+
+```bash
+kit auth login anthropic # Start OAuth flow
+kit auth status # Check authentication status
+kit auth logout anthropic # Remove credentials
+```
+
+### Custom provider URL
+
+For self-hosted or proxy endpoints:
+
+```bash
+kit --provider-url "https://my-proxy.example.com/v1" --model openai/gpt-4o
+```
+
+## Model database
+
+Kit ships with a local model database that maps provider names to API configurations. You can manage it with:
+
+```bash
+kit models # List available models
+kit models openai # Filter by provider
+kit models --all # Show all providers
+kit update-models # Update from models.dev
+kit update-models embedded # Reset to bundled database
+```
+
+---
+
+## Quick Start
+
+# Quick Start
+
+## Basic usage
+
+Start an interactive session:
+
+```bash
+kit
+```
+
+Run a one-off prompt:
+
+```bash
+kit "List files in src/"
+```
+
+Attach files as context using the `@` prefix:
+
+```bash
+kit @main.go @test.go "Review these files"
+```
+
+Use a specific model:
+
+```bash
+kit --model anthropic/claude-sonnet-4-5-20250929
+```
+
+## Non-interactive mode
+
+Kit can run as a non-interactive tool for scripting and automation.
+
+Get JSON output:
+
+```bash
+kit "Explain main.go" --json
+```
+
+Quiet mode (final response only, no TUI):
+
+```bash
+kit "Run tests" --quiet
+```
+
+Ephemeral mode (no session file created):
+
+```bash
+kit "Quick question" --no-session
+```
+
+## Resuming sessions
+
+Continue the most recent session for the current directory:
+
+```bash
+kit --continue
+# or
+kit -c
+```
+
+Pick from previous sessions interactively:
+
+```bash
+kit --resume
+# or
+kit -r
+```
+
+## ACP server mode
+
+Kit can run as an [ACP (Agent Client Protocol)](https://agentclientprotocol.com) agent server, enabling ACP-compatible clients (such as [OpenCode](https://github.com/sst/opencode)) to drive Kit as a remote coding agent over stdio:
+
+```bash
+# Start Kit as an ACP server (JSON-RPC 2.0 on stdin/stdout)
+kit acp
+
+# With debug logging to stderr
+kit acp --debug
+```
+
+The ACP server exposes Kit's full capabilities — LLM execution, tool calls (bash, read, write, edit, grep, etc.), and session persistence — over the standard ACP protocol.
+
+---
+
+## Callbacks
+
+# Callbacks
+
+## PromptWithCallbacks
+
+The `PromptWithCallbacks` method provides real-time visibility into tool calls and streaming output:
+
+```go
+response, err := host.PromptWithCallbacks(
+ ctx,
+ "List files in current directory",
+ func(name, args string) {
+ // Called when the model invokes a tool
+ fmt.Println("Calling tool:", name)
+ },
+ func(name, args, result string, isError bool) {
+ // Called when a tool returns its result
+ if isError {
+ fmt.Println("Tool failed:", name)
+ }
+ },
+ func(chunk string) {
+ // Called for each streaming text chunk
+ fmt.Print(chunk)
+ },
+)
+```
+
+### Callback signatures
+
+| Callback | Signature | When |
+|----------|-----------|------|
+| `onToolCall` | `func(name, args string)` | Model requests a tool call |
+| `onToolResult` | `func(name, args, result string, isError bool)` | Tool execution completes |
+| `onStreaming` | `func(chunk string)` | Streaming text chunk received |
+
+Any callback can be `nil` if you don't need it:
+
+```go
+// Only care about streaming output
+response, err := host.PromptWithCallbacks(ctx, "Hello", nil, nil, func(chunk string) {
+ fmt.Print(chunk)
+})
+```
+
+## Event-based monitoring
+
+For more granular control, use the event subscription API:
+
+```go
+// Subscribe returns an unsubscribe function
+unsub := host.OnToolCall(func(event kit.ToolCallEvent) {
+ fmt.Printf("Tool: %s, Args: %s\n", event.Name, event.Args)
+})
+defer unsub()
+
+unsub2 := host.OnToolResult(func(event kit.ToolResultEvent) {
+ fmt.Printf("Result: %s (error: %v)\n", event.Name, event.IsError)
+})
+defer unsub2()
+
+unsub3 := host.OnStreaming(func(event kit.MessageUpdateEvent) {
+ fmt.Print(event.Chunk)
+})
+defer unsub3()
+
+unsub4 := host.OnResponse(func(event kit.ResponseEvent) {
+ fmt.Println("Final response received")
+})
+defer unsub4()
+
+unsub5 := host.OnTurnStart(func(event kit.TurnStartEvent) {
+ fmt.Println("Turn started")
+})
+defer unsub5()
+
+unsub6 := host.OnTurnEnd(func(event kit.TurnEndEvent) {
+ fmt.Println("Turn ended")
+})
+defer unsub6()
+```
+
+## Hook system
+
+Hooks allow you to intercept and modify behavior. Unlike events, hooks can modify or cancel operations:
+
+```go
+// Intercept tool calls before execution
+host.OnBeforeToolCall(0, func(ctx context.Context, name string, args string) (string, error) {
+ if name == "bash" {
+ log.Println("Bash command:", args)
+ }
+ return args, nil // return modified args or error to cancel
+})
+
+// Process results after tool execution
+host.OnAfterToolResult(0, func(ctx context.Context, name string, result string) (string, error) {
+ return result, nil
+})
+
+// Before/after each agent turn
+host.OnBeforeTurn(0, func(ctx context.Context) error {
+ return nil
+})
+
+host.OnAfterTurn(0, func(ctx context.Context) error {
+ return nil
+})
+```
+
+The first argument is a priority (lower = runs first).
+
+---
+
+## SDK Options
+
+# SDK Options
+
+Pass an `Options` struct to `kit.New()` to configure the Kit instance.
+
+## Full options reference
+
+```go
+host, err := kit.New(ctx, &kit.Options{
+ // Model
+ Model: "ollama/llama3",
+ SystemPrompt: "You are a helpful bot",
+ ConfigFile: "/path/to/config.yml",
+
+ // Behavior
+ MaxSteps: 10,
+ Streaming: true,
+ Quiet: true,
+ Debug: true,
+
+ // Session
+ SessionPath: "./session.jsonl",
+ SessionDir: "/custom/sessions/",
+ Continue: true,
+ NoSession: true,
+
+ // Tools
+ Tools: []kit.Tool{...}, // Replace default tool set entirely
+ ExtraTools: []kit.Tool{...}, // Add tools alongside defaults
+
+ // Compaction
+ AutoCompact: true,
+
+ // Skills
+ Skills: []string{"/path/to/skill.md"},
+ SkillsDir: "/path/to/skills/",
+})
+```
+
+## Options fields
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `Model` | `string` | config default | Model string (provider/model format) |
+| `SystemPrompt` | `string` | — | System prompt text or file path |
+| `ConfigFile` | `string` | `~/.kit.yml` | Path to config file |
+| `MaxSteps` | `int` | `0` | Max agent steps (0 = unlimited) |
+| `Streaming` | `bool` | `true` | Enable streaming output |
+| `Quiet` | `bool` | `false` | Suppress output |
+| `Debug` | `bool` | `false` | Enable debug logging |
+| `SessionPath` | `string` | — | Open a specific session file |
+| `SessionDir` | `string` | — | Base directory for session discovery |
+| `Continue` | `bool` | `false` | Resume most recent session |
+| `NoSession` | `bool` | `false` | Ephemeral mode (no persistence) |
+| `Tools` | `[]Tool` | — | Replace the entire default tool set |
+| `ExtraTools` | `[]Tool` | — | Additional tools alongside core/MCP/extension tools |
+| `AutoCompact` | `bool` | `false` | Auto-compact when near context limit |
+| `CompactionOptions` | `*CompactionOptions` | — | Configuration for auto-compaction |
+| `Skills` | `[]string` | — | Explicit skill files/dirs to load |
+| `SkillsDir` | `string` | — | Override default skills directory |
+
+---
+
+## Go SDK
+
+# Go SDK
+
+The `pkg/kit` package lets you embed Kit as a library in your Go applications.
+
+## Installation
+
+```bash
+go get github.com/mark3labs/kit/pkg/kit
+```
+
+## Basic usage
+
+```go
+package main
+
+import (
+ "context"
+ "log"
+
+ kit "github.com/mark3labs/kit/pkg/kit"
+)
+
+func main() {
+ ctx := context.Background()
+
+ // Create Kit instance with default configuration
+ host, err := kit.New(ctx, nil)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer host.Close()
+
+ // Send a prompt
+ response, err := host.Prompt(ctx, "What is 2+2?")
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ println(response)
+}
+```
+
+## Multi-turn conversations
+
+Conversations retain context automatically across calls:
+
+```go
+host.Prompt(ctx, "My name is Alice")
+response, _ := host.Prompt(ctx, "What's my name?")
+// response: "Your name is Alice"
+```
+
+## Additional prompt methods
+
+The SDK provides several prompt variants:
+
+| Method | Description |
+|--------|-------------|
+| `Prompt(ctx, message)` | Simple prompt, returns response string |
+| `PromptWithCallbacks(ctx, message, ...)` | With tool call and streaming callbacks |
+| `PromptWithOptions(ctx, message, opts)` | With per-call options |
+| `PromptResult(ctx, message)` | Returns full `TurnResult` with usage stats |
+| `PromptResultWithFiles(ctx, message, files)` | Multimodal with file attachments |
+| `Steer(ctx, instruction)` | System-level steering without user message |
+| `FollowUp(ctx, text)` | Continue without new user input |
+
+## Event system
+
+Subscribe to events for monitoring:
+
+```go
+unsubscribe := host.OnToolCall(func(event kit.ToolCallEvent) {
+ fmt.Println("Tool called:", event.Name)
+})
+defer unsubscribe()
+
+host.OnToolResult(func(event kit.ToolResultEvent) {
+ fmt.Println("Tool result:", event.Name)
+})
+
+host.OnStreaming(func(event kit.MessageUpdateEvent) {
+ fmt.Print(event.Chunk)
+})
+```
+
+## Model management
+
+Switch models at runtime:
+
+```go
+host.SetModel(ctx, "openai/gpt-4o")
+info := host.GetModelInfo()
+models := host.GetAvailableModels()
+```
+
+## Context and compaction
+
+Monitor and manage context usage:
+
+```go
+tokens := host.EstimateContextTokens()
+stats := host.GetContextStats()
+
+if host.ShouldCompact() {
+ result, err := host.Compact(ctx, nil, "")
+}
+```
+
+See [Options](/sdk/options), [Callbacks](/sdk/callbacks), and [Sessions](/sdk/sessions) for more details.
+
+---
+
+## SDK Sessions
+
+# SDK Sessions
+
+## Automatic persistence
+
+By default, Kit automatically persists sessions to JSONL files. Multi-turn conversations retain context across calls:
+
+```go
+host.Prompt(ctx, "My name is Alice")
+response, _ := host.Prompt(ctx, "What's my name?")
+// response: "Your name is Alice"
+```
+
+## Accessing session info
+
+```go
+// Get the current session file path
+path := host.GetSessionPath()
+
+// Get the session ID
+id := host.GetSessionID()
+
+// Get the current model string
+model := host.GetModelString()
+```
+
+## Configuring sessions via Options
+
+Session behavior is configured at initialization:
+
+```go
+// Open a specific session file
+host, _ := kit.New(ctx, &kit.Options{
+ SessionPath: "./my-session.jsonl",
+})
+
+// Resume the most recent session for the current directory
+host, _ := kit.New(ctx, &kit.Options{
+ Continue: true,
+})
+
+// Ephemeral mode (no file persistence)
+host, _ := kit.New(ctx, &kit.Options{
+ NoSession: true,
+})
+
+// Custom session directory
+host, _ := kit.New(ctx, &kit.Options{
+ SessionDir: "/custom/sessions/",
+})
+```
+
+## Clearing history
+
+Clear the in-memory conversation history (does not delete the session file):
+
+```go
+host.ClearSession()
+```
+
+## Tree-based sessions
+
+Kit's session model is tree-based, supporting branching. You can branch from any entry to explore alternate conversation paths:
+
+```go
+// Access the tree session manager
+ts := host.GetTreeSession()
+
+// Branch from a specific entry
+err := host.Branch("entry-id-123")
+```
+
+## Listing and managing sessions
+
+Package-level functions for session discovery:
+
+```go
+// List sessions for a specific directory
+sessions := kit.ListSessions("/home/user/project")
+
+// List all sessions across all directories
+all := kit.ListAllSessions()
+
+// Delete a session file
+kit.DeleteSession("/path/to/session.jsonl")
+```
+
+---
+
+## Session Management
+
+# Session Management
+
+Kit uses a tree-based session model that supports branching and forking conversations.
+
+## Session storage
+
+Sessions are stored as JSONL (JSON Lines) files:
+
+```
+~/.kit/sessions/
+\n ![\"KIT\"](\"/logo.jpg\")
\n
\n\nA powerful, extensible AI coding agent CLI with multi-provider support, built-in tools, and a rich extension system.\n\n## Features\n\n- **Multi-Provider LLM Support** — Anthropic, OpenAI, Google Gemini, Ollama, Azure OpenAI, AWS Bedrock, OpenRouter, and more\n- **Built-in Core Tools** — bash, read, write, edit, grep, find, ls, spawn_subagent with no MCP overhead\n- **MCP Integration** — Connect external MCP servers for expanded capabilities\n- **Extension System** — Write custom tools, commands, widgets, and UI modifications in Go\n- **Interactive TUI** — Rich terminal interface powered by Bubble Tea with streaming, syntax highlighting, and custom rendering\n- **Session Management** — Tree-based conversation history with branching support\n- **Non-Interactive Mode** — Script-friendly positional args with JSON output\n- **ACP Server** — Run Kit as an [Agent Client Protocol](https://agentclientprotocol.com) agent over stdio\n- **Go SDK** — Embed Kit in your own applications\n\n## Quick links\n\n| Resource | Description |\n|----------|-------------|\n| [Installation](/installation) | Get Kit up and running |\n| [Quick Start](/quick-start) | Your first Kit session |\n| [Configuration](/configuration) | Customize Kit for your workflow |\n| [Extensions](/extensions/overview) | Build custom tools and UI components |\n| [Go SDK](/sdk/overview) | Embed Kit in your applications |\n"
+ },
+ {
+ "url": "/installation",
+ "title": "Installation",
+ "description": "Install Kit using npm, Go, or build from source.",
+ "headings": [
+ "Using npm (recommended)",
+ "Using Go",
+ "Building from source",
+ "Verifying the installation",
+ "Setting up a provider"
+ ],
+ "tags": [],
+ "content": "\n# Installation\n\n## Using npm (recommended)\n\n```bash\nnpm install -g @mark3labs/kit\n```\n\n## Using Go\n\n```bash\ngo install github.com/mark3labs/kit/cmd/kit@latest\n```\n\n## Building from source\n\n```bash\ngit clone https://github.com/mark3labs/kit.git\ncd kit\ngo build -o kit ./cmd/kit\n```\n\n## Verifying the installation\n\nAfter installing, verify Kit is available:\n\n```bash\nkit --help\n```\n\n## Setting up a provider\n\nKit needs at least one LLM provider configured. Set an API key for your preferred provider:\n\n```bash\n# Anthropic (default provider)\nexport ANTHROPIC_API_KEY=\"sk-...\"\n\n# OpenAI\nexport OPENAI_API_KEY=\"sk-...\"\n\n# Google Gemini\nexport GOOGLE_API_KEY=\"...\"\n```\n\nFor OAuth-enabled providers like Anthropic, you can also authenticate interactively:\n\n```bash\nkit auth login anthropic\n```\n\nSee [Providers](/providers) for the full list of supported providers and their configuration.\n"
+ },
+ {
+ "url": "/providers",
+ "title": "Providers",
+ "description": "Supported LLM providers and model configuration.",
+ "headings": [
+ "Supported providers",
+ "Model string format",
+ "Model aliases",
+ "Specifying a model",
+ "Authentication",
+ "API keys",
+ "OAuth",
+ "Custom provider URL",
+ "Model database"
+ ],
+ "tags": [],
+ "content": "\n# Providers\n\nKit supports a wide range of LLM providers through a unified `provider/model` string format.\n\n## Supported providers\n\n| Provider | Prefix | Description |\n|----------|--------|-------------|\n| **Anthropic** | `anthropic/` | Claude models (native, prompt caching, OAuth) |\n| **OpenAI** | `openai/` | GPT models |\n| **Google** | `google/` or `gemini/` | Gemini models |\n| **Ollama** | `ollama/` | Local models |\n| **Azure OpenAI** | `azure/` | Azure-hosted OpenAI |\n| **AWS Bedrock** | `bedrock/` | Bedrock models |\n| **Google Vertex** | `google-vertex-anthropic/` | Claude on Vertex AI |\n| **OpenRouter** | `openrouter/` | Multi-provider router |\n| **Vercel AI** | `vercel/` | Vercel AI SDK models |\n| **Auto-routed** | any | Any provider from the models.dev database |\n\n## Model string format\n\n```bash\nprovider/model # Standard format\nanthropic/claude-sonnet-4-5-20250929\nopenai/gpt-4o\nollama/llama3\ngoogle/gemini-2.0-flash-exp\n```\n\n## Model aliases\n\nKit provides aliases for commonly used models:\n\n```bash\nclaude-opus-latest → claude-opus-4-20250514\nclaude-sonnet-latest → claude-sonnet-4-5-20250929\nclaude-4-opus-latest → claude-opus-4-20250514\nclaude-4-sonnet-latest → claude-sonnet-4-5-20250929\nclaude-3-7-sonnet-latest → claude-3-7-sonnet-20250219\nclaude-3-5-sonnet-latest → claude-3-5-sonnet-20241022\nclaude-3-5-haiku-latest → claude-3-5-haiku-20241022\nclaude-3-opus-latest → claude-3-opus-20240229\n```\n\n## Specifying a model\n\nVia CLI flag:\n\n```bash\nkit --model openai/gpt-4o\nkit -m ollama/llama3\n```\n\nVia config file:\n\n```yaml\nmodel: anthropic/claude-sonnet-4-5-20250929\n```\n\nVia environment variable:\n\n```bash\nexport KIT_MODEL=\"google/gemini-2.0-flash-exp\"\n```\n\n## Authentication\n\n### API keys\n\nSet the appropriate environment variable for your provider:\n\n```bash\nexport ANTHROPIC_API_KEY=\"sk-...\"\nexport OPENAI_API_KEY=\"sk-...\"\nexport GOOGLE_API_KEY=\"...\"\n```\n\nOr pass it directly:\n\n```bash\nkit --provider-api-key \"sk-...\" --model openai/gpt-4o\n```\n\n### OAuth\n\nFor providers that support OAuth (e.g., Anthropic):\n\n```bash\nkit auth login anthropic # Start OAuth flow\nkit auth status # Check authentication status\nkit auth logout anthropic # Remove credentials\n```\n\n### Custom provider URL\n\nFor self-hosted or proxy endpoints:\n\n```bash\nkit --provider-url \"https://my-proxy.example.com/v1\" --model openai/gpt-4o\n```\n\n## Model database\n\nKit ships with a local model database that maps provider names to API configurations. You can manage it with:\n\n```bash\nkit models # List available models\nkit models openai # Filter by provider\nkit models --all # Show all providers\nkit update-models # Update from models.dev\nkit update-models embedded # Reset to bundled database\n```\n"
+ },
+ {
+ "url": "/quick-start",
+ "title": "Quick Start",
+ "description": "Get up and running with Kit in minutes.",
+ "headings": [
+ "Basic usage",
+ "Non-interactive mode",
+ "Resuming sessions",
+ "ACP server mode"
+ ],
+ "tags": [],
+ "content": "\n# Quick Start\n\n## Basic usage\n\nStart an interactive session:\n\n```bash\nkit\n```\n\nRun a one-off prompt:\n\n```bash\nkit \"List files in src/\"\n```\n\nAttach files as context using the `@` prefix:\n\n```bash\nkit @main.go @test.go \"Review these files\"\n```\n\nUse a specific model:\n\n```bash\nkit --model anthropic/claude-sonnet-4-5-20250929\n```\n\n## Non-interactive mode\n\nKit can run as a non-interactive tool for scripting and automation.\n\nGet JSON output:\n\n```bash\nkit \"Explain main.go\" --json\n```\n\nQuiet mode (final response only, no TUI):\n\n```bash\nkit \"Run tests\" --quiet\n```\n\nEphemeral mode (no session file created):\n\n```bash\nkit \"Quick question\" --no-session\n```\n\n## Resuming sessions\n\nContinue the most recent session for the current directory:\n\n```bash\nkit --continue\n# or\nkit -c\n```\n\nPick from previous sessions interactively:\n\n```bash\nkit --resume\n# or\nkit -r\n```\n\n## ACP server mode\n\nKit can run as an [ACP (Agent Client Protocol)](https://agentclientprotocol.com) agent server, enabling ACP-compatible clients (such as [OpenCode](https://github.com/sst/opencode)) to drive Kit as a remote coding agent over stdio:\n\n```bash\n# Start Kit as an ACP server (JSON-RPC 2.0 on stdin/stdout)\nkit acp\n\n# With debug logging to stderr\nkit acp --debug\n```\n\nThe ACP server exposes Kit's full capabilities — LLM execution, tool calls (bash, read, write, edit, grep, etc.), and session persistence — over the standard ACP protocol.\n"
+ },
+ {
+ "url": "/sdk/callbacks",
+ "title": "Callbacks",
+ "description": "Monitor tool calls and streaming output with the Kit Go SDK.",
+ "headings": [
+ "PromptWithCallbacks",
+ "Callback signatures",
+ "Event-based monitoring",
+ "Hook system"
+ ],
+ "tags": [],
+ "content": "\n# Callbacks\n\n## PromptWithCallbacks\n\nThe `PromptWithCallbacks` method provides real-time visibility into tool calls and streaming output:\n\n```go\nresponse, err := host.PromptWithCallbacks(\n ctx,\n \"List files in current directory\",\n func(name, args string) {\n // Called when the model invokes a tool\n fmt.Println(\"Calling tool:\", name)\n },\n func(name, args, result string, isError bool) {\n // Called when a tool returns its result\n if isError {\n fmt.Println(\"Tool failed:\", name)\n }\n },\n func(chunk string) {\n // Called for each streaming text chunk\n fmt.Print(chunk)\n },\n)\n```\n\n### Callback signatures\n\n| Callback | Signature | When |\n|----------|-----------|------|\n| `onToolCall` | `func(name, args string)` | Model requests a tool call |\n| `onToolResult` | `func(name, args, result string, isError bool)` | Tool execution completes |\n| `onStreaming` | `func(chunk string)` | Streaming text chunk received |\n\nAny callback can be `nil` if you don't need it:\n\n```go\n// Only care about streaming output\nresponse, err := host.PromptWithCallbacks(ctx, \"Hello\", nil, nil, func(chunk string) {\n fmt.Print(chunk)\n})\n```\n\n## Event-based monitoring\n\nFor more granular control, use the event subscription API:\n\n```go\n// Subscribe returns an unsubscribe function\nunsub := host.OnToolCall(func(event kit.ToolCallEvent) {\n fmt.Printf(\"Tool: %s, Args: %s\\n\", event.Name, event.Args)\n})\ndefer unsub()\n\nunsub2 := host.OnToolResult(func(event kit.ToolResultEvent) {\n fmt.Printf(\"Result: %s (error: %v)\\n\", event.Name, event.IsError)\n})\ndefer unsub2()\n\nunsub3 := host.OnStreaming(func(event kit.MessageUpdateEvent) {\n fmt.Print(event.Chunk)\n})\ndefer unsub3()\n\nunsub4 := host.OnResponse(func(event kit.ResponseEvent) {\n fmt.Println(\"Final response received\")\n})\ndefer unsub4()\n\nunsub5 := host.OnTurnStart(func(event kit.TurnStartEvent) {\n fmt.Println(\"Turn started\")\n})\ndefer unsub5()\n\nunsub6 := host.OnTurnEnd(func(event kit.TurnEndEvent) {\n fmt.Println(\"Turn ended\")\n})\ndefer unsub6()\n```\n\n## Hook system\n\nHooks allow you to intercept and modify behavior. Unlike events, hooks can modify or cancel operations:\n\n```go\n// Intercept tool calls before execution\nhost.OnBeforeToolCall(0, func(ctx context.Context, name string, args string) (string, error) {\n if name == \"bash\" {\n log.Println(\"Bash command:\", args)\n }\n return args, nil // return modified args or error to cancel\n})\n\n// Process results after tool execution\nhost.OnAfterToolResult(0, func(ctx context.Context, name string, result string) (string, error) {\n return result, nil\n})\n\n// Before/after each agent turn\nhost.OnBeforeTurn(0, func(ctx context.Context) error {\n return nil\n})\n\nhost.OnAfterTurn(0, func(ctx context.Context) error {\n return nil\n})\n```\n\nThe first argument is a priority (lower = runs first).\n"
+ },
+ {
+ "url": "/sdk/options",
+ "title": "SDK Options",
+ "description": "Configuration options for the Kit Go SDK.",
+ "headings": [
+ "Full options reference",
+ "Options fields"
+ ],
+ "tags": [],
+ "content": "\n# SDK Options\n\nPass an `Options` struct to `kit.New()` to configure the Kit instance.\n\n## Full options reference\n\n```go\nhost, err := kit.New(ctx, &kit.Options{\n // Model\n Model: \"ollama/llama3\",\n SystemPrompt: \"You are a helpful bot\",\n ConfigFile: \"/path/to/config.yml\",\n\n // Behavior\n MaxSteps: 10,\n Streaming: true,\n Quiet: true,\n Debug: true,\n\n // Session\n SessionPath: \"./session.jsonl\",\n SessionDir: \"/custom/sessions/\",\n Continue: true,\n NoSession: true,\n\n // Tools\n Tools: []kit.Tool{...}, // Replace default tool set entirely\n ExtraTools: []kit.Tool{...}, // Add tools alongside defaults\n\n // Compaction\n AutoCompact: true,\n\n // Skills\n Skills: []string{\"/path/to/skill.md\"},\n SkillsDir: \"/path/to/skills/\",\n})\n```\n\n## Options fields\n\n| Field | Type | Default | Description |\n|-------|------|---------|-------------|\n| `Model` | `string` | config default | Model string (provider/model format) |\n| `SystemPrompt` | `string` | — | System prompt text or file path |\n| `ConfigFile` | `string` | `~/.kit.yml` | Path to config file |\n| `MaxSteps` | `int` | `0` | Max agent steps (0 = unlimited) |\n| `Streaming` | `bool` | `true` | Enable streaming output |\n| `Quiet` | `bool` | `false` | Suppress output |\n| `Debug` | `bool` | `false` | Enable debug logging |\n| `SessionPath` | `string` | — | Open a specific session file |\n| `SessionDir` | `string` | — | Base directory for session discovery |\n| `Continue` | `bool` | `false` | Resume most recent session |\n| `NoSession` | `bool` | `false` | Ephemeral mode (no persistence) |\n| `Tools` | `[]Tool` | — | Replace the entire default tool set |\n| `ExtraTools` | `[]Tool` | — | Additional tools alongside core/MCP/extension tools |\n| `AutoCompact` | `bool` | `false` | Auto-compact when near context limit |\n| `CompactionOptions` | `*CompactionOptions` | — | Configuration for auto-compaction |\n| `Skills` | `[]string` | — | Explicit skill files/dirs to load |\n| `SkillsDir` | `string` | — | Override default skills directory |\n"
+ },
+ {
+ "url": "/sdk/overview",
+ "title": "Go SDK",
+ "description": "Embed Kit in your Go applications.",
+ "headings": [
+ "Installation",
+ "Basic usage",
+ "Multi-turn conversations",
+ "Additional prompt methods",
+ "Event system",
+ "Model management",
+ "Context and compaction"
+ ],
+ "tags": [],
+ "content": "\n# Go SDK\n\nThe `pkg/kit` package lets you embed Kit as a library in your Go applications.\n\n## Installation\n\n```bash\ngo get github.com/mark3labs/kit/pkg/kit\n```\n\n## Basic usage\n\n```go\npackage main\n\nimport (\n \"context\"\n \"log\"\n\n kit \"github.com/mark3labs/kit/pkg/kit\"\n)\n\nfunc main() {\n ctx := context.Background()\n\n // Create Kit instance with default configuration\n host, err := kit.New(ctx, nil)\n if err != nil {\n log.Fatal(err)\n }\n defer host.Close()\n\n // Send a prompt\n response, err := host.Prompt(ctx, \"What is 2+2?\")\n if err != nil {\n log.Fatal(err)\n }\n\n println(response)\n}\n```\n\n## Multi-turn conversations\n\nConversations retain context automatically across calls:\n\n```go\nhost.Prompt(ctx, \"My name is Alice\")\nresponse, _ := host.Prompt(ctx, \"What's my name?\")\n// response: \"Your name is Alice\"\n```\n\n## Additional prompt methods\n\nThe SDK provides several prompt variants:\n\n| Method | Description |\n|--------|-------------|\n| `Prompt(ctx, message)` | Simple prompt, returns response string |\n| `PromptWithCallbacks(ctx, message, ...)` | With tool call and streaming callbacks |\n| `PromptWithOptions(ctx, message, opts)` | With per-call options |\n| `PromptResult(ctx, message)` | Returns full `TurnResult` with usage stats |\n| `PromptResultWithFiles(ctx, message, files)` | Multimodal with file attachments |\n| `Steer(ctx, instruction)` | System-level steering without user message |\n| `FollowUp(ctx, text)` | Continue without new user input |\n\n## Event system\n\nSubscribe to events for monitoring:\n\n```go\nunsubscribe := host.OnToolCall(func(event kit.ToolCallEvent) {\n fmt.Println(\"Tool called:\", event.Name)\n})\ndefer unsubscribe()\n\nhost.OnToolResult(func(event kit.ToolResultEvent) {\n fmt.Println(\"Tool result:\", event.Name)\n})\n\nhost.OnStreaming(func(event kit.MessageUpdateEvent) {\n fmt.Print(event.Chunk)\n})\n```\n\n## Model management\n\nSwitch models at runtime:\n\n```go\nhost.SetModel(ctx, \"openai/gpt-4o\")\ninfo := host.GetModelInfo()\nmodels := host.GetAvailableModels()\n```\n\n## Context and compaction\n\nMonitor and manage context usage:\n\n```go\ntokens := host.EstimateContextTokens()\nstats := host.GetContextStats()\n\nif host.ShouldCompact() {\n result, err := host.Compact(ctx, nil, \"\")\n}\n```\n\nSee [Options](/sdk/options), [Callbacks](/sdk/callbacks), and [Sessions](/sdk/sessions) for more details.\n"
+ },
+ {
+ "url": "/sdk/sessions",
+ "title": "SDK Sessions",
+ "description": "Session management in the Kit Go SDK.",
+ "headings": [
+ "Automatic persistence",
+ "Accessing session info",
+ "Configuring sessions via Options",
+ "Clearing history",
+ "Tree-based sessions",
+ "Listing and managing sessions"
+ ],
+ "tags": [],
+ "content": "\n# SDK Sessions\n\n## Automatic persistence\n\nBy default, Kit automatically persists sessions to JSONL files. Multi-turn conversations retain context across calls:\n\n```go\nhost.Prompt(ctx, \"My name is Alice\")\nresponse, _ := host.Prompt(ctx, \"What's my name?\")\n// response: \"Your name is Alice\"\n```\n\n## Accessing session info\n\n```go\n// Get the current session file path\npath := host.GetSessionPath()\n\n// Get the session ID\nid := host.GetSessionID()\n\n// Get the current model string\nmodel := host.GetModelString()\n```\n\n## Configuring sessions via Options\n\nSession behavior is configured at initialization:\n\n```go\n// Open a specific session file\nhost, _ := kit.New(ctx, &kit.Options{\n SessionPath: \"./my-session.jsonl\",\n})\n\n// Resume the most recent session for the current directory\nhost, _ := kit.New(ctx, &kit.Options{\n Continue: true,\n})\n\n// Ephemeral mode (no file persistence)\nhost, _ := kit.New(ctx, &kit.Options{\n NoSession: true,\n})\n\n// Custom session directory\nhost, _ := kit.New(ctx, &kit.Options{\n SessionDir: \"/custom/sessions/\",\n})\n```\n\n## Clearing history\n\nClear the in-memory conversation history (does not delete the session file):\n\n```go\nhost.ClearSession()\n```\n\n## Tree-based sessions\n\nKit's session model is tree-based, supporting branching. You can branch from any entry to explore alternate conversation paths:\n\n```go\n// Access the tree session manager\nts := host.GetTreeSession()\n\n// Branch from a specific entry\nerr := host.Branch(\"entry-id-123\")\n```\n\n## Listing and managing sessions\n\nPackage-level functions for session discovery:\n\n```go\n// List sessions for a specific directory\nsessions := kit.ListSessions(\"/home/user/project\")\n\n// List all sessions across all directories\nall := kit.ListAllSessions()\n\n// Delete a session file\nkit.DeleteSession(\"/path/to/session.jsonl\")\n```\n"
+ },
+ {
+ "url": "/sessions",
+ "title": "Session Management",
+ "description": "How Kit persists and manages conversation sessions.",
+ "headings": [
+ "Session storage",
+ "Resuming sessions",
+ "Continue most recent",
+ "Interactive picker",
+ "Open a specific session",
+ "Ephemeral mode"
+ ],
+ "tags": [],
+ "content": "\n# Session Management\n\nKit uses a tree-based session model that supports branching and forking conversations.\n\n## Session storage\n\nSessions are stored as JSONL (JSON Lines) files:\n\n```\n~/.kit/sessions/\n