@gajae-code/coding-agent 0.1.1

package/src/utils/markit.ts

@@ -0,0 +1,89 @@
+import { untilAborted } from "@gajae-code/utils";
+import type { Markit, StreamInfo } from "markit-ai";
+import { ToolAbortError } from "../tools/tool-errors";
+
+export interface MarkitConversionResult {
+	content: string;
+	ok: boolean;
+	error?: string;
+}
+
+let markit: () => Markit | Promise<Markit> = async () => {
+	const promise = import("markit-ai").then(({ Markit }) => {
+		const instance = new Markit();
+		markit = () => instance;
+		return instance;
+	});
+	markit = () => promise;
+	return promise;
+};
+
+function normalizeExtension(extension: string): string {
+	const trimmed = extension.trim().toLowerCase();
+	if (!trimmed) return ".bin";
+	return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+}
+
+function normalizeError(error: unknown): string {
+	if (error instanceof Error && error.message.trim().length > 0) {
+		return error.message.trim();
+	}
+	return "Conversion failed";
+}
+
+async function runMarkitConversion<T>(task: (markit: Markit) => Promise<T>, signal?: AbortSignal): Promise<T> {
+	try {
+		const instance = await markit();
+		return signal ? await untilAborted(signal, () => task(instance)) : await task(instance);
+	} catch (error) {
+		if (error instanceof ToolAbortError) {
+			throw error;
+		}
+		if (error instanceof Error && error.name === "AbortError") {
+			throw new ToolAbortError();
+		}
+		throw error;
+	}
+}
+
+function finalizeConversion(markdown?: string): MarkitConversionResult {
+	if (typeof markdown === "string" && markdown.length > 0) {
+		return { content: markdown, ok: true };
+	}
+
+	return { content: "", ok: false, error: "Conversion produced no output" };
+}
+
+export async function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult> {
+	try {
+		const result = await runMarkitConversion(markit => markit.convertFile(filePath), signal);
+		return finalizeConversion(result.markdown);
+	} catch (error) {
+		if (error instanceof ToolAbortError) {
+			throw error;
+		}
+		return { content: "", ok: false, error: normalizeError(error) };
+	}
+}
+
+export async function convertBufferWithMarkit(
+	buffer: Uint8Array,
+	extension: string,
+	signal?: AbortSignal,
+): Promise<MarkitConversionResult> {
+	const normalizedExtension = normalizeExtension(extension);
+	const streamInfo: StreamInfo = {
+		extension: normalizedExtension,
+		filename: `input${normalizedExtension}`,
+	};
+
+	try {
+		const result = await runMarkitConversion(markit => markit.convert(Buffer.from(buffer), streamInfo), signal);
+		return finalizeConversion(result.markdown);
+	} catch (error) {
+		if (error instanceof ToolAbortError) {
+			throw error;
+		}
+		return { content: "", ok: false, error: normalizeError(error) };
+	}
+}

package/src/utils/open.ts

@@ -0,0 +1,20 @@
+/** Open a URL or file path in the default browser/application. Best-effort, never throws. */
+export function openPath(urlOrPath: string): void {
+	let cmd: string[];
+	switch (process.platform) {
+		case "darwin":
+			cmd = ["open", urlOrPath];
+			break;
+		case "win32":
+			cmd = ["rundll32", "url.dll,FileProtocolHandler", urlOrPath];
+			break;
+		default:
+			cmd = ["xdg-open", urlOrPath];
+			break;
+	}
+	try {
+		Bun.spawn(cmd, { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+	} catch {
+		// Best-effort: browser opening is non-critical
+	}
+}

package/src/utils/session-color.ts

@@ -0,0 +1,43 @@
+/**
+ * Derive a stable hue (0-359) from a string using djb2 hash.
+ */
+function nameToHue(name: string): number {
+	let hash = 5381;
+	for (let i = 0; i < name.length; i++) {
+		hash = ((hash << 5) + hash) ^ name.charCodeAt(i);
+		hash = hash >>> 0; // keep 32-bit unsigned
+	}
+	return hash % 360;
+}
+
+/**
+ * Convert HSL (h: 0-360, s: 0-1, l: 0-1) to a CSS hex string.
+ */
+function hslToHex(h: number, s: number, l: number): string {
+	const a = s * Math.min(l, 1 - l);
+	const f = (n: number) => {
+		const k = (n + h / 30) % 12;
+		const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+		return Math.round(255 * color)
+			.toString(16)
+			.padStart(2, "0");
+	};
+	return `#${f(0)}${f(8)}${f(4)}`;
+}
+
+/**
+ * Derive a stable CSS hex accent color from a session name.
+ * High saturation, vivid — suitable for both status bar text and border coloring.
+ */
+export function getSessionAccentHex(name: string): string {
+	return hslToHex(nameToHue(name), 0.9, 0.72);
+}
+
+/**
+ * Convert a hex accent color to an ANSI-16m foreground escape sequence.
+ * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.
+ */
+export function getSessionAccentAnsi(hex: string | undefined): string | undefined {
+	if (!hex) return undefined;
+	return Bun.color(hex, "ansi-16m") ?? undefined;
+}

package/src/utils/shell-snapshot.ts

@@ -0,0 +1,187 @@
+/**
+ * Shell environment snapshot for preserving user aliases, functions, and options.
+ *
+ * Creates a snapshot file that captures the user's shell environment from their
+ * .bashrc/.zshrc, which can be sourced before each command to provide a familiar
+ * shell experience.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { postmortem } from "@gajae-code/utils";
+
+const cachedSnapshotPaths = new Map<string, string>();
+const SNAPSHOT_TIMEOUT_MS = 2_000;
+
+function sanitizeSnapshotEnv(env: Record<string, string | undefined>): Record<string, string | undefined> {
+	const sanitized = { ...env };
+	delete sanitized.BASH_ENV;
+	delete sanitized.ENV;
+	return sanitized;
+}
+
+/**
+ * Get the user's shell config file path.
+ */
+function getShellConfigFile(shell: string): string {
+	const home = os.homedir();
+	if (shell.includes("zsh")) return path.join(home, ".zshrc");
+	if (shell.includes("bash")) return path.join(home, ".bashrc");
+	return path.join(home, ".profile");
+}
+
+/**
+ * Generate the snapshot creation script.
+ * This script sources the user's rc file and extracts functions, aliases, and options.
+ * Matches Anthropic Code's snapshot generation logic.
+ */
+function generateSnapshotScript(shell: string, snapshotPath: string, rcFile: string): string {
+	const hasRcFile = fs.existsSync(rcFile);
+	const isZsh = shell.includes("zsh");
+	const commonToolsRegex =
+		"^(ls|dir|vdir|cat|head|tail|less|more|grep|egrep|fgrep|rg|find|fd|locate|sed|awk|perl|cp|mv|rm|mkdir|rmdir|touch|chmod|chown|ln|pwd|readlink|stat|cut|sort|uniq|xargs|tee|tr|basename|dirname)$";
+
+	// Escape the snapshot path for shell
+	const escapedPath = snapshotPath.replace(/'/g, "'\\''");
+
+	// Function extraction differs between bash and zsh
+	const functionScript = isZsh
+		? `
+echo "# Functions" >> "$SNAPSHOT_FILE"
+# Force autoload all functions first
+typeset -f > /dev/null 2>&1
+# Get user function names - filter system/private ones
+typeset +f 2>/dev/null | grep -vE '^(_|__)' | grep -vE '${commonToolsRegex}' | while read func; do
+   typeset -f "$func" >> "$SNAPSHOT_FILE" 2>/dev/null
+done
+`
+		: `
+echo "# Functions" >> "$SNAPSHOT_FILE"
+# Force autoload all functions first
+declare -f > /dev/null 2>&1
+# Get user function names - filter system/private ones
+declare -F 2>/dev/null | cut -d' ' -f3 | grep -vE '^(_|__)' | grep -vE '${commonToolsRegex}' | while read func; do
+   declare -f "$func" >> "$SNAPSHOT_FILE" 2>/dev/null
+done
+`;
+
+	// Shell options extraction
+	const optionsScript = isZsh
+		? `
+echo "# Shell Options" >> "$SNAPSHOT_FILE"
+setopt 2>/dev/null | sed 's/^/setopt /' | head -n 1000 >> "$SNAPSHOT_FILE"
+`
+		: `
+echo "# Shell Options" >> "$SNAPSHOT_FILE"
+shopt -p 2>/dev/null | head -n 1000 >> "$SNAPSHOT_FILE"
+set -o 2>/dev/null | awk '$2 == "on" && $1 !~ /^(onecmd|monitor|restricted)$/ {print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"
+echo "shopt -s expand_aliases" >> "$SNAPSHOT_FILE"
+`;
+
+	return `
+SNAPSHOT_FILE='${escapedPath}'
+
+# Source user's rc file if it exists
+${hasRcFile ? `source "${rcFile}" < /dev/null 2>/dev/null` : "# No user config file to source"}
+
+# Create/clear the snapshot file
+echo "# Shell snapshot - generated by gjc agent" >| "$SNAPSHOT_FILE"
+
+# Unalias everything first to avoid conflicts when sourced
+echo "unalias -a 2>/dev/null || true" >> "$SNAPSHOT_FILE"
+
+${functionScript}
+
+${optionsScript}
+
+# Export aliases (limit to 1000)
+echo "# Aliases" >> "$SNAPSHOT_FILE"
+# Filter out winpty aliases on Windows to avoid "stdin is not a tty" errors
+if [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]]; then
+   alias 2>/dev/null | grep -v "='winpty " | grep -vE '^alias (${commonToolsRegex})=' | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+else
+   alias 2>/dev/null | grep -vE '^alias (${commonToolsRegex})=' | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"
+fi
+
+# Export PATH
+echo "export PATH='$PATH'" >> "$SNAPSHOT_FILE"
+
+# Verify snapshot was created
+if [ ! -f "$SNAPSHOT_FILE" ]; then
+   echo "Error: Snapshot file was not created" >&2
+   exit 1
+fi
+`.trim();
+}
+
+/**
+ * Create a shell snapshot, caching the result.
+ * Returns the path to the snapshot file, or null if creation failed.
+ */
+export async function getOrCreateSnapshot(
+	shell: string,
+	env: Record<string, string | undefined>,
+): Promise<string | null> {
+	const cacheKey = shell;
+	// Return cached snapshot if valid
+	const cached = cachedSnapshotPaths.get(cacheKey);
+	if (cached && fs.existsSync(cached)) {
+		return cached;
+	}
+	if (cached) {
+		cachedSnapshotPaths.delete(cacheKey);
+	}
+
+	// Skip on Windows (no .bashrc in standard location)
+	if (process.platform === "win32") {
+		return null;
+	}
+
+	const rcFile = getShellConfigFile(shell);
+
+	// Create snapshot directory
+	const snapshotDir = path.join(os.tmpdir(), "gjc-shell-snapshots");
+	fs.mkdirSync(snapshotDir, { recursive: true });
+
+	// Generate unique snapshot path
+	const shellName = shell.includes("zsh") ? "zsh" : shell.includes("bash") ? "bash" : "sh";
+	const snapshotPath = path.join(snapshotDir, `snapshot-${shellName}-${crypto.randomUUID()}.sh`);
+
+	// Generate and execute snapshot script
+	const script = generateSnapshotScript(shell, snapshotPath, rcFile);
+
+	try {
+		const snapshotEnv = sanitizeSnapshotEnv(env);
+		const spawnEnv: Record<string, string> = {};
+		for (const [key, value] of Object.entries(snapshotEnv)) {
+			if (value !== undefined) {
+				spawnEnv[key] = value;
+			}
+		}
+		const child = Bun.spawn([shell, "-c", script], {
+			env: spawnEnv,
+			stdin: "ignore",
+			stdout: "ignore",
+			stderr: "ignore",
+			timeout: SNAPSHOT_TIMEOUT_MS,
+			killSignal: "SIGKILL",
+		});
+
+		await child.exited;
+		if (child.exitCode === 0 && fs.existsSync(snapshotPath)) {
+			cachedSnapshotPaths.set(cacheKey, snapshotPath);
+			return snapshotPath;
+		}
+	} catch {
+		// Snapshot creation failed, proceed without it
+	}
+
+	return null;
+}
+
+postmortem.register("shell-snapshot", () => {
+	for (const snapshotPath of cachedSnapshotPaths.values()) {
+		fs.unlinkSync(snapshotPath);
+	}
+	cachedSnapshotPaths.clear();
+});

package/src/utils/sixel.ts

@@ -0,0 +1,69 @@
+import { $env, $flag } from "@gajae-code/utils";
+
+const SIXEL_START_REGEX = /\x1bP(?:[0-9;]*)q/u;
+const SIXEL_END_SEQUENCE = "\x1b\\";
+const SIXEL_END_BELL = "\x07";
+const SIXEL_SEQUENCE_REGEX = /\x1bP(?:[0-9;]*)q[\s\S]*?(?:\x1b\\|\x07)/gu;
+const SIXEL_PLACEHOLDER_PREFIX = "__GJC_SIXEL_SEQUENCE_";
+
+/**
+ * Returns whether SIXEL passthrough is explicitly enabled.
+ *
+ * Both gates must be enabled to preserve SIXEL control sequences:
+ * - PI_FORCE_IMAGE_PROTOCOL=sixel
+ * - PI_ALLOW_SIXEL_PASSTHROUGH=1
+ */
+export function isSixelPassthroughEnabled(): boolean {
+	const forcedProtocol = $env.PI_FORCE_IMAGE_PROTOCOL?.trim().toLowerCase();
+	return forcedProtocol === "sixel" && $flag("PI_ALLOW_SIXEL_PASSTHROUGH");
+}
+/** Returns true when the text contains a SIXEL start sequence. */
+export function containsSixelSequence(text: string): boolean {
+	return SIXEL_START_REGEX.test(text);
+}
+
+/**
+ * Returns a boolean mask indicating which lines belong to a SIXEL sequence block.
+ * Supports multi-line SIXEL payloads generated by libsixel.
+ */
+export function getSixelLineMask(lines: string[]): boolean[] {
+	let inSequence = false;
+	return lines.map(line => {
+		const hasStart = containsSixelSequence(line);
+		if (hasStart) {
+			inSequence = true;
+		}
+		const isSixelLine = inSequence;
+		if (inSequence && (line.includes(SIXEL_END_SEQUENCE) || line.includes(SIXEL_END_BELL))) {
+			inSequence = false;
+		}
+		return isSixelLine;
+	});
+}
+
+/** Returns true when the line contains a SIXEL start sequence. */
+export function isSixelLine(line: string): boolean {
+	return containsSixelSequence(line);
+}
+
+/**
+ * Sanitizes text while preserving embedded SIXEL sequences when passthrough is enabled.
+ */
+export function sanitizeWithOptionalSixelPassthrough(text: string, sanitize: (text: string) => string): string {
+	if (!isSixelPassthroughEnabled() || !containsSixelSequence(text)) {
+		return sanitize(text);
+	}
+
+	const preservedSequences: string[] = [];
+	const tokenized = text.replace(SIXEL_SEQUENCE_REGEX, match => {
+		const token = `${SIXEL_PLACEHOLDER_PREFIX}${preservedSequences.length}__`;
+		preservedSequences.push(match);
+		return token;
+	});
+
+	const sanitized = sanitize(tokenized);
+	return sanitized.replace(/__GJC_SIXEL_SEQUENCE_(\d+)__/gu, (_, indexText: string) => {
+		const index = Number.parseInt(indexText, 10);
+		return preservedSequences[index] ?? "";
+	});
+}

package/src/utils/title-generator.ts

@@ -0,0 +1,223 @@
+/**
+ * Generate session titles using a smol, fast model.
+ */
+import * as path from "node:path";
+
+import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "@gajae-code/ai";
+import { logger, prompt } from "@gajae-code/utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { resolveRoleSelection } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+
+const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
+
+const DEFAULT_TERMINAL_TITLE = "π";
+const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
+
+const MAX_INPUT_CHARS = 2000;
+const TITLE_MAX_TOKENS = 30;
+const REASONING_SAFE_MAX_TOKENS = 1024;
+const SET_TITLE_TOOL_NAME = "set_title";
+
+const setTitleTool: Tool = {
+	name: SET_TITLE_TOOL_NAME,
+	description: "Set the generated session title.",
+	parameters: {
+		type: "object",
+		properties: {
+			title: {
+				type: "string",
+				description: "A concise 3-6 word title for the session.",
+			},
+		},
+		required: ["title"],
+		additionalProperties: false,
+	},
+};
+
+function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry)?.model;
+	if (titleModel) return titleModel;
+
+	if (currentModel) return currentModel;
+
+	return undefined;
+}
+
+/**
+ * Generate a title for a session based on the first user message.
+ *
+ * @param firstMessage The first user message
+ * @param registry Model registry
+ * @param settings Settings used to resolve the smol role
+ * @param sessionId Optional session id for sticky API key selection
+ * @param currentModel Current model (used to derive title model)
+ * @param metadataResolver Optional resolver evaluated after credential selection
+ *   to produce request metadata (e.g. user_id for session attribution). Using a
+ *   resolver instead of a pre-evaluated value ensures the metadata's account_uuid
+ *   reflects the credential actually selected for this request.
+ */
+export async function generateSessionTitle(
+	firstMessage: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
+): Promise<string | null> {
+	const model = getTitleModel(registry, settings, currentModel);
+	if (!model) {
+		logger.debug("title-generator: no title model found");
+		return null;
+	}
+
+	// Truncate message if too long
+	const truncatedMessage =
+		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}…` : firstMessage;
+	const userMessage = `<user-message>
+${truncatedMessage}
+</user-message>`;
+
+	const apiKey = await registry.getApiKey(model, sessionId);
+	if (!apiKey) {
+		logger.debug("title-generator: no API key for smol model", {
+			provider: model.provider,
+			id: model.id,
+		});
+		return null;
+	}
+	// Resolve metadata after getApiKey so the session-sticky credential for this
+	// request is already recorded; metadataResolver can then return the correct
+	// account_uuid rather than the snapshot-at-call-site value.
+	const metadata = metadataResolver?.(model.provider);
+
+	// Title generation is a 3-6 word task, but some reasoning backends ignore
+	// disableReasoning. Keep the normal cheap budget for non-reasoning models
+	// while reserving enough output room for reasoning models to still emit
+	// the forced tool call after any unavoidable thinking tokens.
+	const maxTokens = model.reasoning ? Math.max(TITLE_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : TITLE_MAX_TOKENS;
+	const request = {
+		model: `${model.provider}/${model.id}`,
+		systemPrompt: TITLE_SYSTEM_PROMPT,
+		userMessage,
+		maxTokens,
+	};
+	logger.debug("title-generator: request", request);
+
+	try {
+		const response = await completeSimple(
+			model,
+			{
+				systemPrompt: [request.systemPrompt],
+				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
+				tools: [setTitleTool],
+			},
+			{
+				apiKey,
+				maxTokens: request.maxTokens,
+				disableReasoning: true,
+				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
+				metadata,
+			},
+		);
+
+		if (response.stopReason === "error") {
+			logger.debug("title-generator: response error", {
+				model: request.model,
+				stopReason: response.stopReason,
+				errorMessage: response.errorMessage,
+			});
+			return null;
+		}
+
+		const title = extractGeneratedTitle(response.content);
+
+		logger.debug("title-generator: response", {
+			model: request.model,
+			title,
+			usage: response.usage,
+			stopReason: response.stopReason,
+		});
+
+		if (!title) {
+			return null;
+		}
+
+		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+	} catch (err) {
+		logger.debug("title-generator: error", {
+			model: request.model,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return null;
+	}
+}
+
+function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): string {
+	let textTitle = "";
+	for (const content of contentBlocks) {
+		if (content.type === "toolCall" && content.name === SET_TITLE_TOOL_NAME) {
+			const args = content.arguments as Record<string, unknown>;
+			const title = args.title;
+			return typeof title === "string" ? title.trim() : "";
+		}
+		if (content.type === "text") {
+			textTitle += content.text;
+		}
+	}
+	return textTitle.trim();
+}
+
+/**
+ * Remove control characters so model-generated titles cannot inject terminal escapes.
+ */
+function sanitizeTerminalTitlePart(value: string | undefined): string | undefined {
+	if (!value) return undefined;
+	const sanitized = value.replace(TERMINAL_TITLE_CONTROL_CHARS, "").trim();
+	return sanitized || undefined;
+}
+
+function getFallbackTerminalTitle(cwd: string | undefined): string | undefined {
+	if (!cwd) return undefined;
+	const resolvedCwd = path.resolve(cwd);
+	const baseName = path.basename(resolvedCwd);
+	if (!baseName || baseName === path.parse(resolvedCwd).root) return undefined;
+	return sanitizeTerminalTitlePart(baseName);
+}
+
+export function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string {
+	const label = sanitizeTerminalTitlePart(sessionName) ?? getFallbackTerminalTitle(cwd);
+	return label ? `${DEFAULT_TERMINAL_TITLE}: ${label}` : DEFAULT_TERMINAL_TITLE;
+}
+
+/**
+ * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.
+ */
+export function setTerminalTitle(title: string): void {
+	if (!process.stdout.isTTY) return;
+	process.stdout.write(`\x1b]0;${sanitizeTerminalTitlePart(title) ?? DEFAULT_TERMINAL_TITLE}\x07`);
+}
+
+export function setSessionTerminalTitle(sessionName: string | undefined, cwd?: string): void {
+	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd));
+}
+
+/**
+ * Save the current terminal title on terminals that support xterm window ops.
+ */
+export function pushTerminalTitle(): void {
+	if (!process.stdout.isTTY) return;
+	process.stdout.write("\x1b[22;2t");
+}
+
+/**
+ * Restore the previously saved terminal title on terminals that support xterm window ops.
+ */
+export function popTerminalTitle(): void {
+	if (!process.stdout.isTTY) return;
+	process.stdout.write("\x1b[23;2t");
+}

package/src/utils/tool-choice.ts

@@ -0,0 +1,33 @@
+import type { Api, Model, ToolChoice } from "@gajae-code/ai";
+
+/**
+ * Build a provider-aware tool choice that targets one specific tool when supported.
+ * Providers that only expose required/any forcing may still honor named choices by
+ * narrowing their request tool list before transport.
+ */
+export function buildNamedToolChoice(toolName: string, model?: Model<Api>): ToolChoice | undefined {
+	if (!model) return undefined;
+
+	if (model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") {
+		return { type: "tool", name: toolName };
+	}
+
+	if (
+		model.api === "openai-codex-responses" ||
+		model.api === "openai-responses" ||
+		model.api === "openai-completions" ||
+		model.api === "azure-openai-responses"
+	) {
+		return { type: "function", name: toolName };
+	}
+
+	if (model.api === "ollama-chat") {
+		return { type: "function", name: toolName };
+	}
+
+	if (model.api === "google-generative-ai" || model.api === "google-gemini-cli" || model.api === "google-vertex") {
+		return "required";
+	}
+
+	return undefined;
+}