@gajae-code/ai 0.16.7 → 0.17.1

package/src/providers/google-gemini-headers.d.ts

@@ -5,7 +5,7 @@
  */
 export declare const GEMINI_CLI_VERSION_ENV = "GJC_AI_GEMINI_CLI_VERSION";
 export declare const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
-export declare const DEFAULT_GEMINI_CLI_VERSION = "0.58.0";
+export declare const DEFAULT_GEMINI_CLI_VERSION = "0.60.0";
 export declare function getGeminiCliUserAgent(modelId?: string): string;
 export declare const getGeminiCliHeaders: (modelId?: string) => {
     "User-Agent": string;

package/src/providers/google-gemini-headers.ts

@@ -5,7 +5,7 @@
  */
 export const GEMINI_CLI_VERSION_ENV = "GJC_AI_GEMINI_CLI_VERSION";
 export const LEGACY_GEMINI_CLI_VERSION_ENV = "PI_AI_GEMINI_CLI_VERSION";
-export const DEFAULT_GEMINI_CLI_VERSION = "0.58.0";
+export const DEFAULT_GEMINI_CLI_VERSION = "0.60.0";
 
 export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
 	const version =

package/src/providers/mock.ts

@@ -98,6 +98,8 @@ export interface MockResponse {
 	providerPayload?: AssistantMessage["providerPayload"];
 	/** Optional typed provider failure metadata for retry/fallback tests. */
 	transportFailure?: AssistantMessage["transportFailure"];
+	/** Bounded, redaction-safe failure classifier copied onto the terminal error message. */
+	errorCode?: string;
 	/** If set, the stream emits a terminal error event instead of completing. */
 	throw?: string | Error;
 	/** Delay before any event is emitted. Honors the call's AbortSignal. */
@@ -363,7 +365,7 @@ async function runMock(
 				: response.throw instanceof Error
 					? response.throw.message
 					: String(response.throw);
-		emitTerminalError(stream, model, startedAt, "error", message);
+		emitTerminalError(stream, model, startedAt, "error", message, response.errorCode ?? errorCodeOf(response.throw));
 		return;
 	}
 
@@ -485,6 +487,7 @@ function emitTerminalError(
 	startedAt: number,
 	reason: "aborted" | "error",
 	message: string,
+	errorCode?: string,
 ): void {
 	const failure: AssistantMessage = {
 		role: "assistant",
@@ -495,6 +498,7 @@ function emitTerminalError(
 		usage: emptyUsage(),
 		stopReason: reason as StopReason,
 		errorMessage: message,
+		...(errorCode !== undefined ? { errorCode } : {}),
 		timestamp: startedAt,
 		duration: Date.now() - startedAt,
 	};
@@ -502,6 +506,17 @@ function emitTerminalError(
 	stream.push({ type: "error", reason, error: failure });
 }
 
+/** Bounded safe-token classifier read off a thrown mock error, when present. */
+function errorCodeOf(value: unknown): string | undefined {
+	try {
+		if (!(value instanceof Error)) return undefined;
+		const code = (value as { code?: unknown }).code;
+		return typeof code === "string" && code.length <= 64 && /^[A-Za-z0-9._-]+$/.test(code) ? code : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 function sleep(ms: number, signal?: AbortSignal): Promise<void> {
 	const { promise, resolve, reject } = Promise.withResolvers<void>();
 	if (signal?.aborted) {

package/src/providers/openai-chat-server.ts

@@ -20,7 +20,7 @@ import type {
 	ToolResultMessage,
 	TSchema,
 } from "../types";
-import { sanitizeJsonStrings } from "../utils";
+import { sanitizeJsonStrings, wireToolCallId } from "../utils";
 import {
 	type OpenAIChatContentPart,
 	type OpenAIChatMessage,
@@ -377,7 +377,7 @@ export function encodeResponse(message: AssistantMessage, requestedModelId: stri
 	}
 	if (toolCalls.length > 0) {
 		responseMessage.tool_calls = toolCalls.map(tc => ({
-			id: tc.id,
+			id: wireToolCallId(tc.id),
 			type: "function",
 			function: { name: tc.name, arguments: stringifyArgs(tc.arguments) },
 		}));
@@ -639,7 +639,7 @@ export function encodeStream(
 										tool_calls: [
 											{
 												index: idx,
-												id: call?.id ?? "",
+												id: call ? wireToolCallId(call.id) : "",
 												type: "function",
 												function: { name: call?.name ?? "", arguments: "" },
 											},

package/src/providers/openai-codex-responses.ts

@@ -51,10 +51,6 @@ import {
 	normalizeSystemPrompts,
 	sanitizeOpenAIResponsesHistoryItemsForReplay,
 } from "../utils";
-import {
-	formatOpenAICodexChatGPTEntitlementError,
-	isOpenAICodexChatGPTEntitlementError,
-} from "../utils/codex-entitlement";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE, transportFailureFacts } from "../utils/fallback-transport";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
@@ -134,7 +130,7 @@ const CODEX_PREVIOUS_RESPONSE_STALE_CODES = new Set(["previous_response_not_foun
 // on both sides of the anchor phrase), since a deterministic history fault such
 // as `Previous response's tool call ID is malformed.` must stay fatal:
 // replaying it re-sends the same offending item.
-const CODEX_PREVIOUS_RESPONSE_ID_TOKEN = String.raw`previous[ _-]response[ _-]id`;
+const CODEX_PREVIOUS_RESPONSE_ID_TOKEN = `previous[ _-]response[ _-]id`;
 // Prose anchor reference ("Previous response with id 'resp_1' not found."):
 // the canonical `previous_response_not_found` wording, which codex-lb re-codes
 // as `invalid_request_error` the same way it re-codes the anchor-expiry fault
@@ -146,7 +142,7 @@ const CODEX_PREVIOUS_RESPONSE_PROSE_TOKEN = `previous[ _-]response`;
 // the same offending item. Tempering the qualifier⇄token scan against these
 // tokens keeps them fatal while pure anchor-stale prose still matches.
 const CODEX_PREVIOUS_RESPONSE_STALE_SUBFIELD_GUARD = `tool[ _]calls?|function[ _]calls?|custom[ _]tools?|call[ _-]?ids?|message[ _]?ids?|items?\\b|output[ _-]?items?`;
-const CODEX_ANCHOR_STALE_QUALIFIER = String.raw`invalid|expired|unknown|stale|not[ _-]?found|no longer`;
+const CODEX_ANCHOR_STALE_QUALIFIER = `invalid|expired|unknown|stale|not[ _-]?found|no longer`;
 const CODEX_PREVIOUS_RESPONSE_STALE_MESSAGE = new RegExp(
 	`(?:${CODEX_ANCHOR_STALE_QUALIFIER})[^\\n]{0,48}?${CODEX_PREVIOUS_RESPONSE_ID_TOKEN}` +
 		`|${CODEX_PREVIOUS_RESPONSE_ID_TOKEN}[^\\n]{0,48}?(?:${CODEX_ANCHOR_STALE_QUALIFIER})`,
@@ -178,6 +174,7 @@ const CODEX_NON_RETRYABLE_EVENT_MESSAGE =
 	/invalid[_ -]function[_ -]parameters|invalid schema for function|invalid[_ -]tool[_ -]schema|schema must have type ["']?object["']?|request blocked[^\n]*invalid[_ -]prompt|code=invalid[_ -]prompt/i;
 const CODEX_RETRYABLE_EVENT_MESSAGE =
 	/processing your request|retry your request|temporar(?:y|ily)|overloaded|service.?unavailable|internal error|server error/i;
+const CODEX_ACCOUNT_MODEL_UNAVAILABLE_MESSAGE = /\bnot supported when using codex with a chatgpt account\b/i;
 const CODEX_PROVIDER_SESSION_STATE_KEY = "openai-codex-responses";
 const X_CODEX_TURN_STATE_HEADER = "x-codex-turn-state";
 const X_MODELS_ETAG_HEADER = "x-models-etag";
@@ -1246,7 +1243,7 @@ function handleCodexStreamEvent(args: {
 	}
 
 	if (eventType === "error" || eventType === "response.failed") {
-		throw createCodexProviderStreamError(rawEvent, model.id);
+		throw createCodexProviderStreamError(rawEvent);
 	}
 
 	return firstTokenTime;
@@ -2865,14 +2862,13 @@ async function openCodexSseEventStream(
 	updateCodexSessionMetadataFromHeaders(state, response.headers);
 	if (!response.ok) {
 		const info = await parseCodexError(response);
-		const error = new Error(
-			isOpenAICodexChatGPTEntitlementError(info.message, info.code)
-				? formatOpenAICodexChatGPTEntitlementError(body.model)
-				: info.friendlyMessage || info.message,
-		);
+		const error = new Error(info.friendlyMessage || info.message);
 		(error as { headers?: Headers; status?: number }).headers = response.headers;
 		(error as { headers?: Headers; status?: number }).status = response.status;
 		(error as { code?: string }).code = info.code;
+		if (isCodexAccountModelUnavailable(info.message, info.code)) {
+			(error as { credentialModelUnavailable?: true }).credentialModelUnavailable = true;
+		}
 		throw error;
 	}
 	if (!response.body) {
@@ -3219,6 +3215,7 @@ function getCodexEventErrorMessage(rawEvent: Record<string, unknown>): string {
 class CodexProviderStreamError extends Error {
 	readonly retryable: boolean;
 	readonly code?: string;
+	readonly credentialModelUnavailable: boolean;
 	/**
 	 * Provider-supplied message, before display formatting appends `code=`/`status=`
 	 * metadata. Classification must read this, never `message`: the formatted string
@@ -3227,12 +3224,19 @@ class CodexProviderStreamError extends Error {
 	 */
 	readonly providerMessage: string;
 
-	constructor(message: string, retryable: boolean, code: string | undefined, providerMessage: string) {
+	constructor(
+		message: string,
+		retryable: boolean,
+		code: string | undefined,
+		providerMessage: string,
+		credentialModelUnavailable: boolean,
+	) {
 		super(message);
 		this.name = "CodexProviderStreamError";
 		this.retryable = retryable;
 		this.code = code;
 		this.providerMessage = providerMessage;
+		this.credentialModelUnavailable = credentialModelUnavailable;
 	}
 }
 
@@ -3251,12 +3255,11 @@ function isRetryableCodexFailureEvent(rawEvent: Record<string, unknown>): boolea
 	return !!message && CODEX_RETRYABLE_EVENT_MESSAGE.test(message);
 }
 
-function createCodexProviderStreamError(rawEvent: Record<string, unknown>, modelId: string): CodexProviderStreamError {
+function createCodexProviderStreamError(rawEvent: Record<string, unknown>): CodexProviderStreamError {
 	const code = getCodexEventErrorCode(rawEvent);
 	const message = getCodexEventErrorMessage(rawEvent);
-	const formattedMessage = isOpenAICodexChatGPTEntitlementError(message, code)
-		? formatOpenAICodexChatGPTEntitlementError(modelId)
-		: typeof rawEvent.type === "string" && rawEvent.type === "error"
+	const formattedMessage =
+		typeof rawEvent.type === "string" && rawEvent.type === "error"
 			? formatCodexErrorEvent(rawEvent, code, message)
 			: (formatCodexFailure(rawEvent) ?? "Codex response failed");
 	return new CodexProviderStreamError(
@@ -3264,6 +3267,13 @@ function createCodexProviderStreamError(rawEvent: Record<string, unknown>, model
 		isRetryableCodexFailureEvent(rawEvent),
 		code || undefined,
 		message,
+		isCodexAccountModelUnavailable(message, code),
+	);
+}
+
+function isCodexAccountModelUnavailable(message: string | undefined, code: string | undefined): boolean {
+	return (
+		CODEX_ACCOUNT_MODEL_UNAVAILABLE_MESSAGE.test(message ?? "") && code?.toLowerCase() === "invalid_request_error"
 	);
 }
 

package/src/providers/openai-responses-server.ts

@@ -22,7 +22,7 @@ import type {
 	Tool,
 	ToolCall,
 } from "../types";
-import { sanitizeJsonStrings } from "../utils";
+import { sanitizeJsonStrings, wireToolCallId } from "../utils";
 import {
 	type OpenAIResponsesFunctionCallItem,
 	type OpenAIResponsesFunctionCallOutputItem,
@@ -666,7 +666,7 @@ function buildOutputItems(message: AssistantMessage): OutputItem[] {
 				out.push({
 					type: "custom_tool_call",
 					id: part.thoughtSignature ?? makeCustomCallId(),
-					call_id: part.id,
+					call_id: wireToolCallId(part.id),
 					name: part.customWireName,
 					input: rawInput,
 					status: "completed",
@@ -675,7 +675,7 @@ function buildOutputItems(message: AssistantMessage): OutputItem[] {
 				out.push({
 					type: "function_call",
 					id: part.thoughtSignature ?? makeFuncCallId(),
-					call_id: part.id,
+					call_id: wireToolCallId(part.id),
 					name: part.name,
 					arguments: JSON.stringify(sanitizeJsonStrings(part.arguments ?? {})),
 					status: "completed",
@@ -850,7 +850,7 @@ export function encodeStream(
 						: undefined;
 				const isCustom = customWireName !== undefined;
 				const itemId = tc?.thoughtSignature ?? (isCustom ? makeCustomCallId() : makeFuncCallId());
-				const callId = tc?.id ?? "";
+				const callId = tc ? wireToolCallId(tc.id) : "";
 				const name = customWireName ?? tc?.name ?? "";
 				const item = isCustom
 					? {
@@ -1143,7 +1143,7 @@ export function encodeStream(
 							const tc = ev.toolCall;
 							if (tc.customWireName && !cur.customWireName) cur.customWireName = tc.customWireName;
 							if (tc.thoughtSignature) cur.itemId = tc.thoughtSignature;
-							cur.callId = tc.id;
+							cur.callId = wireToolCallId(tc.id);
 							cur.name = cur.customWireName ?? tc.name;
 							if (cur.customWireName) {
 								// Custom tool: raw input string. Streamed deltas accumulated

package/src/providers/openai-responses-shared.d.ts

@@ -44,7 +44,27 @@ export interface ProcessResponsesStreamOptions {
     onFirstToken?: () => void;
     onOutputItemDone?: (item: ResponseOutputItem) => void;
 }
-export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<void>;
+export declare function processResponsesStream<TApi extends Api>(openaiStream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>, output: AssistantMessage, stream: AssistantMessageEventStream, model: Model<TApi>, options?: ProcessResponsesStreamOptions): Promise<boolean>;
+/**
+ * Bounded classifier for a Responses stream that ended in failure before a
+ * successful terminal event: a `response.failed` envelope, a `response.completed`
+ * with `failed` status, a top-level `error` event, or an unexpected EOF (the
+ * stream returning without any terminal event). It is deliberately NOT a
+ * transport-retry fact: `transportFailureFacts` does not admit it, so preserving
+ * this diagnostic can never authorize a replay.
+ */
+export declare const RESPONSES_STREAM_FAILURE_CODE = "upstream_stream_interrupted";
+/**
+ * Typed error for an SSE stream that ended (EOF) before any terminal event, so
+ * the caller sees a bounded classifier instead of a content-free success.
+ */
+export declare function unexpectedResponsesStreamEndError(): Error;
+/**
+ * Read the bounded stream-failure classifier back off a thrown provider error.
+ * Only this module's own classifier is returned, so a foreign error's arbitrary
+ * `code` can never be forwarded onto the assistant message.
+ */
+export declare function responsesStreamFailureCode(error: unknown): string | undefined;
 /**
  * Mark tool-call blocks left incomplete by a length-truncated response so the
  * agent loop rejects them instead of executing a best-effort partial parse.

package/src/providers/openai-responses-shared.ts

@@ -52,6 +52,7 @@ const OPENAI_RESPONSES_PROGRESS_EVENT_TYPES = new Set([
 	"response.custom_tool_call_input.done",
 	"response.output_item.done",
 	"response.completed",
+	"response.incomplete",
 	"response.failed",
 	"error",
 ]);
@@ -447,7 +448,7 @@ export async function processResponsesStream<TApi extends Api>(
 	stream: AssistantMessageEventStream,
 	model: Model<TApi>,
 	options?: ProcessResponsesStreamOptions,
-): Promise<void> {
+): Promise<boolean> {
 	type StreamItem = ResponseReasoningItem | ResponseOutputMessage | ResponseFunctionToolCall | ResponseCustomToolCall;
 	type StreamBlock = ThinkingContent | TextContent | (ToolCall & { partialJson: string });
 	interface ItemEntry {
@@ -592,6 +593,7 @@ export async function processResponsesStream<TApi extends Api>(
 	};
 	let sawFirstToken = false;
 
+	let sawTerminalEvent = false;
 	for await (const event of openaiStream) {
 		if (event.type === "response.created") {
 			output.responseId = event.response.id;
@@ -963,14 +965,25 @@ export async function processResponsesStream<TApi extends Api>(
 				dropEntry(item.id, event.output_index, item.call_id);
 				stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
 			}
-		} else if (event.type === "response.completed") {
+		} else if (event.type === "response.completed" || event.type === "response.incomplete") {
+			sawTerminalEvent = true;
 			const response = event.response;
 			if (response?.id) {
 				output.responseId = response.id;
 			}
 			populateResponsesUsageFromResponse(output, response?.usage);
 			calculateCost(model, output.usage);
-			output.stopReason = mapOpenAIResponsesStopReason(response?.status);
+			// A `response.incomplete` frame is terminal because the response was cut
+			// short, so the event type itself proves truncation. Deriving `length`
+			// from the event rather than trusting `response.status` stops a relay that
+			// drops or rewrites the status from turning a truncated turn into a plain
+			// `stop`/`toolUse` that would dispatch a tool call carrying repaired
+			// partial arguments with no `incompleteArguments` flag.
+			const terminalStatus = response?.status;
+			output.stopReason =
+				event.type === "response.incomplete" && terminalStatus !== "failed" && terminalStatus !== "cancelled"
+					? "length"
+					: mapOpenAIResponsesStopReason(terminalStatus);
 			if (response?.status === "failed" || response?.status === "cancelled") {
 				const error = response?.error ?? (response as any)?.status_details?.error;
 				const details = response?.incomplete_details;
@@ -998,8 +1011,9 @@ export async function processResponsesStream<TApi extends Api>(
 				output.stopReason = "toolUse";
 			}
 		} else if (event.type === "error") {
-			throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
+			throw createResponsesStreamFailureError(`Error Code ${event.code}: ${event.message}` || "Unknown error");
 		} else if (event.type === "response.failed") {
+			sawTerminalEvent = true;
 			const error = event.response?.error ?? (event.response as any)?.status_details?.error;
 			const details = event.response?.incomplete_details;
 			const message = error
@@ -1010,6 +1024,45 @@ export async function processResponsesStream<TApi extends Api>(
 			throw createResponsesFailedError(message, error?.code);
 		}
 	}
+	return sawTerminalEvent;
+}
+
+/**
+ * Bounded classifier for a Responses stream that ended in failure before a
+ * successful terminal event: a `response.failed` envelope, a `response.completed`
+ * with `failed` status, a top-level `error` event, or an unexpected EOF (the
+ * stream returning without any terminal event). It is deliberately NOT a
+ * transport-retry fact: `transportFailureFacts` does not admit it, so preserving
+ * this diagnostic can never authorize a replay.
+ */
+export const RESPONSES_STREAM_FAILURE_CODE = "upstream_stream_interrupted";
+
+/** Attach the bounded stream-failure classifier without touching retry facts. */
+function createResponsesStreamFailureError(message: string): Error {
+	return Object.assign(new Error(message), { code: RESPONSES_STREAM_FAILURE_CODE });
+}
+
+/**
+ * Typed error for an SSE stream that ended (EOF) before any terminal event, so
+ * the caller sees a bounded classifier instead of a content-free success.
+ */
+export function unexpectedResponsesStreamEndError(): Error {
+	return createResponsesStreamFailureError("Upstream response stream ended before a terminal response event");
+}
+
+/**
+ * Read the bounded stream-failure classifier back off a thrown provider error.
+ * Only this module's own classifier is returned, so a foreign error's arbitrary
+ * `code` can never be forwarded onto the assistant message.
+ */
+export function responsesStreamFailureCode(error: unknown): string | undefined {
+	try {
+		return (error as { code?: unknown } | undefined)?.code === RESPONSES_STREAM_FAILURE_CODE
+			? RESPONSES_STREAM_FAILURE_CODE
+			: undefined;
+	} catch {
+		return undefined;
+	}
 }
 
 /**
@@ -1020,10 +1073,11 @@ export async function processResponsesStream<TApi extends Api>(
  * Exactly OpenAI's capacity-overload code is carried through as transport facts,
  * matched case-sensitively; every other failure stays a plain error, so an
  * untyped, cased, or malformed code can never reach a typed retry admission. The
- * display message is unchanged either way.
+ * display message is unchanged either way. Every non-overload envelope carries
+ * the bounded stream-failure classifier instead of a typed retry fact.
  */
 function createResponsesFailedError(message: string, code: string | undefined): Error {
-	if (code !== SERVER_OVERLOADED_PROVIDER_CODE) return new Error(message);
+	if (code !== SERVER_OVERLOADED_PROVIDER_CODE) return createResponsesStreamFailureError(message);
 	const error = new Error(message) as Error & { openaiErrorCode?: string };
 	error.openaiErrorCode = SERVER_OVERLOADED_PROVIDER_CODE;
 	return error;

package/src/providers/openai-responses.ts

@@ -92,6 +92,8 @@ import {
 	normalizeResponsesToolCallIdForTransform,
 	processResponsesStream,
 	repairOrphanResponsesToolOutputs,
+	responsesStreamFailureCode,
+	unexpectedResponsesStreamEndError,
 } from "./openai-responses-shared";
 import {
 	applyOpenCodeGoSessionHeader,
@@ -468,7 +470,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			stream.push({ type: "start", partial: output });
 
 			const nativeOutputItems: Array<Record<string, unknown>> = [];
-			await processResponsesStream(
+			const sawTerminalEvent = await processResponsesStream(
 				iterateWithIdleTimeout(openaiStream, {
 					idleTimeoutMs,
 					firstItemTimeoutMs: firstEventTimeoutMs,
@@ -505,6 +507,11 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				throw new Error(output.errorMessage ?? "An unknown error occurred");
 			}
 
+			// The Responses SSE contract always ends with a terminal event. A stream
+			// that closes without one is an interrupted upstream, not a completed
+			// turn, and must not surface as a content-free success.
+			if (!sawTerminalEvent) throw unexpectedResponsesStreamEndError();
+
 			output.providerPayload = createOpenAIResponsesHistoryPayload(model.provider, nativeOutputItems);
 			if (isOpenCodeGoEmptyCompletedResponse(model, output, nativeOutputItems.length)) {
 				output.stopReason = "error";
@@ -534,6 +541,8 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 			output.stopReason = abortTracker.wasCallerAbort() ? "aborted" : "error";
 			output.errorStatus = extractHttpStatusFromError(localAbortReason ?? normalizedError);
 			output.transportFailure = transportFailureFacts(localAbortReason ?? normalizedError);
+			const streamFailureCode = responsesStreamFailureCode(localAbortReason ?? normalizedError);
+			if (streamFailureCode !== undefined) output.errorCode = streamFailureCode;
 			output.errorMessage =
 				localAbortReason?.message ?? (await finalizeErrorMessage(normalizedError, rawRequestDump));
 			output.errorMessage = rewriteCopilotError(output.errorMessage, normalizedError, model.provider);

package/src/providers/register-builtins.d.ts

@@ -53,6 +53,7 @@ export declare const streamOpenAICodexResponses: (model: Model<"openai-codex-res
 export declare const streamOpenAICompletions: (model: Model<"openai-completions">, context: Context, options: OptionsForApi<"openai-completions">, onStreamCreated?: () => void) => EventStreamImpl;
 export declare const streamOpenAIResponses: (model: Model<"openai-responses">, context: Context, options: OptionsForApi<"openai-responses">, onStreamCreated?: () => void) => EventStreamImpl;
 export declare const streamCursor: (model: Model<"cursor-agent">, context: Context, options: OptionsForApi<"cursor-agent">, onStreamCreated?: () => void) => EventStreamImpl;
+export declare const streamDevinAcp: (model: Model<"devin-acp">, context: Context, options: import("../types").StreamOptions, onStreamCreated?: () => void) => EventStreamImpl;
 export declare const streamOllama: (model: Model<"ollama-chat">, context: Context, options: OptionsForApi<"ollama-chat">, onStreamCreated?: () => void) => EventStreamImpl;
 export declare const streamBedrock: (model: Model<"bedrock-converse-stream">, context: Context, options: OptionsForApi<"bedrock-converse-stream">, onStreamCreated?: () => void) => EventStreamImpl;
 export declare const streamKiroCodeWhisperer: (model: Model<"kiro-codewhisperer-stream">, context: Context, options: OptionsForApi<"kiro-codewhisperer-stream">, onStreamCreated?: () => void) => EventStreamImpl;

package/src/providers/register-builtins.ts

@@ -34,6 +34,7 @@ import type { BedrockOptions } from "./amazon-bedrock";
 import type { AnthropicOptions } from "./anthropic";
 import type { AzureOpenAIResponsesOptions } from "./azure-openai-responses";
 import type { CursorOptions } from "./cursor";
+import type { DevinAcpOptions } from "./devin-acp";
 import type { GoogleOptions } from "./google";
 import type { GoogleGeminiCliOptions } from "./google-gemini-cli";
 import type { GoogleVertexOptions } from "./google-vertex";
@@ -146,6 +147,14 @@ interface CursorProviderModule {
 	) => AssistantMessageEventStream;
 }
 
+interface DevinAcpProviderModule {
+	streamDevinAcp: (
+		model: Model<"devin-acp">,
+		context: Context,
+		options: DevinAcpOptions,
+	) => AssistantMessageEventStream;
+}
+
 interface BedrockProviderModule {
 	streamBedrock: (
 		model: Model<"bedrock-converse-stream">,
@@ -176,6 +185,7 @@ let openAICompletionsProviderModulePromise: Promise<LazyProviderModule<"openai-c
 let openAIResponsesProviderModulePromise: Promise<LazyProviderModule<"openai-responses">> | undefined;
 let ollamaProviderModulePromise: Promise<LazyProviderModule<"ollama-chat">> | undefined;
 let cursorProviderModulePromise: Promise<LazyProviderModule<"cursor-agent">> | undefined;
+let devinAcpProviderModulePromise: Promise<LazyProviderModule<"devin-acp">> | undefined;
 let bedrockProviderModuleOverride: LazyProviderModule<"bedrock-converse-stream"> | undefined;
 let kiroCodeWhispererProviderModulePromise: Promise<LazyProviderModule<"kiro-codewhisperer-stream">> | undefined;
 let bedrockProviderModulePromise: Promise<LazyProviderModule<"bedrock-converse-stream">> | undefined;
@@ -459,6 +469,14 @@ function loadCursorProviderModule(): Promise<LazyProviderModule<"cursor-agent">>
 	return cursorProviderModulePromise;
 }
 
+function loadDevinAcpProviderModule(): Promise<LazyProviderModule<"devin-acp">> {
+	devinAcpProviderModulePromise ||= Promise.resolve().then(() => {
+		const provider = require("./devin-acp") as DevinAcpProviderModule;
+		return { stream: provider.streamDevinAcp };
+	});
+	return devinAcpProviderModulePromise;
+}
+
 function loadBedrockProviderModule(): Promise<LazyProviderModule<"bedrock-converse-stream">> {
 	if (bedrockProviderModuleOverride) {
 		return Promise.resolve(bedrockProviderModuleOverride);
@@ -492,6 +510,7 @@ export const PROVIDER_RUNTIME_DESCRIPTORS: readonly ProviderRuntimeDescriptor<Ap
 	{ api: "openai-responses", load: loadOpenAIResponsesProviderModule },
 	{ api: "ollama-chat", load: loadOllamaProviderModule },
 	{ api: "cursor-agent", load: loadCursorProviderModule },
+	{ api: "devin-acp", load: loadDevinAcpProviderModule },
 	{ api: "kiro-codewhisperer-stream", load: loadKiroCodeWhispererProviderModule },
 	{ api: "bedrock-converse-stream", load: loadBedrockProviderModule },
 ] as readonly ErasedProviderRuntimeDescriptor[];
@@ -537,7 +556,8 @@ export const streamOpenAIResponses = createLazyStream(
 	loadOpenAIResponsesProviderModule,
 	PROVIDER_OWNED_STREAM_WATCHDOG,
 );
-export const streamCursor = createLazyStream(loadCursorProviderModule);
+export const streamCursor = createLazyStream(loadCursorProviderModule, PROVIDER_OWNED_STREAM_WATCHDOG);
+export const streamDevinAcp = createLazyStream(loadDevinAcpProviderModule, PROVIDER_OWNED_STREAM_WATCHDOG);
 export const streamOllama = createLazyStream(loadOllamaProviderModule);
 
 export const streamBedrock = createLazyStream(loadBedrockProviderModule);

package/src/stream.ts

@@ -39,6 +39,7 @@ import {
 	readAwsStaticEnvironmentCredentials,
 } from "./providers/aws-credential-config";
 import type { CursorOptions } from "./providers/cursor";
+import type { DevinAcpOptions } from "./providers/devin-acp";
 import type { GoogleOptions } from "./providers/google";
 import type { GoogleGeminiCliOptions } from "./providers/google-gemini-cli";
 import type { GoogleVertexOptions } from "./providers/google-vertex";
@@ -54,6 +55,7 @@ import {
 	streamAzureOpenAIResponses,
 	streamBedrock,
 	streamCursor,
+	streamDevinAcp,
 	streamGoogle,
 	streamGoogleGeminiCli,
 	streamGoogleVertex,
@@ -398,6 +400,9 @@ export function stream<TApi extends Api>(
 			(options || {}) as KiroCodeWhispererOptions,
 			onStreamCreated,
 		);
+	} else if (model.api === "devin-acp") {
+		// Devin authenticates through its own CLI, so there is no GJC API key to resolve.
+		return streamDevinAcp(model as Model<"devin-acp">, context, (options || {}) as DevinAcpOptions, onStreamCreated);
 	}
 
 	const apiKey = options?.apiKey || (model.provider === "opencodex" ? "local" : getEnvApiKey(model.provider));
@@ -944,12 +949,15 @@ function mapOptionsForApi<TApi extends Api>(
 		repetitionPenalty: options?.repetitionPenalty,
 		maxTokens: resolveDefaultRequestMaxTokens(model, options?.maxTokens),
 		signal: options?.signal,
+		streamFirstEventTimeoutMs: options?.streamFirstEventTimeoutMs,
+		streamIdleTimeoutMs: options?.streamIdleTimeoutMs,
 		apiKey: apiKey || options?.apiKey,
 		fallbackManaged: options?.fallbackManaged,
 		fallbackAttempt: options?.fallbackAttempt,
 		cacheRetention: options?.cacheRetention ?? model.cacheRetention,
 		headers: options?.headers,
 		initiatorOverride: options?.initiatorOverride,
+		maintenanceCall: options?.maintenanceCall,
 		maxRetryDelayMs: options?.maxRetryDelayMs,
 		requestMaxRetries: options?.fallbackManaged ? 0 : options?.requestMaxRetries,
 		streamMaxRetries: options?.fallbackManaged ? 0 : options?.streamMaxRetries,
@@ -957,6 +965,7 @@ function mapOptionsForApi<TApi extends Api>(
 		sessionId: options?.sessionId,
 		providerSessionId: options?.providerSessionId,
 		providerSessionState: options?.providerSessionState,
+		devinAcp: options?.devinAcp,
 		onPayload: options?.onPayload,
 		onResponse: options?.onResponse,
 		onStreamCreated: options?.onStreamCreated,
@@ -1265,6 +1274,11 @@ function mapOptionsForApi<TApi extends Api>(
 			});
 		}
 
+		case "devin-acp":
+			return castApi<"devin-acp">({
+				...base,
+			});
+
 		case "kiro-codewhisperer-stream":
 			return castApi<"kiro-codewhisperer-stream">({
 				...base,