@gajae-code/ai 0.16.7 → 0.17.1

package/dist/types/utils/block-symbols.d.ts

@@ -1,6 +1,16 @@
-export declare const kCursorExecResolved: unique symbol;
-export type CursorExecResolvedCarrier = object & {
-    [kCursorExecResolved]?: true;
+/**
+ * Provider-resolved tool-call markers.
+ *
+ * A provider that executes a tool call itself (Cursor exec-owned calls, or an
+ * agent-level ACP provider such as Devin, whose agent runs its own tools) marks
+ * the emitted `toolCall` block with this symbol. The agent loop then treats the
+ * call as display-only and never dispatches it to a GJC tool. Symbols are used
+ * instead of a wire field so the marker exists only in-process and can never
+ * round-trip through a transcript or a provider payload.
+ */
+export declare const kProviderResolvedToolCall: unique symbol;
+export type ProviderResolvedCarrier = object & {
+    [kProviderResolvedToolCall]?: true;
 };
-export declare function isCursorExecResolved(block: CursorExecResolvedCarrier | null | undefined): boolean;
-export declare function copyCursorExecResolved(target: CursorExecResolvedCarrier, source: CursorExecResolvedCarrier): void;
+export declare function isProviderResolvedToolCall(block: ProviderResolvedCarrier | null | undefined): boolean;
+export declare function copyProviderResolvedToolCall(target: ProviderResolvedCarrier, source: ProviderResolvedCarrier): void;

package/dist/types/utils/fallback-transport.d.ts

@@ -1,4 +1,4 @@
-export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "server" | "unknown" | "other";
+export type FallbackTriggerClass = "rate_limit" | "quota" | "auth" | "credential" | "server" | "unknown" | "other";
 /**
  * Refinement of an `auth` trigger.
  *
@@ -50,6 +50,8 @@ export interface TransportFailureFacts {
     anthropicErrorType?: string;
     /** OpenAI's typed `error.code`, preserved separately at the transport boundary. */
     openaiErrorCode?: string;
+    /** Provider-authoritative model rejection that is specific to the active credential. */
+    credentialModelUnavailable?: true;
     headers?: Record<string, string>;
     /** Safe request-size observation for retry amplification policy. Never contains body content. */
     requestBytes?: number;
@@ -84,6 +86,7 @@ export interface FallbackTriggerInput {
     status?: number;
     providerCode?: string;
     code?: string;
+    credentialModelUnavailable?: boolean;
     headers?: TransportHeaders;
     response?: {
         status?: number;

package/dist/types/utils.d.ts

@@ -7,6 +7,19 @@ export declare function toNumber(value: unknown): number | undefined;
 export declare function toPositiveNumber(value: unknown, fallback: number): number;
 export declare function toBoolean(value: unknown): boolean | undefined;
 export declare function normalizeToolCallId(id: string): string;
+/**
+ * Wire-facing tool call id for a canonical ToolCall served to a foreign client.
+ *
+ * Responses-backed upstreams (Codex, OpenAI Responses) encode the tool call as
+ * `${call_id}|${item_id}` in `ToolCall.id` so their own replay can recover the
+ * item id. That encoding is gjc-internal: a downstream OpenAI-format client
+ * (OpenCodex, another gjc) truncates the compound value at its own 64-char
+ * limit and can no longer pair its tool output with the call it echoed back,
+ * so the whole chained turn is rejected with "No tool output found". Emit only
+ * the `call_id` half on the wire; the item id travels separately as the item
+ * `id` where the wire format has one.
+ */
+export declare function wireToolCallId(id: string): string;
 type ResponsesToolItemIdPrefix = "fc" | "ctc";
 export declare function normalizeResponsesToolCallId(id: string, itemPrefix?: ResponsesToolItemIdPrefix): {
     callId: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.16.7",
+	"version": "0.17.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -38,10 +38,11 @@
 		"generate-models": "bun scripts/generate-models.ts"
 	},
 	"dependencies": {
+		"@agentclientprotocol/sdk": "1.3.0",
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/natives": "0.16.7",
-		"@gajae-code/utils": "0.16.7",
+		"@gajae-code/natives": "0.17.1",
+		"@gajae-code/utils": "0.17.1",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/api-registry.ts

@@ -26,6 +26,7 @@ const BUILTIN_APIS = new Set<KnownApi>([
 	"google-vertex",
 	"ollama-chat",
 	"cursor-agent",
+	"devin-acp",
 ]);
 
 export type CustomStreamFn = (

package/src/auth-broker/redact.ts

@@ -23,8 +23,16 @@ export function cleanReason(value: unknown): string | undefined {
 		return "Credential diagnostic unavailable.";
 	reason = reason.replace(/bearer\s+[^\s,;]+/gi, "Bearer [redacted]");
 	reason = reason.replace(/basic\s+[^\s,;]+/gi, "Basic [redacted]");
-	reason = reason.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1[redacted]@");
-	reason = reason.replace(/\b([a-z][a-z0-9+.-]*:\/\/[^\s<>"']*?)(?:[?#][^\s<>"']*)/gi, "$1");
+	// The scheme-character run is boundary anchored, so the unbounded suffix is
+	// attempted once per maximal run instead of once at every prefix. Keeping the
+	// leading non-letter characters in the capture preserves redaction for URLs
+	// embedded after digits or scheme punctuation without imposing an arbitrary
+	// scheme-length cap. Upstream failure text is remote-influenced.
+	reason = reason.replace(/(?<![A-Za-z0-9+.-])([0-9+.-]*[a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, "$1[redacted]@");
+	// Apply the same maximal-run boundary to query and fragment stripping. A word
+	// boundary would skip underscore-wrapped URLs, while an unbounded scheme with
+	// no boundary would retry every prefix of a long scheme-character run.
+	reason = reason.replace(/(?<![A-Za-z0-9+.-])([0-9+.-]*[a-z][a-z0-9+.-]*:\/\/[^\s<>"']*?)(?:[?#][^\s<>"']*)/gi, "$1");
 	reason = reason.replace(
 		/((?:\\?["']?(?:key|api[_-]?key|client[_-]?secret|clientSecret|token|secret|authorization|password|access|refresh|cookie|credential)(?:[_-](?:token|key|secret|header|headers))?\\?["']?)\s*:\s*)\\?(["'])(?:\\.|(?!\2)[^\\])*\2/gi,
 		"$1$2[redacted]$2",

package/src/auth-gateway/server.ts

@@ -621,10 +621,9 @@ async function markManagedGatewayCredentialFailure(
 		}
 		if (trigger.class === "auth") {
 			await storage.invalidateCredentialMatching(model.provider, apiKey, signal);
-		} else if (trigger.class === "quota" || trigger.class === "rate_limit") {
-			await storage.markUsageLimitReached(model.provider, undefined, {
+		} else if (trigger.class === "quota" || trigger.class === "rate_limit" || trigger.class === "credential") {
+			await storage.markUsageLimitReachedMatching(model.provider, apiKey, {
 				retryAfterMs: trigger.retryAfterMs,
-				signal,
 			});
 		} else {
 			return;
@@ -647,6 +646,48 @@ async function markManagedGatewayCredentialFailure(
 	}
 }
 
+/**
+ * Records a provider-confirmed account-specific model rejection against the
+ * leased credential on the ordinary (non-managed) gateway path. The leased
+ * account is excluded from future selection so later requests stop picking the
+ * same model-incompatible account, but the credential is never invalidated: it
+ * may still serve other models. Never returns a replacement key — the current
+ * request surfaces the provider's own error and the next lease picks another
+ * credential.
+ */
+async function markUnmanagedGatewayCredentialModelFailure(
+	storage: AuthStorage,
+	model: Model<Api>,
+	apiKey: string,
+	error: unknown,
+	format: string,
+	peer: string,
+): Promise<void> {
+	// Thrown errors may carry the typed facts on a `transportFailure` carrier;
+	// classify the carried facts so a synchronous custom-provider throw is
+	// recognized exactly like a mid-stream error event.
+	const carried = (error as { transportFailure?: unknown } | null | undefined)?.transportFailure;
+	const trigger = classifyFallbackTrigger(carried ?? error);
+	if (trigger.class !== "credential") return;
+	try {
+		await storage.markUsageLimitReachedMatching(model.provider, apiKey, {
+			retryAfterMs: trigger.retryAfterMs,
+		});
+		logger.debug("auth-gateway recorded credential model rejection", {
+			format,
+			provider: model.provider,
+			peer,
+		});
+	} catch (markError) {
+		logger.warn("auth-gateway failed to record credential model rejection", {
+			format,
+			provider: model.provider,
+			peer,
+			error: cleanReason(markError) ?? "Credential bookkeeping failed",
+		});
+	}
+}
+
 function observeManagedGatewayFailure(
 	events: AssistantMessageEventStream,
 	markFailure: (error: unknown) => Promise<void>,
@@ -831,6 +872,8 @@ async function handleFormatEndpoint(
 				route.label,
 				peer,
 			);
+		} else {
+			await markUnmanagedGatewayCredentialModelFailure(bootOpts.storage, model, apiKey, error, route.label, peer);
 		}
 		const classified = classifyGatewayError(error);
 		logger.warn("auth-gateway streamSimple threw", { format: route.label, error: classified.message, peer });
@@ -849,6 +892,10 @@ async function handleFormatEndpoint(
 				peer,
 			),
 		);
+	} else {
+		events = observeManagedGatewayFailure(events, error =>
+			markUnmanagedGatewayCredentialModelFailure(bootOpts.storage, model, apiKey, error, route.label, peer),
+		);
 	}
 	events = redactGatewayStream(events);
 
@@ -1041,6 +1088,8 @@ async function handlePiNative(
 				"pi-native",
 				peer,
 			);
+		} else {
+			await markUnmanagedGatewayCredentialModelFailure(bootOpts.storage, model, apiKey, error, "pi-native", peer);
 		}
 		const classified = classifyGatewayError(error);
 		logger.warn("auth-gateway streamSimple threw", { format: "pi-native", error: classified.message, peer });
@@ -1059,6 +1108,10 @@ async function handlePiNative(
 				peer,
 			),
 		);
+	} else {
+		events = observeManagedGatewayFailure(events, error =>
+			markUnmanagedGatewayCredentialModelFailure(bootOpts.storage, model, apiKey, error, "pi-native", peer),
+		);
 	}
 	events = redactGatewayStream(events);