@fragno-dev/pi-fragment 0.0.1 → 0.0.3

package/dist/browser/routes-CpL_YGWK.d.ts

@@ -0,0 +1,1560 @@
+import { MapStore, ReadableAtom, Store } from "nanostores";
+import * as _fragno_dev_core0 from "@fragno-dev/core";
+import * as zod from "zod";
+import { z } from "zod";
+import * as _fragno_dev_workflows0 from "@fragno-dev/workflows";
+import { InstanceStatus, WorkflowsFragmentServices, WorkflowsHistoryStep } from "@fragno-dev/workflows";
+import * as _fragno_dev_db_schema0 from "@fragno-dev/db/schema";
+import * as _mariozechner_pi_agent_core0 from "@mariozechner/pi-agent-core";
+import { AgentEvent, AgentMessage, AgentOptions, AgentTool, StreamFn, ThinkingLevel } from "@mariozechner/pi-agent-core";
+import * as zod_v4_core0 from "zod/v4/core";
+import * as _standard_schema_spec0 from "@standard-schema/spec";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import * as _fragno_dev_db0 from "@fragno-dev/db";
+import { FragnoPublicConfigWithDatabase, TxResult } from "@fragno-dev/db";
+import { Api, ImageContent, Model, TextContent } from "@mariozechner/pi-ai";
+import * as _fragno_dev_db_fragment_definition_builder0 from "@fragno-dev/db/fragment-definition-builder";
+
+//#region ../fragno/dist/api/internal/path.d.ts
+//#region src/api/internal/path.d.ts
+type SplitPath<T extends string> = T extends `${infer First}/${infer Rest}` ? First extends "" ? SplitPath<Rest> : [First, ...SplitPath<Rest>] : T extends "" ? [] : [T];
+type ExtractParam<T extends string> = T extends `:${infer Name}` ? Name : T extends `**:${infer Name}` ? Name : T extends "**" ? "**" : never;
+type ExtractParamsFromSegments<T extends readonly string[]> = T extends readonly [infer First, ...infer Rest] ? First extends string ? Rest extends readonly string[] ? ExtractParam<First> | ExtractParamsFromSegments<Rest> : ExtractParam<First> : never : never;
+/**
+ * Type helper to extract path parameters from a const string path
+ *
+ * Supports:
+ * - Regular paths: "/path" -> never
+ * - Named parameters: "/path/:name" -> "name"
+ * - Wildcard paths: "/path/foo/**" -> "**"
+ * - Named wildcard paths: "/path/foo/**:name" -> "name"
+ * - String (narrows): string -> never
+ */
+type ExtractPathParams<T extends string, ValueType = string> = ExtractParamsFromSegments<SplitPath<T>> extends never ? Record<string, never> : Record<ExtractParamsFromSegments<SplitPath<T>>, ValueType>;
+/**
+ * Same as @see ExtractPathParams, but returns `Record<string, ValueType>` when a string is
+ * passed in.
+ */
+type ExtractPathParamsOrWiden<T extends string, ValueType = string> = string extends T ? Record<string, ValueType> : ExtractPathParams<T, ValueType>;
+/**
+ * Same as @see ExtractPathParamsOrWiden, but returns `undefined` when no path parameters in the
+ * const.
+ */
+type MaybeExtractPathParamsOrWiden<T extends string, ValueType = string> = HasPathParams<T> extends true ? ExtractPathParamsOrWiden<T, ValueType> : undefined;
+type ExtractPathParamNames<T extends string> = ExtractParamsFromSegments<SplitPath<T>>;
+type HasPathParams<T extends string> = ExtractPathParamNames<T> extends never ? false : true;
+/**
+ * Creates a query parameters type where the specified keys are hints (optional)
+ * and additional string keys are also allowed.
+ *
+ * This allows for flexible query parameter typing where:
+ * - All hinted parameters are optional
+ * - Additional parameters beyond the hints are allowed
+ * - Values can be of any specified type (defaults to string)
+ *
+ * @example
+ * ```ts
+ * type MyQuery = QueryParamsHint<"page" | "limit", string>;
+ * // Allows: { page?: string, limit?: string, [key: string]: string }
+ *
+ * const query1: MyQuery = {}; // Valid - no params required
+ * const query2: MyQuery = { page: "1" }; // Valid - hinted param
+ * const query3: MyQuery = { page: "1", sort: "asc" }; // Valid - additional param
+ * ```
+ */
+type QueryParamsHint<TQueryParameters extends string, ValueType = string> = Partial<Record<TQueryParameters, ValueType>> & Record<string, ValueType | undefined>; //#endregion
+//#endregion
+//#region ../fragno/dist/util/types-util.d.ts
+//#region src/util/types-util.d.ts
+type InferOr<T, U> = T extends NonNullable<StandardSchemaV1> ? StandardSchemaV1.InferOutput<T> : T extends undefined ? U : U;
+type InferOrUnknown<T> = InferOr<T, unknown>; //#endregion
+//#endregion
+//#region ../fragno/dist/http/http-status.d.ts
+//#region src/http/http-status.d.ts
+/**
+ * @module
+ * HTTP Status utility.
+ *
+ * Modified from honojs/hono
+ * Original source: https://github.com/honojs/hono/blob/0e3db674ad3f40be215a55a18062dd8e387ce525/src/utils/http-status.ts
+ * License: MIT
+ * Date obtained: August 28 2025
+ * Copyright (c) 2021-present Yusuke Wada and Hono contributors
+ *
+ */
+type InfoStatusCode = 100 | 101 | 102 | 103;
+type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type DeprecatedStatusCode = 305 | 306;
+type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode;
+type ContentlessStatusCode = 101 | 204 | 205 | 304; //#endregion
+//#endregion
+//#region ../fragno/dist/client/client-error.d.ts
+//#region src/client/client-error.d.ts
+type FragnoErrorOptions = {
+  cause?: Error | unknown;
+};
+/**
+ * Base error class for all Fragno client errors.
+ */
+declare abstract class FragnoClientError<TCode extends string = string> extends Error {
+  #private;
+  constructor(message: string, code: TCode, options?: FragnoErrorOptions);
+  get code(): TCode | (string & {});
+}
+//#endregion
+//#region ../fragno/dist/api/mutable-request-state.d.ts
+//#region src/api/mutable-request-state.d.ts
+/**
+ * Holds mutable request state that can be modified by middleware and consumed by handlers.
+ *
+ * This class provides a structural way for middleware to modify request data:
+ * - Path parameters can be modified
+ * - Query/search parameters can be modified
+ * - Request body can be overridden
+ * - Request headers can be modified
+ *
+ * @example
+ * ```typescript
+ * // In middleware
+ * const state = new MutableRequestState({
+ *   pathParams: { id: "123" },
+ *   searchParams: new URLSearchParams("?role=user"),
+ *   body: { name: "John" },
+ *   headers: new Headers()
+ * });
+ *
+ * // Modify query parameters
+ * state.searchParams.set("role", "admin");
+ *
+ * // Override body
+ * state.setBody({ name: "Jane" });
+ *
+ * // Modify headers
+ * state.headers.set("X-Custom", "value");
+ * ```
+ */
+declare class MutableRequestState {
+  #private;
+  constructor(config: {
+    pathParams: Record<string, string>;
+    searchParams: URLSearchParams;
+    body: RequestBodyType;
+    headers: Headers;
+  });
+  /**
+   * Path parameters extracted from the route.
+   * Can be modified directly (e.g., `state.pathParams.id = "456"`).
+   */
+  get pathParams(): Record<string, string>;
+  /**
+   * URLSearchParams for query parameters.
+   * Can be modified using URLSearchParams API (e.g., `state.searchParams.set("key", "value")`).
+   */
+  get searchParams(): URLSearchParams;
+  /**
+   * Request headers.
+   * Can be modified using Headers API (e.g., `state.headers.set("X-Custom", "value")`).
+   */
+  get headers(): Headers;
+  /**
+   * Get the current body value.
+   * Returns the override if set, otherwise the initial body.
+   */
+  get body(): RequestBodyType;
+  /**
+   * Override the request body.
+   * This allows middleware to replace the body that will be seen by the handler.
+   *
+   * @param body - The new body value
+   *
+   * @example
+   * ```typescript
+   * // In middleware
+   * state.setBody({ modifiedField: "new value" });
+   * ```
+   */
+  setBody(body: RequestBodyType): void;
+  /**
+   * Check if the body has been overridden by middleware.
+   */
+  get hasBodyOverride(): boolean;
+} //#endregion
+//#endregion
+//#region ../fragno/dist/api/request-input-context.d.ts
+//#region src/api/request-input-context.d.ts
+type RequestBodyType = unknown | FormData | Blob | ReadableStream<Uint8Array> | null | undefined;
+declare class RequestInputContext<TPath extends string = string, TInputSchema extends StandardSchemaV1 | undefined = undefined> {
+  #private;
+  constructor(config: {
+    path: TPath;
+    method: string;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams: URLSearchParams;
+    parsedBody: RequestBodyType;
+    rawBody?: string;
+    headers: Headers;
+    request?: Request;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+  });
+  /**
+   * Create a RequestContext from a Request object for server-side handling
+   */
+  static fromRequest<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+    request: Request;
+    method: string;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    inputSchema?: TInputSchema;
+    shouldValidateInput?: boolean;
+    state: MutableRequestState;
+    rawBody?: string;
+  }): Promise<RequestInputContext<TPath, TInputSchema>>;
+  /**
+   * Create a RequestContext for server-side rendering contexts (no Request object)
+   */
+  static fromSSRContext<TPath extends string, TInputSchema extends StandardSchemaV1 | undefined = undefined>(config: {
+    method: "GET";
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams?: URLSearchParams;
+    headers?: Headers;
+  } | {
+    method: Exclude<HTTPMethod, "GET">;
+    path: TPath;
+    pathParams: ExtractPathParams<TPath>;
+    searchParams?: URLSearchParams;
+    headers?: Headers;
+    body: RequestBodyType;
+    inputSchema?: TInputSchema;
+  }): RequestInputContext<TPath, TInputSchema>;
+  /**
+   * The HTTP method as string (e.g., `GET`, `POST`)
+   */
+  get method(): string;
+  /**
+   * The matched route path (e.g., `/users/:id`)
+   * @remarks `string`
+   */
+  get path(): TPath;
+  /**
+   * Extracted path parameters as object (e.g., `{ id: '123' }`)
+   * @remarks `Record<string, string>`
+   */
+  get pathParams(): ExtractPathParams<TPath>;
+  /**
+   * [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) object for query parameters
+   * @remarks `URLSearchParams`
+   */
+  get query(): URLSearchParams;
+  /**
+   * [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object for request headers
+   * @remarks `Headers`
+   */
+  get headers(): Headers;
+  get rawBody(): string | undefined;
+  /**
+   * Access the request body as FormData.
+   *
+   * Use this method when handling file uploads or multipart form submissions.
+   * The request must have been sent with Content-Type: multipart/form-data.
+   *
+   * @throws Error if the request body is not FormData
+   *
+   * @example
+   * ```typescript
+   * defineRoute({
+   *   method: "POST",
+   *   path: "/upload",
+   *   async handler(ctx, res) {
+   *     const formData = ctx.formData();
+   *     const file = formData.get("file") as File;
+   *     const description = formData.get("description") as string;
+   *     // ... process file
+   *   }
+   * });
+   * ```
+   */
+  formData(): FormData;
+  /**
+   * Check if the request body is FormData.
+   *
+   * Useful for routes that accept both JSON and FormData payloads.
+   *
+   * @example
+   * ```typescript
+   * defineRoute({
+   *   method: "POST",
+   *   path: "/upload",
+   *   async handler(ctx, res) {
+   *     if (ctx.isFormData()) {
+   *       const formData = ctx.formData();
+   *       // handle file upload
+   *     } else {
+   *       const json = await ctx.input.valid();
+   *       // handle JSON payload
+   *     }
+   *   }
+   * });
+   * ```
+   */
+  isFormData(): boolean;
+  /**
+   * Access the request body as a ReadableStream (application/octet-stream).
+   *
+   * @throws Error if the request body is not a ReadableStream
+   */
+  bodyStream(): ReadableStream<Uint8Array>;
+  /**
+   * Check if the request body is a ReadableStream.
+   */
+  isBodyStream(): boolean;
+  /**
+   * Input validation context (only if inputSchema is defined)
+   * @remarks `InputContext`
+   */
+  get input(): TInputSchema extends undefined ? undefined : {
+    schema: TInputSchema;
+    valid: () => Promise<TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : unknown>;
+  };
+} //#endregion
+//#endregion
+//#region ../fragno/dist/api/internal/response-stream.d.ts
+//#region src/api/internal/response-stream.d.ts
+/**
+ * @module
+ * Stream utility.
+ *
+ * Modified from honojs/hono
+ * Original source: https://github.com/honojs/hono/blob/0e3db674ad3f40be215a55a18062dd8e387ce525/src/utils/stream.ts
+ * License: MIT
+ * Date obtained: August 28 2025
+ * Copyright (c) 2021-present Yusuke Wada and Hono contributors
+ */
+type Error$1<Message extends string> = {
+  __errorMessage: Message;
+};
+declare class ResponseStream<TArray> {
+  #private;
+  /**
+   * Whether the stream has been aborted.
+   */
+  get aborted(): boolean;
+  /**
+   * Whether the stream has been closed normally.
+   */
+  get closed(): boolean;
+  /**
+   * The readable stream that the response is piped to.
+   */
+  get responseReadable(): ReadableStream;
+  constructor(writable: WritableStream, readable: ReadableStream);
+  writeRaw(input: Uint8Array | string): Promise<void>;
+  write(input: TArray extends (infer U)[] ? U : Error$1<"To use a streaming response, outputSchema must be an array.">): Promise<void>;
+  sleep(ms: number): Promise<unknown>;
+  close(): Promise<void>;
+  onAbort(listener: () => void | Promise<void>): void;
+  /**
+   * Abort the stream.
+   * You can call this method when stream is aborted by external event.
+   */
+  abort(): void;
+} //#endregion
+//#endregion
+//#region ../fragno/dist/api/request-output-context.d.ts
+//#region src/api/request-output-context.d.ts
+interface ResponseInit<T extends StatusCode = StatusCode> {
+  headers?: HeadersInit;
+  status?: T;
+  statusText?: string;
+}
+declare abstract class OutputContext<const TOutput, const TErrorCode extends string> {
+  /**
+   * Creates an error response.
+   *
+   * Shortcut for `throw new FragnoApiError(...)`
+   */
+  error: ({
+    message,
+    code
+  }: {
+    message: string;
+    code: TErrorCode;
+  }, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit) => Response;
+  empty: (initOrStatus?: ResponseInit<ContentlessStatusCode> | ContentlessStatusCode, headers?: HeadersInit) => Response;
+  json: (object: TOutput, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit) => Response;
+  jsonStream: (cb: (stream: ResponseStream<TOutput>) => void | Promise<void>, {
+    onError,
+    headers
+  }?: {
+    onError?: (error: Error, stream: ResponseStream<TOutput>) => void | Promise<void>;
+    headers?: HeadersInit;
+  }) => Response;
+}
+declare class RequestOutputContext<const TOutputSchema extends StandardSchemaV1 | undefined = undefined, const TErrorCode extends string = string> extends OutputContext<InferOrUnknown<TOutputSchema>, TErrorCode> {
+  #private;
+  constructor(outputSchema?: TOutputSchema);
+} //#endregion
+//#endregion
+//#region ../fragno/dist/api/api.d.ts
+//#region src/api/api.d.ts
+type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+type NonGetHTTPMethod = Exclude<HTTPMethod, "GET">;
+interface RequestThisContext {}
+/**
+ * Content types that can be accepted by a route.
+ *
+ * - `"application/json"` (default): JSON request body, validated against inputSchema
+ * - `"multipart/form-data"`: FormData request body (file uploads), no schema validation
+ */
+type RouteContentType = "application/json" | "multipart/form-data" | "application/octet-stream";
+interface FragnoRouteConfig<TMethod extends HTTPMethod, TPath extends string, TInputSchema extends StandardSchemaV1 | undefined, TOutputSchema extends StandardSchemaV1 | undefined, TErrorCode extends string = string, TQueryParameters extends string = string, TThisContext extends RequestThisContext = RequestThisContext> {
+  method: TMethod;
+  path: TPath;
+  /**
+   * The expected content type for this route's request body.
+   *
+   * - `"application/json"` (default): Expects JSON body, will be validated against inputSchema
+   * - `"multipart/form-data"`: Expects FormData body (for file uploads), use `ctx.formData()` in handler
+   *
+   * The server will reject requests with mismatched Content-Type headers.
+   *
+   * @default "application/json"
+   */
+  contentType?: RouteContentType;
+  inputSchema?: TInputSchema;
+  outputSchema?: TOutputSchema;
+  errorCodes?: readonly TErrorCode[];
+  queryParameters?: readonly TQueryParameters[];
+  handler(this: TThisContext, inputCtx: RequestInputContext<TPath, TInputSchema>, outputCtx: RequestOutputContext<TOutputSchema, TErrorCode>): Promise<Response>;
+}
+//#endregion
+//#region ../fragno/dist/api/shared-types.d.ts
+/**
+ * Configuration for custom fetch behavior in client-side fragments.
+ */
+type FetcherConfig = {
+  type: "options";
+  options: RequestInit;
+} | {
+  type: "function";
+  fetcher: typeof fetch;
+};
+/**
+ * Public configuration for Fragno fragments on the client side.
+ */
+interface FragnoPublicClientConfig {
+  mountRoute?: string;
+  baseUrl?: string;
+  fetcherConfig?: FetcherConfig;
+}
+/**
+ * Shared configuration for fragment routes.
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@nanostores+query@0.3.4_nanostores@1.2.0/node_modules/@nanostores/query/dist/factory.d.ts
+type Key = string;
+type FetcherValue<T = any, E = Error> = {
+  data?: T;
+  error?: E;
+  loading: boolean;
+  promise?: Promise<T>;
+};
+type LazyFetchValue<T = any, E = any> = {
+  data: T;
+} | {
+  error: E;
+};
+type FetcherStore<T = any, E = any> = MapStore<FetcherValue<T, E>> & {
+  _: Symbol;
+  key?: Key;
+  invalidate: (...args: any[]) => void;
+  revalidate: (...args: any[]) => void;
+  mutate: (data?: T) => void;
+  fetch: () => Promise<LazyFetchValue<T, E>>;
+};
+type MutateCb<Data, Result = unknown> = Data extends void ? () => Promise<Result> : (data: Data) => Promise<Result>;
+type MutatorStore<Data = void, Result = unknown, E = Error> = MapStore<{
+  mutate: MutateCb<Data, Result>;
+  data?: Result;
+  loading?: boolean;
+  error?: E;
+}> & {
+  mutate: MutateCb<Data, Result>;
+};
+//#endregion
+//#region ../fragno/dist/client/client.d.ts
+//#region src/client/client.d.ts
+/**
+ * Symbols used to identify hook types
+ */
+declare const GET_HOOK_SYMBOL: unique symbol;
+declare const MUTATOR_HOOK_SYMBOL: unique symbol;
+declare const STORE_SYMBOL: unique symbol;
+/**
+ * @internal
+ */
+type FragnoStoreFactoryData<T extends object, TArgs extends unknown[] = []> = {
+  factory: (...args: TArgs) => T;
+  [STORE_SYMBOL]: true;
+};
+type FragnoClientHookData<TMethod$1 extends HTTPMethod, TPath$1 extends string, TOutputSchema$1 extends StandardSchemaV1, TErrorCode$1 extends string, TQueryParameters$1 extends string> = {
+  route: FragnoRouteConfig<TMethod$1, TPath$1, StandardSchemaV1 | undefined, TOutputSchema$1, TErrorCode$1, TQueryParameters$1>;
+  query(args?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath$1, string>;
+    query?: Record<TQueryParameters$1, string | undefined>;
+  }): Promise<StandardSchemaV1.InferOutput<TOutputSchema$1>>;
+  store(args?: {
+    path?: MaybeExtractPathParamsOrWiden<TPath$1, string | ReadableAtom<string>>;
+    query?: Record<TQueryParameters$1, string | undefined | ReadableAtom<string | undefined>>;
+  }): FetcherStore<StandardSchemaV1.InferOutput<TOutputSchema$1>, FragnoClientError<TErrorCode$1>>;
+  [GET_HOOK_SYMBOL]: true;
+} & {
+  readonly _outputSchema?: TOutputSchema$1;
+};
+type FragnoClientMutatorData<TMethod$1 extends NonGetHTTPMethod, TPath$1 extends string, TInputSchema$1 extends StandardSchemaV1 | undefined, TOutputSchema$1 extends StandardSchemaV1 | undefined, TErrorCode$1 extends string, TQueryParameters$1 extends string> = {
+  route: FragnoRouteConfig<TMethod$1, TPath$1, TInputSchema$1, TOutputSchema$1, TErrorCode$1, TQueryParameters$1>;
+  mutateQuery(args?: {
+    body?: InferOr<TInputSchema$1, undefined>;
+    path?: MaybeExtractPathParamsOrWiden<TPath$1, string>;
+    query?: Record<TQueryParameters$1, string | undefined>;
+  }): Promise<InferOr<TOutputSchema$1, undefined>>;
+  mutatorStore: MutatorStore<{
+    body?: InferOr<TInputSchema$1, undefined>;
+    path?: MaybeExtractPathParamsOrWiden<TPath$1, string | ReadableAtom<string>>;
+    query?: Record<TQueryParameters$1, string | undefined | ReadableAtom<string | undefined>>;
+  }, InferOr<TOutputSchema$1, undefined>, FragnoClientError<TErrorCode$1>>;
+  [MUTATOR_HOOK_SYMBOL]: true;
+} & {
+  readonly _inputSchema?: TInputSchema$1;
+  readonly _outputSchema?: TOutputSchema$1;
+};
+/**
+ * @internal
+ */
+//#endregion
+//#region src/debug-log.d.ts
+type PiLogLevel = "off" | "error" | "warn" | "info" | "debug";
+type PiLoggerConfig = {
+  enabled?: boolean;
+  level?: PiLogLevel;
+};
+//#endregion
+//#region src/pi/constants.d.ts
+declare const SESSION_STATUSES: readonly ["active", "paused", "errored", "terminated", "complete", "waiting"];
+declare const STEERING_MODES: readonly ["all", "one-at-a-time"];
+declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
+type PiSessionStatus = (typeof SESSION_STATUSES)[number];
+type PiSteeringMode = (typeof STEERING_MODES)[number];
+//#endregion
+//#region src/pi/workflow/agent-runner.d.ts
+type AgentLoopParams = {
+  sessionId: string;
+  agentName: string;
+  systemPrompt?: string;
+  initialMessages?: AgentMessage[];
+};
+//#endregion
+//#region src/pi/workflow/workflow.d.ts
+declare const PI_WORKFLOW_NAME = "agent-loop-workflow";
+type WorkflowsOptions = {
+  agents: PiAgentRegistry;
+  tools: PiToolRegistry;
+  toolSideEffectReducers?: PiToolSideEffectReducerRegistry;
+  logging?: PiFragmentConfig["logging"];
+};
+declare const createPiAgentLoopWorkflow: (options: WorkflowsOptions) => _fragno_dev_workflows0.WorkflowDefinition<AgentLoopParams, {
+  messages: AgentMessage[];
+}, z.ZodType<AgentLoopParams, unknown, z.core.$ZodTypeInternals<AgentLoopParams, unknown>>, undefined, PiAgentLoopState, "agent-loop-workflow">;
+type PiWorkflowsRegistry = {
+  agentLoop: ReturnType<typeof createPiAgentLoopWorkflow>;
+};
+declare const createPiWorkflows: (options: WorkflowsOptions) => {
+  agentLoop: _fragno_dev_workflows0.WorkflowDefinition<AgentLoopParams, {
+    messages: AgentMessage[];
+  }, z.ZodType<AgentLoopParams, unknown, z.core.$ZodTypeInternals<AgentLoopParams, unknown>>, undefined, PiAgentLoopState, "agent-loop-workflow">;
+};
+//#endregion
+//#region src/pi/types.d.ts
+type WorkflowsService = WorkflowsFragmentServices<PiWorkflowsRegistry>;
+type PiSession = {
+  id: string;
+  name: string | null;
+  status: PiSessionStatus;
+  agent: string;
+  steeringMode: PiSteeringMode;
+  metadata: unknown;
+  tags: string[];
+  createdAt: Date;
+  updatedAt: Date;
+};
+type PiTurnSummary = {
+  turn: number;
+  assistant: AgentMessage | null;
+  summary: string | null;
+};
+type PiSessionDetailEvent = {
+  id: string;
+  type: string;
+  payload: unknown | null;
+  createdAt: Date;
+  deliveredAt: Date | null;
+  consumedByStepKey: string | null;
+  runNumber?: number | null;
+};
+type PiAgentLoopPhase = "waiting-for-user" | "running-agent" | "complete";
+type PiActiveSessionStreamItem = AgentEvent;
+type PiActiveSessionSettledStatus = "waiting-for-user" | "complete" | "errored";
+type PiActiveSessionUpdate = {
+  type: "event";
+  turn: number;
+  event: PiActiveSessionStreamItem;
+} | {
+  type: "settled";
+  turn: number;
+  status: PiActiveSessionSettledStatus;
+};
+type PiActiveSessionSubscriber = (update: PiActiveSessionUpdate) => void;
+type PiActiveSessionReplayBufferEntry = {
+  turn: number;
+  updates: PiActiveSessionUpdate[];
+};
+type PiActiveSessionReplayBuffer = PiActiveSessionReplayBufferEntry[];
+type PiActiveSessionState = {
+  subscribe: (listener: PiActiveSessionSubscriber) => () => void;
+  publishEvent: (turn: number, event: PiActiveSessionStreamItem) => void;
+  settleTurn: (turn: number, status: PiActiveSessionSettledStatus) => void;
+  replayTurn: (turn: number) => PiActiveSessionUpdate[];
+  exportReplayBuffer: () => PiActiveSessionReplayBuffer;
+  importReplayBuffer: (buffer: PiActiveSessionReplayBuffer) => void;
+  listenerCount: () => number;
+};
+type PiAgentLoopWaitingFor = {
+  type: "user_message";
+  turn: number;
+  stepKey: string;
+  timeoutMs: number | null;
+} | {
+  type: "assistant";
+  turn: number;
+  stepKey: string;
+} | null;
+type PiAgentLoopSerializableState = {
+  messages: AgentMessage[];
+  events: PiSessionDetailEvent[];
+  trace: AgentEvent[];
+  summaries: PiTurnSummary[];
+  turn: number;
+  phase: PiAgentLoopPhase;
+  waitingFor: PiAgentLoopWaitingFor;
+};
+type PiAgentLoopPersistedState = PiAgentLoopSerializableState & {
+  activeSessionUpdatesByTurn: PiActiveSessionReplayBuffer;
+};
+type PiSessionWorkflowStatus = {
+  status: PiSessionStatus;
+  error?: {
+    name: string;
+    message: string;
+  };
+  output?: unknown;
+};
+type PiSessionDetail = PiSession & {
+  workflow: PiSessionWorkflowStatus;
+  messages: AgentMessage[];
+  events: PiSessionDetailEvent[];
+  trace: AgentEvent[];
+  summaries: PiTurnSummary[];
+  turn: number;
+  phase: PiAgentLoopPhase;
+  waitingFor: PiAgentLoopWaitingFor;
+};
+type PiAgentLoopState = PiAgentLoopPersistedState & {
+  activeSession?: PiActiveSessionState;
+};
+type PiWorkflowsInstanceStatus = InstanceStatus;
+type PiWorkflowHistoryStep = WorkflowsHistoryStep;
+type PiWorkflowsService = Pick<WorkflowsService, "createInstance" | "getInstanceStatus" | "getLiveInstanceState" | "restoreInstanceState" | "sendEvent"> & {
+  getInstanceStatusBatch?: (workflowName: string, instanceIds: string[]) => TxResult<PiWorkflowsInstanceStatus[], PiWorkflowsInstanceStatus[]>;
+};
+type PiAgentDefinition = {
+  name: string;
+  systemPrompt: string;
+  model: Model<Api>;
+  thinkingLevel?: ThinkingLevel;
+  tools?: string[];
+  toolConfig?: unknown;
+  maxTraceEvents?: number;
+  streamFn?: StreamFn;
+  convertToLlm?: AgentOptions["convertToLlm"];
+  transformContext?: AgentOptions["transformContext"];
+  getApiKey?: AgentOptions["getApiKey"];
+  thinkingBudgets?: AgentOptions["thinkingBudgets"];
+  maxRetryDelayMs?: AgentOptions["maxRetryDelayMs"];
+  onEvent?: (event: AgentEvent, ctx: {
+    sessionId: string;
+    turnId: string;
+  }) => void;
+};
+type PiAgentRegistry = Record<string, PiAgentDefinition>;
+declare const PI_TOOL_JOURNAL_VERSION: 1;
+type PiToolJournalVersion = typeof PI_TOOL_JOURNAL_VERSION;
+type PiToolCallStableKey = string;
+type PiPersistedToolResult = {
+  content: Array<TextContent | ImageContent>;
+  details: unknown;
+};
+type PiPersistedToolCallSource = "executed" | "replay";
+type PiPersistedToolCallV1 = {
+  version: PiToolJournalVersion;
+  key: PiToolCallStableKey;
+  sessionId: string;
+  turnId: string;
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  result: PiPersistedToolResult;
+  isError: boolean;
+  source: PiPersistedToolCallSource;
+  capturedAt: number;
+  seq: number;
+};
+type PiActiveSessionSystemMessage = {
+  layer: "system";
+  type: "snapshot";
+  turn: number;
+  phase: PiAgentLoopPhase;
+  waitingFor: PiAgentLoopWaitingFor;
+  replayCount: number;
+} | {
+  layer: "system";
+  type: "settled";
+  turn: number;
+  status: PiActiveSessionSettledStatus;
+} | {
+  layer: "system";
+  type: "inactive";
+  reason: "session-complete" | "session-idle";
+  turn: number;
+  phase: PiAgentLoopPhase;
+  waitingFor: PiAgentLoopWaitingFor;
+};
+type PiActiveSessionProtocolMessage = PiActiveSessionSystemMessage | {
+  layer: "pi";
+  type: "event";
+  turn: number;
+  source: "replay" | "live";
+  event: PiActiveSessionStreamItem;
+};
+type PiPersistedToolCall = PiPersistedToolCallV1;
+type PiToolReplayCache = Map<PiToolCallStableKey, PiPersistedToolCall>;
+type PiToolSideEffectReducerContext = {
+  key: PiToolCallStableKey;
+  sessionId: string;
+  turnId: string;
+};
+type PiToolSideEffectReducer = (state: unknown, entry: PiPersistedToolCall, ctx: PiToolSideEffectReducerContext) => unknown;
+type PiToolSideEffectReducerRegistry = Record<string, PiToolSideEffectReducer>;
+type PiToolReplayContext = {
+  cache: PiToolReplayCache;
+  journal: PiPersistedToolCall[];
+  sideEffects: Record<string, unknown>;
+};
+type PiToolFactoryContext = {
+  session: PiSession;
+  turnId: string;
+  toolConfig: unknown;
+  messages: AgentMessage[];
+  replay: PiToolReplayContext;
+};
+type PiToolFactory = AgentTool | ((ctx: PiToolFactoryContext) => AgentTool | Promise<AgentTool>);
+type PiToolRegistry = Record<string, PiToolFactory>;
+interface PiFragmentConfig {
+  agents: PiAgentRegistry;
+  tools: PiToolRegistry;
+  defaultSteeringMode?: PiSteeringMode;
+  toolSideEffectReducers?: PiToolSideEffectReducerRegistry;
+  /**
+   * Optional logging config for internal pi-fragment diagnostics.
+   */
+  logging?: PiLoggerConfig;
+}
+//#endregion
+//#region src/client/session-store.d.ts
+type QueryStoreValue<T> = {
+  loading: boolean;
+  data?: T;
+  error?: {
+    message?: string;
+  };
+};
+type QueryStore<T> = ReadableAtom<QueryStoreValue<T>> & {
+  revalidate: () => void;
+};
+type PiLiveToolExecution = {
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+  partialResult: unknown | null;
+};
+type PiSessionConnectionState = "idle" | "connecting" | "listening" | "reconnecting" | "error";
+type PiSessionStoreState = {
+  loading: boolean;
+  session: PiSessionDetail | null;
+  messages: AgentMessage[];
+  traceEvents: AgentEvent[];
+  runningTools: PiLiveToolExecution[];
+  connection: PiSessionConnectionState;
+  statusText: string | null;
+  readyForInput: boolean;
+  sending: boolean;
+  error: string | null;
+  sendError: string | null;
+};
+type CreatePiSessionStoreArgs = {
+  sessionId: string;
+  initialData?: PiSessionDetail | null;
+};
+type PiSessionStoreController = {
+  store: ReadableAtom<PiSessionStoreState>;
+  sendMessage: (input: {
+    text: string;
+    done?: boolean;
+    steeringMode?: "all" | "one-at-a-time";
+  }) => boolean;
+  refetch: () => void;
+  deactivate: () => void;
+  destroy: () => void;
+};
+type CreatePiSessionStoreDependencies = {
+  createDetailStore: (sessionId: string) => QueryStore<PiSessionDetail>;
+  sendMessage: (options: {
+    sessionId: string;
+    text: string;
+    done?: boolean;
+    steeringMode?: "all" | "one-at-a-time";
+  }) => Promise<{
+    status: PiSessionStatus;
+  }>;
+  buildActiveUrl: (sessionId: string) => string;
+  fetcher: typeof fetch;
+  defaultOptions?: RequestInit;
+  enableActiveStream?: boolean;
+  activeLogger?: (event: string, details?: Record<string, unknown>) => void;
+};
+declare function createPiSessionStore(deps: CreatePiSessionStoreDependencies, args: CreatePiSessionStoreArgs): PiSessionStoreController;
+//#endregion
+//#region src/client/session-controller.d.ts
+type PiSessionStoreHookArgs = {
+  path: {
+    sessionId: string;
+  };
+  initialData?: PiSessionDetail | null;
+};
+type PiSessionStoreView = {
+  loading: ReadableAtom<PiSessionStoreState["loading"]>;
+  session: ReadableAtom<PiSessionStoreState["session"]>;
+  messages: ReadableAtom<AgentMessage[]>;
+  traceEvents: ReadableAtom<AgentEvent[]>;
+  runningTools: ReadableAtom<PiSessionStoreState["runningTools"]>;
+  connection: ReadableAtom<PiSessionStoreState["connection"]>;
+  statusText: ReadableAtom<PiSessionStoreState["statusText"]>;
+  readyForInput: ReadableAtom<PiSessionStoreState["readyForInput"]>;
+  sending: ReadableAtom<PiSessionStoreState["sending"]>;
+  error: ReadableAtom<PiSessionStoreState["error"]>;
+  sendError: ReadableAtom<PiSessionStoreState["sendError"]>;
+  sendMessage: PiSessionStoreController["sendMessage"];
+  refetch: PiSessionStoreController["refetch"];
+  [Symbol.dispose]: () => void;
+};
+//#endregion
+//#region src/client/clients.d.ts
+type PiFragmentClientConfig = FragnoPublicClientConfig & {
+  debugActiveSession?: boolean;
+};
+declare function createPiFragmentClients(fragnoConfig: PiFragmentClientConfig): {
+  useSessions: FragnoClientHookData<"GET", "/sessions", zod.ZodArray<zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodNullable<zod.ZodString>;
+    status: zod.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    agent: zod.ZodString;
+    steeringMode: zod.ZodEnum<{
+      all: "all";
+      "one-at-a-time": "one-at-a-time";
+    }>;
+    metadata: zod.ZodNullable<zod.ZodAny>;
+    tags: zod.ZodArray<zod.ZodString>;
+    createdAt: zod.ZodDate;
+    updatedAt: zod.ZodDate;
+  }, zod_v4_core0.$strip>>, string, "limit">;
+  useSessionDetail: FragnoClientHookData<"GET", "/sessions/:sessionId", zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodNullable<zod.ZodString>;
+    status: zod.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    agent: zod.ZodString;
+    steeringMode: zod.ZodEnum<{
+      all: "all";
+      "one-at-a-time": "one-at-a-time";
+    }>;
+    metadata: zod.ZodNullable<zod.ZodAny>;
+    tags: zod.ZodArray<zod.ZodString>;
+    createdAt: zod.ZodDate;
+    updatedAt: zod.ZodDate;
+    workflow: zod.ZodObject<{
+      status: zod.ZodEnum<{
+        active: "active";
+        paused: "paused";
+        errored: "errored";
+        terminated: "terminated";
+        complete: "complete";
+        waiting: "waiting";
+      }>;
+      error: zod.ZodOptional<zod.ZodObject<{
+        name: zod.ZodString;
+        message: zod.ZodString;
+      }, zod_v4_core0.$strip>>;
+      output: zod.ZodOptional<zod.ZodAny>;
+    }, zod_v4_core0.$strip>;
+    messages: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+      role: zod.ZodLiteral<"user">;
+      content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+        type: zod.ZodLiteral<"text">;
+        text: zod.ZodString;
+        textSignature: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"image">;
+        data: zod.ZodString;
+        mimeType: zod.ZodString;
+      }, zod_v4_core0.$strip>]>>]>;
+      timestamp: zod.ZodNumber;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      role: zod.ZodLiteral<"assistant">;
+      content: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+        type: zod.ZodLiteral<"text">;
+        text: zod.ZodString;
+        textSignature: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"thinking">;
+        thinking: zod.ZodString;
+        thinkingSignature: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"toolCall">;
+        id: zod.ZodString;
+        name: zod.ZodString;
+        arguments: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+        thoughtSignature: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>]>>;
+      api: zod.ZodString;
+      provider: zod.ZodString;
+      model: zod.ZodString;
+      usage: zod.ZodObject<{
+        input: zod.ZodNumber;
+        output: zod.ZodNumber;
+        cacheRead: zod.ZodNumber;
+        cacheWrite: zod.ZodNumber;
+        totalTokens: zod.ZodNumber;
+        cost: zod.ZodObject<{
+          input: zod.ZodNumber;
+          output: zod.ZodNumber;
+          cacheRead: zod.ZodNumber;
+          cacheWrite: zod.ZodNumber;
+          total: zod.ZodNumber;
+        }, zod_v4_core0.$strip>;
+      }, zod_v4_core0.$strip>;
+      stopReason: zod.ZodEnum<{
+        length: "length";
+        error: "error";
+        stop: "stop";
+        toolUse: "toolUse";
+        aborted: "aborted";
+      }>;
+      errorMessage: zod.ZodOptional<zod.ZodString>;
+      timestamp: zod.ZodNumber;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      role: zod.ZodLiteral<"toolResult">;
+      toolCallId: zod.ZodString;
+      toolName: zod.ZodString;
+      content: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+        type: zod.ZodLiteral<"text">;
+        text: zod.ZodString;
+        textSignature: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>, zod.ZodObject<{
+        type: zod.ZodLiteral<"image">;
+        data: zod.ZodString;
+        mimeType: zod.ZodString;
+      }, zod_v4_core0.$strip>]>>;
+      details: zod.ZodOptional<zod.ZodUnknown>;
+      isError: zod.ZodBoolean;
+      timestamp: zod.ZodNumber;
+    }, zod_v4_core0.$strip>]>>;
+    events: zod.ZodArray<zod.ZodObject<{
+      id: zod.ZodString;
+      runNumber: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+      type: zod.ZodString;
+      payload: zod.ZodNullable<zod.ZodUnknown>;
+      createdAt: zod.ZodDate;
+      deliveredAt: zod.ZodNullable<zod.ZodDate>;
+      consumedByStepKey: zod.ZodNullable<zod.ZodString>;
+    }, zod_v4_core0.$strip>>;
+    trace: zod.ZodArray<zod.ZodType<_mariozechner_pi_agent_core0.AgentEvent, unknown, zod_v4_core0.$ZodTypeInternals<_mariozechner_pi_agent_core0.AgentEvent, unknown>>>;
+    turn: zod.ZodNumber;
+    phase: zod.ZodEnum<{
+      complete: "complete";
+      "waiting-for-user": "waiting-for-user";
+      "running-agent": "running-agent";
+    }>;
+    waitingFor: zod.ZodNullable<zod.ZodUnion<readonly [zod.ZodObject<{
+      type: zod.ZodLiteral<"user_message">;
+      turn: zod.ZodNumber;
+      stepKey: zod.ZodString;
+      timeoutMs: zod.ZodNullable<zod.ZodNumber>;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      type: zod.ZodLiteral<"assistant">;
+      turn: zod.ZodNumber;
+      stepKey: zod.ZodString;
+    }, zod_v4_core0.$strip>]>>;
+    summaries: zod.ZodArray<zod.ZodObject<{
+      turn: zod.ZodNumber;
+      assistant: zod.ZodNullable<zod.ZodAny>;
+      summary: zod.ZodNullable<zod.ZodString>;
+    }, zod_v4_core0.$strip>>;
+  }, zod_v4_core0.$strip>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", "events" | "trace" | "summaries">;
+  useSession: FragnoStoreFactoryData<PiSessionStoreView, [args: PiSessionStoreHookArgs]>;
+  useCreateSession: FragnoClientMutatorData<NonGetHTTPMethod, "/sessions", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | zod.ZodObject<{
+    agent: zod.ZodString;
+    name: zod.ZodOptional<zod.ZodString>;
+    systemMessage: zod.ZodOptional<zod.ZodString>;
+    metadata: zod.ZodOptional<zod.ZodAny>;
+    tags: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+    steeringMode: zod.ZodOptional<zod.ZodEnum<{
+      all: "all";
+      "one-at-a-time": "one-at-a-time";
+    }>>;
+  }, zod_v4_core0.$strip> | undefined, zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodNullable<zod.ZodString>;
+    status: zod.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    agent: zod.ZodString;
+    steeringMode: zod.ZodEnum<{
+      all: "all";
+      "one-at-a-time": "one-at-a-time";
+    }>;
+    metadata: zod.ZodNullable<zod.ZodAny>;
+    tags: zod.ZodArray<zod.ZodString>;
+    createdAt: zod.ZodDate;
+    updatedAt: zod.ZodDate;
+  }, zod_v4_core0.$strip> | zod.ZodArray<zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodNullable<zod.ZodString>;
+    status: zod.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    agent: zod.ZodString;
+    steeringMode: zod.ZodEnum<{
+      all: "all";
+      "one-at-a-time": "one-at-a-time";
+    }>;
+    metadata: zod.ZodNullable<zod.ZodAny>;
+    tags: zod.ZodArray<zod.ZodString>;
+    createdAt: zod.ZodDate;
+    updatedAt: zod.ZodDate;
+  }, zod_v4_core0.$strip>> | undefined, string, string>;
+  useActiveSession: FragnoClientHookData<"GET", "/sessions/:sessionId/active", zod.ZodArray<zod.ZodType<PiActiveSessionProtocolMessage, unknown, zod_v4_core0.$ZodTypeInternals<PiActiveSessionProtocolMessage, unknown>>>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", string>;
+  useSendMessage: FragnoClientMutatorData<NonGetHTTPMethod, "/sessions/:sessionId/messages", zod.ZodObject<{
+    text: zod.ZodString;
+    done: zod.ZodOptional<zod.ZodBoolean>;
+    steeringMode: zod.ZodOptional<zod.ZodEnum<{
+      all: "all";
+      "one-at-a-time": "one-at-a-time";
+    }>>;
+  }, zod_v4_core0.$strip> | undefined, zod.ZodObject<{
+    status: zod.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+  }, zod_v4_core0.$strip> | undefined, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING" | "SESSION_NOT_READY", string>;
+};
+//#endregion
+//#region src/pi/dsl.d.ts
+type PiAgentDefinitionInput = Omit<PiAgentDefinition, "name"> & {
+  name?: string;
+};
+type PiRuntime = {
+  config: PiFragmentConfig;
+  workflows: PiWorkflowsRegistry;
+};
+declare const defineAgent: (name: string, definition: PiAgentDefinitionInput) => PiAgentDefinition;
+declare const createPi: () => {
+  agent(definition: PiAgentDefinition): /*elided*/any;
+  agents(registry: PiAgentRegistry): /*elided*/any;
+  tool(name: string, tool: PiToolFactory): /*elided*/any;
+  tools(registry: PiToolRegistry): /*elided*/any;
+  toolSideEffectReducer(toolName: string, reducer: PiToolSideEffectReducer): /*elided*/any;
+  toolSideEffectReducers(registry: PiToolSideEffectReducerRegistry): /*elided*/any;
+  defaultSteeringMode(mode: PiSteeringMode): /*elided*/any;
+  logging(config: PiFragmentConfig["logging"]): /*elided*/any;
+  build(): PiRuntime;
+};
+//#endregion
+//#region src/pi/definition.d.ts
+declare const piFragmentDefinition: _fragno_dev_core0.FragmentDefinition<PiFragmentConfig, _fragno_dev_db0.FragnoPublicConfigWithDatabase, _fragno_dev_db0.ImplicitDatabaseDependencies<_fragno_dev_db_schema0.Schema<Record<"session", _fragno_dev_db_schema0.Table<Record<"id", _fragno_dev_db_schema0.IdColumn<"varchar(128)", string | _fragno_dev_db_schema0.FragnoId | null, _fragno_dev_db_schema0.FragnoId>> & Record<"name", _fragno_dev_db_schema0.Column<"string", string | null, string | null>> & Record<"agent", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"status", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"steeringMode", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"metadata", _fragno_dev_db_schema0.Column<"json", unknown, unknown>> & Record<"tags", _fragno_dev_db_schema0.Column<"json", unknown, unknown>> & Record<"createdAt", _fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>> & Record<"updatedAt", _fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>>, Record<string, _fragno_dev_db_schema0.AnyRelation>, Record<string, _fragno_dev_db_schema0.Index<_fragno_dev_db_schema0.AnyColumn[], readonly string[]>> & Record<"idx_session_status", _fragno_dev_db_schema0.Index<readonly [_fragno_dev_db_schema0.Column<"string", string, string>] & _fragno_dev_db_schema0.AnyColumn[], readonly ["status"]>> & Record<"idx_session_created", _fragno_dev_db_schema0.Index<readonly [_fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>] & _fragno_dev_db_schema0.AnyColumn[], readonly ["createdAt"]>>>>>>, {}, {}, {
+  workflows: PiWorkflowsService;
+}, {}, _fragno_dev_db0.DatabaseServiceContext<_fragno_dev_db0.HooksMap>, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>, _fragno_dev_db_fragment_definition_builder0.DatabaseRequestStorage, []>;
+//#endregion
+//#region src/pi/factory.d.ts
+type PiFragmentServices = {
+  workflows: PiWorkflowsService;
+};
+declare function createPiFragment(config: PiFragmentConfig, options: FragnoPublicConfigWithDatabase, services: PiFragmentServices): _fragno_dev_core0.FragnoInstantiatedFragment<readonly [_fragno_dev_core0.FragnoRouteConfig<"POST", "/sessions", zod.ZodObject<{
+  agent: zod.ZodString;
+  name: zod.ZodOptional<zod.ZodString>;
+  systemMessage: zod.ZodOptional<zod.ZodString>;
+  metadata: zod.ZodOptional<zod.ZodAny>;
+  tags: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+  steeringMode: zod.ZodOptional<zod.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  id: zod.ZodString;
+  name: zod.ZodNullable<zod.ZodString>;
+  status: zod.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+  agent: zod.ZodString;
+  steeringMode: zod.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>;
+  metadata: zod.ZodNullable<zod.ZodAny>;
+  tags: zod.ZodArray<zod.ZodString>;
+  createdAt: zod.ZodDate;
+  updatedAt: zod.ZodDate;
+}, zod_v4_core0.$strip>, "AGENT_NOT_FOUND" | "WORKFLOW_CREATE_FAILED", string, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"GET", "/sessions", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | undefined, zod.ZodArray<zod.ZodObject<{
+  id: zod.ZodString;
+  name: zod.ZodNullable<zod.ZodString>;
+  status: zod.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+  agent: zod.ZodString;
+  steeringMode: zod.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>;
+  metadata: zod.ZodNullable<zod.ZodAny>;
+  tags: zod.ZodArray<zod.ZodString>;
+  createdAt: zod.ZodDate;
+  updatedAt: zod.ZodDate;
+}, zod_v4_core0.$strip>>, string, "limit", _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"GET", "/sessions/:sessionId", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | undefined, zod.ZodObject<{
+  id: zod.ZodString;
+  name: zod.ZodNullable<zod.ZodString>;
+  status: zod.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+  agent: zod.ZodString;
+  steeringMode: zod.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>;
+  metadata: zod.ZodNullable<zod.ZodAny>;
+  tags: zod.ZodArray<zod.ZodString>;
+  createdAt: zod.ZodDate;
+  updatedAt: zod.ZodDate;
+  workflow: zod.ZodObject<{
+    status: zod.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    error: zod.ZodOptional<zod.ZodObject<{
+      name: zod.ZodString;
+      message: zod.ZodString;
+    }, zod_v4_core0.$strip>>;
+    output: zod.ZodOptional<zod.ZodAny>;
+  }, zod_v4_core0.$strip>;
+  messages: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+    role: zod.ZodLiteral<"user">;
+    content: zod.ZodUnion<readonly [zod.ZodString, zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+      type: zod.ZodLiteral<"text">;
+      text: zod.ZodString;
+      textSignature: zod.ZodOptional<zod.ZodString>;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      type: zod.ZodLiteral<"image">;
+      data: zod.ZodString;
+      mimeType: zod.ZodString;
+    }, zod_v4_core0.$strip>]>>]>;
+    timestamp: zod.ZodNumber;
+  }, zod_v4_core0.$strip>, zod.ZodObject<{
+    role: zod.ZodLiteral<"assistant">;
+    content: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+      type: zod.ZodLiteral<"text">;
+      text: zod.ZodString;
+      textSignature: zod.ZodOptional<zod.ZodString>;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      type: zod.ZodLiteral<"thinking">;
+      thinking: zod.ZodString;
+      thinkingSignature: zod.ZodOptional<zod.ZodString>;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      type: zod.ZodLiteral<"toolCall">;
+      id: zod.ZodString;
+      name: zod.ZodString;
+      arguments: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+      thoughtSignature: zod.ZodOptional<zod.ZodString>;
+    }, zod_v4_core0.$strip>]>>;
+    api: zod.ZodString;
+    provider: zod.ZodString;
+    model: zod.ZodString;
+    usage: zod.ZodObject<{
+      input: zod.ZodNumber;
+      output: zod.ZodNumber;
+      cacheRead: zod.ZodNumber;
+      cacheWrite: zod.ZodNumber;
+      totalTokens: zod.ZodNumber;
+      cost: zod.ZodObject<{
+        input: zod.ZodNumber;
+        output: zod.ZodNumber;
+        cacheRead: zod.ZodNumber;
+        cacheWrite: zod.ZodNumber;
+        total: zod.ZodNumber;
+      }, zod_v4_core0.$strip>;
+    }, zod_v4_core0.$strip>;
+    stopReason: zod.ZodEnum<{
+      length: "length";
+      error: "error";
+      stop: "stop";
+      toolUse: "toolUse";
+      aborted: "aborted";
+    }>;
+    errorMessage: zod.ZodOptional<zod.ZodString>;
+    timestamp: zod.ZodNumber;
+  }, zod_v4_core0.$strip>, zod.ZodObject<{
+    role: zod.ZodLiteral<"toolResult">;
+    toolCallId: zod.ZodString;
+    toolName: zod.ZodString;
+    content: zod.ZodArray<zod.ZodUnion<readonly [zod.ZodObject<{
+      type: zod.ZodLiteral<"text">;
+      text: zod.ZodString;
+      textSignature: zod.ZodOptional<zod.ZodString>;
+    }, zod_v4_core0.$strip>, zod.ZodObject<{
+      type: zod.ZodLiteral<"image">;
+      data: zod.ZodString;
+      mimeType: zod.ZodString;
+    }, zod_v4_core0.$strip>]>>;
+    details: zod.ZodOptional<zod.ZodUnknown>;
+    isError: zod.ZodBoolean;
+    timestamp: zod.ZodNumber;
+  }, zod_v4_core0.$strip>]>>;
+  events: zod.ZodArray<zod.ZodObject<{
+    id: zod.ZodString;
+    runNumber: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+    type: zod.ZodString;
+    payload: zod.ZodNullable<zod.ZodUnknown>;
+    createdAt: zod.ZodDate;
+    deliveredAt: zod.ZodNullable<zod.ZodDate>;
+    consumedByStepKey: zod.ZodNullable<zod.ZodString>;
+  }, zod_v4_core0.$strip>>;
+  trace: zod.ZodArray<zod.ZodType<_mariozechner_pi_agent_core0.AgentEvent, unknown, zod_v4_core0.$ZodTypeInternals<_mariozechner_pi_agent_core0.AgentEvent, unknown>>>;
+  turn: zod.ZodNumber;
+  phase: zod.ZodEnum<{
+    complete: "complete";
+    "waiting-for-user": "waiting-for-user";
+    "running-agent": "running-agent";
+  }>;
+  waitingFor: zod.ZodNullable<zod.ZodUnion<readonly [zod.ZodObject<{
+    type: zod.ZodLiteral<"user_message">;
+    turn: zod.ZodNumber;
+    stepKey: zod.ZodString;
+    timeoutMs: zod.ZodNullable<zod.ZodNumber>;
+  }, zod_v4_core0.$strip>, zod.ZodObject<{
+    type: zod.ZodLiteral<"assistant">;
+    turn: zod.ZodNumber;
+    stepKey: zod.ZodString;
+  }, zod_v4_core0.$strip>]>>;
+  summaries: zod.ZodArray<zod.ZodObject<{
+    turn: zod.ZodNumber;
+    assistant: zod.ZodNullable<zod.ZodAny>;
+    summary: zod.ZodNullable<zod.ZodString>;
+  }, zod_v4_core0.$strip>>;
+}, zod_v4_core0.$strip>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", "events" | "trace" | "summaries", _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"GET", "/sessions/:sessionId/active", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | undefined, zod.ZodArray<zod.ZodType<PiActiveSessionProtocolMessage, unknown, zod_v4_core0.$ZodTypeInternals<PiActiveSessionProtocolMessage, unknown>>>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", string, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"POST", "/sessions/:sessionId/messages", zod.ZodObject<{
+  text: zod.ZodString;
+  done: zod.ZodOptional<zod.ZodBoolean>;
+  steeringMode: zod.ZodOptional<zod.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>>;
+}, zod_v4_core0.$strip>, zod.ZodObject<{
+  status: zod.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+}, zod_v4_core0.$strip>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING" | "SESSION_NOT_READY", string, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>], _fragno_dev_db0.ImplicitDatabaseDependencies<_fragno_dev_db_schema0.Schema<Record<"session", _fragno_dev_db_schema0.Table<Record<"id", _fragno_dev_db_schema0.IdColumn<"varchar(128)", string | _fragno_dev_db_schema0.FragnoId | null, _fragno_dev_db_schema0.FragnoId>> & Record<"name", _fragno_dev_db_schema0.Column<"string", string | null, string | null>> & Record<"agent", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"status", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"steeringMode", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"metadata", _fragno_dev_db_schema0.Column<"json", unknown, unknown>> & Record<"tags", _fragno_dev_db_schema0.Column<"json", unknown, unknown>> & Record<"createdAt", _fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>> & Record<"updatedAt", _fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>>, Record<string, _fragno_dev_db_schema0.AnyRelation>, Record<string, _fragno_dev_db_schema0.Index<_fragno_dev_db_schema0.AnyColumn[], readonly string[]>> & Record<"idx_session_status", _fragno_dev_db_schema0.Index<readonly [_fragno_dev_db_schema0.Column<"string", string, string>] & _fragno_dev_db_schema0.AnyColumn[], readonly ["status"]>> & Record<"idx_session_created", _fragno_dev_db_schema0.Index<readonly [_fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>] & _fragno_dev_db_schema0.AnyColumn[], readonly ["createdAt"]>>>>>>, _fragno_dev_core0.BoundServices<{}>, _fragno_dev_db0.DatabaseServiceContext<_fragno_dev_db0.HooksMap>, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>, _fragno_dev_db_fragment_definition_builder0.DatabaseRequestStorage, FragnoPublicConfigWithDatabase>;
+//#endregion
+//#region src/routes.d.ts
+declare const piRoutesFactory: _fragno_dev_core0.RouteFactory<PiFragmentConfig, _fragno_dev_db0.ImplicitDatabaseDependencies<_fragno_dev_db_schema0.Schema<Record<"session", _fragno_dev_db_schema0.Table<Record<"id", _fragno_dev_db_schema0.IdColumn<"varchar(128)", string | _fragno_dev_db_schema0.FragnoId | null, _fragno_dev_db_schema0.FragnoId>> & Record<"name", _fragno_dev_db_schema0.Column<"string", string | null, string | null>> & Record<"agent", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"status", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"steeringMode", _fragno_dev_db_schema0.Column<"string", string, string>> & Record<"metadata", _fragno_dev_db_schema0.Column<"json", unknown, unknown>> & Record<"tags", _fragno_dev_db_schema0.Column<"json", unknown, unknown>> & Record<"createdAt", _fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>> & Record<"updatedAt", _fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>>, Record<string, _fragno_dev_db_schema0.AnyRelation>, Record<string, _fragno_dev_db_schema0.Index<_fragno_dev_db_schema0.AnyColumn[], readonly string[]>> & Record<"idx_session_status", _fragno_dev_db_schema0.Index<readonly [_fragno_dev_db_schema0.Column<"string", string, string>] & _fragno_dev_db_schema0.AnyColumn[], readonly ["status"]>> & Record<"idx_session_created", _fragno_dev_db_schema0.Index<readonly [_fragno_dev_db_schema0.Column<"timestamp", (_fragno_dev_db0.DbNow | Date) | null, Date>] & _fragno_dev_db_schema0.AnyColumn[], readonly ["createdAt"]>>>>>>, _fragno_dev_core0.BoundServices<{}>, {
+  workflows: PiWorkflowsService;
+}, readonly [_fragno_dev_core0.FragnoRouteConfig<"POST", "/sessions", z.ZodObject<{
+  agent: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  systemMessage: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodAny>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  steeringMode: z.ZodOptional<z.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+  agent: z.ZodString;
+  steeringMode: z.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>;
+  metadata: z.ZodNullable<z.ZodAny>;
+  tags: z.ZodArray<z.ZodString>;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>, "AGENT_NOT_FOUND" | "WORKFLOW_CREATE_FAILED", string, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"GET", "/sessions", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | undefined, z.ZodArray<z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+  agent: z.ZodString;
+  steeringMode: z.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>;
+  metadata: z.ZodNullable<z.ZodAny>;
+  tags: z.ZodArray<z.ZodString>;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>>, string, "limit", _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"GET", "/sessions/:sessionId", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | undefined, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+  agent: z.ZodString;
+  steeringMode: z.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>;
+  metadata: z.ZodNullable<z.ZodAny>;
+  tags: z.ZodArray<z.ZodString>;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+  workflow: z.ZodObject<{
+    status: z.ZodEnum<{
+      active: "active";
+      paused: "paused";
+      errored: "errored";
+      terminated: "terminated";
+      complete: "complete";
+      waiting: "waiting";
+    }>;
+    error: z.ZodOptional<z.ZodObject<{
+      name: z.ZodString;
+      message: z.ZodString;
+    }, z.core.$strip>>;
+    output: z.ZodOptional<z.ZodAny>;
+  }, z.core.$strip>;
+  messages: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+      textSignature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"image">;
+      data: z.ZodString;
+      mimeType: z.ZodString;
+    }, z.core.$strip>]>>]>;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"assistant">;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+      textSignature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"thinking">;
+      thinking: z.ZodString;
+      thinkingSignature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"toolCall">;
+      id: z.ZodString;
+      name: z.ZodString;
+      arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+      thoughtSignature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    api: z.ZodString;
+    provider: z.ZodString;
+    model: z.ZodString;
+    usage: z.ZodObject<{
+      input: z.ZodNumber;
+      output: z.ZodNumber;
+      cacheRead: z.ZodNumber;
+      cacheWrite: z.ZodNumber;
+      totalTokens: z.ZodNumber;
+      cost: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        total: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    stopReason: z.ZodEnum<{
+      length: "length";
+      error: "error";
+      stop: "stop";
+      toolUse: "toolUse";
+      aborted: "aborted";
+    }>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"toolResult">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    content: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+      type: z.ZodLiteral<"text">;
+      text: z.ZodString;
+      textSignature: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      type: z.ZodLiteral<"image">;
+      data: z.ZodString;
+      mimeType: z.ZodString;
+    }, z.core.$strip>]>>;
+    details: z.ZodOptional<z.ZodUnknown>;
+    isError: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+  }, z.core.$strip>]>>;
+  events: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    runNumber: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    type: z.ZodString;
+    payload: z.ZodNullable<z.ZodUnknown>;
+    createdAt: z.ZodDate;
+    deliveredAt: z.ZodNullable<z.ZodDate>;
+    consumedByStepKey: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+  trace: z.ZodArray<z.ZodType<_mariozechner_pi_agent_core0.AgentEvent, unknown, z.core.$ZodTypeInternals<_mariozechner_pi_agent_core0.AgentEvent, unknown>>>;
+  turn: z.ZodNumber;
+  phase: z.ZodEnum<{
+    complete: "complete";
+    "waiting-for-user": "waiting-for-user";
+    "running-agent": "running-agent";
+  }>;
+  waitingFor: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"user_message">;
+    turn: z.ZodNumber;
+    stepKey: z.ZodString;
+    timeoutMs: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"assistant">;
+    turn: z.ZodNumber;
+    stepKey: z.ZodString;
+  }, z.core.$strip>]>>;
+  summaries: z.ZodArray<z.ZodObject<{
+    turn: z.ZodNumber;
+    assistant: z.ZodNullable<z.ZodAny>;
+    summary: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", "events" | "trace" | "summaries", _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"GET", "/sessions/:sessionId/active", _standard_schema_spec0.StandardSchemaV1<unknown, unknown> | undefined, z.ZodArray<z.ZodType<PiActiveSessionProtocolMessage, unknown, z.core.$ZodTypeInternals<PiActiveSessionProtocolMessage, unknown>>>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING", string, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>, _fragno_dev_core0.FragnoRouteConfig<"POST", "/sessions/:sessionId/messages", z.ZodObject<{
+  text: z.ZodString;
+  done: z.ZodOptional<z.ZodBoolean>;
+  steeringMode: z.ZodOptional<z.ZodEnum<{
+    all: "all";
+    "one-at-a-time": "one-at-a-time";
+  }>>;
+}, z.core.$strip>, z.ZodObject<{
+  status: z.ZodEnum<{
+    active: "active";
+    paused: "paused";
+    errored: "errored";
+    terminated: "terminated";
+    complete: "complete";
+    waiting: "waiting";
+  }>;
+}, z.core.$strip>, "SESSION_NOT_FOUND" | "WORKFLOW_INSTANCE_MISSING" | "SESSION_NOT_READY", string, _fragno_dev_db0.DatabaseRequestContext<_fragno_dev_db0.HooksMap>>]>;
+//#endregion
+export { InferOr as $, PiToolFactoryContext as A, PiWorkflowsService as B, PiFragmentConfig as C, PiSession as D, PiPersistedToolResult as E, PiToolSideEffectReducerContext as F, PiSteeringMode as G, PiWorkflowsRegistry as H, PiToolSideEffectReducerRegistry as I, THINKING_LEVELS as J, SESSION_STATUSES as K, PiTurnSummary as L, PiToolReplayCache as M, PiToolReplayContext as N, PiSessionDetail as O, PiToolSideEffectReducer as P, FragnoClientError as Q, PiWorkflowHistoryStep as R, PiAgentRegistry as S, PiPersistedToolCallSource as T, createPiWorkflows as U, PI_WORKFLOW_NAME as V, PiSessionStatus as W, FetcherValue as X, FragnoStoreFactoryData as Y, NonGetHTTPMethod as Z, createPiSessionStore as _, PiRuntime as a, PiActiveSessionStreamItem as b, PiFragmentClientConfig as c, PiSessionStoreView as d, ExtractPathParamsOrWiden as et, CreatePiSessionStoreArgs as f, PiSessionStoreState as g, PiSessionStoreController as h, PiAgentDefinitionInput as i, PiToolRegistry as j, PiToolFactory as k, createPiFragmentClients as l, PiSessionConnectionState as m, createPiFragment as n, MaybeExtractPathParamsOrWiden as nt, createPi as o, PiLiveToolExecution as p, STEERING_MODES as q, piFragmentDefinition as r, QueryParamsHint as rt, defineAgent as s, piRoutesFactory as t, HasPathParams as tt, PiSessionStoreHookArgs as u, PI_TOOL_JOURNAL_VERSION as v, PiPersistedToolCall as w, PiAgentDefinition as x, PiActiveSessionProtocolMessage as y, PiWorkflowsInstanceStatus as z };
+//# sourceMappingURL=routes-CpL_YGWK.d.ts.map