@hachej/boring-agent 0.1.111 → 0.2.1

package/dist/piChatSessionService-CBct-hmz.d.ts

@@ -1,86 +0,0 @@
-import { P as PromptPayload, a as SessionListOptions, b as SessionSummary, C as ChatModelSelection, O as OriginChannel, c as PiChatSnapshot, d as PiChatEvent, e as PromptReceipt, F as FollowUpPayload, f as FollowUpReceipt, Q as QueueClearPayload, g as QueueClearReceipt, I as InterruptPayload, h as CommandReceipt, i as StopPayload, j as StopReceipt } from './piChatEvent-DpE0lIb9.js';
-
-/** Server-only prompt admission selector; browser schemas never accept requireIdle. */
-type AgentPromptPayload = PromptPayload & {
-    readonly requireIdle?: true;
-};
-
-interface PiChatAttachmentResult {
-    data: Uint8Array;
-    mediaType: string;
-    filename?: string;
-}
-
-interface PiSessionRequestContext {
-    workspaceId?: string;
-    storageScope?: string;
-    authSubject?: string;
-    authEmail?: string;
-    authEmailVerified?: boolean;
-    /** Addressed Gateway binds sessions to the verified workspace/storage scope. */
-    sessionAuthority?: 'workspace-scope';
-    requestId: string;
-}
-interface PiSessionCreateInit {
-    title?: string;
-    modelDefault?: ChatModelSelection;
-    originChannel?: OriginChannel;
-}
-type PiChatReplayRangeError = {
-    type: 'replay_gap';
-    latestSeq: number;
-    minReplaySeq: number;
-} | {
-    type: 'cursor_ahead';
-    latestSeq: number;
-    minReplaySeq: number;
-};
-interface PiChatEventStreamSubscription {
-    type: 'ok';
-    unsubscribe: () => void;
-    /** Optional test/service completion hook. Real live streams normally omit it. */
-    closed?: Promise<void>;
-}
-type PiChatEventStreamResult = PiChatEventStreamSubscription | PiChatReplayRangeError;
-type PiChatEventSubscriber = (event: PiChatEvent) => void;
-interface PiChatSessionService {
-    listSessions?(ctx: PiSessionRequestContext, options?: SessionListOptions): Promise<SessionSummary[]>;
-    createSession?(ctx: PiSessionRequestContext, init?: PiSessionCreateInit): Promise<SessionSummary>;
-    deleteSession?(ctx: PiSessionRequestContext, sessionId: string): Promise<void>;
-    readAttachment?(ctx: PiSessionRequestContext, sessionId: string, messageId: string, index: number): Promise<PiChatAttachmentResult>;
-    readState(ctx: PiSessionRequestContext, sessionId: string): Promise<PiChatSnapshot>;
-    subscribe(ctx: PiSessionRequestContext, sessionId: string, cursor: number, subscriber: PiChatEventSubscriber): Promise<PiChatEventStreamResult>;
-    prompt(ctx: PiSessionRequestContext, sessionId: string, payload: AgentPromptPayload): Promise<PromptReceipt>;
-    followUp(ctx: PiSessionRequestContext, sessionId: string, payload: FollowUpPayload): Promise<FollowUpReceipt>;
-    clearQueue(ctx: PiSessionRequestContext, sessionId: string, payload: QueueClearPayload): Promise<QueueClearReceipt>;
-    interrupt(ctx: PiSessionRequestContext, sessionId: string, payload: InterruptPayload): Promise<CommandReceipt>;
-    stop(ctx: PiSessionRequestContext, sessionId: string, payload: StopPayload): Promise<StopReceipt>;
-}
-interface AgentCoreSessionService extends PiChatSessionService {
-    /** Trusted host-only durable-tail resolver; never exposed as an HTTP route. */
-    resolveSessionStreamPath?(ctx: PiSessionRequestContext, sessionId: string): Promise<string>;
-    /** Trusted host-only validation/binding seam; never exposed as an HTTP route. */
-    ensurePiSessionBound?(ctx: PiSessionRequestContext, sessionId: string): Promise<void>;
-    createSession(ctx: PiSessionRequestContext, init?: PiSessionCreateInit): Promise<SessionSummary>;
-    deleteSession(ctx: PiSessionRequestContext, sessionId: string): Promise<void>;
-    dispose?(): Promise<void>;
-}
-type AgentEffectAdmission = (ctx: Pick<PiSessionRequestContext, 'workspaceId' | 'requestId'>) => Promise<void>;
-declare class AgentEffectAdmissionError extends Error {
-    readonly code: string;
-    readonly details?: unknown | undefined;
-    readonly statusCode = 500;
-    constructor(code: string, details?: unknown | undefined);
-}
-declare const AGENT_EFFECT_METHODS: {
-    readonly createSession: true;
-    readonly deleteSession: true;
-    readonly prompt: true;
-    readonly followUp: true;
-    readonly clearQueue: true;
-    readonly interrupt: true;
-    readonly stop: true;
-};
-declare function withAgentEffectAdmission(service: AgentCoreSessionService, admit: AgentEffectAdmission): AgentCoreSessionService;
-
-export { type AgentCoreSessionService as A, type PiChatEventStreamResult as P, type AgentEffectAdmission as a, AGENT_EFFECT_METHODS as b, AgentEffectAdmissionError as c, type PiChatEventStreamSubscription as d, type PiChatEventSubscriber as e, type PiChatReplayRangeError as f, type PiChatSessionService as g, type PiSessionCreateInit as h, type PiSessionRequestContext as i, type AgentPromptPayload as j, type PiChatAttachmentResult as k, withAgentEffectAdmission as w };

package/dist/sandbox-BMhut3kh.d.ts

@@ -1,317 +0,0 @@
-interface WorkspaceRuntimeContext {
-    /** Agent-visible working directory shared by file-tree and shell execution. */
-    readonly runtimeCwd: string;
-}
-
-type RuntimeFilesystemCapability = 'read' | 'write' | 'create-child' | 'delete' | 'move-from';
-declare const READONLY_FILESYSTEM_MUTATION_CODE: "readonly";
-declare const RUNTIME_FILESYSTEM_CAPABILITIES: readonly ["read", "write", "create-child", "delete", "move-from"];
-declare class ReadonlyFilesystemMutationError extends Error {
-    readonly code: "readonly";
-    readonly statusCode: 403;
-    readonly filesystem: string;
-    readonly operation: RuntimeFilesystemCapability;
-    constructor(filesystem: string, operation: RuntimeFilesystemCapability);
-}
-declare function isReadonlyFilesystemMutationError(value: unknown): value is ReadonlyFilesystemMutationError;
-interface Workspace {
-    /** Agent-visible workspace root; must match runtimeContext.runtimeCwd. */
-    readonly root: string;
-    readonly runtimeContext: WorkspaceRuntimeContext;
-    readFile(relPath: string): Promise<string>;
-    /** Optional binary read operation for media/document previews. */
-    readBinaryFile?(relPath: string): Promise<Uint8Array>;
-    writeFile(relPath: string, data: string): Promise<void>;
-    /**
-     * Optional binary write operation for user-uploaded assets. Shared callers use
-     * Uint8Array so browser-safe workspace contracts do not depend on Node-only types.
-     */
-    writeBinaryFile?(relPath: string, data: Uint8Array): Promise<void>;
-    /**
-     * Atomically creates a binary file without overwriting an existing path.
-     * Implementations must throw an error with code EEXIST on collision.
-     */
-    createBinaryFile?(relPath: string, data: Uint8Array): Promise<void>;
-    /**
-     * Optional optimized read+metadata operation. Remote workspaces should
-     * implement this as one round trip when possible.
-     */
-    readFileWithStat?(relPath: string): Promise<{
-        content: string;
-        stat: Stat;
-    }>;
-    /**
-     * Optional optimized write+metadata operation. Remote workspaces should
-     * implement this as one round trip when possible.
-     */
-    writeFileWithStat?(relPath: string, data: string): Promise<Stat>;
-    /** Optional optimized binary write+metadata operation. */
-    writeBinaryFileWithStat?(relPath: string, data: Uint8Array): Promise<Stat>;
-    unlink(relPath: string): Promise<void>;
-    readdir(relPath: string): Promise<Entry[]>;
-    stat(relPath: string): Promise<Stat>;
-    mkdir(relPath: string, opts?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    rename(fromRelPath: string, toRelPath: string): Promise<void>;
-    /**
-     * Optional change-event channel. Implementations that can observe
-     * out-of-band file changes (e.g. local fs via chokidar, or an
-     * in-process EventEmitter for sandbox-driven tool writes) return a
-     * watcher; implementations that can't observe changes (and don't
-     * want to fake it via polling) omit this method or leave it
-     * undefined.
-     *
-     * Frontends should always assume the method may be missing and
-     * degrade to "rely on tool-reported events + window-focus refetch."
-     * Calling `watch()` more than once on a single workspace must yield
-     * watchers that share the same underlying observation source —
-     * spawning N OS-level watchers per HTTP connection is not allowed.
-     */
-    watch?(): WorkspaceWatcher;
-    /**
-     * Optional control-event channel for out-of-band changes.
-     *
-     * The primary `watch()` subscription is for fine-grained file
-     * events. This is a secondary channel for coarse-grained external
-     * events that should trigger a client-side resync — e.g. a bash
-     * tool that mutates many files, or a git pull that swaps many refs.
-     *
-     * Implementations that can't observe changes (and don't
-     * want to fake it via polling) omit this method or leave it
-     * undefined.
-     */
-    notifyExternalChange?(event: WorkspaceWatchControlEvent): void;
-    /**
-     * Capability hint for hosts that want to render a UI affordance
-     * ("connected"/"polling"/"manual refresh"). Optional — absence
-     * means "treat as 'none' and consult `watch?` for the truth." When
-     * present this is purely advisory; the actual events flow through
-     * `watch()`.
-     */
-    readonly fsCapability?: FsCapability;
-}
-type FsCapability = 'none' | 'best-effort' | 'strong';
-interface Entry {
-    name: string;
-    kind: 'file' | 'dir';
-}
-interface Stat {
-    size: number;
-    mtimeMs: number;
-    kind: 'file' | 'dir';
-}
-/**
- * Single fs-event payload. `op` is the canonical mutation kind, the
- * paths are workspace-relative, and `mtimeMs` is filled when the
- * implementation can stat the result cheaply (lets the client run an
- * idempotent staleness check without a follow-up stat request).
- */
-interface WorkspaceChangeEvent {
-    op: 'write' | 'unlink' | 'rename' | 'mkdir';
-    path: string;
-    /** Set on rename only — the path before the move. */
-    oldPath?: string;
-    mtimeMs?: number;
-}
-/**
- * Result of a watcher's readiness probe. `ok: false` means the
- * implementation decided it cannot observe this workspace (e.g. the
- * tree is too large to watch without harming the host process) —
- * hosts should tell clients to fall back rather than wait for events
- * that will never come.
- */
-type WorkspaceWatcherReadiness = {
-    ok: true;
-} | {
-    ok: false;
-    reason: string;
-    message?: string;
-};
-interface WorkspaceWatchControlEvent {
-    type: 'resync-required';
-    reason: string;
-}
-interface WorkspaceWatchSubscribeOptions {
-    /**
-     * Called when the watcher detects a gap where changes may have been
-     * missed. Consumers should drop caches/refetch instead of trusting
-     * incremental events alone.
-     */
-    onControlEvent?: (event: WorkspaceWatchControlEvent) => void;
-}
-interface WorkspaceWatcher {
-    /**
-     * Add a listener for change events. Returns an unsubscribe fn —
-     * the underlying observation source stays open until the workspace
-     * itself is disposed, so unsubscribing one listener is cheap and
-     * does NOT tear down the watcher.
-     */
-    subscribe(listener: (event: WorkspaceChangeEvent) => void, options?: WorkspaceWatchSubscribeOptions): () => void;
-    /**
-     * Optional readiness probe. Implementations with a startup guard
-     * (workspace-size check, native module availability, …) resolve it
-     * once the underlying source is observing — or with `ok: false`
-     * when observation was refused. Absent → assume always ready.
-     */
-    whenReady?(): Promise<WorkspaceWatcherReadiness>;
-    /**
-     * Tear down the underlying observation source (chokidar instance,
-     * sandbox emitter binding, …). Idempotent. Subscribers added after
-     * close are no-ops. Hosts call this on workspace disposal.
-     */
-    close(): void;
-}
-
-/**
- * Capabilities a sandbox advertises. Consumers use this set to decide
- * whether a tool can run (e.g. `executeIsolatedCodeTool` only registers
- * when `'isolated-code'` is present). Backends opt in by including the
- * capability string in their `Sandbox.capabilities` array.
- *
- * Open string union — backends and downstream packages can extend it
- * without modifying this file (TypeScript declaration-merging or just
- * casting). New capabilities to expect over time:
- *   - `'gpu'`           — backend can attach GPUs to isolated-code calls
- *   - `'persistent-fs'` — backend retains workspace state across sessions
- *   - `'snapshot'`      — backend supports baking + restoring snapshots
- *   - `'network-allow'` — backend can apply egress allow/deny lists
- */
-type SandboxCapability = 'exec' | 'isolated-code' | (string & {});
-/**
- * Where the sandbox actually executes — relative to the agent backend
- * process running pi.
- *
- * - `'server'` — same process / same host as the agent backend (e.g.
- *   `DirectSandbox`, `BwrapSandbox`).
- * - `'remote'` — a separate machine reached over the network (e.g.
- *   `VercelSandboxExec` Firecracker VM, SSH, Modal, Docker host
- *   accessed by API). Implementations must tolerate higher latency and
- *   handle abort by signalling the remote.
- * - `'browser'` — runs in the user's browser (e.g. WASM bash,
- *   `JustBashSandbox`). Reserved for future browser-agent mode.
- */
-type SandboxPlacement = 'server' | 'remote' | 'browser';
-interface Sandbox {
-    /** Stable identifier for this sandbox instance. */
-    readonly id: string;
-    /** Where the sandbox runs relative to the agent backend. */
-    readonly placement: SandboxPlacement;
-    /**
-     * Provider name — e.g. `'direct'`, `'bwrap'`, `'vercel-sandbox'`,
-     * `'docker'`, `'modal'`, `'apple-container'`, `'ssh'`. Used for
-     * telemetry, diagnostics, and capability negotiation. Free-form
-     * convention: matches the runtime mode id where one exists.
-     */
-    readonly provider: string;
-    /** Capabilities this sandbox advertises (used for tool gating). */
-    readonly capabilities: readonly SandboxCapability[];
-    /** Agent-visible runtime cwd; must match the paired Workspace root. */
-    readonly runtimeContext: WorkspaceRuntimeContext;
-    /**
-     * Optional initialization hook. Some backends bind to a workspace +
-     * session at construction (Vercel: snapshot warm-up; Bwrap: bind
-     * mounts). Ephemeral backends (Direct, on-demand Docker exec) can
-     * omit this entirely.
-     */
-    init?(ctx: {
-        workspace: Workspace;
-        sessionId: string;
-    }): Promise<void>;
-    /**
-     * Run a shell command. Required capability: `'exec'`.
-     *
-     * Implementations MUST honor `signal` for abort, `timeoutMs` for
-     * timeout, and `maxOutputBytes` for output truncation (and set
-     * `truncated: true` in the result when truncation fires).
-     *
-     * The optional `onStdout` / `onStderr` callbacks (when implemented)
-     * stream output incrementally as bytes arrive. When omitted,
-     * implementations buffer normally and surface output via
-     * `ExecResult.stdout` / `stderr` only. See the `Sandbox.exec` streaming
-     * extension added in Phase 1.0.
-     */
-    exec(cmd: string, opts?: ExecOptions): Promise<ExecResult>;
-    /**
-     * Run a self-contained snippet of code in an ephemeral sandbox
-     * instance. Capability: `'isolated-code'`. Optional — backends that
-     * cannot offer per-call isolation (`DirectSandbox`, `BwrapSandbox`)
-     * omit this method entirely.
-     */
-    executeIsolatedCode?(input: IsolatedCodeInput): Promise<IsolatedCodeOutput>;
-    dispose?(): Promise<void>;
-}
-interface ExecOptions {
-    /** Runtime-visible cwd. Relative paths resolve from `runtimeContext.runtimeCwd`. */
-    cwd?: string;
-    env?: Record<string, string>;
-    signal?: AbortSignal;
-    timeoutMs?: number;
-    maxOutputBytes?: number;
-    onHeartbeat?: (elapsedMs: number) => void;
-    onStdout?: (chunk: Uint8Array) => void;
-    onStderr?: (chunk: Uint8Array) => void;
-}
-interface ExecResult {
-    stdout: Uint8Array;
-    stderr: Uint8Array;
-    exitCode: number;
-    durationMs: number;
-    truncated: boolean;
-    stdoutEncoding?: 'utf-8' | 'binary';
-    stderrEncoding?: 'utf-8' | 'binary';
-}
-/**
- * Abstract resource hints for `executeIsolatedCode`. Backends round to
- * their own size tiers (Vercel: `xxs`/…/`l`; Modal: `cpu`/`memory`
- * floats; Docker: cgroups). Each field is a HINT, not a contract — a
- * backend may ignore or clamp values it cannot honor.
- */
-interface SandboxResources {
-    /** Requested logical CPU cores. Backend rounds up. */
-    cpuCores?: number;
-    /** Requested memory in MB. Backend rounds up. */
-    memoryMb?: number;
-    /**
-     * GPU class hint. Free-form vendor-specific token (e.g. `'t4'`,
-     * `'a10g'`, `'h100'`). Empty/omitted means CPU-only. Only honored
-     * when the sandbox advertises capability `'gpu'`.
-     */
-    gpu?: string;
-}
-interface IsolatedCodeInput {
-    code: string;
-    language: 'python' | 'shell';
-    /**
-     * Container / snapshot identifier. Format is vendor-specific:
-     * Docker → image ref (`node:20`), Vercel → `snapshotId`, Modal →
-     * image name, Apple-container → bundle path. Treat as opaque.
-     */
-    image?: string;
-    /**
-     * Per-call dependencies (npm/pip-style). Honored by backends that
-     * build environments on demand (Modal, Vercel snapshot-bake).
-     * Ignored by backends that require pre-built images (vanilla Docker
-     * exec).
-     */
-    packages?: string[];
-    /** Reuse an existing sandbox handle if the backend supports it. */
-    sandboxId?: string;
-    /** Generic resource request. Backends round to their own size tiers. */
-    resources?: SandboxResources;
-    /**
-     * Backend-specific knobs that don't fit the generic shape — opaque
-     * pass-through. Example: Modal's `min_containers`, Docker's
-     * `--cap-add`, Vercel's `region`. Consumers should never read this
-     * field; it exists so callers can target a specific provider.
-     */
-    vendorHints?: Record<string, unknown>;
-}
-interface IsolatedCodeOutput {
-    sandboxId: string;
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-
-export { type Entry as E, type IsolatedCodeInput as I, READONLY_FILESYSTEM_MUTATION_CODE as R, type Stat as S, type WorkspaceChangeEvent as W, type ExecResult as a, type Workspace as b, type Sandbox as c, type ExecOptions as d, type IsolatedCodeOutput as e, RUNTIME_FILESYSTEM_CAPABILITIES as f, ReadonlyFilesystemMutationError as g, type RuntimeFilesystemCapability as h, type SandboxCapability as i, type WorkspaceRuntimeContext as j, type WorkspaceWatchControlEvent as k, isReadonlyFilesystemMutationError as l };

package/dist/server/agent-host/testing/compositionRouteProof.d.ts

@@ -1,8 +0,0 @@
-import { FastifyInstance } from 'fastify';
-
-/** Executable final route-table proof shared by every composition root. */
-declare function assertComposedAgentHostRouteTable(app: FastifyInstance, options?: {
-    readonly testOnlyAllowed?: readonly string[];
-}): void;
-
-export { assertComposedAgentHostRouteTable };

package/dist/server/agent-host/testing/compositionRouteProof.js

@@ -1,78 +0,0 @@
-// src/server/agent-host/testing/compositionRouteProof.ts
-var EXPECTED_ROUTES_ENV = "BORING_AGENTHOST_EXPECTED_ROUTES";
-var FALLBACK_EXPECTED_ROUTES = [
-  "GET /api/v1/agents",
-  "GET /api/v1/agents/:agentTypeId/sessions",
-  "POST /api/v1/agents/:agentTypeId/sessions/summaries",
-  "POST /api/v1/agents/:agentTypeId/sessions",
-  "DELETE /api/v1/agents/:agentTypeId/sessions/:sessionId",
-  "GET /api/v1/agents/:agentTypeId/sessions/:sessionId/state",
-  "GET /api/v1/agents/:agentTypeId/sessions/:sessionId/events",
-  "POST /api/v1/agents/:agentTypeId/sessions/:sessionId/rename",
-  "POST /api/v1/agents/:agentTypeId/sessions/:sessionId/prompt",
-  "POST /api/v1/agents/:agentTypeId/sessions/:sessionId/followup",
-  "POST /api/v1/agents/:agentTypeId/sessions/:sessionId/queue/clear",
-  "POST /api/v1/agents/:agentTypeId/sessions/:sessionId/interrupt",
-  "POST /api/v1/agents/:agentTypeId/sessions/:sessionId/stop",
-  "GET /api/v1/agents/:agentTypeId/sessions/:sessionId/attachments/:messageId/:index",
-  "POST /api/v1/agents/:agentTypeId/reload",
-  "GET /api/v1/agents/:agentTypeId/skills",
-  "GET /api/v1/agents/:agentTypeId/commands",
-  "POST /api/v1/agents/:agentTypeId/commands/execute",
-  "GET /api/v1/agents/:agentTypeId/models",
-  "GET /api/v1/agents/:agentTypeId/sessions/:sessionId/system-prompt",
-  "GET /api/v1/agents/:agentTypeId/tools",
-  "GET /api/v1/agents/:agentTypeId/describe",
-  "GET /api/v1/agents/:agentTypeId/sessions/:sessionId/changes",
-  "GET /api/v1/agents/:agentTypeId/ready-status"
-];
-function configuredContract() {
-  const encoded = process.env[EXPECTED_ROUTES_ENV];
-  if (!encoded) return { required: FALLBACK_EXPECTED_ROUTES, allowed: FALLBACK_EXPECTED_ROUTES, classified: FALLBACK_EXPECTED_ROUTES };
-  const parsed = JSON.parse(encoded);
-  if (!Array.isArray(parsed.required) || !Array.isArray(parsed.allowed) || !Array.isArray(parsed.classified)) {
-    throw new Error("invalid Agent Host route proof contract");
-  }
-  return parsed;
-}
-function composedMatrixRoutes(app, classified) {
-  const routes = /* @__PURE__ */ new Map();
-  const parentPaths = [];
-  for (const line of app.printRoutes({ commonPrefix: false }).split("\n")) {
-    const match = line.match(/^((?:│   |    )*)[├└]── (\/\S+) \(([^)]+)\)$/);
-    if (!match) continue;
-    const depth = match[1].length / 4;
-    const path = depth === 0 ? match[2] : `${parentPaths[depth - 1]}${match[2]}`;
-    parentPaths[depth] = path;
-    parentPaths.length = depth + 1;
-    for (const method of match[3].split(",").map((value) => value.trim())) {
-      if (method === "HEAD") continue;
-      const contract = `${method} ${path}`;
-      if (!classified.has(contract)) continue;
-      routes.set(contract, (routes.get(contract) ?? 0) + 1);
-    }
-  }
-  return routes;
-}
-function assertComposedAgentHostRouteTable(app, options = {}) {
-  const expected = configuredContract();
-  if (expected.required.length === 0) throw new Error("expected Agent Host route table is empty");
-  const observed = composedMatrixRoutes(app, new Set(expected.classified));
-  const allowed = /* @__PURE__ */ new Set([...expected.allowed, ...options.testOnlyAllowed ?? []]);
-  for (const contract of expected.required) {
-    const count = observed.get(contract) ?? 0;
-    if (count !== 1) throw new Error(
-      `composed Agent Host route multiplicity is ${count}, expected 1: ${contract}
-${app.printRoutes({ commonPrefix: false })}`
-    );
-  }
-  for (const [contract, count] of observed) {
-    if (!allowed.has(contract)) {
-      throw new Error(`matrix route is composed but not applicable to this root: ${contract}`);
-    }
-    if (count !== 1) throw new Error(`duplicate Agent route is composed (${count}): ${contract}`);
-  }
-}
-export {
-  assertComposedAgentHostRouteTable
-};

package/dist/server/agent-host/testing/gatewayConformance.d.ts

@@ -1,43 +0,0 @@
-import { A as AgentGateway, a as AuthorizedAgentScope, b as AgentSessionRef, c as AgentSessionActivity } from '../../../admin-DORVQfLn.js';
-import { A as AgentGatewayEffect } from '../../../types-DcWoQMn8.js';
-import '../../../piChatEvent-DpE0lIb9.js';
-import 'zod';
-import '../../../harness-qHlMJhZo.js';
-import '@mariozechner/pi-coding-agent';
-import 'fastify';
-import '../../../file-search-BUgMSKZE.js';
-import '../../../sandbox-BMhut3kh.js';
-import '@hachej/boring-bash/agent';
-import '@hachej/boring-sandbox/providers/bwrap';
-import '@hachej/boring-sandbox/providers/node-workspace';
-import '@earendil-works/pi-ai';
-
-/** G1 ships only the embedded bounded-replay contract. */
-type GatewayReplayConformanceLevel = 'B';
-/** G1 ships only mutation-best-effort keyset pagination. */
-type GatewayPaginationConformanceLevel = 'keyset';
-interface GatewayConformanceFixture {
-    readonly gateway: AgentGateway;
-    issueScope(input?: {
-        readonly workspaceScopeId?: string;
-        readonly authSubjectId?: string;
-        readonly issuer?: 'primary' | 'foreign';
-    }): AuthorizedAgentScope;
-    revoke(scope: AuthorizedAgentScope): void;
-    setActivity(ref: AgentSessionRef, activity: AgentSessionActivity): void;
-    moveSession(ref: AgentSessionRef, updatedAt: number): void;
-    queueAdmission(operation: AgentGatewayEffect, disposition: 'strong-reject' | 'retryable'): void;
-}
-interface GatewayConformanceOptions {
-    readonly createFixture: () => Promise<GatewayConformanceFixture>;
-    readonly replayLevel: GatewayReplayConformanceLevel;
-    readonly paginationLevel: GatewayPaginationConformanceLevel;
-}
-/**
- * Registers the placement-independent Gateway semantic contract against any
- * implementation. Pagination capability is intentionally independent of the
- * replay durability level.
- */
-declare function gatewayConformance(options: GatewayConformanceOptions): void;
-
-export { type GatewayConformanceFixture, type GatewayConformanceOptions, type GatewayPaginationConformanceLevel, type GatewayReplayConformanceLevel, gatewayConformance };