@fragno-dev/pi-harness 0.0.0-stage → 0.0.3

package/dist/node/pi/factory.d.ts

@@ -0,0 +1,142 @@
+import { PiHarnessFrontendAgentMessage } from "./harness/agent-harness-event-protocol.js";
+import { PiFragmentConfig, PiSession } from "./types.js";
+import { PiHarnessHooksMap } from "./definition.js";
+import { FragnoPublicConfigWithDatabase } from "@fragno-dev/db";
+import { WorkflowRegistryEntry, WorkflowsRegistry } from "@fragno-dev/workflows/workflow";
+import { WorkflowsFragmentServices } from "@fragno-dev/workflows";
+//#region src/pi/factory.d.ts
+type PiFragmentServices = {
+  workflows: WorkflowsFragmentServices;
+};
+type WorkflowsOptions = {
+  logging?: PiFragmentConfig["logging"];
+  workflows?: WorkflowRegistryEntry[];
+};
+declare const createPiWorkflows: (options: WorkflowsOptions) => WorkflowsRegistry;
+declare function createPiFragment<TRequestContext = never>(config: PiFragmentConfig, options: FragnoPublicConfigWithDatabase, services: PiFragmentServices): import("@fragno-dev/core").FragnoInstantiatedFragment<readonly [import("@fragno-dev/core").FragnoRouteConfig<"POST", "/workflows/:workflowName/sessions", import("zod").ZodObject<{
+  name: import("zod").ZodOptional<import("zod").ZodString>;
+  metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+  input: import("zod").ZodOptional<import("zod").ZodUnknown>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  id: import("zod").ZodString;
+  name: import("zod").ZodNullable<import("zod").ZodString>;
+  metadata: import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+  workflowName: import("zod").ZodString;
+  createdAt: import("zod").ZodDate;
+  updatedAt: import("zod").ZodDate;
+}, import("zod/v4/core").$strip>, "WORKFLOW_NOT_FOUND" | "WORKFLOW_PARAMS_INVALID" | "WORKFLOW_CREATE_FAILED", string, import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>>, import("@fragno-dev/core").FragnoRouteConfig<"GET", "/workflows/:workflowName/sessions", import("@standard-schema/spec").StandardSchemaV1<unknown, unknown> | undefined, import("zod").ZodArray<import("zod").ZodObject<{
+  id: import("zod").ZodString;
+  name: import("zod").ZodNullable<import("zod").ZodString>;
+  metadata: import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+  workflowName: import("zod").ZodString;
+  createdAt: import("zod").ZodDate;
+  updatedAt: import("zod").ZodDate;
+}, import("zod/v4/core").$strip>>, "SESSION_DATA_INTEGRITY_ERROR", "limit", import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>>, import("@fragno-dev/core").FragnoRouteConfig<"GET", "/workflows/:workflowName/sessions/:sessionId", import("@standard-schema/spec").StandardSchemaV1<unknown, unknown> | undefined, import("zod").ZodObject<{
+  id: import("zod").ZodString;
+  name: import("zod").ZodNullable<import("zod").ZodString>;
+  metadata: import("zod").ZodNullable<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+  workflowName: import("zod").ZodString;
+  createdAt: import("zod").ZodDate;
+  updatedAt: import("zod").ZodDate;
+  workflow: import("zod").ZodObject<{
+    status: import("zod").ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    error: import("zod").ZodOptional<import("zod").ZodObject<{
+      name: import("zod").ZodString;
+      message: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>;
+    output: import("zod").ZodOptional<import("zod").ZodAny>;
+  }, import("zod/v4/core").$strip>;
+  agent: import("zod").ZodObject<{
+    state: import("zod").ZodObject<{
+      messages: import("zod").ZodArray<import("zod").ZodType<PiHarnessFrontendAgentMessage, unknown, import("zod/v4/core").$ZodTypeInternals<PiHarnessFrontendAgentMessage, unknown>>>;
+    }, import("zod/v4/core").$strip>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, "SESSION_DATA_INTEGRITY_ERROR" | "SESSION_NOT_FOUND" | "SESSION_DATA_UNAVAILABLE" | "WORKFLOW_INSTANCE_MISSING", string, import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>>, import("@fragno-dev/core").FragnoRouteConfig<"GET", "/workflows/:workflowName/sessions/:sessionId/export/pi-jsonl", import("@standard-schema/spec").StandardSchemaV1<unknown, unknown> | undefined, import("@standard-schema/spec").StandardSchemaV1<unknown, unknown> | undefined, "SESSION_DATA_INTEGRITY_ERROR" | "SESSION_NOT_FOUND" | "SESSION_DATA_UNAVAILABLE" | "WORKFLOW_INSTANCE_MISSING", string, import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>>, import("@fragno-dev/core").FragnoRouteConfig<"GET", "/workflows/:workflowName/sessions/:sessionId/commands/:commandId/wait", import("@standard-schema/spec").StandardSchemaV1<unknown, unknown> | undefined, import("@standard-schema/spec").StandardSchemaV1<unknown, unknown> | undefined, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING" | "INVALID_COMMAND_ID" | "COMMAND_NOT_WAITABLE" | "COMMAND_STEP_TIMEOUT" | "COMMAND_STEP_FAILED" | "COMMAND_WORKFLOW_TERMINAL", "timeoutMs", import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>>, import("@fragno-dev/core").FragnoRouteConfig<"POST", "/workflows/:workflowName/sessions/:sessionId/command", import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"prompt">;
+  input: import("zod").ZodObject<{
+    text: import("zod").ZodString;
+    images: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+      type: import("zod").ZodLiteral<"image">;
+      data: import("zod").ZodBase64;
+      mimeType: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"skill">;
+  input: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    additionalInstructions: import("zod").ZodOptional<import("zod").ZodString>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"promptFromTemplate">;
+  input: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    args: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"compact">;
+  input: import("zod").ZodObject<{
+    customInstructions: import("zod").ZodOptional<import("zod").ZodString>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"abort">;
+  reason: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"steer">;
+  input: import("zod").ZodObject<{
+    text: import("zod").ZodString;
+    images: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+      type: import("zod").ZodLiteral<"image">;
+      data: import("zod").ZodBase64;
+      mimeType: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+  kind: import("zod").ZodLiteral<"followUp">;
+  input: import("zod").ZodObject<{
+    text: import("zod").ZodString;
+    images: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+      type: import("zod").ZodLiteral<"image">;
+      data: import("zod").ZodBase64;
+      mimeType: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>>>;
+  }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>], "kind">, import("zod").ZodObject<{
+  accepted: import("zod").ZodLiteral<true>;
+  commandId: import("zod").ZodString;
+  status: import("zod").ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+}, import("zod/v4/core").$strip>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", string, import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>>], import("@fragno-dev/db").ImplicitDatabaseDependencies<import("@fragno-dev/db/schema").Schema<{}>>, import("@fragno-dev/core").BoundServices<{
+  getSessionDetailSnapshot: (workflowName: string, sessionId: string) => import("@fragno-dev/db").TxResult<{
+    session: PiSession;
+    workflowStatus: import("@fragno-dev/workflows/workflow").InstanceStatus;
+    messages: PiHarnessFrontendAgentMessage[];
+    sessionEntries: import("@earendil-works/pi-agent-core").SessionTreeEntry[];
+  }, []>;
+  createWorkflowSession: (values: {
+    id: string;
+    workflowName: string;
+    name?: string;
+    params?: Record<string, unknown>;
+  }) => import("@fragno-dev/db").TxResult<{
+    id: string;
+    details: import("@fragno-dev/workflows/workflow").InstanceStatus;
+  }[], []>;
+}>, import("@fragno-dev/db").DatabaseServiceContext<PiHarnessHooksMap>, import("@fragno-dev/db").DatabaseRequestContext<PiHarnessHooksMap>, import("@fragno-dev/db/fragment-definition-builder").DatabaseRequestStorage, FragnoPublicConfigWithDatabase, TRequestContext>;
+declare const createPiHarness: typeof createPiFragment;
+//#endregion
+export { createPiFragment, createPiHarness, createPiWorkflows };
+//# sourceMappingURL=factory.d.ts.map

package/dist/node/pi/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","names":[],"sources":["../../../src/pi/factory.ts"],"mappings":";;;;;;;KAWK;EACH,WAAW;;KAGR;EACH,UAAU;EACV,YAAY;;cAGD,oBAAqB,SAAS,qBAAgB;iBAkB3C,iBAAiB,yBAC/B,QAAQ,kBACR,SAAS,gCACT,UAAU,gDAAkB,gEAAA,6EAAA;;;;;;;;;;;uKAAlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAY63F;;;;;oDAAA;cAD53F,wBAAe"}

package/dist/node/pi/factory.js

@@ -0,0 +1,22 @@
+import { piHarnessDefinition } from "./definition.js";
+import { piRoutesFactory } from "../routes.js";
+import { instantiate } from "@fragno-dev/core";
+import { WorkflowsLogger } from "@fragno-dev/workflows/debug-log";
+//#region src/pi/factory.ts
+const createPiWorkflows = (options) => {
+	if (options.logging) WorkflowsLogger.configure(options.logging);
+	const registry = {};
+	for (const workflow of options.workflows ?? []) {
+		if (registry[workflow.name]) throw new Error(`Duplicate Pi workflow name '${workflow.name}'.`);
+		registry[workflow.name] = workflow;
+	}
+	return registry;
+};
+function createPiFragment(config, options, services) {
+	return instantiate(piHarnessDefinition).withConfig(config).withRoutes([piRoutesFactory]).withOptions(options).withServices(services).withRequestContext().build();
+}
+const createPiHarness = createPiFragment;
+//#endregion
+export { createPiFragment, createPiHarness, createPiWorkflows };
+
+//# sourceMappingURL=factory.js.map

package/dist/node/pi/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","names":[],"sources":["../../../src/pi/factory.ts"],"sourcesContent":["import { WorkflowsLogger } from \"@fragno-dev/workflows/debug-log\";\nimport type { WorkflowRegistryEntry, WorkflowsRegistry } from \"@fragno-dev/workflows/workflow\";\n\nimport { instantiate } from \"@fragno-dev/core\";\nimport type { FragnoPublicConfigWithDatabase } from \"@fragno-dev/db\";\nimport type { WorkflowsFragmentServices } from \"@fragno-dev/workflows\";\n\nimport { piRoutesFactory } from \"../routes\";\nimport { piHarnessDefinition } from \"./definition\";\nimport type { PiFragmentConfig } from \"./types\";\n\ntype PiFragmentServices = {\n  workflows: WorkflowsFragmentServices;\n};\n\ntype WorkflowsOptions = {\n  logging?: PiFragmentConfig[\"logging\"];\n  workflows?: WorkflowRegistryEntry[];\n};\n\nexport const createPiWorkflows = (options: WorkflowsOptions) => {\n  if (options.logging) {\n    WorkflowsLogger.configure(options.logging);\n  }\n\n  const registry: WorkflowsRegistry = {};\n\n  for (const workflow of options.workflows ?? []) {\n    if (registry[workflow.name]) {\n      throw new Error(`Duplicate Pi workflow name '${workflow.name}'.`);\n    }\n\n    registry[workflow.name] = workflow;\n  }\n\n  return registry;\n};\n\nexport function createPiFragment<TRequestContext = never>(\n  config: PiFragmentConfig,\n  options: FragnoPublicConfigWithDatabase,\n  services: PiFragmentServices,\n) {\n  return instantiate(piHarnessDefinition)\n    .withConfig(config)\n    .withRoutes([piRoutesFactory])\n    .withOptions(options)\n    .withServices(services)\n    .withRequestContext<TRequestContext>()\n    .build();\n}\n\nexport const createPiHarness = createPiFragment;\n"],"mappings":";;;;;AAoBA,MAAa,qBAAqB,YAA8B;CAC9D,IAAI,QAAQ,SACV,gBAAgB,UAAU,QAAQ,OAAO;CAG3C,MAAM,WAA8B,CAAC;CAErC,KAAK,MAAM,YAAY,QAAQ,aAAa,CAAC,GAAG;EAC9C,IAAI,SAAS,SAAS,OACpB,MAAM,IAAI,MAAM,+BAA+B,SAAS,KAAK,GAAG;EAGlE,SAAS,SAAS,QAAQ;CAC5B;CAEA,OAAO;AACT;AAEA,SAAgB,iBACd,QACA,SACA,UACA;CACA,OAAO,YAAY,mBAAmB,CAAC,CACpC,WAAW,MAAM,CAAC,CAClB,WAAW,CAAC,eAAe,CAAC,CAAC,CAC7B,YAAY,OAAO,CAAC,CACpB,aAAa,QAAQ,CAAC,CACtB,mBAAoC,CAAC,CACrC,MAAM;AACX;AAEA,MAAa,kBAAkB"}

package/dist/node/pi/harness/agent-harness-event-protocol.d.ts

@@ -0,0 +1,261 @@
+import { AgentHarnessEvent, AgentMessage } from "@earendil-works/pi-agent-core";
+import { AssistantMessage, ToolCall } from "@earendil-works/pi-ai";
+//#region src/pi/harness/agent-harness-event-protocol.d.ts
+interface PiHarnessEventStreamEncoder<TEncodedEvent> {
+  encode(event: AgentHarnessEvent): TEncodedEvent;
+}
+type PiHarnessProjectedEvent = {
+  readonly type: AgentHarnessEvent["type"];
+};
+type PiHarnessFrontendToolCall = Omit<ToolCall, "thoughtSignature">;
+type PiHarnessFrontendAssistantContent = Omit<Extract<AssistantMessage["content"][number], {
+  type: "text";
+}>, "textSignature"> | Omit<Extract<AssistantMessage["content"][number], {
+  type: "thinking";
+}>, "thinkingSignature"> | PiHarnessFrontendToolCall;
+type PiHarnessFrontendAssistantMessage = Omit<AssistantMessage, "api" | "provider" | "model" | "responseModel" | "responseId" | "diagnostics" | "content"> & {
+  readonly content: PiHarnessFrontendAssistantContent[];
+};
+type PiHarnessFrontendMessage<TMessage> = TMessage extends AssistantMessage ? PiHarnessFrontendAssistantMessage : TMessage;
+type PiHarnessFrontendAgentMessage = PiHarnessFrontendMessage<AgentMessage>;
+type PiHarnessFrontendAssistantMessageEvent<TEvent> = TEvent extends {
+  partial: AssistantMessage;
+} ? Omit<TEvent, "partial" | "toolCall"> & {
+  readonly partial: PiHarnessFrontendAssistantMessage;
+} & (TEvent extends {
+  toolCall: ToolCall;
+} ? {
+  readonly toolCall: PiHarnessFrontendToolCall;
+} : object) : TEvent;
+type PiHarnessFrontendEventFields<TEvent> = { readonly [TKey in keyof TEvent]: TKey extends "message" ? PiHarnessFrontendMessage<TEvent[TKey]> : TKey extends "messages" | "toolResults" | "steer" | "followUp" | "nextTurn" | "clearedSteer" | "clearedFollowUp" ? TEvent[TKey] extends readonly (infer TMessage)[] ? PiHarnessFrontendMessage<TMessage>[] : TEvent[TKey] : TKey extends "assistantMessageEvent" ? PiHarnessFrontendAssistantMessageEvent<TEvent[TKey]> : TEvent[TKey]; };
+/** The frontend projection preserves every event while omitting provider-owned message metadata. */
+type PiHarnessFrontendEvent = AgentHarnessEvent extends (infer TEvent) ? TEvent extends PiHarnessProjectedEvent ? PiHarnessFrontendEventFields<TEvent> : never : never;
+interface PiHarnessEventStreamDecoder<TEncodedEvent> {
+  decode(event: TEncodedEvent): PiHarnessFrontendEvent;
+}
+/** Projects each AgentHarness event into one frontend-safe event with the same event type. */
+interface PiHarnessEventProtocol {
+  createEncoder(): PiHarnessEventStreamEncoder<unknown>;
+  createDecoder(): PiHarnessEventStreamDecoder<unknown>;
+  eventType(event: unknown): PiHarnessFrontendEvent["type"];
+}
+declare const piToolCallArgumentsText: (toolCall: ToolCall) => string | undefined;
+type PiHarnessSubscribedEvent = Exclude<AgentHarnessEvent, {
+  type: "before_agent_start";
+} | {
+  type: "context";
+} | {
+  type: "before_provider_request";
+} | {
+  type: "before_provider_payload";
+} | {
+  type: "tool_call";
+} | {
+  type: "tool_result";
+} | {
+  type: "session_before_compact";
+} | {
+  type: "session_before_tree";
+}>;
+type EncodedValue<TValue = unknown> = {
+  readonly kind: "value";
+  readonly id: number;
+  readonly value: TValue;
+} | {
+  readonly kind: "reference";
+  readonly id: number;
+};
+type ProjectedAgentMessage = Exclude<AgentMessage, AssistantMessage> | PiHarnessFrontendAssistantMessage;
+type EncodedMessage = {
+  readonly kind: "message";
+  readonly id: number;
+  readonly message: ProjectedAgentMessage;
+} | {
+  readonly kind: "reference";
+  readonly id: number;
+};
+type CompactAssistantMessageEvent = {
+  readonly type: "text_start";
+  readonly contentIndex: number;
+} | {
+  readonly type: "text_delta";
+  readonly contentIndex: number;
+  readonly delta: string;
+} | {
+  readonly type: "text_end";
+  readonly contentIndex: number;
+  readonly content: string;
+} | {
+  readonly type: "thinking_start";
+  readonly contentIndex: number;
+  readonly redacted?: boolean;
+} | {
+  readonly type: "thinking_delta";
+  readonly contentIndex: number;
+  readonly delta: string;
+  readonly redacted?: boolean;
+} | {
+  readonly type: "thinking_end";
+  readonly contentIndex: number;
+  readonly content: string;
+  readonly redacted?: boolean;
+} | {
+  readonly type: "toolcall_start";
+  readonly contentIndex: number;
+  readonly toolCall: PiHarnessFrontendToolCall;
+} | {
+  readonly type: "toolcall_delta";
+  readonly contentIndex: number;
+  readonly delta: string;
+} | {
+  readonly type: "toolcall_end";
+  readonly contentIndex: number;
+  readonly toolCall: PiHarnessFrontendToolCall;
+};
+type CompactAssistantMessageMetadataUpdate = {
+  readonly usage?: AssistantMessage["usage"];
+  readonly stopReason?: AssistantMessage["stopReason"];
+  readonly errorMessage?: string | null;
+  readonly timestamp?: number;
+};
+type CompactMessageUpdate = {
+  readonly type: "message_update";
+  readonly update: CompactAssistantMessageEvent;
+  readonly metadata?: CompactAssistantMessageMetadataUpdate;
+};
+type PiHarnessCompactEvent = {
+  readonly type: "raw";
+  readonly event: PiHarnessSubscribedEvent;
+} | {
+  readonly type: "agent_start";
+} | {
+  readonly type: "agent_end";
+  readonly messages: readonly EncodedMessage[];
+} | {
+  readonly type: "turn_start";
+} | {
+  readonly type: "turn_end";
+  readonly message: EncodedMessage;
+  readonly toolResults: readonly EncodedMessage[];
+} | {
+  readonly type: "message_start";
+  readonly message: EncodedMessage;
+} | CompactMessageUpdate | {
+  readonly type: "message_end";
+  readonly message: EncodedMessage;
+} | {
+  readonly type: "tool_execution_start";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly args: EncodedValue;
+} | {
+  readonly type: "tool_execution_update";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly args: EncodedValue;
+  readonly partialResult: EncodedValue;
+} | {
+  readonly type: "tool_execution_end";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: EncodedValue;
+  readonly isError: boolean;
+} | {
+  readonly type: "queue_update";
+  readonly steer: readonly EncodedMessage[];
+  readonly followUp: readonly EncodedMessage[];
+  readonly nextTurn: readonly EncodedMessage[];
+} | {
+  readonly type: "save_point";
+  readonly hadPendingMutations: boolean;
+} | {
+  readonly type: "abort";
+  readonly clearedSteer: readonly EncodedMessage[];
+  readonly clearedFollowUp: readonly EncodedMessage[];
+} | {
+  readonly type: "settled";
+  readonly nextTurnCount: number;
+} | {
+  readonly type: "after_provider_response";
+  readonly status: number;
+  readonly headers: EncodedValue<SubscribedEvent<"after_provider_response">["headers"]>;
+} | {
+  readonly type: "session_compact";
+  readonly compactionEntry: EncodedValue<SubscribedEvent<"session_compact">["compactionEntry"]>;
+  readonly fromHook: boolean;
+} | {
+  readonly type: "session_tree";
+  readonly newLeafId: string | null;
+  readonly oldLeafId: string | null;
+  readonly summaryEntry?: EncodedValue<NonNullable<SubscribedEvent<"session_tree">["summaryEntry"]>>;
+  readonly fromHook?: boolean;
+} | {
+  readonly type: "retry_scheduled";
+  readonly operation: "compaction" | "branch_summary";
+  readonly attempt: number;
+  readonly maxAttempts: number;
+  readonly delayMs: number;
+  readonly errorMessage: string;
+} | {
+  readonly type: "retry_attempt_start" | "retry_finished";
+  readonly operation: "compaction" | "branch_summary";
+} | {
+  readonly type: "model_update";
+  readonly model: EncodedValue<SubscribedEvent<"model_update">["model"]>;
+  readonly previousModel?: EncodedValue<NonNullable<SubscribedEvent<"model_update">["previousModel"]>>;
+  readonly source: "set" | "restore";
+} | {
+  readonly type: "thinking_level_update";
+  readonly level: SubscribedEvent<"thinking_level_update">["level"];
+  readonly previousLevel: SubscribedEvent<"thinking_level_update">["previousLevel"];
+} | {
+  readonly type: "tools_update";
+  readonly toolNames: readonly string[];
+  readonly previousToolNames: readonly string[];
+  readonly activeToolNames: readonly string[];
+  readonly previousActiveToolNames: readonly string[];
+  readonly source: "set" | "restore";
+} | {
+  readonly type: "resources_update";
+  readonly resources: EncodedValue<SubscribedEvent<"resources_update">["resources"]>;
+  readonly previousResources: EncodedValue<SubscribedEvent<"resources_update">["previousResources"]>;
+};
+type SubscribedEvent<TType extends PiHarnessSubscribedEvent["type"]> = Extract<PiHarnessSubscribedEvent, {
+  type: TType;
+}>;
+type PiHarnessEncodedEvent = {
+  readonly protocol: "pi-harness-event";
+  readonly version: 2;
+  readonly event: PiHarnessCompactEvent;
+};
+type PiHarnessEncodedEventEmission = {
+  readonly kind: "harness-event";
+  readonly event: PiHarnessEncodedEvent;
+};
+type PiHarnessEventStreamIdentity = {
+  readonly stepKey: string;
+  readonly executionId: string;
+  readonly epoch: string;
+};
+declare class PiHarnessEventEncoder {
+  #private;
+  encode(event: PiHarnessSubscribedEvent): PiHarnessEncodedEvent;
+}
+declare const piHarnessEventProtocol: {
+  createEncoder: () => PiHarnessEventEncoder;
+  createDecoder: () => PiHarnessEventDecoder;
+  eventType: (value: unknown) => "abort" | "agent_start" | "agent_end" | "turn_start" | "turn_end" | "message_start" | "message_update" | "message_end" | "tool_execution_start" | "tool_execution_update" | "tool_execution_end" | "queue_update" | "save_point" | "settled" | "after_provider_response" | "session_compact" | "session_tree" | "retry_scheduled" | "retry_attempt_start" | "retry_finished" | "model_update" | "thinking_level_update" | "tools_update" | "resources_update";
+};
+declare class PiHarnessEventDecoder {
+  #private;
+  decode(value: unknown): PiHarnessFrontendEvent;
+}
+declare class PiHarnessEventStreamDecoders {
+  #private;
+  start(identity: PiHarnessEventStreamIdentity): void;
+  finish(identity: PiHarnessEventStreamIdentity): void;
+  decode(identity: PiHarnessEventStreamIdentity, event: unknown): PiHarnessFrontendEvent;
+}
+//#endregion
+export { PiHarnessCompactEvent, PiHarnessEncodedEvent, PiHarnessEncodedEventEmission, PiHarnessEventDecoder, PiHarnessEventEncoder, PiHarnessEventProtocol, PiHarnessEventStreamDecoder, PiHarnessEventStreamDecoders, PiHarnessEventStreamEncoder, PiHarnessEventStreamIdentity, PiHarnessFrontendAgentMessage, PiHarnessFrontendAssistantContent, PiHarnessFrontendAssistantMessage, PiHarnessFrontendEvent, PiHarnessFrontendMessage, PiHarnessFrontendToolCall, PiHarnessProjectedEvent, PiHarnessSubscribedEvent, piHarnessEventProtocol, piToolCallArgumentsText };
+//# sourceMappingURL=agent-harness-event-protocol.d.ts.map

package/dist/node/pi/harness/agent-harness-event-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-harness-event-protocol.d.ts","names":[],"sources":["../../../../src/pi/harness/agent-harness-event-protocol.ts"],"mappings":";;;UAGiB,4BAA4B;EAC3C,OAAO,OAAO,oBAAoB;;KAGxB;WACD,MAAM;;KAGL,4BAA4B,KAAK;KAEjC,oCACR,KAAK,QAAQ;EAAuC;uBACpD,KAAK,QAAQ;EAAuC;2BACpD;KAEQ,oCAAoC,KAC9C;WAGS,SAAS;;KAGR,yBAAyB,YAAY,iBAAiB,mBAC9D,oCACA;KAEQ,gCAAgC,yBAAyB;KAEhE,uCAAuC,UAAU;EACpD,SAAS;IAEP,KAAK;WACM,SAAS;KACf;EAAiB,UAAU;;WACf,UAAU;cAE3B;KAEC,6BAA6B,sBACtB,cAAc,SAAS,yBAC7B,yBAAyB,OAAO,SAChC,mHAQE,OAAO,8BAA8B,cACnC,yBAAyB,cACzB,OAAO,QACT,uCACE,uCAAuC,OAAO,SAC9C,OAAO;;KAIL,yBAAyB,iCAAgC,UACjE,eAAe,0BACb,6BAA6B;UAIlB,4BAA4B;EAC3C,OAAO,OAAO,gBAAgB;;;UAIf;EACf,iBAAiB;EACjB,iBAAiB;EACjB,UAAU,iBAAiB;;cAGhB,0BAA2B,UAAU;KAWtC,2BAA2B,QACrC;EACI;;EACA;;EACA;;EACA;;EACA;;EACA;;EACA;;EACA;;KAGD,aAAa;WACH;WAAwB;WAAqB,OAAO;;WACpD;WAA4B;;KAEtC,wBACD,QAAQ,cAAc,oBACtB;KAEC;WAEU;WACA;WACA,SAAS;;WAET;WAA4B;;KAkBtC;WAEU;WACA;;WAGA;WACA;WACA;;WAGA;WACA;WACA;;WAGA;WACA;WACA;;WAGA;WACA;WACA;WACA;;WAGA;WACA;WACA;WACA;;WAGA;WACA;WACA,UAAU;;WAGV;WACA;WACA;;WAGA;WACA;WACA,UAAU;;KAGpB;WACM,QAAQ;WACR,aAAa;WACb;WACA;;KAGN;WACM;WACA,QAAQ;WACR,WAAW;;KAGV;WACG;WAAsB,OAAO;;WAC7B;;WACA;WAA4B,mBAAmB;;WAC/C;;WAEA;WACA,SAAS;WACT,sBAAsB;;WAEtB;WAAgC,SAAS;IACpD;WACW;WAA8B,SAAS;;WAEvC;WACA;WACA;WACA,MAAM;;WAGN;WACA;WACA;WACA,MAAM;WACN,eAAe;;WAGf;WACA;WACA;WACA,QAAQ;WACR;;WAGA;WACA,gBAAgB;WAChB,mBAAmB;WACnB,mBAAmB;;WAEnB;WAA6B;;WAE7B;WACA,uBAAuB;WACvB,0BAA0B;;WAE1B;WAA0B;;WAE1B;WACA;WACA,SAAS,aAAa;;WAGtB;WACA,iBAAiB,aAAa;WAC9B;;WAGA;WACA;WACA;WACA,eAAe,aACtB,YAAY;WAEL;;WAGA;WACA;WACA;WACA;WACA;WACA;;WAGA;WACA;;WAGA;WACA,OAAO,aAAa;WACpB,gBAAgB,aACvB,YAAY;WAEL;;WAGA;WACA,OAAO;WACP,eAAe;;WAGf;WACA;WACA;WACA;WACA;WACA;;WAGA;WACA,WAAW,aAAa;WACxB,mBAAmB,aAC1B;;KAIH,gBAAgB,cAAc,oCAAoC,QACrE;EACE,MAAM;;KAqbE;WACD;WACA;WACA,OAAO;;KAGN;WACD;WACA,OAAO;;KAGN;WACD;WACA;WACA;;cA4BE;;EAKX,OAAO,OAAO,2BAA2B;;cAoK9B;uBAAA;uBAAA;;;cASA;;EAMX,OAAO,iBAAiB;;cA+Ib;;EAGX,MAAM,UAAU;EAIhB,OAAO,UAAU;EAIjB,OAAO,UAAU,8BAA8B,iBAAiB"}