zidane 5.8.0 → 5.8.3

package/dist/{login-D-3A5CK7.js → login-Ck6dmcMH.js}

@@ -1,8 +1,8 @@
-import { A as getReadState } from "./tools-BmPeBGU1.js";
+import { j as getReadState } from "./tools-DLRIhCl1.js";
 import { h as utf8ByteLength, m as estimateTokens } from "./edit-utils-DnfNoj16.js";
 import { o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-CvRQTdbR.js";
 import { n as toolOutputByteLength } from "./types-BPw_i5vb.js";
-import { a as createTolerantClient, o as sseToJsonFetchIfNeeded, s as McpOAuthProvider } from "./mcp-Kqzz-Rs_.js";
+import { c as McpOAuthProvider, o as createTolerantClient, s as sseToJsonFetchIfNeeded } from "./mcp-Br3b1Xm3.js";
 import { createServer } from "node:http";
 //#region src/compact/errors.ts
 /**
@@ -940,6 +940,303 @@ async function buildPostCompactAttachments(opts) {
 	};
 }
 //#endregion
+//#region src/logger.ts
+/**
+* Build a Logger from a sink. Stateless and cheap; create one per agent
+* (or per app) and use `.with()` to attach correlation ids per-call.
+*/
+function createLogger(sink, baseAttributes = {}) {
+	function emit(level, message, attrs) {
+		try {
+			sink.emit({
+				level,
+				timestamp: Date.now(),
+				message,
+				attrs: attrs ? {
+					...baseAttributes,
+					...attrs
+				} : { ...baseAttributes }
+			});
+		} catch {}
+	}
+	return {
+		debug: (m, a) => emit("debug", m, a),
+		info: (m, a) => emit("info", m, a),
+		warn: (m, a) => emit("warn", m, a),
+		error: (m, a) => emit("error", m, a),
+		with: (extra) => createLogger(sink, {
+			...baseAttributes,
+			...extra
+		}),
+		baseAttributes
+	};
+}
+const LEVEL_ORDER = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Human-readable terminal sink. Renders each record as
+* `<ISO timestamp> <LEVEL> <message> <attrs as kv pairs>`.
+*
+* Honors `process.stderr` by default so log lines don't interleave with
+* the agent's stdout-bound output (chat responses, JSON results).
+*/
+function consoleSink(options = {}) {
+	const min = LEVEL_ORDER[options.minLevel ?? "info"];
+	const stream = options.stream ?? process.stderr;
+	return { emit(record) {
+		if (LEVEL_ORDER[record.level] < min) return;
+		const ts = new Date(record.timestamp).toISOString();
+		const kv = Object.entries(record.attrs).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+		stream.write(`${ts} ${record.level.toUpperCase().padEnd(5)} ${record.message}${kv ? ` ${kv}` : ""}\n`);
+	} };
+}
+/**
+* One-JSON-object-per-line sink. Suitable for piping into log aggregators
+* (Datadog Agent, Fluent Bit, Loki, Vector) that expect JSONL.
+*/
+function jsonSink(options = {}) {
+	const min = LEVEL_ORDER[options.minLevel ?? "info"];
+	const stream = options.stream ?? process.stderr;
+	return { emit(record) {
+		if (LEVEL_ORDER[record.level] < min) return;
+		try {
+			stream.write(`${JSON.stringify(record)}\n`);
+		} catch {}
+	} };
+}
+/**
+* Install a bundle of hook handlers that emit a structured line per
+* relevant lifecycle event, automatically attaching correlation ids
+* (`runId`, `turnId`, `callId`, `childId`, `depth`, `agentName`).
+*
+* @example
+* ```ts
+* const logger = createLogger(consoleSink({ minLevel: 'debug' }), { service: 'tui' })
+* const lh = createLoggingHooks({ logger })
+* const uninstall = lh.install(agent.hooks)
+* try { await agent.run({ prompt }) }
+* finally { uninstall() }
+* ```
+*/
+function createLoggingHooks(options) {
+	const root = options.logger;
+	const includeLifecycle = options.includeLifecycle ?? true;
+	const minLevel = LEVEL_ORDER[options.level ?? "info"];
+	/**
+	* Wrap a Logger so emissions below `minLevel` are dropped before they
+	* hit the sink. Lets us gate harness chatter without forcing every
+	* `LogSink` to re-implement level filtering. Preserves `.with()`
+	* composition (children inherit the filter).
+	*/
+	function gateLevel(logger) {
+		const skip = (level) => LEVEL_ORDER[level] < minLevel;
+		const wrap = (l) => ({
+			debug: (m, a) => {
+				if (!skip("debug")) l.debug(m, a);
+			},
+			info: (m, a) => {
+				if (!skip("info")) l.info(m, a);
+			},
+			warn: (m, a) => {
+				if (!skip("warn")) l.warn(m, a);
+			},
+			error: (m, a) => {
+				if (!skip("error")) l.error(m, a);
+			},
+			with: (extra) => wrap(l.with(extra)),
+			baseAttributes: l.baseAttributes
+		});
+		return wrap(logger);
+	}
+	return { install(hooks) {
+		const unregisters = [];
+		const gatedRoot = gateLevel(root);
+		let runLogger = gatedRoot;
+		let turnLogger = gatedRoot;
+		unregisters.push(hooks.hook("agent:start", (ctx) => {
+			runLogger = gatedRoot.with({
+				runId: ctx.runId,
+				...ctx.parentRunId ? { parentRunId: ctx.parentRunId } : {},
+				depth: ctx.depth,
+				...ctx.agentName ? { agentName: ctx.agentName } : {}
+			});
+			turnLogger = runLogger;
+			if (includeLifecycle) runLogger.debug("agent run started");
+		}));
+		unregisters.push(hooks.hook("agent:done", (stats) => {
+			runLogger.info("agent run completed", {
+				turns: stats.turns,
+				totalIn: stats.totalIn,
+				totalOut: stats.totalOut,
+				...typeof stats.cost === "number" ? { cost: stats.cost } : {},
+				elapsedMs: stats.elapsed,
+				...typeof stats.timeTillFirstTokenMs === "number" ? { ttftMs: stats.timeTillFirstTokenMs } : {}
+			});
+		}));
+		unregisters.push(hooks.hook("agent:abort", () => {
+			runLogger.warn("agent run aborted");
+		}));
+		unregisters.push(hooks.hook("turn:before", (ctx) => {
+			turnLogger = runLogger.with({
+				turnId: ctx.turnId,
+				turn: ctx.turn
+			});
+			if (includeLifecycle) turnLogger.debug("turn started");
+		}));
+		unregisters.push(hooks.hook("turn:after", (ctx) => {
+			turnLogger.debug("turn ended", {
+				inputTokens: ctx.usage.input,
+				outputTokens: ctx.usage.output,
+				...ctx.usage.finishReason ? { finishReason: ctx.usage.finishReason } : {},
+				...ctx.usage.modelId ? { modelId: ctx.usage.modelId } : {},
+				...typeof ctx.usage.timeToFirstTokenMs === "number" ? { ttftMs: ctx.usage.timeToFirstTokenMs } : {}
+			});
+		}));
+		unregisters.push(hooks.hook("stream:error", (ctx) => {
+			turnLogger.error("stream error", {
+				message: ctx.err instanceof Error ? ctx.err.message : String(ctx.err),
+				...ctx.statusCode !== void 0 ? { statusCode: ctx.statusCode } : {},
+				...ctx.requestId !== void 0 ? { requestId: ctx.requestId } : {}
+			});
+		}));
+		unregisters.push(hooks.hook("tool:before", (ctx) => {
+			if (!includeLifecycle) return;
+			turnLogger.debug("tool started", {
+				toolName: ctx.name,
+				displayName: ctx.displayName,
+				callId: ctx.callId
+			});
+		}));
+		unregisters.push(hooks.hook("tool:after", (ctx) => {
+			if (!includeLifecycle) return;
+			turnLogger.debug("tool ended", {
+				toolName: ctx.name,
+				callId: ctx.callId,
+				outputBytes: ctx.outputBytes
+			});
+		}));
+		unregisters.push(hooks.hook("tool:error", (ctx) => {
+			turnLogger.error("tool error", {
+				toolName: ctx.name,
+				callId: ctx.callId,
+				message: ctx.error.message
+			});
+		}));
+		unregisters.push(hooks.hook("tool:dispatched", (ctx) => {
+			const isAnomaly = ctx.outcome === "gate-block" || ctx.outcome === "unknown" || ctx.outcome === "invalid-input";
+			if (!isAnomaly && !includeLifecycle) return;
+			turnLogger[isAnomaly ? "warn" : "debug"]("tool dispatched", {
+				toolName: ctx.name,
+				callId: ctx.callId,
+				outcome: ctx.outcome,
+				...ctx.reason ? { reason: ctx.reason } : {}
+			});
+		}));
+		unregisters.push(hooks.hook("validation:reject", (ctx) => {
+			turnLogger.warn("tool input rejected", {
+				toolName: ctx.name,
+				callId: ctx.callId,
+				reason: ctx.reason
+			});
+		}));
+		unregisters.push(hooks.hook("budget:exceeded", (ctx) => {
+			turnLogger.warn("byte budget exceeded", {
+				bytes: ctx.bytes,
+				budget: ctx.budget
+			});
+		}));
+		unregisters.push(hooks.hook("tool-budget:exceeded", (ctx) => {
+			turnLogger.warn("tool budget exceeded", {
+				toolName: ctx.tool,
+				count: ctx.count,
+				max: ctx.max,
+				mode: ctx.mode
+			});
+		}));
+		unregisters.push(hooks.hook("mcp:bootstrap:end", (ctx) => {
+			if (ctx.ok) {
+				if (includeLifecycle) runLogger.debug("mcp bootstrap ok", {
+					server: ctx.name,
+					transport: ctx.transport,
+					durationMs: ctx.durationMs,
+					toolCount: ctx.toolCount,
+					...ctx.lazy ? { lazy: true } : {},
+					...ctx.cached ? { cached: true } : {}
+				});
+			} else runLogger.warn("mcp bootstrap failed", {
+				server: ctx.name,
+				transport: ctx.transport,
+				durationMs: ctx.durationMs,
+				message: ctx.error.message
+			});
+		}));
+		unregisters.push(hooks.hook("mcp:error", (ctx) => {
+			runLogger.error("mcp error", {
+				server: ctx.name,
+				message: ctx.error.message
+			});
+		}));
+		unregisters.push(hooks.hook("mcp:warn", (ctx) => {
+			runLogger.warn("mcp warn", {
+				server: ctx.name,
+				message: ctx.message
+			});
+		}));
+		unregisters.push(hooks.hook("mcp:auth:required", (ctx) => {
+			runLogger.warn("mcp auth required", {
+				server: ctx.name,
+				transport: ctx.transport,
+				reason: ctx.reason
+			});
+		}));
+		unregisters.push(hooks.hook("mcp:tool:error", (ctx) => {
+			turnLogger.error("mcp tool error", {
+				server: ctx.server,
+				tool: ctx.displayName,
+				callId: ctx.callId,
+				message: ctx.error.message
+			});
+		}));
+		unregisters.push(hooks.hook("spawn:before", (ctx) => {
+			if (!includeLifecycle) return;
+			runLogger.debug("spawn started", {
+				childId: ctx.id,
+				depth: ctx.depth
+			});
+		}));
+		unregisters.push(hooks.hook("spawn:complete", (ctx) => {
+			runLogger.info("spawn completed", {
+				childId: ctx.id,
+				...ctx.depth ? { depth: ctx.depth } : {},
+				status: ctx.status ?? "completed",
+				turns: ctx.stats.turns,
+				totalIn: ctx.stats.totalIn,
+				totalOut: ctx.stats.totalOut,
+				...typeof ctx.stats.cost === "number" ? { cost: ctx.stats.cost } : {}
+			});
+		}));
+		unregisters.push(hooks.hook("spawn:error", (ctx) => {
+			runLogger.error("spawn error", {
+				childId: ctx.id,
+				...ctx.depth ? { depth: ctx.depth } : {},
+				message: ctx.error.message
+			});
+		}));
+		let disposed = false;
+		return function uninstall() {
+			if (disposed) return;
+			disposed = true;
+			for (const un of unregisters) try {
+				un();
+			} catch {}
+		};
+	} };
+}
+//#endregion
 //#region src/mcp/oauth-callback.ts
 const DEFAULT_PATH = "/callback";
 const DEFAULT_HOST = "127.0.0.1";
@@ -1202,6 +1499,6 @@ async function raceLoginCallback(handle, timeoutMs, signal) {
 	}
 }
 //#endregion
-export { CompactPromptTooLongError as C, CompactInvalidInputError as S, anchorPreviewFor as _, selectFilesFromSession as a, summaryToTurn as b, BASE_INSTRUCTIONS as c, buildCompactPrompt as d, buildFromCompactPrompt as f, ANCHOR_PREVIEW_MAX_CHARS as g, buildUpToCompactPrompt as h, selectFilesFromReadState as i, NO_TOOLS_PREAMBLE as l, buildTailCompactPrompt as m, startOAuthCallback as n, selectRecentFiles as o, buildFullCompactPrompt as p, buildPostCompactAttachments as r, compactConversation as s, loginMcpServer as t, TRAILER as u, sliceForCompaction as v, truncateHeadForPtlRetry as x, stripImagesFromTurns as y };
+export { stripImagesFromTurns as C, CompactPromptTooLongError as D, CompactInvalidInputError as E, sliceForCompaction as S, truncateHeadForPtlRetry as T, buildFullCompactPrompt as _, createLoggingHooks as a, ANCHOR_PREVIEW_MAX_CHARS as b, selectFilesFromReadState as c, compactConversation as d, BASE_INSTRUCTIONS as f, buildFromCompactPrompt as g, buildCompactPrompt as h, createLogger as i, selectFilesFromSession as l, TRAILER as m, startOAuthCallback as n, jsonSink as o, NO_TOOLS_PREAMBLE as p, consoleSink as r, buildPostCompactAttachments as s, loginMcpServer as t, selectRecentFiles as u, buildTailCompactPrompt as v, summaryToTurn as w, anchorPreviewFor as x, buildUpToCompactPrompt as y };
 
-//# sourceMappingURL=login-D-3A5CK7.js.map
+//# sourceMappingURL=login-Ck6dmcMH.js.map