@overmux/pi 0.0.1

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":[],"sources":["../src/plugin.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\n\nimport {\n  defineOperation,\n  type HandlerContext,\n  type StreamHandlerDefinition,\n} from \"overmux\";\nimport {\n  defineResourceContract,\n  defineStreamContract,\n  noInputSchema,\n} from \"overmux\";\nimport { z } from \"zod\";\n\nimport {\n  sendAbort,\n  sendSetModel,\n  sendSetThinkingLevel,\n  sendUserMessage,\n  type AbortResponse,\n  type UserMessageResponse,\n} from \"./protocol.js\";\nimport {\n  createPiAgentConversationService,\n  piConversationSnapshotSchema,\n  piSessionMetadataSchema,\n  type PiAgentSession,\n  type PiConversationSnapshot,\n} from \"./projection.js\";\n\ntype Awaitable<T> = T | Promise<T>;\ntype Dispose = () => void;\nexport type PiSessionSource = {\n  list: () => Awaitable<readonly PiAgentSession[]>;\n  subscribe: (\n    invalidate: () => void,\n    options: { signal: AbortSignal },\n  ) => Dispose | void;\n};\ntype PiAgentListener = () => void;\n\nexport type PiAgents = {\n  get: (agentId: string) => Promise<PiAgentSession | undefined>;\n  list: () => Promise<readonly PiAgentSession[]>;\n  subscribe: (listener: PiAgentListener) => Dispose;\n};\n\nconst piAgentSessionSchema = z\n  .object({\n    id: z.string().min(1),\n    liveEventsDir: z.string().min(1).optional(),\n    sessionFile: z.string().min(1),\n    sessionMetadata: piSessionMetadataSchema.optional(),\n  })\n  .strict();\n\nconst piSessionSchema = z.object({ agentId: z.string().min(1) }).strict();\nconst piMessageInputSchema = z\n  .object({\n    agentId: z.string().min(1),\n    deliverAs: z.enum([\"steer\", \"followUp\"]),\n    message: z.string().trim().min(1),\n  })\n  .strict();\nconst piMessageResultSchema = z.object({\n  delivery: z.enum([\"immediate\", \"steer\", \"followUp\"]),\n  requestId: z.string().min(1),\n});\nconst piStopInputSchema = z.object({ agentId: z.string().min(1) }).strict();\nconst piStopResultSchema = z.object({ requestId: z.string().min(1) });\nconst piModelInputSchema = z\n  .object({\n    agentId: z.string().min(1),\n    provider: z.string().min(1),\n    id: z.string().min(1),\n  })\n  .strict();\nconst piThinkingInputSchema = z\n  .object({\n    agentId: z.string().min(1),\n    level: z.enum([\"off\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\", \"max\"]),\n  })\n  .strict();\nconst piControlResultSchema = z.object({ requestId: z.string().min(1) });\n\nconst once = (dispose: Dispose): Dispose => {\n  let disposed = false;\n  return () => {\n    if (disposed) {\n      return;\n    }\n    disposed = true;\n    dispose();\n  };\n};\n\nconst sameSessions = (\n  left: readonly PiAgentSession[],\n  right: readonly PiAgentSession[],\n): boolean =>\n  left.length === right.length &&\n  left.every(\n    (session, index) =>\n      session.id === right[index]?.id &&\n      session.sessionFile === right[index]?.sessionFile &&\n      session.liveEventsDir === right[index]?.liveEventsDir &&\n      JSON.stringify(session.sessionMetadata) ===\n        JSON.stringify(right[index]?.sessionMetadata),\n  );\n\nexport const definePiAgents = ({\n  liveEventsDir,\n  sessions,\n}: {\n  liveEventsDir: string;\n  sessions: PiSessionSource;\n}): PiAgents => {\n  const listeners = new Set<PiAgentListener>();\n  let cached: PiAgentSession[] = [];\n  let sourceDispose: Dispose | undefined;\n  let refreshQueue = Promise.resolve();\n\n  const refresh = async () => {\n    const result = refreshQueue.then(async () => {\n      const next = (await sessions.list())\n        .map((session) =>\n          piAgentSessionSchema.parse({ ...session, liveEventsDir }),\n        )\n        .sort((left, right) => left.id.localeCompare(right.id));\n      if (new Set(next.map(({ id }) => id)).size !== next.length) {\n        throw new Error(\"Pi agent discovery returned duplicate IDs\");\n      }\n      if (!sameSessions(cached, next)) {\n        cached = next;\n        listeners.forEach((listener) => listener());\n      }\n    });\n    refreshQueue = result.catch(() => undefined);\n    await result;\n    return cached;\n  };\n\n  const stopSource = () => {\n    sourceDispose?.();\n    sourceDispose = undefined;\n  };\n\n  const startSource = () => {\n    if (sourceDispose) {\n      return;\n    }\n    const controller = new AbortController();\n    const dispose = sessions.subscribe(\n      () => void refresh().catch(() => undefined),\n      { signal: controller.signal },\n    );\n    sourceDispose = once(() => {\n      controller.abort();\n      dispose?.();\n    });\n  };\n\n  return {\n    get: async (agentId) => (await refresh()).find(({ id }) => id === agentId),\n    list: refresh,\n    subscribe: (listener) => {\n      listeners.add(listener);\n      startSource();\n      return () => {\n        listeners.delete(listener);\n        if (!listeners.size) {\n          stopSource();\n        }\n      };\n    },\n  };\n};\n\nconst piSessionsContract = defineResourceContract({\n  input: noInputSchema,\n  output: z.array(piSessionSchema),\n});\n\nexport const piSessionsResource = ({ agents }: { agents: PiAgents }) => ({\n  contract: piSessionsContract,\n  kind: \"subscription\" as const,\n  read: async (_input: void, _context: HandlerContext) =>\n    (await agents.list()).map(({ id }) => ({ agentId: id })),\n  subscribe: (\n    _input: void,\n    invalidate: () => void,\n    context: HandlerContext,\n  ) => {\n    const dispose = once(agents.subscribe(invalidate));\n    context.signal.addEventListener(\"abort\", dispose, { once: true });\n    return once(() => {\n      context.signal.removeEventListener(\"abort\", dispose);\n      dispose();\n    });\n  },\n});\n\nconst piConversationContract = defineStreamContract({\n  clientMessage: z.never(),\n  input: z.object({ agentId: z.string().min(1) }).strict(),\n  serverMessage: piConversationSnapshotSchema,\n});\n\nconst limitConversationEntries = (\n  snapshot: PiConversationSnapshot,\n  maxEntries: number | undefined,\n): PiConversationSnapshot =>\n  maxEntries === undefined\n    ? snapshot\n    : { ...snapshot, entries: snapshot.entries.slice(-maxEntries) };\n\nexport const piConversationStream = ({\n  agents,\n  maxEntries,\n}: {\n  agents: PiAgents;\n  maxEntries?: number;\n}): StreamHandlerDefinition<\n  typeof piConversationContract.input,\n  typeof piConversationContract.clientMessage,\n  typeof piConversationContract.serverMessage\n> => {\n  if (\n    maxEntries !== undefined &&\n    (!Number.isSafeInteger(maxEntries) || maxEntries < 1)\n  ) {\n    throw new Error(\"Pi conversation maxEntries must be a positive integer\");\n  }\n  return {\n    contract: piConversationContract,\n    open: async ({ agentId }, context) => {\n      const service = createPiAgentConversationService({\n        resolveAgent: async (id) => {\n          const agent = await agents.get(id);\n          if (!agent) {\n            throw new Error(`Pi agent not found: ${id}`);\n          }\n          return { ...agent, sessionId: agent.id };\n        },\n      });\n      try {\n        context.emit(\n          limitConversationEntries(\n            await service.getSnapshot(agentId),\n            maxEntries,\n          ),\n        );\n        const unsubscribe = service.subscribe(agentId, (snapshot) =>\n          context.emit(limitConversationEntries(snapshot, maxEntries)),\n        );\n        return {\n          dispose: once(() => {\n            unsubscribe();\n            service.dispose();\n          }),\n        };\n      } catch (error) {\n        service.dispose();\n        throw error;\n      }\n    },\n  };\n};\n\nconst piMessageResult = async (\n  agent: PiAgentSession | undefined,\n  input: z.infer<typeof piMessageInputSchema>,\n): Promise<z.infer<typeof piMessageResultSchema>> => {\n  if (!agent) {\n    throw new Error(`Pi agent not found: ${input.agentId}`);\n  }\n  const response = await sendUserMessage(agent.id, {\n    deliverAs: input.deliverAs,\n    message: input.message,\n    requestId: randomUUID(),\n  });\n  if (!response?.ok) {\n    throw new Error(\"Pi agent is unavailable\");\n  }\n  return response;\n};\n\nconst piStopResult = async (\n  agent: PiAgentSession | undefined,\n  input: z.infer<typeof piStopInputSchema>,\n): Promise<z.infer<typeof piStopResultSchema>> => {\n  if (!agent) {\n    throw new Error(`Pi agent not found: ${input.agentId}`);\n  }\n  const requestId = randomUUID();\n  const response = await sendAbort(agent.id, { requestId });\n  if (!response?.ok) {\n    throw new Error(\"Pi agent is unavailable\");\n  }\n  return { requestId };\n};\n\nconst piControlResult = async (\n  agent: PiAgentSession | undefined,\n  input: { agentId: string },\n  send: (\n    agentId: string,\n    requestId: string,\n  ) => Promise<{ ok: boolean; error?: string } | undefined>,\n): Promise<z.infer<typeof piControlResultSchema>> => {\n  if (!agent) {\n    throw new Error(`Pi agent not found: ${input.agentId}`);\n  }\n  const requestId = randomUUID();\n  const response = await send(agent.id, requestId);\n  if (response?.ok) {\n    return { requestId };\n  }\n  if (response?.error === \"not_found\") {\n    throw new Error(\"Pi model was not found\");\n  }\n  if (response?.error === \"no_key\") {\n    throw new Error(\"No API key is available for this Pi model\");\n  }\n  throw new Error(\"Pi agent is unavailable\");\n};\n\nexport const piOperationHandlers = ({ agents }: { agents: PiAgents }) => ({\n  sendPiMessage: defineOperation({\n    handle: async (input) =>\n      piMessageResult(await agents.get(input.agentId), input),\n    input: piMessageInputSchema,\n    output: piMessageResultSchema,\n  }),\n  stopPiAgent: defineOperation({\n    handle: async (input) =>\n      piStopResult(await agents.get(input.agentId), input),\n    input: piStopInputSchema,\n    output: piStopResultSchema,\n  }),\n  setPiModel: defineOperation({\n    handle: async (input) =>\n      piControlResult(\n        await agents.get(input.agentId),\n        input,\n        (agentId, requestId) =>\n          sendSetModel(agentId, {\n            id: input.id,\n            provider: input.provider,\n            requestId,\n          }),\n      ),\n    input: piModelInputSchema,\n    output: piControlResultSchema,\n  }),\n  setPiThinkingLevel: defineOperation({\n    handle: async (input) =>\n      piControlResult(\n        await agents.get(input.agentId),\n        input,\n        (agentId, requestId) =>\n          sendSetThinkingLevel(agentId, { level: input.level, requestId }),\n      ),\n    input: piThinkingInputSchema,\n    output: piControlResultSchema,\n  }),\n});\n\nexport type { AbortResponse, UserMessageResponse };\n"],"mappings":"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"}

package/dist/projection.d.ts

@@ -0,0 +1,101 @@
+import { S as UserMessageResponse, b as UserMessageInput, c as ProbeOptions } from "./protocol-CsrnSPOv.js";
+import { z } from "zod";
+//#region src/projection.d.ts
+type PiContentBlock = {
+  arguments?: unknown;
+  data?: string;
+  id?: string;
+  mimeType?: string;
+  name?: string;
+  text?: string;
+  thinking?: string;
+  tool?: PiToolProjection;
+  type: string;
+};
+type PiToolResultProjection = {
+  content: PiContentBlock[];
+  details?: unknown;
+  isError: boolean;
+  toolCallId: string;
+  toolName: string;
+};
+type PiToolProjection = {
+  result?: PiToolResultProjection;
+  status: "error" | "pending" | "success";
+};
+type PiConversationEntry = {
+  content: PiContentBlock[];
+  details?: unknown;
+  errorMessage?: string;
+  id: string;
+  isError?: boolean;
+  role: "assistant" | "toolResult" | "user";
+  source: "canonical" | "live";
+  status: "complete" | "error" | "pending";
+  stopReason?: string;
+  timestamp?: number;
+  toolCallId?: string;
+  toolName?: string;
+};
+declare const piContentBlockSchema: z.ZodType<PiContentBlock>;
+declare const piToolResultProjectionSchema: z.ZodType<PiToolResultProjection>;
+declare const piToolProjectionSchema: z.ZodType<PiToolProjection>;
+declare const piSessionMetadataSchema: z.ZodObject<{
+  contextUsage: z.ZodOptional<z.ZodObject<{
+    tokens: z.ZodNumber;
+    contextWindow: z.ZodNumber;
+    percent: z.ZodNumber;
+  }, z.core.$strict>>;
+  model: z.ZodOptional<z.ZodObject<{
+    provider: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$strict>>;
+  thinkingLevel: z.ZodString;
+  modelOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    provider: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodString;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type PiSessionMetadata = z.infer<typeof piSessionMetadataSchema>;
+type PiConversationSnapshot = {
+  agentAvailable: boolean;
+  entries: PiConversationEntry[];
+  sessionMetadata?: PiSessionMetadata;
+  status: "busy" | "degraded" | "idle" | "offline";
+};
+declare const piConversationSnapshotSchema: z.ZodType<PiConversationSnapshot>;
+type PiAgentSession = {
+  id: string;
+  liveEventsDir?: string;
+  sessionFile: string;
+  sessionMetadata?: PiSessionMetadata;
+};
+type PiAgentResource = PiAgentSession & {
+  sessionId: string;
+};
+type SnapshotListener = (snapshot: PiConversationSnapshot) => void;
+type PiAgentConversationService = {
+  dispose: () => void;
+  getSnapshot: (agentId: string) => Promise<PiConversationSnapshot>;
+  subscribe: (agentId: string, listener: SnapshotListener) => () => void;
+};
+type PiMessageResponse = Extract<UserMessageResponse, {
+  ok: true;
+}>;
+type PiMessageSender = (sessionId: string, request: UserMessageInput) => Promise<UserMessageResponse | undefined>;
+declare const probePiAgent: (sessionId: string, options?: ProbeOptions) => Promise<boolean>;
+declare const createPiAgentConversationService: ({ resolveAgent, pollIntervalMs, probe }: {
+  resolveAgent: (agentId: string) => Promise<PiAgentResource>;
+  pollIntervalMs?: number;
+  probe?: (sessionId: string) => Promise<boolean>;
+}) => PiAgentConversationService;
+declare const sendPiAgentMessage: ({ deliverAs, message, sessionId }: {
+  deliverAs: "followUp" | "steer";
+  message: string;
+  sessionId: string;
+}, send?: PiMessageSender) => Promise<PiMessageResponse>;
+//#endregion
+export { PiAgentConversationService, PiAgentSession, PiContentBlock, PiConversationEntry, PiConversationSnapshot, PiMessageSender, PiSessionMetadata, PiToolProjection, PiToolResultProjection, createPiAgentConversationService, piContentBlockSchema, piConversationSnapshotSchema, piSessionMetadataSchema, piToolProjectionSchema, piToolResultProjectionSchema, probePiAgent, sendPiAgentMessage };
+//# sourceMappingURL=projection.d.ts.map

package/dist/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","names":[],"sources":["../src/projection.ts"],"mappings":";;;KAiBY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;EACP;;KAEU;EACV,SAAS;EACT;EACA;EACA;EACA;;KAEU;EACV,SAAS;EACT;;KAEU;EACV,SAAS;EACT;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;cAGW,sBAAsB,EAAE,QAAQ;cAchC,8BAA8B,EAAE,QAAQ;cASxC,wBAAwB,EAAE,QAAQ;cAMlC,yBAAuB,EAAA;;;;;;;;;;;;;;;;;GAgCzB,EAAA,KAAA;KAEC,oBAAoB,EAAE,aAAa;KACnC;EACV;EACA,SAAS;EACT,kBAAkB;EAClB;;cAGW,8BAA8B,EAAE,QAAQ;KAuBzC;EACV;EACA;EACA;EACA,kBAAkB;;KAGf,kBAAkB;EAAmB;;KA+CrC,oBAAoB,UAAU;KAEvB;EACV;EACA,cAAc,oBAAoB,QAAQ;EAC1C,YAAY,iBAAiB,UAAU;;KAGpC,oBAAoB,QAAQ;EAAuB;;KAE5C,mBACV,mBACA,SAAS,qBACN,QAAQ;cA6nBA,eAAY,mBAAA,UAAZ,iBAAY;cAEZ,qCAAoC,cAAA,gBAAA;EAK/C,eAAe,oBAAoB,QAAQ;EAC3C;EACA,SAAS,sBAAsB;MAC7B;cA+GS,uBACX,WAAA,SAAA;EAKE;EACA;EACA;GAEF,OAAM,oBACL,QAAQ"}

package/dist/projection.js

@@ -0,0 +1,550 @@
+import { probePiSession, sendUserMessage } from "./protocol.js";
+import { o as parseLiveEventRecord } from "./live-events-ClhFOMGW.js";
+import { createJsonlTail } from "./jsonl-tail.js";
+import { randomUUID } from "node:crypto";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+//#region src/projection.ts
+const piContentBlockSchema = z.lazy(() => z.object({
+	arguments: z.unknown().optional(),
+	data: z.string().optional(),
+	id: z.string().optional(),
+	mimeType: z.string().optional(),
+	name: z.string().optional(),
+	text: z.string().optional(),
+	thinking: z.string().optional(),
+	tool: piToolProjectionSchema.optional(),
+	type: z.string()
+}));
+const piToolResultProjectionSchema = z.object({
+	content: z.array(piContentBlockSchema),
+	details: z.unknown().optional(),
+	isError: z.boolean(),
+	toolCallId: z.string(),
+	toolName: z.string()
+});
+const piToolProjectionSchema = z.lazy(() => z.object({
+	result: piToolResultProjectionSchema.optional(),
+	status: z.enum([
+		"error",
+		"pending",
+		"success"
+	])
+}));
+const piSessionMetadataSchema = z.object({
+	contextUsage: z.object({
+		tokens: z.number().nonnegative(),
+		contextWindow: z.number().positive(),
+		percent: z.number().nonnegative()
+	}).strict().optional(),
+	model: z.object({
+		provider: z.string().min(1),
+		id: z.string().min(1),
+		name: z.string().min(1)
+	}).strict().optional(),
+	thinkingLevel: z.string().min(1),
+	modelOptions: z.array(z.object({
+		provider: z.string().min(1),
+		id: z.string().min(1),
+		name: z.string().min(1)
+	}).strict()).max(256).optional()
+}).strict();
+const piConversationSnapshotSchema = z.object({
+	agentAvailable: z.boolean(),
+	entries: z.array(z.object({
+		content: z.array(piContentBlockSchema),
+		details: z.unknown().optional(),
+		errorMessage: z.string().optional(),
+		id: z.string(),
+		isError: z.boolean().optional(),
+		role: z.enum([
+			"assistant",
+			"toolResult",
+			"user"
+		]),
+		source: z.enum(["canonical", "live"]),
+		status: z.enum([
+			"complete",
+			"error",
+			"pending"
+		]),
+		stopReason: z.string().optional(),
+		timestamp: z.number().optional(),
+		toolCallId: z.string().optional(),
+		toolName: z.string().optional()
+	})),
+	sessionMetadata: piSessionMetadataSchema.optional(),
+	status: z.enum([
+		"busy",
+		"degraded",
+		"idle",
+		"offline"
+	])
+});
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const timestampOf = (value) => {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "string") return;
+	const timestamp = Date.parse(value);
+	return Number.isNaN(timestamp) ? void 0 : timestamp;
+};
+const contentBlocksOf = (content) => {
+	if (typeof content === "string") return [{
+		text: content,
+		type: "text"
+	}];
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((value) => {
+		if (!isObject(value) || typeof value.type !== "string") return [];
+		return [{
+			...value,
+			type: value.type
+		}];
+	});
+};
+const browserToolDetails = (details) => {
+	if (!isObject(details)) return details;
+	const { fullOutputPath: _fullOutputPath, ...safeDetails } = details;
+	return safeDetails;
+};
+const toolResultOf = (message) => {
+	if (message.role !== "toolResult" || typeof message.toolCallId !== "string" || typeof message.toolName !== "string") return;
+	return {
+		content: contentBlocksOf(message.content),
+		details: browserToolDetails(message.details),
+		isError: message.isError === true,
+		toolCallId: message.toolCallId,
+		toolName: message.toolName
+	};
+};
+const entryOf = (value, source) => {
+	if (!isObject(value) || value.type !== "message" || !isObject(value.message)) return;
+	if (typeof value.id !== "string") return;
+	const message = value.message;
+	if (message.role !== "assistant" && message.role !== "toolResult" && message.role !== "user") return;
+	return {
+		content: contentBlocksOf(message.content),
+		details: message.details,
+		errorMessage: message.errorMessage,
+		id: value.id,
+		isError: message.isError,
+		role: message.role,
+		source,
+		status: message.isError === true || message.stopReason === "error" ? "error" : "complete",
+		stopReason: message.stopReason,
+		timestamp: timestampOf(value.timestamp) ?? timestampOf(message.timestamp),
+		toolCallId: message.toolCallId,
+		toolName: message.toolName
+	};
+};
+const appendDelta = (blocks, event) => {
+	const update = event.assistantMessageEvent;
+	if (!isObject(update) || !Number.isSafeInteger(update.contentIndex)) return;
+	const index = update.contentIndex;
+	if (index < 0) return;
+	const current = blocks[index] ?? { type: "text" };
+	if (update.type === "text_start") blocks[index] = { type: "text" };
+	if (update.type === "thinking_start") blocks[index] = { type: "thinking" };
+	if (update.type === "toolcall_start") blocks[index] = { type: "toolCall" };
+	if (update.type === "text_delta") blocks[index] = {
+		...current,
+		text: `${current.text ?? ""}${typeof update.delta === "string" ? update.delta : ""}`,
+		type: "text"
+	};
+	if (update.type === "thinking_delta") blocks[index] = {
+		...current,
+		thinking: `${current.thinking ?? ""}${typeof update.delta === "string" ? update.delta : ""}`,
+		type: "thinking"
+	};
+	if (update.type === "toolcall_delta") blocks[index] = {
+		...current,
+		arguments: `${typeof current.arguments === "string" ? current.arguments : ""}${typeof update.delta === "string" ? update.delta : ""}`,
+		type: "toolCall"
+	};
+};
+const updateMessage = (messages, record, sourceOrder) => {
+	const event = record.event;
+	if (typeof event.messageId !== "string") return;
+	const key = `${record.streamId}\0${event.messageId}`;
+	const current = messages.get(key) ?? {
+		blocks: [],
+		ended: false,
+		id: key,
+		messageSequence: typeof event.messageSequence === "number" ? event.messageSequence : sourceOrder,
+		sourceOrder,
+		status: "pending",
+		streamId: record.streamId
+	};
+	current.timestamp = record.timestamp;
+	if (event.type === "message_start" && isObject(event.message)) current.message = event.message;
+	if (event.type === "message_update") {
+		appendDelta(current.blocks, event);
+		const update = event.assistantMessageEvent;
+		if (isObject(update) && update.type === "done") current.status = "complete";
+		if (isObject(update) && update.type === "error") {
+			current.status = "error";
+			current.message = {
+				...current.message,
+				errorMessage: typeof update.errorMessage === "string" ? update.errorMessage : void 0
+			};
+		}
+	}
+	if (event.type === "message_end" && isObject(event.message)) {
+		current.ended = true;
+		current.message = event.message;
+		current.blocks = contentBlocksOf(current.message.content);
+		current.status = current.message.isError === true || current.message.stopReason === "error" ? "error" : "complete";
+	}
+	messages.set(key, current);
+};
+const updateTool = (tools, event) => {
+	if (event.type !== "tool_execution_start" && event.type !== "tool_execution_end" || typeof event.toolCallId !== "string" || typeof event.toolName !== "string") return;
+	tools.set(event.toolCallId, {
+		isError: event.type === "tool_execution_end" && event.isError === true,
+		result: event.type === "tool_execution_end" ? event.result : void 0,
+		status: event.type === "tool_execution_start" ? "pending" : event.isError === true ? "error" : "success",
+		toolCallId: event.toolCallId,
+		toolName: event.toolName
+	});
+};
+const liveEntryOf = (state) => {
+	const message = state.message;
+	if (!message) return;
+	const role = message.role;
+	if (role !== "assistant" && role !== "toolResult" && role !== "user") return;
+	return {
+		content: state.ended ? contentBlocksOf(message.content) : state.blocks.length ? state.blocks : contentBlocksOf(message.content),
+		details: message.details,
+		errorMessage: message.errorMessage,
+		id: state.id,
+		isError: message.isError,
+		role,
+		source: "live",
+		status: state.status,
+		stopReason: message.stopReason,
+		timestamp: state.timestamp ?? timestampOf(message.timestamp),
+		toolCallId: message.toolCallId,
+		toolName: message.toolName
+	};
+};
+const projectLive = (records) => {
+	const messages = /* @__PURE__ */ new Map();
+	const tools = /* @__PURE__ */ new Map();
+	let active = false;
+	let shutdown = false;
+	records.forEach((record, index) => {
+		updateMessage(messages, record, index);
+		updateTool(tools, record.event);
+		if (record.event.type === "agent_start") active = true;
+		if (record.event.type === "agent_settled") active = false;
+		if (record.event.type === "session_shutdown") shutdown = true;
+		if (record.event.type === "session_start") shutdown = false;
+	});
+	return {
+		active,
+		entries: [...messages.values()].sort((left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0) || left.streamId.localeCompare(right.streamId) || left.messageSequence - right.messageSequence).flatMap((message) => {
+			const entry = liveEntryOf(message);
+			return entry ? [entry] : [];
+		}),
+		shutdown,
+		tools
+	};
+};
+const fingerprint = (entry) => JSON.stringify({
+	content: entry.content.map(({ tool: _tool, ...block }) => block),
+	details: entry.details,
+	isError: entry.isError,
+	role: entry.role,
+	toolCallId: entry.toolCallId,
+	toolName: entry.toolName
+});
+const matchedLiveIndexes = (canonical, live) => {
+	const liveByFingerprint = /* @__PURE__ */ new Map();
+	live.forEach((entry, index) => {
+		if (entry.status === "pending") return;
+		const key = fingerprint(entry);
+		const indexes = liveByFingerprint.get(key) ?? [];
+		indexes.push(index);
+		liveByFingerprint.set(key, indexes);
+	});
+	const consumed = /* @__PURE__ */ new Map();
+	const matched = /* @__PURE__ */ new Set();
+	canonical.forEach((entry) => {
+		const key = fingerprint(entry);
+		const offset = consumed.get(key) ?? 0;
+		const index = liveByFingerprint.get(key)?.[offset];
+		if (index !== void 0) {
+			matched.add(index);
+			consumed.set(key, offset + 1);
+		}
+	});
+	return matched;
+};
+const contentFromToolEnd = (result) => {
+	if (isObject(result) && "content" in result) return contentBlocksOf(result.content);
+	if (typeof result === "string") return [{
+		text: result,
+		type: "text"
+	}];
+	return result === void 0 ? [] : [{
+		text: JSON.stringify(result, null, 2),
+		type: "text"
+	}];
+};
+const pairTools = (entries, liveTools) => {
+	const callIds = new Set(entries.flatMap((entry) => entry.content.flatMap((block) => block.type === "toolCall" && typeof block.id === "string" ? [block.id] : [])));
+	const results = /* @__PURE__ */ new Map();
+	entries.forEach((entry) => {
+		if (entry.role !== "toolResult") return;
+		const result = toolResultOf({
+			content: entry.content,
+			details: entry.details,
+			isError: entry.isError,
+			role: entry.role,
+			toolCallId: entry.toolCallId,
+			toolName: entry.toolName
+		});
+		if (result) results.set(result.toolCallId, result);
+	});
+	liveTools.forEach((tool) => {
+		if (results.has(tool.toolCallId) || tool.result === void 0) return;
+		results.set(tool.toolCallId, {
+			content: contentFromToolEnd(tool.result),
+			details: isObject(tool.result) ? browserToolDetails(tool.result.details) : void 0,
+			isError: tool.isError === true,
+			toolCallId: tool.toolCallId,
+			toolName: tool.toolName
+		});
+	});
+	return entries.map((entry) => ({
+		...entry,
+		content: entry.content.map((block) => {
+			if (block.type !== "toolCall" || typeof block.id !== "string") return block;
+			const result = results.get(block.id);
+			const live = liveTools.get(block.id);
+			return {
+				...block,
+				tool: {
+					result,
+					status: result ? result.isError ? "error" : "success" : live?.status ?? "pending"
+				}
+			};
+		})
+	})).filter((entry) => entry.role !== "toolResult" || !entry.toolCallId || !callIds.has(entry.toolCallId));
+};
+const recordsSafeToProject = (stream) => {
+	const records = [...stream.records.values()].sort((left, right) => left.sequence - right.sequence);
+	const gapIndex = records.findIndex((record, index) => record.sequence !== index + 1);
+	if (gapIndex < 0) return records;
+	return [...records.slice(0, gapIndex), ...records.slice(gapIndex).filter((record) => record.event.type === "message_end")];
+};
+const sortedStreamRecords = (streams) => [...streams.values()].flatMap(recordsSafeToProject).sort((left, right) => left.timestamp - right.timestamp || left.streamId.localeCompare(right.streamId) || left.sequence - right.sequence);
+const streamHasIssue = (stream) => {
+	if (stream.conflict) return true;
+	return [...stream.records.keys()].sort((left, right) => left - right).some((sequence, index) => sequence !== index + 1);
+};
+const refreshCanonical = async (state, sessionFile) => {
+	if (!sessionFile) {
+		const changed = state.canonicalRecords.length > 0;
+		state.canonicalRecords = [];
+		return changed;
+	}
+	const update = await state.canonicalTail.read(sessionFile);
+	if (update.reset) state.canonicalRecords = [];
+	state.canonicalRecords.push(...update.records);
+	return update.reset || update.records.length > 0;
+};
+const refreshStreams = async (state, data) => {
+	if (!data.liveEventsDir) {
+		const changed = state.streams.size > 0;
+		state.streams.clear();
+		return changed;
+	}
+	const directory = join(data.liveEventsDir, data.sessionId);
+	const files = (await readdir(directory).catch(() => [])).filter((file) => file.endsWith(".jsonl"));
+	const present = new Set(files);
+	let removed = false;
+	[...state.streams.keys()].forEach((file) => {
+		if (!present.has(file)) {
+			const stream = state.streams.get(file);
+			removed = removed || Boolean(stream?.conflict || stream?.records.size);
+			state.streams.delete(file);
+		}
+	});
+	const updates = await Promise.all(files.map(async (file) => {
+		const stream = state.streams.get(file) ?? {
+			conflict: false,
+			records: /* @__PURE__ */ new Map(),
+			tail: createJsonlTail()
+		};
+		state.streams.set(file, stream);
+		const update = await stream.tail.read(join(directory, file));
+		let changed = update.reset && Boolean(stream.conflict || stream.records.size);
+		if (update.reset) {
+			stream.conflict = false;
+			stream.records.clear();
+		}
+		const expectedStreamId = file.slice(0, -6);
+		update.records.forEach((value) => {
+			const record = parseLiveEventRecord(value, data.sessionId);
+			if (!record) return;
+			if (record.streamId !== expectedStreamId) {
+				changed = changed || !stream.conflict;
+				stream.conflict = true;
+				return;
+			}
+			const previous = stream.records.get(record.sequence);
+			if (previous && JSON.stringify(previous) !== JSON.stringify(record)) {
+				changed = changed || !stream.conflict;
+				stream.conflict = true;
+				return;
+			}
+			changed = changed || !previous;
+			stream.records.set(record.sequence, record);
+		});
+		return changed;
+	}));
+	return removed || updates.some(Boolean);
+};
+const activeCanonicalBranch = (records) => {
+	const treeEntries = records.flatMap((record) => {
+		if (!isObject(record) || typeof record.id !== "string" || record.parentId !== null && typeof record.parentId !== "string") return [];
+		return [record];
+	});
+	const leaf = treeEntries.at(-1);
+	if (!leaf) return records;
+	const byId = new Map(treeEntries.map((entry) => [entry.id, entry]));
+	const ancestry = /* @__PURE__ */ new Set();
+	for (let current = leaf; current;) {
+		if (ancestry.has(current.id)) return [];
+		ancestry.add(current.id);
+		current = typeof current.parentId === "string" ? byId.get(current.parentId) : void 0;
+	}
+	return records.filter((record) => isObject(record) && typeof record.id === "string" && ancestry.has(record.id));
+};
+const projectSnapshot = (state, agentAvailable) => {
+	const canonical = activeCanonicalBranch(state.canonicalRecords).flatMap((value) => {
+		const entry = entryOf(value, "canonical");
+		return entry ? [entry] : [];
+	});
+	const live = projectLive(sortedStreamRecords(state.streams));
+	const matched = matchedLiveIndexes(canonical, live.entries);
+	const entries = pairTools([...canonical, ...live.entries.filter((_entry, index) => !matched.has(index))].sort((left, right) => (left.timestamp ?? 0) - (right.timestamp ?? 0) || left.id.localeCompare(right.id)), live.tools);
+	const degraded = [...state.streams.values()].some(streamHasIssue);
+	return piConversationSnapshotSchema.parse({
+		entries,
+		agentAvailable,
+		...state.sessionMetadata ? { sessionMetadata: state.sessionMetadata } : {},
+		status: degraded ? "degraded" : live.shutdown || !agentAvailable && !live.active ? "offline" : live.active || entries.some((entry) => entry.status === "pending") ? "busy" : "idle"
+	});
+};
+const configKeyOf = (data) => JSON.stringify([
+	data.sessionId,
+	data.sessionFile,
+	data.liveEventsDir
+]);
+const createProjectionState = (data) => ({
+	canonicalRecords: [],
+	canonicalTail: createJsonlTail(),
+	configKey: configKeyOf(data),
+	refreshQueue: Promise.resolve(),
+	sessionMetadata: data.sessionMetadata,
+	streams: /* @__PURE__ */ new Map()
+});
+const queueProjectionRefresh = (state, operation) => {
+	const result = state.refreshQueue.then(operation);
+	state.refreshQueue = result.then(() => void 0, () => void 0);
+	return result;
+};
+const probePiAgent = probePiSession;
+const createPiAgentConversationService = ({ resolveAgent, pollIntervalMs = 250, probe = probePiAgent }) => {
+	const projections = /* @__PURE__ */ new Map();
+	const subscriptions = /* @__PURE__ */ new Map();
+	let timer;
+	let polling = false;
+	const refresh = async (agentId) => {
+		const data = await resolveAgent(agentId);
+		const key = agentId;
+		const previous = projections.get(key);
+		const state = previous?.configKey === configKeyOf(data) ? previous : createProjectionState(data);
+		projections.set(key, state);
+		return queueProjectionRefresh(state, async () => {
+			const metadataChanged = JSON.stringify(state.sessionMetadata) !== JSON.stringify(data.sessionMetadata);
+			state.sessionMetadata = data.sessionMetadata;
+			const [canonicalChanged, streamsChanged, agentAvailable] = await Promise.all([
+				refreshCanonical(state, data.sessionFile),
+				refreshStreams(state, data),
+				probe(data.sessionId)
+			]);
+			if (state.snapshot && !canonicalChanged && !streamsChanged && !metadataChanged && state.agentAvailable === agentAvailable) return state.snapshot;
+			const snapshot = projectSnapshot(state, agentAvailable);
+			state.agentAvailable = agentAvailable;
+			state.snapshot = snapshot;
+			return snapshot;
+		});
+	};
+	const poll = async () => {
+		if (polling) return;
+		polling = true;
+		try {
+			await Promise.all([...subscriptions.entries()].map(async ([key, listeners]) => {
+				const id = key;
+				try {
+					const before = projections.get(key)?.snapshot;
+					const snapshot = await refresh(id);
+					if (snapshot !== before) listeners.forEach((listener) => listener(snapshot));
+				} catch {
+					const state = projections.get(key);
+					if (!state || state.agentAvailable === false) return;
+					const snapshot = projectSnapshot(state, false);
+					state.agentAvailable = false;
+					state.snapshot = snapshot;
+					listeners.forEach((listener) => listener(snapshot));
+				}
+			}));
+		} finally {
+			polling = false;
+		}
+	};
+	const startPolling = () => {
+		if (!timer) timer = setInterval(() => void poll(), pollIntervalMs);
+	};
+	return {
+		dispose: () => {
+			if (timer) clearInterval(timer);
+			timer = void 0;
+			subscriptions.clear();
+			projections.clear();
+		},
+		getSnapshot: (agentId) => refresh(agentId),
+		subscribe: (agentId, listener) => {
+			const key = agentId;
+			const listeners = subscriptions.get(key) ?? /* @__PURE__ */ new Set();
+			listeners.add(listener);
+			subscriptions.set(key, listeners);
+			startPolling();
+			return () => {
+				listeners.delete(listener);
+				if (!listeners.size) subscriptions.delete(key);
+				if (!subscriptions.size && timer) {
+					clearInterval(timer);
+					timer = void 0;
+				}
+			};
+		}
+	};
+};
+const sendPiAgentMessage = async ({ deliverAs, message, sessionId }, send = sendUserMessage) => {
+	const response = await send(sessionId, {
+		deliverAs,
+		message,
+		requestId: randomUUID()
+	});
+	if (!response?.ok) throw new Error("Pi agent is unavailable");
+	return response;
+};
+//#endregion
+export { createPiAgentConversationService, piContentBlockSchema, piConversationSnapshotSchema, piSessionMetadataSchema, piToolProjectionSchema, piToolResultProjectionSchema, probePiAgent, sendPiAgentMessage };
+
+//# sourceMappingURL=projection.js.map