Shared from "Claude-Code" on Inkdown
The heart of Claude Code — how it talks to the AI model, streams responses, executes tools, and manages context.
query.ts)Location: src/query.ts (1500+ lines)
This is the most important file in the codebase. Every AI interaction goes through this loop.
async function* queryLoop(params): AsyncGenerator<..., Terminal> {
while (true) {
// STEP 1: Prepare messages
messages = applyToolResultBudget(messages) // Cap tool result sizes
messages = snipCompactIfNeeded(messages) // Remove old messages (snip)
messages = microcompact(messages) // Remove redundant tool blocks
messages = applyCollapses(messages) // Context collapse
messages = autocompact(messages) // Summarize if too large
// STEP 2: Call the model
for await (const message of callModel({ messages, tools, ... })) {
yield message // Stream to UI
if (message has tool_use blocks) {
streamingToolExecutor.addTool(toolBlock)
needsFollowUp = true
}
}
// STEP 3: Execute tools
for await (const result of streamingToolExecutor.getCompletedResults()) {
yield result.message
toolResults.push(result)
}
// STEP 4: Decide what to do next
if (aborted) return { reason: 'aborted_streaming' }
if (!needsFollowUp) {
// No more tools — we're done
// But first: check for recoverable errors
if (prompt_too_long) {
try collapse drain → try reactive compact → surface error
}
if (max_output_tokens) {
inject recovery message → retry (up to 3 times)
}
// Run stop hooks (e.g., "should I dream?", "PR ready?")
if (stopHookRetried) continue
return { reason: 'done' }
}
// STEP 5: Loop — send tool results back to the model
state = { messages: [...messages, ...assistantMessages, ...toolResults], ... }
continue
}
}Each query tracks token usage. If context approaches the model's limit, the loop triggers compaction before the API call.
Tools execute concurrently while the model is still streaming. The StreamingToolExecutor:
tool_result blocks for aborted tools| Error | Recovery Strategy |
|---|---|
| Prompt too long (413) | 1. Drain staged context collapses 2. Reactive compact (summarize) 3. Surface error if both fail |
| Max output tokens | 1. Escalate to 64k output (once) 2. Inject "resume mid-thought" message 3. Retry up to 3 times |
| Model fallback | Switch to fallback model, strip thinking signatures, retry |
| Media size error | Reactive compact strips oversized media, retries |
The system has four context reduction strategies, applied in order:
snipCompact.ts)projectView() replays the commit log on every entryservices/api/)claude.ts)The main API client that talks to Anthropic's API:
callModel({
messages,
systemPrompt,
tools,
thinkingConfig,
model,
signal,
options: {
onStreamingFallback,
querySource,
agents,
mcpTools,
taskBudget,
...
}
})The API uses server-sent events (SSE) streaming:
data: {"type": "message_start", "message": {...}}
data: {"type": "content_block_start", "content_block": {"type": "text", "text": ""}}
data: {"type": "content_block_delta", "delta": {"type": "text_delta", "text": "H"}}
data: {"type": "content_block_delta", "delta": {"type": "text_delta", "text": "ello"}}
data: {"type": "content_block_stop"}
data: {"type": "message_delta", "usage": {...}}
data: {"type": "message_stop"}Each event is parsed and yielded as a StreamEvent or Message.
tengu_model_fallback_triggered eventThe system optimizes for Anthropic's prompt cache:
services/tools/)The orchestrator for parallel tool execution:
addTool(toolBlock, assistantMessage)
→ Queue the tool call
→ Start execution (async)
getCompletedResults()
→ Return all finished tool results
→ Generate synthetic results for aborted tools
getRemainingResults()
→ Wait for all in-flight tools to complete
→ Called on abort to ensure every tool_use has a tool_resultModel calls tool
│
▼
canUseTool(toolName, input)
│
├─ Check deny rules (settings-based)
│ └─ If denied → return false (tool not available to model)
│
├─ Check auto-allow rules
│ └─ If auto-allowed → return true
│
├─ Check if user previously approved this tool
│ └─ If yes → return true
│
└─ Prompt user for permission
├─ User approves → return true (remember for session)
├─ User denies → return false
└─ User approves always → return true (save to settings)Location: src/QueryEngine.ts
A higher-level wrapper around the query loop that:
query/config.ts)Builds a snapshot of immutable config for each query:
This avoids re-evaluating feature flags on every loop iteration.
services/tokenEstimation.ts)Estimates token counts for:
Used to decide when to trigger compaction.
| File | Purpose |
|---|---|
src/query.ts | The query loop — model calls, tool execution, recovery |
src/QueryEngine.ts | High-level query orchestration |
src/query/config.ts | Query configuration snapshot |
src/query/deps.ts | Dependency injection for query (callModel, compact, etc.) |
src/query/transitions.ts | Continue/terminal state types |
src/query/tokenBudget.ts | Per-turn token budget tracking |
src/query/stopHooks.ts | Post-turn hooks (dream, PR review, etc.) |
src/services/api/claude.ts | Anthropic API client, streaming |
src/services/api/bootstrap.ts | Bootstrap data fetching |
src/services/api/filesApi.ts | File download/upload API |
src/services/api/withRetry.ts | Retry logic with exponential backoff |
src/services/tools/toolOrchestration.ts | Tool execution orchestration |
src/services/tools/StreamingToolExecutor.ts | Parallel tool execution |
src/services/compact/compact.ts | Auto-compaction |
src/services/compact/autoCompact.ts | Auto-compact trigger logic |
src/services/compact/microcompact.ts | Micro-compaction |
src/services/compact/reactiveCompact.ts | Reactive compact (on 413) |
src/services/compact/snipCompact.ts | Snip compact (remove old messages) |
src/services/contextCollapse/ | Context collapse service |
src/services/toolUseSummary/ | Tool use summary generation |