@xopcai/xopc 0.0.389 → 0.0.390

package/dist/src/agent/inbound/inbound-loop.d.ts

@@ -1,18 +1,3 @@
-/**
- * InboundLoop — owns the bus-driven inbound pipeline.
- *
- * Replaces the previous `AgentService.start()` while-loop, `handleInboundMessage`,
- * and `handleSystemMessage` methods. Everything that "a message arrives, run the
- * agent turn, publish the reply" needs is concentrated here; the parent
- * `AgentService` now just constructs the loop with collaborators and forwards
- * start/stop to it.
- *
- * The constructor takes a fairly wide config because handling a single inbound
- * message touches almost every subsystem (router, command handler, lifecycle
- * manager, agent orchestrator, outbound coordinator, session state, etc.). All
- * dependencies are injected so this class is unit-testable and the inbound
- * pipeline can evolve without touching `AgentService`.
- */
 import type { MessageBus } from '../../infra/bus/index.js';
 import type { Config } from '../../config/schema.js';
 import type { ChannelManager } from '../../channels/manager.js';
@@ -74,5 +59,6 @@ export declare class InboundLoop {
     /** Cooperatively stop the loop; the current message (if any) is allowed to finish. */
     stop(): void;
     private handleInboundMessage;
+    private handleInboundMessageScoped;
     private handleSystemMessage;
 }

package/dist/src/agent/inbound/inbound-loop.js

@@ -1,5 +1,6 @@
 import { runWithLogContext, updateAsyncLogContext } from "../../utils/logger/context.js";
 import { init_logger } from "../../utils/logger.js";
+import { init_model_usage, withModelUsageOrigin } from "../../providers/model-usage.js";
 import { shouldSkipResetOverlapCommand } from "../../session/reset-triggers.js";
 import { initSessionTurn } from "../../session/init-session-turn.js";
 import { MessageBusShutdownError } from "../../infra/bus/queue.js";
@@ -7,6 +8,7 @@ import "../../infra/bus/index.js";
 import { runEmbeddedTurnForSession } from "../embedded/run-for-session.js";
 import { inboundMessageLogRequestId } from "../service-inbound-utils.js";
 //#region src/agent/inbound/inbound-loop.ts
+init_model_usage();
 init_logger();
 /** Initial back-off when bus consume fails. Doubles each consecutive failure. */
 const INBOUND_CONSUME_BASE_BACKOFF_MS = 1e3;
@@ -75,6 +77,9 @@ var InboundLoop = class {
 		this.running = false;
 	}
 	async handleInboundMessage(msg) {
+		return withModelUsageOrigin(msg.channel === "system" ? "background" : "interactive", () => this.handleInboundMessageScoped(msg));
+	}
+	async handleInboundMessageScoped(msg) {
 		await runWithLogContext({ requestId: inboundMessageLogRequestId(msg) }, async () => {
 			const { context, isCommand, command, commandArgs } = await this.cfg.messageRouter.routeMessage(msg);
 			const sessionContext = {

package/dist/src/agent/mcp/connection-errors.d.ts

@@ -0,0 +1,3 @@
+export type McpConnectionErrorCode = 'command_missing' | 'connection_refused' | 'host_not_found' | 'timeout' | 'access_denied' | 'network' | 'tls' | 'invalid_response' | 'not_found' | 'rate_limited' | 'configuration' | 'unknown';
+/** Return a safe category without exposing addresses, headers, or credential-bearing errors. */
+export declare function classifyMcpConnectionError(error: unknown): McpConnectionErrorCode;

package/dist/src/agent/mcp/connection-errors.js

@@ -0,0 +1,32 @@
+//#region src/agent/mcp/connection-errors.ts
+/** Return a safe category without exposing addresses, headers, or credential-bearing errors. */
+function classifyMcpConnectionError(error) {
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current && !seen.has(current) && seen.size < 8) {
+		seen.add(current);
+		if (typeof current !== "object") {
+			messages.push(String(current));
+			break;
+		}
+		const detail = current;
+		messages.push(String(detail.message ?? ""), String(detail.code ?? ""));
+		current = detail.cause;
+	}
+	const message = messages.join(" ");
+	if (/ENOENT|command not found|executable.{0,30}not found/i.test(message)) return "command_missing";
+	if (/ECONNREFUSED|connection refused/i.test(message)) return "connection_refused";
+	if (/ENOTFOUND|EAI_AGAIN|could not resolve/i.test(message)) return "host_not_found";
+	if (/timeout|timed out|ETIMEDOUT/i.test(message)) return "timeout";
+	if (/CERT_|CERTIFICATE|ERR_TLS|UNABLE_TO_VERIFY|DEPTH_ZERO|self.signed|unable to verify/i.test(message)) return "tls";
+	if (/\b429\b|too many requests|rate.limit/i.test(message)) return "rate_limited";
+	if (/\b(?:401|403)\b|unauthorized|forbidden|permission denied|invalid_token/i.test(message)) return "access_denied";
+	if (/\b404\b|\b405\b|method not allowed/i.test(message)) return "not_found";
+	if (/ECONNRESET|EHOSTUNREACH|ENETUNREACH|fetch failed|network error|socket.*closed/i.test(message)) return "network";
+	if (/content.type|text\/html|invalid json|unexpected token|protocol version|not a valid JSON/i.test(message)) return "invalid_response";
+	if (/not configured|invalid configuration|is disabled/i.test(message)) return "configuration";
+	return "unknown";
+}
+//#endregion
+export { classifyMcpConnectionError };

package/dist/src/agent/mcp/connection-setup.d.ts

@@ -1,9 +1,11 @@
 import type { Config } from '../../config/schema.js';
+import { type McpConnectionErrorCode } from './connection-errors.js';
 import { type McpSessionOptions } from './tool-catalog.js';
 export type McpConnectionProbe = {
     state: 'connected' | 'oauth_required' | 'token_required' | 'error';
     toolCount?: number;
     error?: string;
+    errorCode?: McpConnectionErrorCode;
 };
 export declare function probeMcpConnection(config: Config, workspace: string, serverId: string, options?: McpSessionOptions): Promise<McpConnectionProbe>;
 export type McpAuthorization = {

package/dist/src/agent/mcp/connection-setup.js

@@ -1,34 +1,44 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
 import { isManagedConnectorServer } from "../../connectors/materialize.js";
 import { prepareNativeMcpConfig } from "./native-mcp.js";
+import { classifyMcpConnectionError } from "./connection-errors.js";
 import { McpAuthenticationRequiredError, discoverMcpTools, signInNativeMcp } from "./tool-catalog.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/agent/mcp/connection-setup.ts
+init_logger();
+const log = createLogger("McpConnectionSetup");
 function httpUrl(value) {
 	const url = new URL(value);
 	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("Use an HTTP or HTTPS MCP address without embedded credentials.");
 	return url;
 }
-async function metadata(url) {
+async function metadata(url, signal) {
 	try {
 		const response = await fetch(url, {
-			signal: AbortSignal.timeout(5e3),
+			signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(5e3)]) : AbortSignal.timeout(5e3),
 			redirect: "error",
 			headers: { Accept: "application/json" }
 		});
 		if (!response.ok) return;
 		const result = await response.json();
 		if (result && typeof result === "object" && !Array.isArray(result)) return result;
-	} catch {}
+	} catch {
+		signal?.throwIfAborted();
+	}
 }
 /** A 401 alone is not evidence that a service supports OAuth. */
-async function advertisesOAuth(config, workspace, serverId) {
-	const entry = (await prepareNativeMcpConfig(config, workspace)).servers.find((server) => server.name === serverId);
+async function advertisesOAuth(config, workspace, serverId, signal) {
+	signal?.throwIfAborted();
+	const loaded = await prepareNativeMcpConfig(config, workspace);
+	signal?.throwIfAborted();
+	const entry = loaded.servers.find((server) => server.name === serverId);
 	if (!entry || !("url" in entry.config)) return false;
 	const url = httpUrl(entry.config.url);
 	if (Object.keys(entry.config.headers ?? {}).some((name) => name.toLowerCase() === "authorization")) return false;
 	const response = await fetch(url, {
 		method: "POST",
-		signal: AbortSignal.timeout(1e4),
+		signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(1e4)]) : AbortSignal.timeout(1e4),
 		redirect: "error",
 		headers: {
 			Accept: "application/json, text/event-stream",
@@ -58,7 +68,8 @@ async function advertisesOAuth(config, workspace, serverId) {
 		new URL("/.well-known/oauth-protected-resource", url)
 	];
 	for (const candidate of candidates) {
-		const data = await metadata(candidate);
+		signal?.throwIfAborted();
+		const data = await metadata(candidate, signal);
 		if (data && typeof data.resource === "string" && data.resource === url.href && Array.isArray(data.authorization_servers) && data.authorization_servers.some((value) => {
 			try {
 				return typeof value === "string" && Boolean(httpUrl(value));
@@ -68,7 +79,7 @@ async function advertisesOAuth(config, workspace, serverId) {
 		})) return true;
 	}
 	if (!/\bBearer\b/i.test(challenge)) return false;
-	const legacy = await metadata(new URL("/.well-known/oauth-authorization-server", url));
+	const legacy = await metadata(new URL("/.well-known/oauth-authorization-server", url), signal);
 	return Boolean(legacy && legacy.issuer === url.origin && typeof legacy.authorization_endpoint === "string" && typeof legacy.token_endpoint === "string");
 }
 async function probeMcpConnection(config, workspace, serverId, options) {
@@ -78,20 +89,29 @@ async function probeMcpConnection(config, workspace, serverId, options) {
 			toolCount: (await discoverMcpTools(config, workspace, serverId, options)).length
 		};
 	} catch (error) {
-		if (error instanceof McpAuthenticationRequiredError) try {
-			return { state: await advertisesOAuth(config, workspace, serverId) ? "oauth_required" : "token_required" };
-		} catch (error) {
+		const failed = (cause) => {
+			const errorCode = classifyMcpConnectionError(cause);
+			log.warn({
+				serverId,
+				errorCode
+			}, `MCP connection check failed: ${errorCode}`);
 			return {
 				state: "error",
-				error: error instanceof Error ? error.message : String(error)
+				error: cause instanceof Error ? cause.message : String(cause),
+				errorCode
 			};
-		}
-		const server = config.mcp?.servers?.[serverId];
-		if (server?.url && Object.keys(server.headers ?? {}).some((name) => name.toLowerCase() === "authorization") && /401|403|unauthorized|forbidden/i.test(String(error))) return { state: "token_required" };
-		return {
-			state: "error",
-			error: error instanceof Error ? error.message : String(error)
 		};
+		const server = config.mcp?.servers?.[serverId];
+		const rejectedCredential = /\b401\b|unauthorized|invalid_token/i.test(String(error));
+		const hasCredentials = server?.auth || Object.keys(server?.headers ?? {}).some((name) => name.toLowerCase() === "authorization");
+		if (error instanceof McpAuthenticationRequiredError || server?.url && rejectedCredential && !hasCredentials) try {
+			options?.signal?.throwIfAborted();
+			return { state: await advertisesOAuth(config, workspace, serverId, options?.signal) ? "oauth_required" : "token_required" };
+		} catch (cause) {
+			return failed(cause);
+		}
+		if (server?.url && hasCredentials && /\b(?:401|403)\b|unauthorized|forbidden/i.test(String(error))) return { state: "token_required" };
+		return failed(error);
 	}
 }
 const attempts = /* @__PURE__ */ new Map();

package/dist/src/agent/memory/compaction.js

@@ -2,6 +2,7 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_compaction_types, isCompactionHandover } from "../../session/compaction-types.js";
 import { buildSessionContextForLlm, init_session_context_for_llm, isTranscriptCompactionEntry } from "../../session/session-context-for-llm.js";
+import { getModelUsageOrigin, init_model_usage, isProviderUsageScopeError } from "../../providers/model-usage.js";
 import { completeWithResolvedCredentials } from "../../providers/model-call.js";
 import { estimateMessagesTokens, estimateTextTokens } from "./context-budget.js";
 import { applyCompactionHandoverDelta, consolidateCompactionHandover, handoverForPrompt, renderCompactionHandover } from "./compaction-ledger.js";
@@ -11,6 +12,7 @@ import { CompactionChunkCursor } from "./compaction-chunks.js";
 import { COMPACTION_REPAIR_RESERVE, CompactionRequestError, compactionOutputLimit, compactionPayloadGuard, compactionPromptFits, initialCompactionOutputLimit, isPermanentCompactionError } from "./compaction-request.js";
 import { createHash } from "node:crypto";
 //#region src/agent/memory/compaction.ts
+init_model_usage();
 init_session_context_for_llm();
 init_compaction_types();
 init_logger();
@@ -397,6 +399,7 @@ Return a valid JSON delta only.`;
 				auditModelRef: reviewed.modelRef
 			};
 		} catch (error) {
+			if (isProviderUsageScopeError(error)) throw error;
 			signal?.throwIfAborted();
 			log.warn({
 				err: error,
@@ -521,7 +524,7 @@ Return a JSON delta containing only missing facts, using {"upserts":[]}. Include
 					}, void 0, {
 						operation: "session.compact",
 						conversationId: callContext.conversationId,
-						trigger: attempt === 0 && modelIndex === 0 ? "system" : "retry"
+						trigger: attempt === 0 && modelIndex === 0 ? getModelUsageOrigin() === "interactive" ? "agent" : "system" : "retry"
 					});
 					parentSignal?.throwIfAborted();
 					if (linked.timedOut()) throw new CompactionRequestError("timeout", "Compaction handover timed out");
@@ -554,6 +557,7 @@ Return a JSON delta containing only missing facts, using {"upserts":[]}. Include
 						modelRef: `${model.provider}/${model.id}`
 					};
 				} catch (error) {
+					if (isProviderUsageScopeError(error)) throw error;
 					parentSignal?.throwIfAborted();
 					lastError = linked.timedOut() ? new CompactionRequestError("timeout", `Compaction handover timed out after ${this.config.summaryTimeoutMs}ms`) : error;
 					const kind = lastError instanceof CompactionRequestError ? lastError.kind : "provider";

package/dist/src/agent/memory/idle-compaction-scheduler.js

@@ -1,6 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { init_model_usage, withModelUsageOrigin } from "../../providers/model-usage.js";
 //#region src/agent/memory/idle-compaction-scheduler.ts
+init_model_usage();
 init_logger();
 const log = createLogger("IdleCompaction");
 /** Generation checks protect commits even when a provider ignores cancellation. */
@@ -89,7 +91,7 @@ var IdleCompactionScheduler = class {
 			state.deadline = timeout;
 			timeout.unref?.();
 		});
-		const operation = Promise.resolve().then(() => job(controller.signal, isCurrent));
+		const operation = Promise.resolve().then(() => withModelUsageOrigin("background", () => job(controller.signal, isCurrent)));
 		Promise.race([operation, deadline]).then((outcome) => {
 			this.metrics[outcome]++;
 			if (outcome === "committed") state.eligibleAt = Date.now() + options.cooldownMs;

package/dist/src/agent/models/manager.d.ts

@@ -62,6 +62,7 @@ export declare class ModelManager {
      * Get model for session, checking session override first
      */
     getModelForSession(conversationId: string): string;
+    hasSessionModelOverride(conversationId: string): boolean;
     /**
      * Apply model to agent if different from current
      */

package/dist/src/agent/models/manager.js

@@ -42,8 +42,7 @@ var ModelManager = class {
 	setSessionProfileDefault(conversationId, modelRef, fallbacks = []) {
 		this.sessionProfileDefaults.set(conversationId, modelRef);
 		const cleanFallbacks = fallbacks.map((ref) => ref.trim()).filter(Boolean);
-		if (cleanFallbacks.length > 0) this.sessionProfileFallbacks.set(conversationId, cleanFallbacks);
-		else this.sessionProfileFallbacks.delete(conversationId);
+		this.sessionProfileFallbacks.set(conversationId, cleanFallbacks);
 	}
 	/**
 	* Register the profile model and return the model that should initialize the
@@ -117,6 +116,9 @@ var ModelManager = class {
 		if (profileDefault) return profileDefault;
 		return this.defaultModel;
 	}
+	hasSessionModelOverride(conversationId) {
+		return this.sessionModels.has(conversationId);
+	}
 	/**
 	* Apply model to agent if different from current
 	*/

package/dist/src/agent/orchestration/agent-orchestrator.d.ts

@@ -1,9 +1,3 @@
-/**
- * Agent Orchestrator - Coordinates Agent execution flow
- *
- * Manages the complete agent execution pipeline from message processing
- * to response generation.
- */
 import type { Config } from '../../config/schema.js';
 import type { InboundMessage } from '../../infra/bus/index.js';
 import type { SessionConfigStore, SessionStore } from '../../session/index.js';
@@ -52,6 +46,7 @@ export declare class AgentOrchestrator {
      * Process a message through the agent orchestration pipeline
      */
     process(msg: InboundMessage, context: SessionContext): Promise<void>;
+    private processScoped;
     /**
      * Get the current agent model ID
      */

package/dist/src/agent/orchestration/agent-orchestrator.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { init_model_usage, modelUsageOriginFromTurn, withModelUsageOrigin } from "../../providers/model-usage.js";
 import { abortEmbeddedRun } from "../embedded/runs.js";
 import { persistInboundAttachments } from "../../channels/attachments/inbound-persist.js";
 import { buildTranscriptUserMessage, clearPendingTranscriptUserMessage, hydrateUserTurnForLlm, setPendingTranscriptUserMessage } from "../inbound/attachment-pipeline.js";
@@ -13,6 +14,7 @@ import { randomUUID } from "node:crypto";
 * Manages the complete agent execution pipeline from message processing
 * to response generation.
 */
+init_model_usage();
 init_logger();
 const log = createLogger("AgentOrchestrator");
 var AgentOrchestrator = class {
@@ -42,6 +44,9 @@ var AgentOrchestrator = class {
 	* Process a message through the agent orchestration pipeline
 	*/
 	async process(msg, context) {
+		return withModelUsageOrigin(modelUsageOriginFromTurn(context.origin), () => this.processScoped(msg, context));
+	}
+	async processScoped(msg, context) {
 		const { conversationId } = context;
 		log.debug({ conversationId }, "Processing message through agent orchestrator");
 		await this.sessionHydrator.workspace(conversationId);

package/dist/src/agent/service/process-direct-one-shot.js

@@ -1,13 +1,18 @@
+import { init_model_usage, modelUsageOriginFromTurn, withModelUsageOrigin } from "../../providers/model-usage.js";
 import { clearPendingTranscriptUserMessage, setPendingTranscriptUserMessage } from "../inbound/attachment-pipeline.js";
 import { initSessionTurn } from "../../session/init-session-turn.js";
 import "../../session/index.js";
 import { buildDirectUserMessageContent } from "./build-direct-message-content.js";
 import { hydratePerTurnState, runDirectAgentTurn, tryRunSlashCommand } from "./direct-turn-helpers.js";
 //#region src/agent/service/process-direct-one-shot.ts
+init_model_usage();
 function isReviewOutput(value) {
 	return !!value && typeof value === "object" && !Array.isArray(value) && value.type === "review";
 }
 async function runProcessDirect(deps, input) {
+	return withModelUsageOrigin(modelUsageOriginFromTurn(input.origin), () => runProcessDirectInner(deps, input));
+}
+async function runProcessDirectInner(deps, input) {
 	deps.sessionStore?.idleCompaction?.interrupt(input.conversationId);
 	const { channel, chatId } = await deps.resolveSessionEndpoint(input.conversationId);
 	deps.initSessionContext(input.conversationId, channel, chatId, input.origin);

package/dist/src/agent/service/process-direct-streaming.d.ts

@@ -77,4 +77,5 @@ export type ProcessDirectStreamEvent = {
     type: string;
     [key: string]: unknown;
 };
+/** Bind each generator advancement so independent streams retain their own origin. */
 export declare function runProcessDirectStreaming(deps: ProcessDirectStreamingDeps, input: ProcessDirectStreamingInput): AsyncGenerator<ProcessDirectStreamEvent, void, unknown>;

package/dist/src/agent/service/process-direct-streaming.js

@@ -5,6 +5,7 @@ import { getClarificationResumeInput, init_clarification_wait_repository } from
 import { getConnectionResumeInput, init_connection_wait_repository } from "../../storage/sqlite/connection-wait-repository.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../agent-scope.js";
 import { init_agent_session_key, resolveAgentMainConversationId } from "../../routing/agent-session-key.js";
+import { init_model_usage, modelUsageOriginFromTurn, withModelUsageOrigin } from "../../providers/model-usage.js";
 import { readAgentMessageContent } from "../memory/agent-message-access.js";
 import { abortEmbeddedRun } from "../embedded/runs.js";
 import { clearPendingTranscriptUserMessage, setPendingTranscriptUserMessage } from "../inbound/attachment-pipeline.js";
@@ -24,6 +25,7 @@ import { AsyncQueue, AsyncQueueOverflowError } from "./async-queue.js";
 import { hydratePerTurnState, runDirectAgentTurn, tryRunSlashCommand } from "./direct-turn-helpers.js";
 import { isSuccessfulWebchatTtsToolEvent } from "./webchat-tts.js";
 //#region src/agent/service/process-direct-streaming.ts
+init_model_usage();
 init_agent_session_key();
 init_agent_scope();
 init_src();
@@ -137,7 +139,7 @@ function pushAssistantReceipt(queue, text, runId, metadata) {
 		message
 	});
 }
-async function* runProcessDirectStreaming(deps, input) {
+async function* runProcessDirectStreamingInner(deps, input) {
 	const conversationId = input.conversationId ?? resolveAgentMainConversationId({ agentId: resolveDefaultAgentId() });
 	deps.sessionStore?.idleCompaction?.interrupt(conversationId);
 	const isConnectionResume = Boolean(input.runId && getConnectionResumeInput(conversationId, input.runId));
@@ -445,5 +447,19 @@ async function* runProcessDirectStreaming(deps, input) {
 		deps.endDirectRequestContext();
 	}
 }
+/** Bind each generator advancement so independent streams retain their own origin. */
+async function* runProcessDirectStreaming(deps, input) {
+	const iterator = runProcessDirectStreamingInner(deps, input);
+	const origin = modelUsageOriginFromTurn(input.origin);
+	try {
+		while (true) {
+			const result = await withModelUsageOrigin(origin, () => iterator.next());
+			if (result.done) return;
+			yield result.value;
+		}
+	} finally {
+		await withModelUsageOrigin(origin, () => iterator.return());
+	}
+}
 //#endregion
 export { runProcessDirectStreaming };

package/dist/src/agent/tools/image-generate-tool.js

@@ -195,10 +195,14 @@ function createImageGenerateTool(options) {
 	});
 	if (!imageGenerationModelConfig) return null;
 	const effectiveCfg = applyImageGenerationModelConfigDefaults(options.config, imageGenerationModelConfig) ?? options.config;
+	const primaryRef = imageGenerationModelConfig.primary;
+	const primaryProvider = primaryRef ? getImageGenerationProvider(primaryRef.slice(0, primaryRef.indexOf("/"))) : void 0;
+	const primaryModel = primaryRef?.slice(primaryRef.indexOf("/") + 1);
+	const capabilities = primaryModel ? primaryProvider?.modelCapabilities?.[primaryModel] ?? primaryProvider?.capabilities : void 0;
 	return {
 		name: "image_generate",
 		label: "Image Generation",
-		description: "Generate and attach images with the configured image-generation model. Use action=\"list\" to see providers. Also saves files under workspace/media/generated/. Do not call send_media for generated images.",
+		description: `Generate and attach images with the configured image-generation model (${primaryRef}). ${capabilities ? `Configured model capabilities: ${JSON.stringify(capabilities)}. ` : ""}Omit optional image parameters unless needed. Keep the configured model unless the user asks for another provider/model. Use action="list" to see providers. Also saves files under workspace/media/generated/. Do not call send_media for generated images.`,
 		parameters: ImageGenerateToolSchema,
 		async execute(_toolCallId, args) {
 			const params = args;

package/dist/src/agent-config/resolver.js

@@ -55,10 +55,15 @@ function resolveEffectiveAgentConfig(params) {
 	const models = {
 		chat: structuredClone(agent.models?.chat ?? defaults.models.chat),
 		intents,
+		...agent.models?.background === null ? {} : agent.models?.background ?? defaults.models.background ? { background: structuredClone(agent.models?.background ?? defaults.models.background) } : {},
 		...agent.models?.computerUse ?? defaults.models.computerUse ? { computerUse: structuredClone(agent.models?.computerUse ?? defaults.models.computerUse) } : {},
 		...agent.models?.imageUnderstanding === null ? {} : agent.models?.imageUnderstanding ? { imageUnderstanding: structuredClone(agent.models.imageUnderstanding) } : defaults.models.imageUnderstanding ? { imageUnderstanding: structuredClone(defaults.models.imageUnderstanding) } : {},
 		...agent.models?.imageGeneration === null ? {} : agent.models?.imageGeneration ? { imageGeneration: structuredClone(agent.models.imageGeneration) } : defaults.models.imageGeneration ? { imageGeneration: structuredClone(defaults.models.imageGeneration) } : {}
 	};
+	if (agent.models && Object.hasOwn(agent.models, "background")) {
+		clearSources("models.background", sources);
+		if (agent.models.background) markObjectSources(agent.models.background, "agent", "models.background", sources);
+	}
 	if (agent.models?.chat) markObjectSources(agent.models.chat, "agent", "models.chat", sources);
 	if (agent.models?.computerUse) {
 		clearSources("models.computerUse", sources);

package/dist/src/agent-config/schema.d.ts

@@ -24,9 +24,9 @@ export declare const ComputerModelRouteSchema: z.ZodObject<{
 export declare const ModelIntentSchema: z.ZodEnum<{
     review: "review";
     coding: "coding";
+    vision: "vision";
     fast: "fast";
     reasoning: "reasoning";
-    vision: "vision";
     understanding: "understanding";
 }>;
 export declare const AgentModelsDefaultsSchema: z.ZodObject<{
@@ -34,12 +34,16 @@ export declare const AgentModelsDefaultsSchema: z.ZodObject<{
         primary: z.ZodString;
         fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>;
+    background: z.ZodOptional<z.ZodObject<{
+        primary: z.ZodString;
+        fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
     intents: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
         review: "review";
         coding: "coding";
+        vision: "vision";
         fast: "fast";
         reasoning: "reasoning";
-        vision: "vision";
         understanding: "understanding";
     }> & z.core.$partial, z.ZodObject<{
         primary: z.ZodString;
@@ -65,12 +69,16 @@ export declare const AgentModelsOverrideSchema: z.ZodObject<{
         primary: z.ZodString;
         fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
+    background: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        primary: z.ZodString;
+        fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
     intents: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
         review: "review";
         coding: "coding";
+        vision: "vision";
         fast: "fast";
         reasoning: "reasoning";
-        vision: "vision";
         understanding: "understanding";
     }> & z.core.$partial, z.ZodNullable<z.ZodObject<{
         primary: z.ZodString;
@@ -184,12 +192,16 @@ export declare const AgentDefaultsSchema: z.ZodObject<{
             primary: z.ZodString;
             fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>;
+        background: z.ZodOptional<z.ZodObject<{
+            primary: z.ZodString;
+            fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         intents: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
             review: "review";
             coding: "coding";
+            vision: "vision";
             fast: "fast";
             reasoning: "reasoning";
-            vision: "vision";
             understanding: "understanding";
         }> & z.core.$partial, z.ZodObject<{
             primary: z.ZodString;
@@ -424,12 +436,16 @@ export declare const AgentEntrySchema: z.ZodObject<{
             primary: z.ZodString;
             fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
+        background: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            primary: z.ZodString;
+            fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>;
         intents: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
             review: "review";
             coding: "coding";
+            vision: "vision";
             fast: "fast";
             reasoning: "reasoning";
-            vision: "vision";
             understanding: "understanding";
         }> & z.core.$partial, z.ZodNullable<z.ZodObject<{
             primary: z.ZodString;
@@ -590,12 +606,16 @@ export declare const EffectiveAgentConfigSchema: z.ZodObject<{
             primary: z.ZodString;
             fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>;
+        background: z.ZodOptional<z.ZodObject<{
+            primary: z.ZodString;
+            fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         intents: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
             review: "review";
             coding: "coding";
+            vision: "vision";
             fast: "fast";
             reasoning: "reasoning";
-            vision: "vision";
             understanding: "understanding";
         }> & z.core.$partial, z.ZodObject<{
             primary: z.ZodString;

package/dist/src/agent-config/schema.js

@@ -43,6 +43,7 @@ var init_schema = __esmMin((() => {
 	ModelIntentOverridesSchema = z.partialRecord(ModelIntentSchema, ModelRouteSchema.nullable());
 	AgentModelsDefaultsSchema = z.object({
 		chat: ModelRouteSchema,
+		background: ModelRouteSchema.optional(),
 		intents: ModelIntentRoutesSchema.default({}),
 		imageUnderstanding: ModelRouteSchema.optional(),
 		computerUse: ComputerModelRouteSchema.optional(),
@@ -50,6 +51,7 @@ var init_schema = __esmMin((() => {
 	}).strict();
 	AgentModelsOverrideSchema = z.object({
 		chat: ModelRouteSchema.optional(),
+		background: ModelRouteSchema.nullable().optional(),
 		intents: ModelIntentOverridesSchema.optional(),
 		imageUnderstanding: ModelRouteSchema.nullable().optional(),
 		computerUse: ComputerModelRouteSchema.nullable().optional(),

package/dist/src/ai-assist/text-assist.js

@@ -1,11 +1,8 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
-import { createExtensionAwareStreamFn } from "../providers/extension-stream-bridge.js";
-import { trackAiUsageStream } from "../usage/recorder.js";
-import { isLocalModelBaseUrl, resolveModelCallApiKey, resolveModelCallOptions } from "../providers/model-call.js";
+import { createResolvedModelStream, isLocalModelBaseUrl, resolveModelCallApiKey } from "../providers/model-call.js";
 import { getAssistantMessageErrorReason, stripCodeFences } from "../providers/model-response.js";
-import { normalizeContext } from "@earendil-works/pi-ai";
 //#region src/ai-assist/text-assist.ts
 init_providers();
 init_logger();
@@ -228,28 +225,20 @@ async function* streamTextAssist(request, config, signal) {
 	};
 	const scenario = scenarioFromRequest(resolvedRequest);
 	const model = resolveModel(getDefaultModelSync(config));
-	const prompt = buildPrompt(resolvedRequest, scenario);
-	const modelCallOptions = await resolveModelCallOptions(model, {
+	const stream = await createResolvedModelStream(model, buildPrompt(resolvedRequest, scenario), {
 		maxTokens: 1600,
 		temperature: intent === "fix" ? .15 : .25,
 		signal
+	}, void 0, {
+		operation: "text_assist.generate",
+		trigger: "user"
 	});
-	log.debug({
-		provider: model.provider,
-		modelId: model.id,
-		hasApiKey: Boolean(modelCallOptions.apiKey),
-		localBaseUrl: isLocalModelBaseUrl(model.baseUrl)
-	}, "Resolved AI text assist model auth");
 	yield {
 		type: "start",
 		provider: model.provider,
 		modelId: model.id,
 		scenario: scenario.id
 	};
-	const stream = await trackAiUsageStream(model, {
-		operation: "text_assist.generate",
-		trigger: "user"
-	}, () => createExtensionAwareStreamFn()(model, normalizeContext(prompt), modelCallOptions));
 	let streamedText = "";
 	for await (const event of stream) {
 		const streamEvent = event;

package/dist/src/automations/service/action-executor.js

@@ -3,8 +3,10 @@ import { init_logger } from "../../utils/logger.js";
 import { normalizeAgentId } from "../../agent-catalog/id.js";
 import { init_agent_scope } from "../../agent/agent-scope.js";
 import { init_session_key, resolveConversationId } from "../../routing/session-key.js";
+import { init_model_usage, withModelUsageOrigin } from "../../providers/model-usage.js";
 import { resolveAutomationTimeoutSeconds } from "../domain/defaults.js";
 //#region src/automations/service/action-executor.ts
+init_model_usage();
 init_agent_scope();
 init_session_key();
 init_logger();
@@ -111,7 +113,7 @@ var AutomationActionExecutor = class {
 		const deadlineAtMs = run.deadlineAtMs ?? Date.now() + configuredTimeoutMs;
 		const timeoutMs = Math.max(1, deadlineAtMs - Date.now());
 		await hooks.onRunPatch?.({ deadlineAtMs });
-		return executeWithDeadline((deadlineSignal) => this.executeWithoutTimeout(automation, run, deadlineSignal, hooks, deadlineAtMs, context), timeoutMs, signal, deadlineAtMs).catch((err) => {
+		return withModelUsageOrigin("background", () => executeWithDeadline((deadlineSignal) => this.executeWithoutTimeout(automation, run, deadlineSignal, hooks, deadlineAtMs, context), timeoutMs, signal, deadlineAtMs)).catch((err) => {
 			const message = err instanceof Error ? err.message : String(err);
 			if (err instanceof AutomationExecutionStoppedError) return {
 				status: err.status,