@classytic/arc 2.41.1 → 2.44.0

package/dist/integrations/mcp/index.mjs

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { a as defaultCrudDescription, c as mcpHandlerAdapter, d as toCallToolResult, f as toCallToolSuccess, h as resolveToolCollisions, i as fieldRulesToZod, l as permissionDeniedResult, m as createMcpServer, n as mcpPlugin, o as resolveCrudDescription, p as buildRequestContext, r as resourceToTools, s as invokeController, t as filterResourcesForMcp, u as toCallToolError } from "../../mcpPlugin-BX5PujI0.mjs";
+/*! @classytic/arc v2.44.0 | MIT | https://classytic.com */
+import { _ as resolveToolCollisions, a as toolInputShape, c as resolveCrudDescription, d as permissionDeniedResult, f as toCallToolError, g as createMcpServer, h as buildRequestContext, i as isZodTypeSchema, l as invokeController, m as toCallToolSuccess, n as mcpPlugin, o as fieldRulesToZod, p as toCallToolResult, r as resourceToTools, s as defaultCrudDescription, t as filterResourcesForMcp, u as mcpHandlerAdapter } from "../../mcpPlugin-srPc7ItN.mjs";
 //#region src/integrations/mcp/defineTool.ts
 /**
 * Define a type-safe MCP tool.
@@ -277,6 +277,9 @@ function definePrompt(name, config) {
 }
 //#endregion
 //#region src/integrations/mcp/realtimeBridge.ts
+function isPlainArgs(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 /**
 * Dispatch a batch of tool calls through the host's MCP tool registry.
 *
@@ -329,7 +332,19 @@ async function dispatchOne(def, call, ctx) {
 			response: { error: "arguments_json is not valid JSON" }
 		};
 	}
-	if (def.inputSchema) {
+	if (isZodTypeSchema(def.inputSchema)) {
+		const result = def.inputSchema.safeParse(parsedArgs);
+		if (!result.success) return {
+			id: call.id,
+			name: call.name,
+			isError: true,
+			response: {
+				error: "argument validation failed",
+				fields: result.error.issues.map((i) => `${i.path.join(".") || "input"}: ${i.message}`)
+			}
+		};
+		parsedArgs = isPlainArgs(result.data) ? result.data : {};
+	} else if (def.inputSchema) {
 		const fieldErrors = [];
 		const validated = {};
 		for (const [key, schema] of Object.entries(def.inputSchema)) {
@@ -376,4 +391,4 @@ function normalizeResult(result) {
 	return {};
 }
 //#endregion
-export { bridgeToMcp, buildMcpToolsFromBridges, buildRequestContext, createMcpAuthFromBetterAuthApiKey, createMcpServer, customGuard, defaultCrudDescription, definePrompt, defineTool, denied, dispatchRealtimeToolCall, fieldRulesToZod, filterResourcesForMcp, getOrgId, getUserId, guard, hasOrg, invokeController, isAuthenticated, isOrg, mcpHandlerAdapter, mcpPlugin, permissionDeniedResult, requireAuth, requireOrg, requireOrgId, requireRole, resolveCrudDescription, resolveToolCollisions, resourceToTools, toCallToolError, toCallToolResult, toCallToolSuccess };
+export { bridgeToMcp, buildMcpToolsFromBridges, buildRequestContext, createMcpAuthFromBetterAuthApiKey, createMcpServer, customGuard, defaultCrudDescription, definePrompt, defineTool, denied, dispatchRealtimeToolCall, fieldRulesToZod, filterResourcesForMcp, getOrgId, getUserId, guard, hasOrg, invokeController, isAuthenticated, isOrg, mcpHandlerAdapter, mcpPlugin, permissionDeniedResult, requireAuth, requireOrg, requireOrgId, requireRole, resolveCrudDescription, resolveToolCollisions, resourceToTools, toCallToolError, toCallToolResult, toCallToolSuccess, toolInputShape };

package/dist/integrations/mcp/testing.d.mts

@@ -1,10 +1,10 @@
 
-import { c as McpAuthResult, u as McpPluginOptions } from "../../types-CWQn9-IC.mjs";
-import { n as McpServerInstance } from "../../createMcpServer-CbDWkZ1T.mjs";
+import { c as McpAuthResult, u as McpPluginOptions } from "../../types-D3Ixsh00.mjs";
+import { n as McpServerInstance } from "../../createMcpServer-DSztofa9.mjs";
 import { Client } from "@modelcontextprotocol/client";
 //#region src/integrations/mcp/testing.d.ts
 /** An MCP client bound to a live loopback server, plus its teardown. */
-interface ConnectedMcpTestClient {
+export interface ConnectedMcpTestClient {
   /** The connected SDK client — full `listTools` / `callTool` / `listPrompts` surface. */
   client: Client;
   /** Closes the client and the HTTP server. Always await it. */
@@ -20,8 +20,8 @@ interface ConnectedMcpTestClient {
  * One implementation, two entry points: this for a server you built, that for
  * one built from resources.
  */
-declare function connectMcpTestClient(server: McpServerInstance | unknown): Promise<ConnectedMcpTestClient>;
-interface TestMcpClientOptions {
+export declare function connectMcpTestClient(server: McpServerInstance | unknown): Promise<ConnectedMcpTestClient>;
+export interface TestMcpClientOptions {
   /** MCP plugin options (resources, overrides, etc.) — same as mcpPlugin config */
   pluginOptions?: Pick<McpPluginOptions, "resources" | "overrides" | "expose" | "exclude" | "toolNamePrefix" | "extraTools" | "extraPrompts" | "instructions">;
   /** Auth identity for the test session */
@@ -29,7 +29,7 @@ interface TestMcpClientOptions {
   /** Server name (default: 'test-mcp') */
   serverName?: string;
 }
-interface TestMcpClient {
+export interface TestMcpClient {
   /** List all registered tools */
   listTools(): Promise<Array<{
     name: string;
@@ -68,6 +68,5 @@ interface TestMcpClient {
  * await client.close();
  * ```
  */
-declare function createTestMcpClient(options?: TestMcpClientOptions): Promise<TestMcpClient>;
-//#endregion
-export { ConnectedMcpTestClient, TestMcpClient, TestMcpClientOptions, connectMcpTestClient, createTestMcpClient };
+export declare function createTestMcpClient(options?: TestMcpClientOptions): Promise<TestMcpClient>;
+//#endregion

package/dist/integrations/mcp/testing.mjs

@@ -1,5 +1,5 @@
-/*! @classytic/arc v2.41.1 | MIT | https://classytic.com */
-import { m as createMcpServer, r as resourceToTools, t as filterResourcesForMcp } from "../../mcpPlugin-BX5PujI0.mjs";
+/*! @classytic/arc v2.44.0 | MIT | https://classytic.com */
+import { g as createMcpServer, r as resourceToTools, t as filterResourcesForMcp } from "../../mcpPlugin-srPc7ItN.mjs";
 //#region src/integrations/mcp/testing.ts
 /**
 * Serve an already-built `McpServer` on an ephemeral loopback port and connect

package/dist/integrations/streamline.d.mts

@@ -2,15 +2,11 @@
 import { FastifyPluginAsync, FastifyRequest } from "fastify";
 //#region src/integrations/streamline.d.ts
 /**
- * Start options — matches @classytic/streamline v2.3+ `StartOptions`.
- *
- * v2.3 additions:
- *   - `tenantId` — required when streamline's `multiTenant.strict: true`.
- *     Hosts should NOT accept this from the request body in untrusted
- *     contexts; use `tenantResolver` to extract from auth context instead.
- *   - `bypassTenant` — admin/cross-tenant operations. Same caveat.
+ * Start options — matches streamline's `StartOptions`. `tenantId` /
+ * `bypassTenant` must come from auth context (`tenantResolver`), never the
+ * request body.
  */
-interface WorkflowStartOptions {
+export interface WorkflowStartOptions {
   meta?: Record<string, unknown>;
   idempotencyKey?: string;
   priority?: number;
@@ -18,7 +14,7 @@ interface WorkflowStartOptions {
   bypassTenant?: boolean;
 }
 /** Minimal workflow interface — matches @classytic/streamline's createWorkflow() return */
-interface WorkflowLike {
+export interface WorkflowLike {
   definition: {
     id: string;
     name?: string;
@@ -40,6 +36,13 @@ interface WorkflowLike {
       timeout?: number;
     }): Promise<WorkflowRunLike>;
     shutdown?(): void;
+    /**
+     * Read for `compensationHandlers` only — whether a failed run will roll
+     * back, which decides if `workflow:failed` ends its stream. Absent = no saga.
+     */
+    options?: {
+      compensationHandlers?: unknown;
+    };
   };
   start(input: unknown, options?: WorkflowStartOptions): Promise<WorkflowRunLike>;
   resume(runId: string, payload?: unknown): Promise<WorkflowRunLike>;
@@ -48,7 +51,7 @@ interface WorkflowLike {
   }): Promise<WorkflowRunLike>;
   get(runId: string): Promise<WorkflowRunLike | null>;
   shutdown?(): void;
-  /** Streamline container for event bridging + repository access (streamline >=2.1) */
+  /** Streamline container for event bridging + repository access. */
   container?: {
     eventBus: {
       on(event: string, listener: (...args: unknown[]) => void): void;
@@ -58,42 +61,24 @@ interface WorkflowLike {
     repository?: {
       getAll(params: Record<string, unknown>, options?: Record<string, unknown>): Promise<unknown>;
       /**
-       * Tenant-scoped lookup by id. Used by the DELETE handler for a
-       * defense-in-depth pre-flight: streamline 2.3.3's `wf.get(runId)` /
-       * `engine.get` does NOT accept tenant options, so a cross-tenant
-       * runId can leak data through the engine path. Going through the
-       * repository here means mongokit's tenant-filter plugin scopes the
-       * read — cross-tenant requests get a clean 404 and DELETEs only
-       * touch rows the caller actually owns.
+       * Tenant-scoped lookup — the per-run ownership pre-flight. The engine's
+       * `get` takes no tenant options, so the tenant-filtered repository read
+       * is what stops cross-tenant access (clean 404).
        */
       getById?(id: string, options?: Record<string, unknown>): Promise<WorkflowRunLike | null>;
-      /**
-       * Hard-delete a run by id. Routed through mongokit's inherited
-       * `Repository.delete()` so multi-tenant scope + audit/cache plugins
-       * fire. Wired into `DELETE /:workflowId/runs/:runId` — operator
-       * escape hatch for dead-lettered or stuck rows.
-       */
+      /** Tenant-scoped hard delete, backing `DELETE /:workflowId/runs/:runId`. */
       delete?(id: string, options?: Record<string, unknown>): Promise<unknown>;
     };
     /**
-     * Streamline >= 2.3.2 — explicit deploy-time index sync (TTL on
-     * terminal runs + tenant compounds). When the host configured
-     * `createContainer({ retention })`, arc's app-level deploy hook
-     * should call `await container.syncRetentionIndexes()` after
-     * `mongoose.connect`. Optional so older streamline versions
-     * (and partial mocks) still satisfy the structural shape.
+     * Deploy-time index sync (retention TTL + tenant compounds). Hosts using
+     * `createContainer({ retention })` call it after connecting.
      */
     syncRetentionIndexes?: () => Promise<void>;
-    /**
-     * Streamline >= 2.3.2 — stop background sweepers and release timers.
-     * Arc's `onClose` hook below calls this on every workflow's container
-     * during graceful shutdown so SIGTERM doesn't leave the stale-run
-     * sweeper running. Optional + idempotent.
-     */
+    /** Stop background sweepers; called on `onClose`. Idempotent. */
     dispose?: () => void;
   };
 }
-interface WorkflowRunLike {
+export interface WorkflowRunLike {
   _id: string;
   workflowId: string;
   status: string;
@@ -107,43 +92,26 @@ interface WorkflowRunLike {
   stepLogs?: unknown[];
   createdAt?: Date;
   updatedAt?: Date;
-  /**
-   * Streamline >= 2.3.3 — pinned definition version (semver) the run
-   * started under. Hosts surfacing a "stuck on old version" UI read this
-   * to decide whether to nudge a migration. Optional for back-compat
-   * with runs created before 2.3.3.
-   */
+  /** Definition version (semver) the run started under. */
   definitionVersion?: string;
-  /**
-   * Streamline >= 2.3.3 — count of stale-recovery / sweeper transitions
-   * applied to this run. Sweeper dead-letters once this hits
-   * `RetentionOptions.maxStaleRecoveries`; UIs can highlight runs trending
-   * toward dead-letter.
-   */
+  /** Stale-recovery transitions so far; dead-lettered at `maxStaleRecoveries`. */
   recoveryAttempts?: number;
-  /**
-   * Streamline >= 2.7 — operator-supplied cancellation reason, set when
-   * `cancel(runId, { reason })` was called. Absent on runs cancelled without
-   * a reason or under older streamline. Surfaced so dashboards can show WHY.
-   */
+  /** Reason passed to `cancel(runId, { reason })`, if any. */
   cancellationReason?: string;
 }
 /**
- * Streamline >= 2.3.3 dead-letter discriminator. The run.status stays
- * `'failed'`; the discrimination is `error.code`:
+ * Dead-letter discriminator: `run.status` stays `'failed'`; `error.code` says why:
  *   - `'stale_heartbeat'` — sweeper terminated; transient crash signal.
  *   - `'dead_lettered'`   — exceeded `maxStaleRecoveries`; permanent.
  *   - `'VERSION_MISMATCH'` — engine deployed a step graph the run can't
  *     resume against; admin must rewind / migrate / cancel.
- *
- * Hosts switch on `error.code` for dashboards / alerting.
  */
-declare const STREAMLINE_FAILURE_CODES: {
+export declare const STREAMLINE_FAILURE_CODES: {
   readonly STALE_HEARTBEAT: "stale_heartbeat";
   readonly DEAD_LETTERED: "dead_lettered";
   readonly VERSION_MISMATCH: "VERSION_MISMATCH";
 };
-interface StreamlinePluginOptions {
+export interface StreamlinePluginOptions {
   /** Array of workflows created with createWorkflow() */
   workflows: WorkflowLike[];
   /** URL prefix for workflow endpoints (default: '/workflows') */
@@ -153,65 +121,35 @@ interface StreamlinePluginOptions {
   /** Connect workflow lifecycle events to Arc's event bus (default: true) */
   bridgeEvents?: boolean;
   /**
-   * Bridge the workflow's internal event bus (step + workflow lifecycle +
-   * engine telemetry) to Arc's event bus, topic-scoped as
-   * `workflow.${workflowId}.${eventName}`.
-   *
-   * Covers the full streamline 2.3 event surface:
-   *   - Step events: started, completed, failed, waiting, skipped,
-   *     retry-scheduled, compensated
-   *   - Workflow lifecycle: started, completed, failed, waiting, resumed,
-   *     cancelled, recovered, retry, compensating, paused (>= 2.7)
-   *   - Engine telemetry: engine:error, scheduler:error,
-   *     scheduler:circuit-open
-   *
-   * Subscriptions use structural `container.eventBus.on(...)` — future
-   * streamline releases can add events without breaking arc; missing
-   * events are simply never handled (no crash). Requires the workflow
-   * to expose `container.eventBus`.
-   *
-   * Disabled by default — enable for dashboards or monitoring.
+   * Bridge every {@link STREAMLINE_BUS_EVENTS} event (step, workflow
+   * lifecycle, engine telemetry) from `container.eventBus` to Arc's event bus
+   * as `workflow.${workflowId}.${eventName}`.
    * @default false
    */
   bridgeBusEvents?: boolean;
   /**
    * Enable SSE streaming endpoint: GET /:workflowId/runs/:runId/stream
    * Streams step-level + lifecycle events as Server-Sent Events for live
-   * UI updates. Auto-closes the stream on terminal workflow events
-   * (completed / failed / cancelled).
+   * UI updates. Auto-closes the stream when the run ends: completed /
+   * cancelled / compensated / compensation_failed, and failed only for a
+   * workflow with no compensation (a saga keeps streaming its rollback).
    * @default false
    */
   enableStreaming?: boolean;
   /**
-   * Enable webhook resume endpoint: POST /hooks/:token
-   *
-   * Routes incoming webhook calls through streamline's `resumeHook(token,
-   * body)` — which validates the token against the stored `hookToken` on
-   * the waiting step (fail-closed since streamline 2.3). Hosts use this
-   * for "wait for external approval / SaaS callback" patterns.
-   *
-   * Workflows MUST pass `{ hookToken: hook.token }` to `ctx.wait(...)` —
-   * streamline 2.3 rejects resume otherwise (security). The endpoint is
-   * registered at the plugin's `prefix` root, NOT scoped per workflow,
-   * because the token encodes the runId.
-   *
-   * Auth is OPTIONAL on this route by design — the token IS the
-   * authentication. If you also want to gate by user (e.g. only the
-   * inviting user can approve), set `auth: true` and a permission check.
+   * Enable `POST /hooks/:token` (at the prefix root — the token encodes the
+   * runId), routed through streamline's `resumeHook(token, body)`, which
+   * validates against the waiting step's stored `hookToken` (fail-closed).
+   * Workflows MUST pass `{ hookToken: hook.token }` to `ctx.wait(...)`.
    *
+   * The token IS the authentication; `auth` adds a user gate on top.
    * @default false
    */
   enableHookEndpoint?: boolean;
   /**
-   * Resolve the tenant id for a request — extract from auth context
-   * (JWT claim, session, header), NOT from the request body. Returning
-   * `undefined` skips tenant injection (use for non-multi-tenant routes
-   * or admin paths that pass `bypassTenant` explicitly).
-   *
-   * When set, the resolved tenantId is forwarded to every streamline
-   * call (`start`, `resume`, `cancel`, `get`, `list`, etc.) so
-   * streamline's `multiTenant.strict` mode never throws "missing
-   * tenantId" inside arc's request lifecycle.
+   * Resolve the request's tenant id from auth context — NEVER the request
+   * body. Forwarded to streamline calls, and enables the per-run tenant
+   * ownership check. `undefined` skips tenant scoping.
    *
    * @example
    * tenantResolver: (req) => req.user?.organizationId
@@ -224,63 +162,66 @@ interface StreamlinePluginOptions {
    * (`allowBypass: true`, the default).
    */
   bypassTenantResolver?: (request: FastifyRequest) => boolean;
-  /** Custom permission check for workflow operations */
+  /**
+   * Custom permission check for workflow operations. `execute` falls back to
+   * `start`, and `pause` / `rewind` to `cancel`, when not set — so restricting
+   * the broader operation also covers these.
+   */
   permissions?: {
     start?: (request: unknown) => boolean | Promise<boolean>;
     resume?: (request: unknown) => boolean | Promise<boolean>;
     cancel?: (request: unknown) => boolean | Promise<boolean>;
     list?: (request: unknown) => boolean | Promise<boolean>;
     get?: (request: unknown) => boolean | Promise<boolean>;
+    execute?: (request: unknown) => boolean | Promise<boolean>;
+    pause?: (request: unknown) => boolean | Promise<boolean>;
+    rewind?: (request: unknown) => boolean | Promise<boolean>;
+  };
+  /**
+   * Operations whose call requires an idempotency key (400 `arc.idempotency_key_required`
+   * when absent; a keyed retry replays). `workflows` narrows it to those ids (default: all).
+   * On `start` the header key IS the run's `idempotencyKey`; a different body key is refused.
+   * Needs `idempotencyPlugin` enabled.
+   */
+  idempotency?: {
+    readonly required: readonly ("start" | "execute" | "resume" | "rewind")[];
+    readonly workflows?: readonly string[];
   };
 }
 /**
- * Full event list published on a streamline workflow's internal `eventBus`
- * (tracks streamline 2.3's `EventPayloadMap` in
- * `@classytic/streamline/src/core/events.ts`).
- *
- * Hardcoded here by design — arc subscribes via structural
- * `eventBus.on(name, handler)`, which is a no-op for events the running
- * streamline version doesn't emit. New events a future streamline release
- * adds can be bridged by updating this list; arc never breaks just
- * because streamline extended its bus.
+ * Events published on a streamline workflow's internal `eventBus`. Subscribing
+ * to one the running version doesn't emit is a no-op. Pinned against
+ * streamline's `ALL_WORKFLOW_EVENT_NAMES` by `tests/integrations/streamline-drift.test.ts`.
  */
-declare const STREAMLINE_BUS_EVENTS: readonly ["step:started", "step:completed", "step:failed", "step:waiting", "step:skipped", "step:retry-scheduled", "step:compensated", "workflow:started", "workflow:completed", "workflow:failed", "workflow:waiting", "workflow:resumed", "workflow:cancelled", "workflow:recovered", "workflow:retry", "workflow:compensating", "workflow:paused", "engine:error", "scheduler:error", "scheduler:circuit-open"];
+export declare const STREAMLINE_BUS_EVENTS: readonly ["step:started", "step:completed", "step:failed", "step:waiting", "step:skipped", "step:retry-scheduled", "step:compensated", "workflow:started", "workflow:completed", "workflow:failed", "workflow:waiting", "workflow:resumed", "workflow:cancelled", "workflow:recovered", "workflow:retry", "workflow:compensating", "workflow:paused", "workflow:compensated", "workflow:compensation_failed", "engine:error", "scheduler:error", "scheduler:circuit-open"];
 /**
- * Non-durable streaming frames from streamline >= 2.6's `ctx.stream(frame)`
- * (LLM tokens, percent-complete, live previews).
- *
- * Delivered on the SSE endpoint ONLY — deliberately excluded from
- * `STREAMLINE_BUS_EVENTS` / `bridgeBusEvents` because frames are
- * high-frequency, at-most-once UI traffic, not domain events: republishing
- * every token onto arc's Redis/Kafka transport would flood it. Subscribers
- * that genuinely want frames on the transport can bridge
- * `streamline:step.stream` from streamline's own arc-shape transport.
+ * Non-durable `ctx.stream(frame)` frames (LLM tokens, progress). SSE ONLY —
+ * excluded from `bridgeBusEvents` because high-frequency at-most-once UI
+ * traffic would flood arc's event transport.
+ */
+export declare const STREAMLINE_STREAM_EVENTS: readonly ["step:stream"];
+/**
+ * Workflow events that end a run and auto-close an SSE stream.
  *
- * On streamline < 2.6 the subscription is a structural no-op (the bus never
- * emits the event) — no version gate needed.
+ * `workflow:failed` is terminal ONLY without compensation handlers: a saga
+ * emits `failed` THEN rolls back, so closing there would hide the rollback.
+ * See {@link isStreamTerminal}.
  */
-declare const STREAMLINE_STREAM_EVENTS: readonly ["step:stream"];
+export declare const STREAMLINE_TERMINAL_EVENTS: readonly ["workflow:completed", "workflow:failed", "workflow:cancelled", "workflow:compensated", "workflow:compensation_failed"];
 /**
- * Workflow events that should auto-close an SSE stream when observed.
- * Recovered / waiting / resumed / retry / compensating are NOT terminal —
- * the run is still active after them.
+ * Terminal run STATUSES (vs. the event names above). A run in one emits no
+ * further events, so SSE sends its snapshot and closes. Pinned against
+ * streamline's own list by `tests/integrations/streamline-drift.test.ts`.
  */
-declare const STREAMLINE_TERMINAL_EVENTS: readonly ["workflow:completed", "workflow:failed", "workflow:cancelled"];
+export declare const TERMINAL_RUN_STATUSES: Set<string>;
 /**
- * Terminal run STATUSES (distinct from the terminal EVENT names above).
- * Mirrors streamline's `isTerminalState()` — a run in one of these will
- * emit no further bus events, so the SSE handler sends its snapshot and
- * closes immediately rather than holding a connection open on a dead run.
+ * Whether a run has ended, for the purpose of closing its stream — by event
+ * name or by status. `failed` ends a run only when nothing will compensate it.
  */
-declare const TERMINAL_RUN_STATUSES: Set<string>;
+export declare function isStreamTerminal(eventOrStatus: string, compensates: boolean, kind: "event" | "status"): boolean;
 /**
- * Pluggable streamline integration for Arc.
- *
- * Wrapped in `fastify-plugin` so Fastify treats `options.prefix` as a
- * plain plugin option (NOT an encapsulation prefix). Without the wrapper,
- * Fastify would prepend `options.prefix` to every route, then the plugin
- * code would prepend it again — the duplicate-prefix bug.
+ * Streamline integration for Arc. Wrapped in `fastify-plugin` so `prefix` is
+ * a plain option, not an encapsulation prefix (which would apply it twice).
  */
-declare const streamlinePlugin: FastifyPluginAsync<StreamlinePluginOptions>;
-//#endregion
-export { STREAMLINE_BUS_EVENTS, STREAMLINE_FAILURE_CODES, STREAMLINE_STREAM_EVENTS, STREAMLINE_TERMINAL_EVENTS, StreamlinePluginOptions, TERMINAL_RUN_STATUSES, WorkflowLike, WorkflowRunLike, WorkflowStartOptions, streamlinePlugin };
+export declare const streamlinePlugin: FastifyPluginAsync<StreamlinePluginOptions>;
+//#endregion