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

package/dist/browser/types-Dk856kV1.d.ts

@@ -0,0 +1,527 @@
+import { d as PiHarnessFrontendAgentMessage } from "./agent-harness-event-protocol-d6mH_9n3.js";
+import "@fragno-dev/db";
+import { AgentMessage, SessionTreeEntry } from "@earendil-works/pi-agent-core";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { AssistantMessage, ToolCall } from "@earendil-works/pi-ai";
+import { InstanceStatus } from "@fragno-dev/workflows/workflow";
+import "typebox";
+//#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
+//#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
+//#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: unknown;
+    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(): unknown;
+  /**
+   * 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: unknown): void;
+  /**
+   * Check if the body has been overridden by middleware.
+   */
+  get hasBodyOverride(): boolean;
+}
+//#endregion
+//#region ../fragno/dist/api/request-input-context.d.ts
+//#region src/api/request-input-context.d.ts
+type ValidatedInputContext<TInputSchema extends StandardSchemaV1 | undefined> = TInputSchema extends undefined ? undefined : {
+  schema: TInputSchema;
+  valid: () => Promise<TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TInputSchema> : unknown>;
+};
+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: unknown;
+    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: unknown;
+    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;
+  get request(): Request | 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(): ValidatedInputContext<TInputSchema>;
+}
+//#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
+//#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<boolean>;
+  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(): Promise<void>;
+}
+//#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;
+}
+type JsonStreamCallbackRunner = (callback: () => void | Promise<void>) => void | Promise<void>;
+type OutputContextOptions = {
+  runJsonStreamCallback?: JsonStreamCallbackRunner;
+};
+declare abstract class OutputContext<const TOutput, const TErrorCode extends string> {
+  #private;
+  constructor(options?: OutputContextOptions);
+  /**
+   * 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, options?: OutputContextOptions);
+}
+//#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;
+  /**
+   * Use this fetcher even when `window` is undefined.
+   * By default, server-side clients call route handlers directly for SSR.
+   */
+  useOnServer?: boolean;
+};
+/**
+ * Public configuration for Fragno fragments on the client side.
+ */
+interface FragnoPublicClientConfig {
+  mountRoute?: string;
+  baseUrl?: string;
+  fetcherConfig?: FetcherConfig;
+}
+//#endregion
+//#region src/pi/workflows/workflow-agent-harness.d.ts
+type PiHarnessStepResult = {
+  type: "harness-run";
+  appendedEntries: SessionTreeEntry[];
+  leafId: string | null;
+};
+type PiHarnessSessionEntryEmission = {
+  kind: "harness-session-entry";
+  entry: SessionTreeEntry;
+};
+type PiHarnessOperationStartEmission = {
+  kind: "harness-operation-start";
+  operationId: string;
+  replay: {
+    protocol: "pi-harness-operation";
+    version: 1;
+  };
+};
+type PiHarnessOperationCompleteEmission<TResult = PiHarnessStepResult> = {
+  kind: "harness-operation-complete";
+  operationId: string;
+  result: TResult;
+};
+//#endregion
+//#region src/pi/types.d.ts
+type PiWorkflowStatus = InstanceStatus["status"];
+type PiPromptInput = {
+  text: string;
+  images?: Array<{
+    type: "image";
+    data: string;
+    mimeType: string;
+  }>;
+};
+type PiCompactCommandOutcome = {
+  kind: "compact";
+  commandId: string;
+  status: "succeeded";
+} | {
+  kind: "compact";
+  commandId: string;
+  status: "rejected";
+  code: "nothing_to_compact" | "compaction_failed";
+  message: string;
+};
+type PiSessionCommandPayload = {
+  commandId: string;
+  kind: "prompt";
+  input: PiPromptInput;
+} | {
+  commandId: string;
+  kind: "skill";
+  input: {
+    name: string;
+    additionalInstructions?: string;
+  };
+} | {
+  commandId: string;
+  kind: "promptFromTemplate";
+  input: {
+    name: string;
+    args?: string[];
+  };
+} | {
+  commandId: string;
+  kind: "compact";
+  input: {
+    customInstructions?: string;
+  };
+} | {
+  commandId: string;
+  kind: "abort";
+  reason?: string;
+} | {
+  commandId: string;
+  kind: "steer";
+  input: PiPromptInput;
+} | {
+  commandId: string;
+  kind: "followUp";
+  input: PiPromptInput;
+};
+type PiAgentStateSnapshot = {
+  messages: PiHarnessFrontendAgentMessage[];
+};
+//#endregion
+export { QueryParamsHint as _, PiHarnessOperationCompleteEmission as a, FragnoPublicClientConfig as c, NonGetHTTPMethod as d, StatusCode as f, MaybeExtractPathParamsOrWiden as g, HasPathParams as h, PiWorkflowStatus as i, FragnoRouteConfig as l, ExtractPathParamsOrWiden as m, PiCompactCommandOutcome as n, PiHarnessOperationStartEmission as o, InferOr as p, PiSessionCommandPayload as r, PiHarnessSessionEntryEmission as s, PiAgentStateSnapshot as t, HTTPMethod as u };
+//# sourceMappingURL=types-Dk856kV1.d.ts.map

package/dist/browser/types-Dk856kV1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Dk856kV1.d.ts","names":[],"sources":["../../../fragno/dist/api/internal/path.d.ts","../../../fragno/dist/util/types-util.d.ts","../../../fragno/dist/api/mutable-request-state.d.ts","../../../fragno/dist/api/request-input-context.d.ts","../../../fragno/dist/http/http-status.d.ts","../../../fragno/dist/api/internal/response-stream.d.ts","../../../fragno/dist/api/request-output-context.d.ts","../../../fragno/dist/api/api.d.ts","../../../fragno/dist/api/shared-types.d.ts","../../src/pi/workflows/workflow-agent-harness.ts","../../src/pi/types.ts"],"mappings":"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"}