@selesai/code 0.13.29 → 0.13.30

package/dist/extensions/pi-hermes-memory/src/tools/memory-search-tool.ts

@@ -6,13 +6,12 @@ import { searchMemories, getMemoryStats } from '../store/sqlite-memory-store.js'
 import type { MemoryCategory } from '../types.js';
 import { createSharedToolResultRenderer } from './shared-output-view.js';
 import { searchResultView } from './tool-result-views.js';
-
-interface SearchResult {
-  success: boolean;
-  count?: number;
-  message?: string;
-  output?: string;
-}
+import {
+  isMemorySearchRequest,
+  MEMORY_SEARCH_REQUEST_EVENT,
+  type MemorySearchRequestInput,
+  type MemorySearchResponse,
+} from '../memory-search-bridge.js';
 
 function mutationTarget(entry: { target: "memory" | "user" | "failure"; project: string | null }): "memory" | "user" | "failure" | "project" {
   // A project name scopes ordinary memory entries, but project-attributed
@@ -24,7 +23,50 @@ function scopeLabel(project: string | null): string {
   return project ? `project:${encodeURIComponent(project)}` : "global";
 }
 
+/** The read-only implementation shared by the model tool and local extensions. */
+export function searchMemory(dbManager: DatabaseManager, args: MemorySearchRequestInput): MemorySearchResponse {
+  const query = args.query;
+  const project = args.project;
+  const target = args.target;
+  const category = args.category as MemoryCategory | undefined;
+  const limit = Math.min(args.limit || 10, 20);
+
+  if (!query || query.trim().length === 0) {
+    return { success: false, message: 'query is required' };
+  }
+
+  const stats = getMemoryStats(dbManager);
+  if (stats.total === 0) {
+    return { success: false, message: 'No memories in extended store yet. Use memory_add to store memories.' };
+  }
+
+  const results = searchMemories(dbManager, query, { project, target, category, limit });
+
+  if (results.length === 0) {
+    return { success: true, count: 0, message: `No memories found matching "${query}". Try a different search term or broader query.` };
+  }
+
+  let output = `Found ${results.length} memories matching "${query}":\n\n`;
+
+  for (const entry of results) {
+    const resultTarget = mutationTarget(entry);
+    const projectLabel = `scope=${scopeLabel(entry.project)}`;
+    const mutationTargetLabel = `[target=${resultTarget}]`;
+    const targetLabel = entry.target === 'user' ? '👤' : entry.target === 'failure' ? '⚠️' : '🧠';
+    const categoryLabel = entry.category ? ` [${entry.category}]` : '';
+    output += `${targetLabel} ${projectLabel} ${mutationTargetLabel}${categoryLabel} ${entry.content}\n`;
+    output += `   Created: ${entry.created} | Last used: ${entry.lastReferenced}\n\n`;
+  }
+
+  return { success: true, count: results.length, output: output.trim() };
+}
+
 export function registerMemorySearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
+  pi.events?.on(MEMORY_SEARCH_REQUEST_EVENT, (request: unknown) => {
+    if (!isMemorySearchRequest(request)) return;
+    request.respond(searchMemory(dbManager, request.input));
+  });
+
   pi.registerTool({
     name: 'memory_search',
     label: 'Memory Search',
@@ -40,6 +82,11 @@ target="project" returns only project-attributed memory entries (the ones labele
 
 Returns matching memory entries with their mutation target, scope, and dates. The displayed target is the value required by memory_replace and memory_remove.`,
     promptSnippet: 'Search extended memory store (unlimited capacity)',
+    ...{ discovery: {
+      summary: 'Search the extended durable memory store for relevant entries',
+      aliases: ['memory lookup', 'search memories', 'recall memory'],
+      category: 'memory',
+    } },
     promptGuidelines: [
       'Use memory_search when you need context beyond what is in the system prompt.',
       'Use memory_search to find project-specific memories or user preferences.',
@@ -53,45 +100,9 @@ Returns matching memory entries with their mutation target, scope, and dates. Th
       category: Type.Optional(StringEnum(['failure', 'correction', 'insight', 'preference', 'convention', 'tool-quirk'] as const, { description: 'Filter by memory category.' })),
       limit: Type.Optional(Type.Number({ description: 'Maximum results to return (default: 10, max: 20).' })),
     }),
-    execute: async (_id: string, args: { query: string; project?: string; target?: 'memory' | 'user' | 'failure' | 'project'; category?: string; limit?: number }) => {
-      const query = args.query;
-      const project = args.project;
-      const target = args.target;
-      const category = args.category as MemoryCategory | undefined;
-      const limit = Math.min(args.limit || 10, 20);
-
-      if (!query || query.trim().length === 0) {
-        const result: SearchResult = { success: false, message: 'query is required' };
-        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
-      }
-
-      const stats = getMemoryStats(dbManager);
-      if (stats.total === 0) {
-        const result: SearchResult = { success: false, message: 'No memories in extended store yet. Use memory_add to store memories.' };
-        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
-      }
-
-      const results = searchMemories(dbManager, query, { project, target, category, limit });
-
-      if (results.length === 0) {
-        const result: SearchResult = { success: true, count: 0, message: `No memories found matching "${query}". Try a different search term or broader query.` };
-        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
-      }
-
-      let output = `Found ${results.length} memories matching "${query}":\n\n`;
-
-      for (const entry of results) {
-        const target = mutationTarget(entry);
-        const projectLabel = `scope=${scopeLabel(entry.project)}`;
-        const mutationTargetLabel = `[target=${target}]`;
-        const targetLabel = entry.target === 'user' ? '👤' : entry.target === 'failure' ? '⚠️' : '🧠';
-        const categoryLabel = entry.category ? ` [${entry.category}]` : '';
-        output += `${targetLabel} ${projectLabel} ${mutationTargetLabel}${categoryLabel} ${entry.content}\n`;
-        output += `   Created: ${entry.created} | Last used: ${entry.lastReferenced}\n\n`;
-      }
-
-      const finalResult: SearchResult = { success: true, count: results.length, output: output.trim() };
-      return { content: [{ type: 'text' as const, text: output.trim() }], details: finalResult };
+    execute: async (_id: string, args: { query: string; project?: string; target?: 'memory' | 'user' | 'failure' | 'project'; category?: MemorySearchRequestInput['category']; limit?: number }) => {
+      const result = searchMemory(dbManager, args);
+      return { content: [{ type: 'text' as const, text: result.output ?? result.message ?? '' }], details: result };
     },
   });
 }

package/dist/extensions/pi-hermes-memory/src/tools/memory-tool.ts

@@ -413,12 +413,14 @@ This action-specific tool accepts only the parameters listed in its schema.`;
     label: string,
     description: string,
     parameters: TSchema,
+    discovery: { summary: string; aliases: string[]; category: string },
   ) => {
     pi.registerTool({
       name,
       label,
       description,
       promptSnippet: `${label}: persistent memory that survives across sessions`,
+      ...{ discovery },
       promptGuidelines: [
         "Use this tool proactively when the user corrects you, shares a preference, or reveals durable environment or project facts.",
         "Do not use memory tools for temporary task state, TODO items, or session progress.",
@@ -454,6 +456,11 @@ Add one durable entry. The target and content fields are required.`,
       category: Type.Optional(category),
       failure_reason: Type.Optional(Type.String({ description: "Why a failure occurred." })),
     }),
+    {
+      summary: "Save durable information to persistent memory",
+      aliases: ["remember this", "save memory", "store memory"],
+      category: "memory",
+    },
   );
   registerActionTool(
     "replace",
@@ -467,6 +474,11 @@ Replace one existing entry. The target, old_text, and content fields are require
       old_text: Type.String({ description: "Substring identifying the entry to replace." }),
       content: Type.String({ description: "Replacement entry content." }),
     }),
+    {
+      summary: "Replace an existing durable memory entry in place",
+      aliases: ["update memory", "edit memory"],
+      category: "memory",
+    },
   );
   registerActionTool(
     "remove",
@@ -479,6 +491,11 @@ Remove one existing entry. The target and old_text fields are required.`,
       target,
       old_text: Type.String({ description: "Substring identifying the entry to remove." }),
     }),
+    {
+      summary: "Remove a durable memory entry",
+      aliases: ["forget memory", "delete memory", "remove memory"],
+      category: "memory",
+    },
   );
   return configureProjectStore;
 }

package/dist/extensions/pi-hermes-memory/src/tools/session-search-tool.ts

@@ -87,6 +87,11 @@ any:
 exclude:
 - delta`,
     promptSnippet: 'Search past session JSONL files for compact source anchors',
+    ...{ discovery: {
+      summary: 'Search past Selesai sessions for compact source anchors',
+      aliases: ['past sessions', 'session history anchors'],
+      category: 'memory',
+    } },
     promptGuidelines: [
       'Use session_search with markdown only when the session search anchor mode is configured.',
       'Request source anchors, not summaries or previews.',
@@ -156,6 +161,11 @@ Examples:
 
 Returns bounded conversation snippets with session dates and project context. Large messages are truncated with their original character count.`,
     promptSnippet: 'Search past conversations for relevant context',
+    ...{ discovery: {
+      summary: 'Search past Selesai sessions for relevant conversation context',
+      aliases: ['past sessions', 'conversation history', 'session history'],
+      category: 'memory',
+    } },
     promptGuidelines: [
       'Use session_search when the user asks about previous discussions or past work.',
       'Use session_search when you need context from earlier sessions.',

package/dist/extensions/pi-hermes-memory/src/tools/skill-tool.ts

@@ -95,6 +95,11 @@ export function registerSkillTool(pi: ExtensionAPI, store: SkillStore): void {
     label: "Skill Manager",
     description: SKILL_TOOL_DESCRIPTION,
     promptSnippet: "Create, inspect, and update reusable procedures and patterns",
+    ...{ discovery: {
+      summary: "Create, inspect, or update reusable procedure skills",
+      aliases: ["manage skills", "save procedure", "create skill"],
+      category: "capability",
+    } },
     promptGuidelines: [
       "Use the skill_manage tool after completing complex tasks that required trial and error or multiple tool calls.",
       "Use 'create' to save a new reusable procedure, 'patch' to update a section of an existing skill by skill_id, and 'update' for a full rewrite.",

package/dist/extensions/pi-hermes-memory/tests/tools/memory-search-tool.test.ts

@@ -7,6 +7,7 @@ import { DatabaseManager } from '../../src/store/db.js';
 import { addMemory } from '../../src/store/sqlite-memory-store.js';
 import { normalizeMemoryLookupText } from '../../src/store/memory-lookup.js';
 import { registerMemorySearchTool } from '../../src/tools/memory-search-tool.js';
+import { MEMORY_SEARCH_REQUEST_EVENT } from '../../src/memory-search-bridge.js';
 
 let ROOT_DIR = '';
 
@@ -103,4 +104,28 @@ describe('registerMemorySearchTool', () => {
 
     dbManager.close();
   });
+
+  it('serves one local read-only lookup through the extension bridge', () => {
+    const dbManager = makeDbManager();
+    addMemory(dbManager, 'project deployment convention', 'memory', 'project-a');
+
+    let handler: ((request: unknown) => void) | undefined;
+    registerMemorySearchTool({
+      registerTool: () => {},
+      events: { on: (channel: string, listener: (request: unknown) => void) => {
+        if (channel === MEMORY_SEARCH_REQUEST_EVENT) handler = listener;
+      } },
+    } as any, dbManager);
+
+    let response: any;
+    handler!({
+      input: { query: 'deployment', target: 'project', project: 'project-a', limit: 5 },
+      respond: (result: unknown) => { response = result; },
+    });
+
+    assert.equal(response.success, true);
+    assert.equal(response.count, 1);
+    assert.match(response.output, /project deployment convention/);
+    dbManager.close();
+  });
 });

package/dist/extensions/pi-intercom/index.ts

@@ -1819,6 +1819,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
       label: "Contact Supervisor",
       description: "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision when blocked, uncertain, needing approval, or facing a product/API/scope decision before continuing; this waits for the supervisor's reply. Use interview_request when multiple structured questions need supervisor answers; this also waits for a reply. Use progress_update only for meaningful progress or unexpected discoveries that change the plan; this does not wait for a reply. Do not use for routine completion handoffs.",
       promptSnippet: "Subagent-only: contact the supervisor for decisions, structured interviews, or meaningful plan-changing updates. Do not use for routine completion handoffs.",
+      discovery: {
+        summary: "Subagent-only channel to ask the supervisor for decisions or send plan-changing updates",
+        aliases: ["contact supervisor", "ask supervisor"],
+        category: "coordination",
+      },
       promptGuidelines: [
         "Use contact_supervisor with reason='need_decision' when a subagent is blocked, uncertain, needs approval, or faces a product/API/scope decision before continuing.",
         "Use contact_supervisor with reason='interview_request' when the child needs multiple structured answers from the supervisor in one blocking exchange.",
@@ -2088,6 +2093,11 @@ export default function piIntercomExtension(pi: ExtensionAPI) {
   pi.registerTool(defineTool({
     name: "intercom",
     label: "Intercom",
+    discovery: {
+      summary: "Send messages and coordinate with other local Selesai sessions",
+      aliases: ["contact session", "session message", "peer session"],
+      category: "coordination",
+    },
     description: `Send a message to another Selesai session running on this machine.
 Use this to communicate findings, request help, or coordinate work with other sessions.
 

package/dist/extensions/pi-subagents/src/extension/fanout-child.ts

@@ -181,6 +181,11 @@ export default function registerFanoutChildSubagentExtension(pi: ExtensionAPI, c
 			"Allowed management/control actions: list, get, status, lane.status, interrupt, resume, steer, doctor.",
 			"Mutating management actions (create, update, delete, eject, disable, enable, reset, grant-spawn-budget, lane.recordMerge, lane.recordSupersession) are blocked in this mode.",
 		].join("\n"),
+		...{ discovery: {
+			summary: "Delegate to subagents from child-safe fanout mode",
+			aliases: ["delegate task", "child agent", "parallel agents"],
+			category: "agents",
+		} },
 		parameters: params,
 		async execute(id, params, signal, onUpdate, ctx) {
 			return finalizeToolResult(await executor.executePublic(id, params as SubagentParamsLike, signal ?? new AbortController().signal, onUpdate, ctx));

package/dist/extensions/pi-subagents/src/extension/index.ts

@@ -757,6 +757,11 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		label: "Subagent",
 		description: buildSubagentToolDescription(config),
 		...buildSubagentToolPromptMetadata(config),
+		...{ discovery: {
+			summary: "Delegate a task to one or more child agents, or run a workflow script",
+			aliases: ["delegate task", "child agent", "parallel agents"],
+			category: "agents",
+		} },
 		parameters,
 
 		async execute(id, params, signal, onUpdate, ctx) {

package/dist/extensions/pi-subagents/src/intercom/native-supervisor-channel.ts

@@ -259,6 +259,11 @@ export function registerNativeSupervisorClient(pi: ExtensionAPI, metadata: Child
 		name: "contact_supervisor",
 		label: "Contact Supervisor",
 		description: "Contact the parent/supervisor session for a blocking decision, structured interview, or progress update.",
+		...{ discovery: {
+			summary: "Contact the parent/supervisor session for decisions, interviews, or progress updates",
+			aliases: ["contact supervisor", "ask supervisor"],
+			category: "coordination",
+		} },
 		parameters: ContactSupervisorParamsSchema,
 		execute(id, params, signal) {
 			return sendSupervisorRequest(params as ContactSupervisorParams, metadata, signal, id);
@@ -578,6 +583,11 @@ function buildParentSupervisorTool(pi: ExtensionAPI, pending: Map<string, Pendin
 		name: NATIVE_SUPERVISOR_TOOL_NAME,
 		label: "Subagent Supervisor",
 		description: "Native pi-subagents supervisor channel. Use reply/pending/status to answer child subagent requests without overriding pi-intercom.",
+		...{ discovery: {
+			summary: "Answer child subagent requests: reply, pending, or status",
+			aliases: ["supervisor channel", "reply to subagent"],
+			category: "coordination",
+		} },
 		parameters: IntercomParamsSchema,
 		async execute(_id, params) {
 			// Discover new request files even when demand-gated polling is idle.

package/dist/extensions/pi-subagents/src/runs/background/wait-tool.ts

@@ -37,6 +37,11 @@ Non-blocking subscriptions are visible in subagent status and differ from disabl
 		name: "bg_wait",
 		label: "Background Wait",
 		description,
+		...{ discovery: {
+			summary: "Wait for background or detached subagent work to finish",
+			aliases: ["wait for background work", "background wait"],
+			category: "agents",
+		} },
 		parameters: SubagentWaitParams,
 		execute,
 	};
@@ -46,6 +51,11 @@ Non-blocking subscriptions are visible in subagent status and differ from disabl
 		name: "subagent_wait",
 		label: "Subagent Wait (deprecated)",
 		description: "Deprecated compatibility alias for `bg_wait`. Use `bg_wait` for background, provider, or detached work without a native completion notification. It has the same parameters and behavior.",
+		...{ discovery: {
+			summary: "Deprecated compatibility alias for bg_wait",
+			aliases: ["wait for subagent"],
+			category: "agents",
+		} },
 	});
 }
 

package/dist/extensions/pi-web-agent/src/extension.ts

@@ -114,6 +114,11 @@ export default function extension(pi: ExtensionAPI) {
     label: 'Web Explore',
     description:
       'Research a web question using bounded search/fetch passes, source ranking, and targeted headless escalation. Use this for web research, current docs/discussion lookups, and recommendation summaries.',
+    discovery: {
+      summary: 'Research a web question with bounded search, fetch, and source ranking',
+      aliases: ['web research', 'web search', 'current docs lookup'],
+      category: 'web'
+    },
     parameters: Type.Object({
       query: Type.String({ description: 'Web research question to explore.' })
     }),

package/dist/extensions/question/index.ts

@@ -616,6 +616,11 @@ export default function questionExtension(pi: ExtensionAPI) {
 		description:
 			"Ask one or more typed questions in a terminal wizard. Supports select, multiselect, text, stable option values, Other answers, and partial atomic submission.",
 		promptSnippet: "Ask the user one or more typed questions when a decision is required.",
+		discovery: {
+			summary: "Ask the user one or more typed questions in a terminal wizard",
+			aliases: ["ask user", "user decision", "clarifying questions"],
+			category: "interaction",
+		},
 		promptGuidelines: [
 			"Use question only for decisions the user must make; inspect facts yourself.",
 			"Send one questions array containing independent decisions that can be answered together.",

package/dist/extensions/tokenin-onboarding.ts

@@ -14,13 +14,18 @@ import { dirname, join } from "node:path";
 import { getAgentDir, getModelsPath } from "@selesai/code";
 import type { AuthStorage, ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionStartEvent } from "@selesai/code";
 import {
+	calculateCost,
+	contentText,
 	createAssistantMessageEventStream,
+	getSystemMessageText,
 	lazyStream,
+	type AssistantMessage,
 	type AssistantMessageEvent,
 	type AssistantMessageEventStream,
 	type Context,
 	type Model,
 	type SimpleStreamOptions,
+	type TextContent,
 } from "@earendil-works/pi-ai";
 import { getApiProvider } from "@earendil-works/pi-ai/compat";
 
@@ -335,6 +340,171 @@ function persistActiveTokenInAccount(account: TokenInAccount, authPath: string =
 	}
 }
 
+/**
+ * The decisions deployments Token-In serves (Jev).
+ *
+ * These answer exactly one non-streaming JSON completion, and the gateway's
+ * Jev deployment rejects the SSE path outright, so the normal OpenAI-compatible
+ * streaming adapter can only turn a working decision into an HTTP 500. Every
+ * other tokenin model keeps the untouched streaming path below.
+ */
+export const TOKEN_IN_DECISIONS_MODEL_PATTERN = /^jev-/;
+
+export function isTokenInDecisionsModel(model: { id: string }): boolean {
+	return TOKEN_IN_DECISIONS_MODEL_PATTERN.test(model.id);
+}
+
+function emptyUsage(): AssistantMessage["usage"] {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
+/**
+ * The plain-text chat messages a decisions request carries: the transcript's
+ * text, and nothing else. Decisions deployments take no tools, no images, and
+ * no thinking blocks, so anything richer is dropped rather than mis-sent.
+ */
+export function tokenInDecisionMessages(context: Context): Array<{ role: "system" | "user" | "assistant"; content: string }> {
+	const messages: Array<{ role: "system" | "user" | "assistant"; content: string }> = [];
+	for (const message of context.messages) {
+		if (message.role === "system") {
+			const content = getSystemMessageText(message).trim();
+			if (content) messages.push({ role: "system", content });
+			continue;
+		}
+		if (message.role === "assistant") {
+			const content = contentText(message.content).trim();
+			if (content) messages.push({ role: "assistant", content });
+			continue;
+		}
+		// User and tool-result text both travel as user turns: a decisions model has
+		// no tool protocol to answer through.
+		const content = contentText(message.content).trim();
+		if (content) messages.push({ role: "user", content });
+	}
+	return messages;
+}
+
+/** The decisions completion's text, when the body is OpenAI-shaped. */
+function decisionCompletion(body: unknown): { text: string; finishReason: unknown; usage: Record<string, unknown> } | undefined {
+	if (typeof body !== "object" || body === null) return undefined;
+	const choices = (body as { choices?: unknown }).choices;
+	if (!Array.isArray(choices) || choices.length === 0) return undefined;
+	const choice = choices[0] as { message?: { content?: unknown }; finish_reason?: unknown };
+	const content = choice?.message?.content;
+	const text =
+		typeof content === "string"
+			? content
+			: Array.isArray(content)
+				? contentText(content as readonly { type: "text"; text: string }[])
+				: undefined;
+	if (text === undefined) return undefined;
+	const usage = (body as { usage?: unknown }).usage;
+	return {
+		text,
+		finishReason: choice?.finish_reason,
+		usage: typeof usage === "object" && usage !== null ? (usage as Record<string, unknown>) : {},
+	};
+}
+
+function usageNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+/**
+ * One non-streaming decisions call, rendered into the normal event protocol so
+ * every pi consumer (and cost accounting) sees an ordinary assistant message.
+ * The returned `errorMessage` feeds the caller's account-rotation decision.
+ */
+async function requestTokenInDecision(
+	model: Model<any>,
+	context: Context,
+	options: SimpleStreamOptions,
+): Promise<{ stream: AssistantMessageEventStream; errorMessage?: string }> {
+	const stream = createAssistantMessageEventStream();
+	const message: AssistantMessage = {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: emptyUsage(),
+		stopReason: "pending",
+		timestamp: Date.now(),
+	};
+	const fail = (text: string): { stream: AssistantMessageEventStream; errorMessage: string } => {
+		const aborted = options.signal?.aborted === true;
+		message.stopReason = aborted ? "aborted" : "error";
+		message.errorMessage = text;
+		stream.push({ type: "error", reason: message.stopReason, error: message });
+		stream.end(message);
+		return { stream, errorMessage: text };
+	};
+
+	const requested: Record<string, unknown> = {
+		model: model.id,
+		messages: tokenInDecisionMessages(context),
+	};
+	if (options.maxTokens !== undefined) requested.max_tokens = options.maxTokens;
+	const payload = (await options.onPayload?.(requested, model)) ?? requested;
+
+	let response: Response;
+	try {
+		response = await (options.fetch ?? fetch)(`${model.baseUrl.replace(/\/+$/, "")}/chat/completions`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json", ...(options.headers ?? {}) },
+			body: JSON.stringify(payload),
+			...(options.signal ? { signal: options.signal } : {}),
+		});
+	} catch (error) {
+		return fail(error instanceof Error ? error.message : String(error));
+	}
+	await options.onResponse?.(
+		{ status: response.status, headers: Object.fromEntries(response.headers.entries()) },
+		model,
+	);
+
+	const raw = await response.text();
+	if (!response.ok) return fail(`HTTP ${response.status}: ${raw.slice(0, 400)}`);
+
+	let body: unknown;
+	try {
+		body = JSON.parse(raw);
+	} catch {
+		return fail(`Malformed decisions response: ${raw.slice(0, 200)}`);
+	}
+	const completion = decisionCompletion(body);
+	if (!completion) return fail(`Unexpected decisions response: ${raw.slice(0, 200)}`);
+
+	const input = usageNumber(completion.usage.prompt_tokens ?? completion.usage.input_tokens);
+	const output = usageNumber(completion.usage.completion_tokens ?? completion.usage.output_tokens);
+	message.usage = {
+		...emptyUsage(),
+		input,
+		output,
+		totalTokens: usageNumber(completion.usage.total_tokens) || input + output,
+	};
+	calculateCost(model, message.usage);
+	message.stopReason = completion.finishReason === "length" ? "length" : "stop";
+
+	stream.push({ type: "start", partial: { ...message } });
+	const block: TextContent = { type: "text", text: "" };
+	message.content = [block];
+	stream.push({ type: "text_start", contentIndex: 0, partial: { ...message } });
+	block.text = completion.text;
+	stream.push({ type: "text_delta", contentIndex: 0, delta: completion.text, partial: { ...message } });
+	stream.push({ type: "text_end", contentIndex: 0, content: completion.text, partial: { ...message } });
+	stream.push({ type: "done", reason: message.stopReason === "length" ? "length" : "stop", message });
+	stream.end(message);
+	return { stream };
+}
+
 /**
  * Custom streamSimple implementation for tokenin provider that wraps OpenAI completions
  * and automatically rotates to alternative saved keys on 401/429/budget exceeded errors.
@@ -407,6 +577,21 @@ export function createTokenInStreamSimple(options?: {
 
 				const requestOptions = withAccountAuthorization(streamOptions, currentAccount);
 
+				// Decisions deployments never stream: one POST, one text block, and only
+				// a rotateable failure moves on to the next account.
+				if (isTokenInDecisionsModel(model)) {
+					const decided = await requestTokenInDecision(model, context, requestOptions);
+					if (decided.errorMessage === undefined) return decided.stream;
+					if (isRotateableTokenInError(decided.errorMessage) && i + 1 < candidateAccounts.length) {
+						setTokenInCooldown(currentAccount.id);
+						const nextAccount = candidateAccounts[i + 1]!;
+						activate(nextAccount);
+						options?.onRotate?.(currentAccount, nextAccount, decided.errorMessage);
+						continue;
+					}
+					return decided.stream;
+				}
+
 				let underlyingStream: AssistantMessageEventStream;
 				try {
 					underlyingStream = streamSimple(model, context, requestOptions);