bitfab 0.68.7 → 0.68.9

package/dist/{src-B7_GnVaZ.cjs → src-BOmu6a4v.cjs}

@@ -1,6 +1,6 @@
 const require_bamlPeer = require("./bamlPeer-5Ohpq8q9.cjs");
-const require_http = require("./http-DAMAcv_J.cjs");
-const require_autoTrace = require("./autoTrace-DUmR1KJ8.cjs");
+const require_http = require("./http-BB9wDcLm.cjs");
+const require_autoTrace = require("./autoTrace-DPWV1Xzr.cjs");
 const require_optionalPeer = require("./optionalPeer-CUH756lt.cjs");
 let superjson = require("superjson");
 superjson = require_bamlPeer.__toESM(superjson, 1);
@@ -1412,11 +1412,11 @@ var GradersClient = class {
 const JEV_PROVIDER = "typesafe";
 const JEV_WATCH_STORAGE_SYMBOL = Symbol.for("bitfab.jevWatchStorage");
 const repliesRecordedByAutoTrace = /* @__PURE__ */ new WeakSet();
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return typeof value === "object" && value !== null;
 }
 function isJevReply(value) {
-	return isRecord$4(value) && typeof value.model === "string" && isRecord$4(value.usage);
+	return isRecord$5(value) && typeof value.model === "string" && isRecord$5(value.usage);
 }
 function tokenCount(usage, key) {
 	const count = usage[key];
@@ -1475,7 +1475,7 @@ function recordWatchedJevReply(span, watch, reply, durationMs) {
 	markEnclosingWatches(watch);
 }
 function isRecordedByAutoTrace(reply) {
-	return isRecord$4(reply) && repliesRecordedByAutoTrace.has(reply);
+	return isRecord$5(reply) && repliesRecordedByAutoTrace.has(reply);
 }
 function recordAutoTracedJev(invokeFn, span) {
 	const startedAt = Date.now();
@@ -1988,7 +1988,7 @@ var BitfabLangGraphCallbackHandler = class {
 //#region src/integrationFixture.ts
 const INTEGRATION_FIXTURE_CONTEXT_KEY = "__bitfabIntegrationFixture";
 const INTEGRATION_FIXTURE_VERSION = 1;
-function isRecord$3(value) {
+function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function createIntegrationFixtureContext(name, value) {
@@ -2002,8 +2002,8 @@ function createIntegrationFixtureContext(name, value) {
 }
 function hasIntegrationFixture(contexts, name) {
 	return contexts.some((context) => {
-		const fixture = isRecord$3(context) ? context[INTEGRATION_FIXTURE_CONTEXT_KEY] : void 0;
-		return isRecord$3(fixture) && fixture.version === INTEGRATION_FIXTURE_VERSION && fixture.name === name;
+		const fixture = isRecord$4(context) ? context[INTEGRATION_FIXTURE_CONTEXT_KEY] : void 0;
+		return isRecord$4(fixture) && fixture.version === INTEGRATION_FIXTURE_VERSION && fixture.name === name;
 	});
 }
 function extractIntegrationFixtures(spanData) {
@@ -2011,9 +2011,9 @@ function extractIntegrationFixtures(spanData) {
 	if (!Array.isArray(contexts)) return;
 	const fixtures = /* @__PURE__ */ new Map();
 	for (const context of contexts) {
-		if (!isRecord$3(context)) continue;
+		if (!isRecord$4(context)) continue;
 		const fixture = context[INTEGRATION_FIXTURE_CONTEXT_KEY];
-		if (!isRecord$3(fixture) || fixture.version !== INTEGRATION_FIXTURE_VERSION || typeof fixture.name !== "string" || fixtures.has(fixture.name)) continue;
+		if (!isRecord$4(fixture) || fixture.version !== INTEGRATION_FIXTURE_VERSION || typeof fixture.name !== "string" || fixtures.has(fixture.name)) continue;
 		fixtures.set(fixture.name, deserializeValue({
 			json: fixture.value,
 			...fixture.valueMeta !== void 0 && { meta: fixture.valueMeta }
@@ -2032,7 +2032,7 @@ const THREAD_CONFIG_KEYS = [
 	"checkpoint_ns",
 	"checkpoint_id"
 ];
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null;
 }
 function toBase64(bytes) {
@@ -2059,12 +2059,12 @@ async function newMemorySaver() {
 	return new MemorySaver();
 }
 async function unstoredDeltaChannels(graph, tuple) {
-	const channels = isRecord$2(graph) ? graph.channels : void 0;
-	if (!isRecord$2(channels)) return [];
+	const channels = isRecord$3(graph) ? graph.channels : void 0;
+	if (!isRecord$3(channels)) return [];
 	const { DeltaChannel } = await loadLangGraphPeer();
 	if (DeltaChannel === void 0) return [];
-	const versions = isRecord$2(tuple.checkpoint.channel_versions) ? tuple.checkpoint.channel_versions : {};
-	const values = isRecord$2(tuple.checkpoint.channel_values) ? tuple.checkpoint.channel_values : {};
+	const versions = isRecord$3(tuple.checkpoint.channel_versions) ? tuple.checkpoint.channel_versions : {};
+	const values = isRecord$3(tuple.checkpoint.channel_values) ? tuple.checkpoint.channel_values : {};
 	return Object.entries(channels).filter(([name, spec]) => spec instanceof DeltaChannel && name in versions && !(name in values)).map(([name]) => name);
 }
 async function selfContained(graph, checkpointer, tuple) {
@@ -2077,27 +2077,27 @@ async function selfContained(graph, checkpointer, tuple) {
 		checkpoint: {
 			...tuple.checkpoint,
 			channel_values: {
-				...isRecord$2(tuple.checkpoint.channel_values) ? tuple.checkpoint.channel_values : {},
+				...isRecord$3(tuple.checkpoint.channel_values) ? tuple.checkpoint.channel_values : {},
 				...Object.fromEntries(names.filter((name) => name in values).map((name) => [name, values[name]]))
 			}
 		}
 	};
 }
 function savingCheckpointer(graph) {
-	const own = isRecord$2(graph) ? graph.checkpointer : void 0;
-	const inner = isRecord$2(graph) && isRecord$2(graph.graph) ? graph.graph.checkpointer : void 0;
+	const own = isRecord$3(graph) ? graph.checkpointer : void 0;
+	const inner = isRecord$3(graph) && isRecord$3(graph.graph) ? graph.graph.checkpointer : void 0;
 	const checkpointer = own ?? inner;
-	return isRecord$2(checkpointer) && typeof checkpointer.getTuple === "function" ? checkpointer : null;
+	return isRecord$3(checkpointer) && typeof checkpointer.getTuple === "function" ? checkpointer : null;
 }
 function threadConfig(config) {
-	const configurable = isRecord$2(config?.configurable) ? config.configurable : {};
+	const configurable = isRecord$3(config?.configurable) ? config.configurable : {};
 	return Object.fromEntries(THREAD_CONFIG_KEYS.filter((key) => key in configurable).map((key) => [key, configurable[key]]));
 }
 function withConfigurable(config, values) {
 	return {
 		...config ?? {},
 		configurable: {
-			...isRecord$2(config?.configurable) ? config.configurable : {},
+			...isRecord$3(config?.configurable) ? config.configurable : {},
 			...values
 		}
 	};
@@ -2234,7 +2234,7 @@ var GraphRun = class {
 	}
 	async restoreThread(replay) {
 		const { saver, thread } = await restoredCheckpointer(replay.integrationFixtures?.get(this.fixtureName) ?? null);
-		const configurable = isRecord$2(this.config?.configurable) ? this.config.configurable : {};
+		const configurable = isRecord$3(this.config?.configurable) ? this.config.configurable : {};
 		return {
 			saver,
 			thread: {
@@ -2248,19 +2248,19 @@ var GraphRun = class {
 //#region src/langgraphIntegration.ts
 const TOOL_RESULT_TAG = "__bitfabLangGraphToolResult";
 const AGENT_MIDDLEWARE_BRAND = Symbol.for("AgentMiddleware");
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null;
 }
 function isToolMessage(value) {
-	return isRecord$1(value) && value.lc_direct_tool_output === true && value.type === "tool" && (typeof value.content === "string" || Array.isArray(value.content));
+	return isRecord$2(value) && value.lc_direct_tool_output === true && value.type === "tool" && (typeof value.content === "string" || Array.isArray(value.content));
 }
 function isCommand(value) {
-	return isRecord$1(value) && value.lg_name === "Command";
+	return isRecord$2(value) && value.lg_name === "Command";
 }
 function encodeNested(value) {
 	if (isToolMessage(value) || isCommand(value)) return encodeNativeToolResult(value);
 	if (Array.isArray(value)) return value.map(encodeNested);
-	if (isRecord$1(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeNested(entry)]));
+	if (isRecord$2(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeNested(entry)]));
 	return value;
 }
 function encodeNativeToolResult(value) {
@@ -2277,17 +2277,17 @@ function encodeNativeToolResult(value) {
 	};
 	return {
 		[TOOL_RESULT_TAG]: "command",
-		graph: isRecord$1(value) && typeof value.graph === "string" ? value.graph : void 0,
-		update: isRecord$1(value) ? encodeNested(value.update) : void 0,
-		resume: isRecord$1(value) ? encodeNested(value.resume) : void 0,
-		goto: isRecord$1(value) ? encodeNested(value.goto) : void 0
+		graph: isRecord$2(value) && typeof value.graph === "string" ? value.graph : void 0,
+		update: isRecord$2(value) ? encodeNested(value.update) : void 0,
+		resume: isRecord$2(value) ? encodeNested(value.resume) : void 0,
+		goto: isRecord$2(value) ? encodeNested(value.goto) : void 0
 	};
 }
 function finalizeToolResult(value) {
 	return isToolMessage(value) || isCommand(value) ? encodeNativeToolResult(value) : value;
 }
 function isEncodedToolResult(value) {
-	return isRecord$1(value) && typeof value[TOOL_RESULT_TAG] === "string";
+	return isRecord$2(value) && typeof value[TOOL_RESULT_TAG] === "string";
 }
 async function loadPeer(specifierParts, packageName, docsPath) {
 	try {
@@ -2317,7 +2317,7 @@ async function loadLangGraph() {
 async function reviveNested(value, toolCallId) {
 	if (isEncodedToolResult(value)) return reviveToolResult(value, toolCallId);
 	if (Array.isArray(value)) return Promise.all(value.map((entry) => reviveNested(entry, toolCallId)));
-	if (isRecord$1(value)) {
+	if (isRecord$2(value)) {
 		const entries = await Promise.all(Object.entries(value).map(async ([key, entry]) => [key, await reviveNested(entry, toolCallId)]));
 		return Object.fromEntries(entries);
 	}
@@ -2333,9 +2333,9 @@ async function reviveToolResult(value, toolCallId) {
 			...typeof value.id === "string" && { id: value.id },
 			...(value.status === "success" || value.status === "error") && { status: value.status },
 			...value.artifact !== void 0 && { artifact: await reviveNested(value.artifact, toolCallId) },
-			...isRecord$1(value.metadata) && { metadata: await reviveNested(value.metadata, toolCallId) },
-			...isRecord$1(value.additionalKwargs) && { additional_kwargs: await reviveNested(value.additionalKwargs, toolCallId) },
-			...isRecord$1(value.responseMetadata) && { response_metadata: await reviveNested(value.responseMetadata, toolCallId) }
+			...isRecord$2(value.metadata) && { metadata: await reviveNested(value.metadata, toolCallId) },
+			...isRecord$2(value.additionalKwargs) && { additional_kwargs: await reviveNested(value.additionalKwargs, toolCallId) },
+			...isRecord$2(value.responseMetadata) && { response_metadata: await reviveNested(value.responseMetadata, toolCallId) }
 		});
 	}
 	const { Command } = await loadLangGraph();
@@ -2412,7 +2412,7 @@ var BitfabLangGraphIntegration = class {
 		return middleware.includes(this.middleware) ? [...middleware] : [...middleware, this.middleware];
 	}
 	withSubagentMiddleware(spec) {
-		if (!isRecord$1(spec) || "runnable" in spec || "graphId" in spec) return spec;
+		if (!isRecord$2(spec) || "runnable" in spec || "graphId" in spec) return spec;
 		return {
 			...spec,
 			middleware: this.withMiddleware(Array.isArray(spec.middleware) ? spec.middleware : [])
@@ -2429,7 +2429,7 @@ var BitfabLangGraphIntegration = class {
 		return await this.runClaimedToolCall(traceId, toolCallId, toolName, shouldMock, request.toolCall.args, async () => await handler(request), stepSpanId);
 	}
 	stepSpanIdFor(config, traceId) {
-		const namespace = isRecord$1(config) && isRecord$1(config.configurable) ? config.configurable.checkpoint_ns : void 0;
+		const namespace = isRecord$2(config) && isRecord$2(config.configurable) ? config.configurable.checkpoint_ns : void 0;
 		return typeof namespace === "string" ? this.callbackHandler.visibleStepSpanId(namespace, traceId) : null;
 	}
 	recordingTraceId(toolName) {
@@ -2476,8 +2476,8 @@ var BitfabLangGraphIntegration = class {
 		const originalInvoke = tool.invoke.bind(tool);
 		return new Proxy(tool, { get: (target, property) => {
 			if (property === "invoke") return async (input, ...rest) => {
-				const toolCallId = isRecord$1(input) && typeof input.id === "string" ? input.id : "";
-				const args = isRecord$1(input) && "args" in input ? input.args : input;
+				const toolCallId = isRecord$2(input) && typeof input.id === "string" ? input.id : "";
+				const args = isRecord$2(input) && "args" in input ? input.args : input;
 				this.assertReplayToolResultExists(toolName, shouldMock);
 				const traceId = this.getActiveSpan()?.traceId ?? null;
 				const run = async () => await originalInvoke(input, ...rest);
@@ -2587,6 +2587,415 @@ var OrganizationMembersClient = class {
 	}
 };
 //#endregion
+//#region src/piIntegration.ts
+const STREAM_FN_PROPERTY_NAMES_BY_RELEASE = /* @__PURE__ */ new Set(["streamFunction", "streamFn"]);
+const STATE_PROPERTIES = /* @__PURE__ */ new Set(["state", "_state"]);
+const HOOKS_RETURNING_CONTEXT = /* @__PURE__ */ new Set([
+	"prepareRequest",
+	"prepareNextTurn",
+	"prepareNextTurnWithContext"
+]);
+const FAILED_STOP_REASONS = /* @__PURE__ */ new Set(["error", "aborted"]);
+const replayFailuresHiddenByPi = /* @__PURE__ */ new WeakMap();
+const instrumentedByAnyIntegration = /* @__PURE__ */ new WeakSet();
+const wrappersByAnyIntegration = /* @__PURE__ */ new WeakSet();
+const replayItemsWithRestoredTranscript = /* @__PURE__ */ new WeakSet();
+function transcriptFixtureName(traceFunctionKey) {
+	return `pi-transcript:${traceFunctionKey}`;
+}
+function isTranscriptFixture(value) {
+	return isRecord$1(value) && (value.method === "prompt" || value.method === "continue") && Array.isArray(value.messages);
+}
+function conversationMessages(messages) {
+	return messages.filter((message) => message?.role !== "system");
+}
+function leadingSystemMessages(messages) {
+	const firstConversation = messages.findIndex((message) => message?.role !== "system");
+	return firstConversation === -1 ? messages.slice() : messages.slice(0, firstConversation);
+}
+function serializedBytes(value) {
+	try {
+		return JSON.stringify(value)?.length;
+	} catch {
+		return;
+	}
+}
+const TRANSCRIPT_BUDGET_BYTES = Math.floor(require_http.MAX_SPAN_CARRIER_BYTES * .7);
+function mostRecentTurnsWithinBudget(messages) {
+	const sizes = messages.map((message) => serializedBytes(message) ?? 0);
+	let total = sizes.reduce((sum, size) => sum + size, 0);
+	let start = 0;
+	while (start < messages.length && total > TRANSCRIPT_BUDGET_BYTES) {
+		total -= sizes[start] ?? 0;
+		start += 1;
+	}
+	while (start < messages.length && messages[start]?.role !== "user") start += 1;
+	return {
+		kept: messages.slice(start),
+		dropped: start
+	};
+}
+function callsWithoutArguments(args) {
+	return args.every((arg) => arg === void 0);
+}
+function spanNameForModel(model) {
+	if (typeof model?.id !== "string") return "llm";
+	return typeof model.provider === "string" ? `${model.provider}/${model.id}` : model.id;
+}
+function keepReplayFailure(error) {
+	const replay = require_http.getReplayContext();
+	if (replay !== null && error instanceof require_http.BitfabError) {
+		if (!replayFailuresHiddenByPi.has(replay)) replayFailuresHiddenByPi.set(replay, error);
+	}
+}
+function throwKeptReplayFailure() {
+	const replay = require_http.getReplayContext();
+	if (replay !== null && replayFailuresHiddenByPi.has(replay)) {
+		const error = replayFailuresHiddenByPi.get(replay);
+		replayFailuresHiddenByPi.delete(replay);
+		throw error;
+	}
+}
+async function rethrowingKept(work) {
+	try {
+		return await work();
+	} catch (error) {
+		keepReplayFailure(error);
+		throw error;
+	}
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function isAgentLike(value) {
+	return isRecord$1(value) && typeof value.prompt === "function" && typeof value.continue === "function" && isRecord$1(value.state) && Array.isArray(value.state.messages);
+}
+function isSessionLike(value) {
+	return isRecord$1(value) && typeof value.prompt === "function" && isAgentLike(value.agent);
+}
+function isEventStream(value) {
+	return isRecord$1(value) && typeof value.result === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function failed(message) {
+	return typeof message?.stopReason === "string" && FAILED_STOP_REASONS.has(message.stopReason);
+}
+function messageText(message) {
+	const content = message?.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
+}
+function asCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function wholePromptTokens(usage) {
+	const uncachedInput = asCount(usage.input);
+	const cacheRead = asCount(usage.cacheRead);
+	if (uncachedInput === void 0 && cacheRead === void 0) return;
+	return (uncachedInput ?? 0) + (cacheRead ?? 0) + (asCount(usage.cacheWrite) ?? 0);
+}
+function pricedCost(usage) {
+	const cost = asCount(usage.cost?.total);
+	return cost !== void 0 && cost > 0 ? cost : void 0;
+}
+function usageContext(message, model) {
+	const context = {};
+	const modelName = message.model ?? model.id;
+	if (typeof modelName === "string") context.model = modelName;
+	const usage = message.usage;
+	if (!isRecord$1(usage)) return context;
+	const entries = {
+		inputTokens: wholePromptTokens(usage),
+		outputTokens: asCount(usage.output),
+		cachedInputTokens: asCount(usage.cacheRead),
+		costUsd: pricedCost(usage)
+	};
+	for (const [name, value] of Object.entries(entries)) if (value !== void 0) context[name] = value;
+	return context;
+}
+function toolDeclarations(tools) {
+	return tools.filter(isRecord$1).map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters
+	}));
+}
+function llmRequest(model, context, options) {
+	const request = { model: {
+		id: model.id,
+		provider: model.provider,
+		api: model.api
+	} };
+	if (typeof context.systemPrompt === "string") request.systemPrompt = context.systemPrompt;
+	request.messages = context.messages;
+	if (Array.isArray(context.tools)) request.tools = toolDeclarations(context.tools);
+	for (const setting of [
+		"reasoning",
+		"maxTokens",
+		"temperature"
+	]) if (options?.[setting] !== void 0) request[setting] = options[setting];
+	return request;
+}
+function streamOfRecordedMessage(message) {
+	const reason = message.stopReason ?? "stop";
+	const terminalEvent = failed(message) ? {
+		type: "error",
+		reason,
+		error: message
+	} : {
+		type: "done",
+		reason,
+		message
+	};
+	return {
+		async *[Symbol.asyncIterator]() {
+			yield terminalEvent;
+		},
+		result: () => Promise.resolve(message)
+	};
+}
+function lastAssistantMessageSince(state, start) {
+	const assistantMessages = state.messages.slice(start).filter((message) => message?.role === "assistant");
+	return assistantMessages[assistantMessages.length - 1];
+}
+var BitfabPiIntegration = class {
+	constructor(config) {
+		this.instrumented = /* @__PURE__ */ new WeakMap();
+		this.toolArrays = /* @__PURE__ */ new WeakMap();
+		this.wrappedStreamFns = /* @__PURE__ */ new WeakMap();
+		this.wrappedTools = /* @__PURE__ */ new WeakMap();
+		this.originalTools = /* @__PURE__ */ new WeakMap();
+		this.wrappedHooks = /* @__PURE__ */ new WeakMap();
+		this.host = config.host;
+		this.traceFunctionKey = config.traceFunctionKey;
+		this.mockToolsOnReplay = config.options?.mockToolsOnReplay ?? true;
+	}
+	instrument(target) {
+		if (instrumentedByAnyIntegration.has(target)) return target;
+		const existing = this.instrumented.get(target);
+		if (existing !== void 0) return existing;
+		const proxy = this.proxyFor(target);
+		this.instrumented.set(target, proxy);
+		instrumentedByAnyIntegration.add(proxy);
+		return proxy;
+	}
+	proxyFor(target) {
+		if (isAgentLike(target)) return this.instrumentAgent(target);
+		if (isSessionLike(target)) return this.instrumentSession(target);
+		throw new require_http.BitfabError("getPiIntegration().instrument() expects a Pi Agent (from @earendil-works/pi-agent-core) or an AgentSession (from createAgentSession)", "https://docs.bitfab.ai/frameworks/pi");
+	}
+	instrumentAgent(agent) {
+		const proxy = new Proxy(agent, { get: (target, property) => {
+			if (property === "prompt" || property === "continue") return (...args) => this.runRoot(property, target, proxy, args, {
+				state: () => target.state,
+				sessionId: () => target.sessionId,
+				restoreConversation: (messages) => {
+					target.state.messages = [...leadingSystemMessages(target.state.messages), ...messages];
+				}
+			});
+			const value = Reflect.get(target, property, proxy);
+			if (STREAM_FN_PROPERTY_NAMES_BY_RELEASE.has(property) && typeof value === "function") return this.wrapStreamFn(value);
+			if (STATE_PROPERTIES.has(property) && isRecord$1(value)) return this.toolWrappingState(value);
+			if (HOOKS_RETURNING_CONTEXT.has(property) && typeof value === "function") return this.toolWrappingHook(value);
+			return value;
+		} });
+		return proxy;
+	}
+	instrumentSession(session) {
+		const proxy = new Proxy(session, { get: (target, property) => {
+			if (property === "prompt") return (...args) => this.runRoot("prompt", target, proxy, args, {
+				state: () => target.agent.state,
+				sessionId: () => target.sessionId,
+				restoreConversation: (messages) => this.restoreIntoSession(target, messages)
+			});
+			const value = Reflect.get(target, property, proxy);
+			if (property === "agent" && isAgentLike(value)) return this.instrument(value);
+			return value;
+		} });
+		return proxy;
+	}
+	toolWrappingHook(hook) {
+		const existing = this.wrappedHooks.get(hook);
+		if (existing !== void 0) return existing;
+		const wrapped = async (...args) => {
+			const update = await hook(...args);
+			if (!isRecord$1(update) || !isRecord$1(update.context)) return update;
+			const tools = update.context.tools;
+			if (!Array.isArray(tools)) return update;
+			return {
+				...update,
+				context: {
+					...update.context,
+					tools: tools.map((tool) => this.wrapTool(tool))
+				}
+			};
+		};
+		this.wrappedHooks.set(hook, wrapped);
+		return wrapped;
+	}
+	restoreIntoSession(session, messages) {
+		const store = session.sessionManager;
+		if (store?.isPersisted?.() !== false || typeof store.appendMessage !== "function") {
+			require_autoTrace.warnOnce(`pi-replay-session-persisted:${this.traceFunctionKey}`, `A replayed "${this.traceFunctionKey}" run used an AgentSession saved to disk, so Bitfab did not restore the recorded conversation into it. Build the session in your replay function with SessionManager.inMemory() to replay each turn with its history.`);
+			return;
+		}
+		for (const message of messages) store.appendMessage(message);
+	}
+	toolWrappingState(state) {
+		const existing = this.instrumented.get(state);
+		if (existing !== void 0) return existing;
+		const proxy = new Proxy(state, {
+			get: (target, property) => {
+				const value = Reflect.get(target, property, target);
+				if (property === "tools" && Array.isArray(value)) return this.toolWrappingArray(value);
+				return value;
+			},
+			set: (target, property, value) => Reflect.set(target, property, property === "tools" && Array.isArray(value) ? value.map((tool) => this.unwrapTool(tool)) : value, target)
+		});
+		this.instrumented.set(state, proxy);
+		return proxy;
+	}
+	toolWrappingArray(tools) {
+		const existing = this.toolArrays.get(tools);
+		if (existing !== void 0) return existing;
+		const proxy = new Proxy(tools, {
+			get: (target, property, receiver) => {
+				const value = Reflect.get(target, property, receiver);
+				if (typeof property === "string" && /^\d+$/.test(property)) return this.wrapTool(value);
+				return value;
+			},
+			set: (target, property, value) => Reflect.set(target, property, this.unwrapTool(value))
+		});
+		this.toolArrays.set(tools, proxy);
+		return proxy;
+	}
+	recordTranscript(method, state) {
+		const contexts = this.host.traceRootContexts();
+		const name = transcriptFixtureName(this.traceFunctionKey);
+		if (contexts === null || hasIntegrationFixture(contexts, name)) return;
+		const messages = conversationMessages(state.messages);
+		if (method === "prompt" && messages.length === 0) return;
+		const { kept, dropped } = mostRecentTurnsWithinBudget(messages);
+		if (dropped > 0) this.warnConversationTrimmed(messages, kept);
+		contexts.push(createIntegrationFixtureContext(name, {
+			method,
+			messages: kept,
+			...dropped > 0 && { droppedMessages: dropped }
+		}));
+	}
+	warnConversationTrimmed(messages, kept) {
+		const megabytes = ((serializedBytes(messages) ?? 0) / 1e6).toFixed(1);
+		require_autoTrace.warnOnce(`pi-conversation-too-large:${this.traceFunctionKey}`, `The conversation before a "${this.traceFunctionKey}" prompt is ${megabytes} MB, more than one span can carry, so Bitfab recorded only its most recent ${kept.length} of ${messages.length} messages. A replay of that turn starts from those. Prune agent.state.messages (or the session) to replay long conversations in full.`);
+	}
+	restoredTranscript(run) {
+		const replay = require_http.getReplayContext();
+		if (replay === null || replayItemsWithRestoredTranscript.has(replay)) return;
+		const fixture = replay.integrationFixtures?.get(transcriptFixtureName(this.traceFunctionKey));
+		if (!isTranscriptFixture(fixture)) {
+			if (fixture !== void 0) require_autoTrace.warnOnce(`pi-replay-conversation-unavailable:${this.traceFunctionKey}`, `A replayed "${this.traceFunctionKey}" turn had a recorded conversation that was too large to keep, so it replays without the earlier turns.`);
+			return;
+		}
+		replayItemsWithRestoredTranscript.add(replay);
+		if ((fixture.droppedMessages ?? 0) > 0) require_autoTrace.warnOnce(`pi-replay-conversation-trimmed:${this.traceFunctionKey}`, `A replayed "${this.traceFunctionKey}" turn had a conversation too large to record in full, so it replays with only the most recent ${fixture.messages.length} messages.`);
+		run.restoreConversation(fixture.messages);
+		return fixture;
+	}
+	runRoot(method, target, receiver, args, run) {
+		const call = async (...callArgs) => {
+			const replaysContinue = this.restoredTranscript(run)?.method === "continue" && callsWithoutArguments(callArgs);
+			const calledMethod = replaysContinue ? "continue" : method;
+			if (require_http.getReplayContext() === null) this.recordTranscript(method, run.state());
+			await Reflect.get(target, calledMethod, target).apply(receiver, replaysContinue ? [] : callArgs);
+			throwKeptReplayFailure();
+		};
+		if (this.host.activeRootTraceFunctionKey() === this.traceFunctionKey) return call(...args);
+		const callReturningFinalMessage = async (...callArgs) => {
+			const sessionId = run.sessionId();
+			if (typeof sessionId === "string" && sessionId.length > 0) this.host.setTraceSessionId(sessionId);
+			const start = run.state().messages.length;
+			await call(...callArgs);
+			return lastAssistantMessageSince(run.state(), start);
+		};
+		return this.host.withSpan(this.traceFunctionKey, {
+			name: this.traceFunctionKey,
+			type: "agent",
+			surface: "inherit",
+			instrumentation: "pi",
+			finalize: (result) => {
+				const finalMessage = result;
+				const text = messageText(finalMessage);
+				if (failed(finalMessage)) throw new StreamFinalizationError(finalMessage?.errorMessage ?? `Agent run ${finalMessage?.stopReason}`, text);
+				return text;
+			}
+		}, callReturningFinalMessage)(...args).then(() => void 0);
+	}
+	warnIfOutsideRun(what) {
+		if (this.host.activeRootTraceFunctionKey() !== void 0) return;
+		require_autoTrace.warnOnce(`pi-call-outside-run:${this.traceFunctionKey}`, `A Pi ${what} for "${this.traceFunctionKey}" ran outside any traced run, so it was not recorded. Run the agent through getPiIntegration("${this.traceFunctionKey}").instrument(agent).prompt() so its model requests and tool calls are traced.`);
+	}
+	wrapStreamFn(streamFn) {
+		if (wrappersByAnyIntegration.has(streamFn)) return streamFn;
+		const existing = this.wrappedStreamFns.get(streamFn);
+		if (existing !== void 0) return existing;
+		const wrapped = async (model, context, options) => {
+			this.warnIfOutsideRun("model request");
+			let llmSpan;
+			const recordFinalMessage = async (result) => {
+				const message = await result.result();
+				llmSpan?.addContext(usageContext(message, model));
+				if (failed(message)) throw new StreamFinalizationError(message.errorMessage ?? `Model request ${message.stopReason}`, message);
+				return message;
+			};
+			const traced = this.host.withSpan(this.traceFunctionKey, {
+				name: spanNameForModel(model),
+				type: "llm",
+				captureWhen: "nested",
+				surface: "inherit",
+				instrumentation: "pi",
+				finalize: recordFinalMessage
+			}, async (_request) => {
+				llmSpan = this.host.currentSpan();
+				return streamFn(model, context, options);
+			});
+			const result = await rethrowingKept(() => traced(llmRequest(model, context, options)));
+			return isEventStream(result) ? result : streamOfRecordedMessage(result ?? {});
+		};
+		this.wrappedStreamFns.set(streamFn, wrapped);
+		wrappersByAnyIntegration.add(wrapped);
+		return wrapped;
+	}
+	mocksTool(name) {
+		return Array.isArray(this.mockToolsOnReplay) ? this.mockToolsOnReplay.includes(name) : this.mockToolsOnReplay === true;
+	}
+	unwrapTool(tool) {
+		return this.originalTools.get(tool) ?? tool;
+	}
+	wrapTool(tool) {
+		if (!isRecord$1(tool) || typeof tool.execute !== "function" || wrappersByAnyIntegration.has(tool)) return tool;
+		const existing = this.wrappedTools.get(tool);
+		if (existing !== void 0) return existing;
+		const execute = tool.execute;
+		const executeName = execute.name || "execute";
+		const spanOptions = {
+			name: tool.name,
+			type: "function",
+			captureWhen: "nested",
+			mockOnReplay: this.mocksTool(tool.name),
+			surface: "inherit",
+			instrumentation: "pi"
+		};
+		const tracedExecute = (toolCallId, params, signal, onUpdate) => {
+			this.warnIfOutsideRun("tool call");
+			return rethrowingKept(() => this.host.withSpan(this.traceFunctionKey, spanOptions, async (args) => this.host.withDiscoveredCallsUnderCurrentSpan(() => require_autoTrace.runAsAutoTraceRootFunction(executeName, () => execute.call(tool, toolCallId, args, signal, onUpdate))))(params));
+		};
+		const wrapped = new Proxy(tool, { get: (target, property, receiver) => property === "execute" ? tracedExecute : Reflect.get(target, property, receiver) });
+		this.wrappedTools.set(tool, wrapped);
+		this.originalTools.set(wrapped, tool);
+		wrappersByAnyIntegration.add(wrapped);
+		return wrapped;
+	}
+};
+//#endregion
 //#region src/codeChange.ts
 const MAX_FILES = 60;
 const MAX_FILE_BYTES = 5e5;
@@ -4599,6 +5008,9 @@ var TracesClient = class {
 	async getScenario(traceId) {
 		return (await this.httpClient.get(traceScenarioPath(traceId))).scenario;
 	}
+	async generateScenario(traceId) {
+		return (await this.httpClient.request(`${traceScenarioPath(traceId)}/generate`, {})).generation;
+	}
 	async saveScenario({ traceId, ...edit }) {
 		return (await this.httpClient.request(traceScenarioPath(traceId), withoutDataRecords(edit))).scenario;
 	}
@@ -5808,6 +6220,24 @@ var Bitfab = class {
 			}
 		}, options);
 	}
+	getPiIntegration(traceFunctionKey, options) {
+		this.prepareFrameworkIntegration();
+		return new BitfabPiIntegration({
+			traceFunctionKey,
+			options,
+			host: {
+				withSpan: (key, spanOptions, fn) => this.withSpan(key, spanOptions, fn),
+				activeRootTraceFunctionKey: () => {
+					const stack = getSpanStack();
+					return stack[stack.length - 1]?.rootTraceFunctionKey;
+				},
+				currentSpan: () => getCurrentSpan(),
+				traceRootContexts: () => currentTraceRootSpan()?.details.contexts ?? null,
+				setTraceSessionId: (sessionId) => getCurrentTrace().setSessionId(sessionId),
+				withDiscoveredCallsUnderCurrentSpan: (fn) => require_autoTrace.runWithAutoTraceFramesAt(getSpanStack(), fn)
+			}
+		});
+	}
 	getClaudeAgentHandler(traceFunctionKey) {
 		this.prepareFrameworkIntegration();
 		return new BitfabClaudeAgentHandler({
@@ -6573,7 +7003,7 @@ var Bitfab = class {
 			await runWithSeedContext({ traceId }, async () => target(...args));
 		} finally {
 			try {
-				const { flushTraces } = await Promise.resolve().then(() => require("./http-DAMAcv_J.cjs")).then((n) => n.http_exports);
+				const { flushTraces } = await Promise.resolve().then(() => require("./http-BB9wDcLm.cjs")).then((n) => n.http_exports);
 				await flushTraces(3e4);
 			} finally {
 				unrecorded = activeTraceStates.delete(traceId);
@@ -6656,6 +7086,9 @@ var BitfabFunction = class {
 	getDeepAgentsIntegration(options) {
 		return this.client.getDeepAgentsIntegration(this.traceFunctionKey, options);
 	}
+	getPiIntegration(options) {
+		return this.client.getPiIntegration(this.traceFunctionKey, options);
+	}
 	getRivetIntegration(options) {
 		return this.client.getRivetIntegration(this.traceFunctionKey, options);
 	}
@@ -6776,7 +7209,7 @@ async function seedFromRegistry(registry, pipeline, cases, options = {}) {
 		metadata: seedCase.metadata,
 		sessionId: seedCase.sessionId
 	}));
-	const { flushTraces } = await Promise.resolve().then(() => require("./http-DAMAcv_J.cjs")).then((n) => n.http_exports);
+	const { flushTraces } = await Promise.resolve().then(() => require("./http-BB9wDcLm.cjs")).then((n) => n.http_exports);
 	await flushTraces(3e4);
 	return {
 		pipeline,
@@ -6857,6 +7290,12 @@ Object.defineProperty(exports, "BitfabOpenAITracingProcessor", {
 		return BitfabOpenAITracingProcessor;
 	}
 });
+Object.defineProperty(exports, "BitfabPiIntegration", {
+	enumerable: true,
+	get: function() {
+		return BitfabPiIntegration;
+	}
+});
 Object.defineProperty(exports, "BitfabRivetIntegration", {
 	enumerable: true,
 	get: function() {
@@ -7020,4 +7459,4 @@ Object.defineProperty(exports, "serializeReplayResult", {
 	}
 });
 
-//# sourceMappingURL=src-B7_GnVaZ.cjs.map
+//# sourceMappingURL=src-BOmu6a4v.cjs.map