@rafads/plugin-openapi 1.5.38

package/dist/sdk/errors.d.ts

@@ -0,0 +1,45 @@
+import { Schema } from "effect";
+import type { Option } from "effect";
+import type { AuthToolFailureCode } from "@rafads/sdk/core";
+declare const OpenApiParseError_base: Schema.Class<OpenApiParseError, Schema.TaggedStruct<"OpenApiParseError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class OpenApiParseError extends OpenApiParseError_base {
+}
+declare const OpenApiExtractionError_base: Schema.Class<OpenApiExtractionError, Schema.TaggedStruct<"OpenApiExtractionError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class OpenApiExtractionError extends OpenApiExtractionError_base {
+}
+declare const OpenApiInvocationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OpenApiInvocationError";
+} & Readonly<A>;
+export declare class OpenApiInvocationError extends OpenApiInvocationError_base<{
+    readonly message: string;
+    readonly statusCode: Option.Option<number>;
+    readonly reason?: "response_headers_timeout" | "unknown_arguments";
+    readonly cause?: unknown;
+}> {
+}
+declare const OpenApiOAuthError_base: Schema.Class<OpenApiOAuthError, Schema.TaggedStruct<"OpenApiOAuthError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class OpenApiOAuthError extends OpenApiOAuthError_base {
+}
+declare const OpenApiAuthRequiredError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "OpenApiAuthRequiredError";
+} & Readonly<A>;
+export declare class OpenApiAuthRequiredError extends OpenApiAuthRequiredError_base<{
+    readonly code: AuthToolFailureCode;
+    readonly message: string;
+    readonly owner: "org" | "user";
+    readonly integration: string;
+    readonly connection: string;
+    readonly credentialKind: "secret" | "oauth" | "upstream";
+    readonly credentialLabel?: string;
+    readonly status?: number;
+    readonly details?: unknown;
+    readonly cause?: unknown;
+}> {
+}
+export {};

package/dist/sdk/extract.d.ts

@@ -0,0 +1,157 @@
+import { Effect, Option } from "effect";
+import { OpenApiExtractionError } from "./errors";
+import type { ParsedDocument } from "./parse";
+import { type KeepPathItem, type SpecStructure } from "./split";
+import { OperationBinding, OperationParameter, OperationRequestBody, OperationResponseBody, ServerInfo } from "./types";
+/**
+ * Derive an operation's output schema from its response body. NDJSON bodies
+ * (`application/stream+json` and friends) are spec'd per LINE but returned by
+ * the invoke path as an array of parsed lines, so the advertised schema wraps
+ * the line schema in an array; otherwise describe previews promise a single
+ * object that invocations never return. Used by both the whole-tree extract
+ * and the serve path's stored-binding rebuild so the two stay in lockstep.
+ */
+export declare const outputSchemaFromResponseBody: (responseBody: OperationResponseBody) => unknown | undefined;
+export declare const buildInputSchema: (parameters: readonly OperationParameter[], requestBody: OperationRequestBody | undefined, servers: readonly ServerInfo[]) => Record<string, unknown> | undefined;
+/** Extract all operations from a bundled OpenAPI 3.x document */
+export declare const extract: (doc: ParsedDocument) => Effect.Effect<{
+    readonly version: Option.Option<string>;
+    readonly operations: readonly {
+        readonly description: Option.Option<string>;
+        readonly summary: Option.Option<string>;
+        readonly parameters: readonly {
+            readonly name: string;
+            readonly required: boolean;
+            readonly description: Option.Option<string>;
+            readonly location: "path" | "header" | "query" | "cookie";
+            readonly schema: Option.Option<unknown>;
+            readonly style: Option.Option<string>;
+            readonly explode: Option.Option<boolean>;
+            readonly allowReserved: Option.Option<boolean>;
+        }[];
+        readonly method: "post" | "options" | "get" | "delete" | "put" | "patch" | "head" | "trace";
+        readonly inputSchema: Option.Option<unknown>;
+        readonly outputSchema: Option.Option<unknown>;
+        readonly deprecated: boolean;
+        readonly toolPath: Option.Option<string>;
+        readonly servers: readonly {
+            readonly description: Option.Option<string>;
+            readonly url: string;
+            readonly variables: Option.Option<{
+                readonly [x: string]: {
+                    readonly default: string;
+                    readonly description: Option.Option<string>;
+                    readonly enum: Option.Option<readonly string[]>;
+                };
+            }>;
+        }[];
+        readonly tags: readonly string[];
+        readonly requestBody: Option.Option<{
+            readonly required: boolean;
+            readonly schema: Option.Option<unknown>;
+            readonly contentType: string;
+            readonly contents: Option.Option<readonly {
+                readonly schema: Option.Option<unknown>;
+                readonly encoding: Option.Option<{
+                    readonly [x: string]: {
+                        readonly style: Option.Option<string>;
+                        readonly contentType: Option.Option<string>;
+                        readonly explode: Option.Option<boolean>;
+                        readonly allowReserved: Option.Option<boolean>;
+                    };
+                }>;
+                readonly contentType: string;
+            }[]>;
+        }>;
+        readonly responseBody: Option.Option<{
+            readonly schema: Option.Option<unknown>;
+            readonly contentType: string;
+            readonly fileHint: Option.Option<{
+                readonly kind: "binaryResponse" | "byteField";
+                readonly encoding: Option.Option<"base64" | "base64url">;
+                readonly mimeType: Option.Option<string>;
+                readonly dataField: Option.Option<string>;
+                readonly sizeField: Option.Option<string>;
+            }>;
+        }>;
+        readonly operationId: string & import("effect/Brand").Brand<"OperationId">;
+        readonly pathTemplate: string;
+        readonly requiredScopeAlternatives?: readonly (readonly string[])[] | undefined;
+    }[];
+    readonly description: Option.Option<string>;
+    readonly title: Option.Option<string>;
+    readonly servers: readonly {
+        readonly description: Option.Option<string>;
+        readonly url: string;
+        readonly variables: Option.Option<{
+            readonly [x: string]: {
+                readonly default: string;
+                readonly description: Option.Option<string>;
+                readonly enum: Option.Option<readonly string[]>;
+            };
+        }>;
+    }[];
+}, OpenApiExtractionError, never>;
+/** One persisted invocation binding plus the tool name and description it
+ *  backs. The description is the resolved operation description / summary /
+ *  method+path fallback, persisted so the serve path needs no re-parse. */
+export interface OperationBindingChunk {
+    readonly toolName: string;
+    readonly description: string;
+    readonly binding: OperationBinding;
+}
+/**
+ * Stream invocation bindings out of a parsed document in bounded chunks,
+ * persisting each chunk via `onChunk` before building the next.
+ *
+ * This is the memory-safe compile path for huge specs (e.g. Microsoft Graph,
+ * 16.5k operations / 37MB). It differs from `extract` + `compileToolDefinitions`
+ * in two ways that keep peak memory at parse level rather than ~doubling it:
+ *
+ *   1. It never builds `hoistedDefs` or per-operation `inputSchema`/`outputSchema`
+ *      (the add path only needs invocation bindings, which carry `$ref`s, not
+ *      inlined schemas).
+ *   2. It never holds all bindings at once. Tool-path planning needs a global
+ *      view, but only of lightweight metadata (`planToolPaths`, schema-free);
+ *      the heavy per-operation bindings are built, flushed, and dropped one
+ *      chunk at a time.
+ *
+ * Bindings reference subtrees of the parsed document rather than copying them,
+ * so `onChunk` must sever those references (its storage layer JSON-serializes
+ * the binding) before the chunk is dropped. Returns the resolved tool names in
+ * sorted order, matching `compileToolDefinitions`.
+ */
+export declare const streamOperationBindings: <E, R>(doc: ParsedDocument, chunkSize: number, onChunk: (chunk: readonly OperationBindingChunk[]) => Effect.Effect<void, E, R>) => Effect.Effect<{
+    readonly toolCount: number;
+    readonly toolNames: readonly string[];
+}, OpenApiExtractionError | E, R>;
+/**
+ * Stream invocation bindings straight from a `SpecStructure` (the structural
+ * split of a large spec) without ever materializing the whole-document tree.
+ *
+ * This is the fully-streaming compile path: it never parses the spec whole.
+ * Each path-item is parsed in isolation twice (pass 1 for light tool-path
+ * planning metadata, pass 2 to build the heavy binding) and discarded, so peak
+ * memory stays near the size of a single path-item plus the raw text, even for
+ * the 37MB / 16.5k-operation Microsoft Graph spec that OOMs a whole-tree parse.
+ * Re-parsing in pass 2 (rather than holding pass-1 tree references) is the
+ * deliberate CPU-for-memory trade that keeps peak at one-path-item level.
+ *
+ * `keepPathItem`, when given, filters (and may trim) each path-item, so the same
+ * primitive serves both a full-spec compile (no filter) and a selection (e.g.
+ * the Microsoft Graph scope filter) with identical streaming guarantees. It is
+ * applied identically in both passes so the per-operation index stays aligned.
+ *
+ * Schemas are never resolved here: parameter / requestBody / response component
+ * `$ref`s resolve against the small (schema-free) components built from the
+ * structure; `#/components/schemas/X` refs stay as strings in the binding and
+ * are normalized + served from the content-addressed defs blob. Returns the
+ * resolved tool names in sorted order, matching `compileToolDefinitions`.
+ */
+export declare const streamOperationBindingsFromStructure: <E, R>(structure: SpecStructure, options: {
+    readonly chunkSize: number;
+    readonly keepPathItem?: KeepPathItem;
+}, onChunk: (chunk: readonly OperationBindingChunk[]) => Effect.Effect<void, E, R>) => Effect.Effect<{
+    readonly toolCount: number;
+    readonly toolNames: readonly string[];
+}, E, R>;

package/dist/sdk/extract.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/form-urlencoded-body.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/index.d.ts

@@ -0,0 +1,19 @@
+export { parse, resolveSpecText, fetchSpecText } from "./parse";
+export { extract, streamOperationBindingsFromStructure } from "./extract";
+export { structuralSplit, isStreamableSpec, indexSchemas, collectReferencedSchemas, parseEntry, parseHead, parseSmallComponents, type SpecStructure, type ByteRange, type KeepPathItem, } from "./split";
+export { invoke, invokeWithLayer, buildRequest, annotationsForOperation, RESPONSE_HEADERS_TIMEOUT_MS, type InvokeOptions, } from "./invoke";
+export { buildDefsJsonStreaming, checkHealthOpenApi, compileAndPersistOpenApiOperations, compileAndPersistOpenApiSpec, compileAndPersistOpenApiSpecStreaming, compileOpenApiDocument, compileOpenApiSpec, extractOpenApiUpstreamMessage, invokeOpenApiBackedTool, listHealthCheckCandidatesOpenApi, loadOpenApiSpecText, normalizeOpenApiRefs, openApiStoredOperationsFromCompiled, openApiToolDefsFromCompiled, resolveOpenApiBackedAnnotations, resolveOpenApiBackedTools, validateOpenApiBackedToolArgs, type CompiledOpenApiSpec, type OpenApiPersistResult, } from "./backing";
+export type { ParsedDocument } from "./parse";
+export { openApiPlugin, type OpenApiSpecConfig, type OpenApiConfigureInput, type OpenApiSpecInput, type OpenApiPreviewInput, type OpenApiPluginExtension, type OpenApiPluginOptions, } from "./plugin";
+export { resolveSpecFormatAdapter, type ConvertedSpec, type DerivedIdentity, type SpecFetchCredentials, type SpecFetchInput, type SpecFormatAdapter, } from "./spec-format";
+export { type OpenapiStore, type StoredOperation, makeDefaultOpenapiStore } from "./store";
+export { decodeOpenApiIntegrationConfig, renderAuthTemplate, AuthenticationSchema, OpenApiIntegrationConfigSchema, type OpenApiIntegrationConfig, type RenderedAuth, } from "./config";
+export { previewSpec, SecurityScheme, AuthStrategy, HeaderPreset, OAuth2Preset, OAuth2Flows, OAuth2AuthorizationCodeFlow, OAuth2ClientCredentialsFlow, PreviewOperation, SpecPreview, } from "./preview";
+export { DocResolver, resolveServerUrl, substituteUrlVariables, preferredContent, } from "./openapi-utils";
+export { OpenApiParseError, OpenApiExtractionError, OpenApiInvocationError, OpenApiOAuthError, OpenApiAuthRequiredError, } from "./errors";
+export { EncodingObject, ExtractedOperation, ExtractionResult, InvocationResult, MediaBinding, OperationBinding, OperationParameter, OperationRequestBody, ServerInfo, ServerVariable, OperationId, HttpMethod, ParameterLocation, TOKEN_VARIABLE, normalizeOpenApiAuthInputs, type Authentication, type AuthenticationInput, type APIKeyAuthentication, } from "./types";
+export { variable, type ApiKeyAuthTemplate } from "@rafads/sdk/http-auth";
+export { migrateOpenApiAuthConfig } from "./migrate-config";
+export { openApiOutputSchemaDataMigration, runSqliteOpenApiOutputSchemaMigration, unwrapOpenApiTransportEnvelope, } from "./output-schema-migration";
+export { openApiNdjsonOutputDataMigration, runSqliteNdjsonOutputMigration, } from "./ndjson-output-migration";
+export { openApiSpecBlobDataMigration } from "./spec-blob-migration";

package/dist/sdk/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/invoke.d.ts

@@ -0,0 +1,150 @@
+import { Effect, Layer, Option, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { OpenApiInvocationError } from "./errors";
+import { type OperationBinding } from "./types";
+export declare const STREAM_MAX_BYTES = 1000000;
+export declare const STREAM_MAX_MS = 10000;
+export declare const RESPONSE_HEADERS_TIMEOUT_MS = 110000;
+export interface StreamingResponseCaps {
+    readonly maxBytes?: number;
+    readonly maxMs?: number;
+}
+export interface InvokeOptions {
+    readonly responseHeadersTimeoutMs?: number;
+}
+export declare const collectStreamingBody: (stream: Stream.Stream<Uint8Array, unknown, never>, contentType: string | null, caps?: StreamingResponseCaps) => Effect.Effect<{
+    data: unknown;
+    headers: {
+        "x-executor-stream": string;
+        "x-executor-stream-bytes": string;
+        "x-executor-stream-duration-ms": string;
+    };
+}, unknown, never>;
+export declare const buildRequest: (operation: {
+    readonly parameters: readonly {
+        readonly name: string;
+        readonly required: boolean;
+        readonly description: Option.Option<string>;
+        readonly location: "path" | "header" | "query" | "cookie";
+        readonly schema: Option.Option<unknown>;
+        readonly style: Option.Option<string>;
+        readonly explode: Option.Option<boolean>;
+        readonly allowReserved: Option.Option<boolean>;
+    }[];
+    readonly method: "post" | "options" | "get" | "delete" | "put" | "patch" | "head" | "trace";
+    readonly requestBody: Option.Option<{
+        readonly required: boolean;
+        readonly schema: Option.Option<unknown>;
+        readonly contentType: string;
+        readonly contents: Option.Option<readonly {
+            readonly schema: Option.Option<unknown>;
+            readonly encoding: Option.Option<{
+                readonly [x: string]: {
+                    readonly style: Option.Option<string>;
+                    readonly contentType: Option.Option<string>;
+                    readonly explode: Option.Option<boolean>;
+                    readonly allowReserved: Option.Option<boolean>;
+                };
+            }>;
+            readonly contentType: string;
+        }[]>;
+    }>;
+    readonly responseBody: Option.Option<{
+        readonly schema: Option.Option<unknown>;
+        readonly contentType: string;
+        readonly fileHint: Option.Option<{
+            readonly kind: "binaryResponse" | "byteField";
+            readonly encoding: Option.Option<"base64" | "base64url">;
+            readonly mimeType: Option.Option<string>;
+            readonly dataField: Option.Option<string>;
+            readonly sizeField: Option.Option<string>;
+        }>;
+    }>;
+    readonly pathTemplate: string;
+    readonly servers?: readonly {
+        readonly description: Option.Option<string>;
+        readonly url: string;
+        readonly variables: Option.Option<{
+            readonly [x: string]: {
+                readonly default: string;
+                readonly description: Option.Option<string>;
+                readonly enum: Option.Option<readonly string[]>;
+            };
+        }>;
+    }[] | undefined;
+    readonly requiredScopeAlternatives?: readonly (readonly string[])[] | undefined;
+}, args: Record<string, unknown>, resolvedHeaders: Record<string, string>, integrationQueryParams?: Record<string, string> | undefined) => Effect.Effect<HttpClientRequest.HttpClientRequest, OpenApiInvocationError, never>;
+export declare const invoke: (operation: {
+    readonly parameters: readonly {
+        readonly name: string;
+        readonly required: boolean;
+        readonly description: Option.Option<string>;
+        readonly location: "path" | "header" | "query" | "cookie";
+        readonly schema: Option.Option<unknown>;
+        readonly style: Option.Option<string>;
+        readonly explode: Option.Option<boolean>;
+        readonly allowReserved: Option.Option<boolean>;
+    }[];
+    readonly method: "post" | "options" | "get" | "delete" | "put" | "patch" | "head" | "trace";
+    readonly requestBody: Option.Option<{
+        readonly required: boolean;
+        readonly schema: Option.Option<unknown>;
+        readonly contentType: string;
+        readonly contents: Option.Option<readonly {
+            readonly schema: Option.Option<unknown>;
+            readonly encoding: Option.Option<{
+                readonly [x: string]: {
+                    readonly style: Option.Option<string>;
+                    readonly contentType: Option.Option<string>;
+                    readonly explode: Option.Option<boolean>;
+                    readonly allowReserved: Option.Option<boolean>;
+                };
+            }>;
+            readonly contentType: string;
+        }[]>;
+    }>;
+    readonly responseBody: Option.Option<{
+        readonly schema: Option.Option<unknown>;
+        readonly contentType: string;
+        readonly fileHint: Option.Option<{
+            readonly kind: "binaryResponse" | "byteField";
+            readonly encoding: Option.Option<"base64" | "base64url">;
+            readonly mimeType: Option.Option<string>;
+            readonly dataField: Option.Option<string>;
+            readonly sizeField: Option.Option<string>;
+        }>;
+    }>;
+    readonly pathTemplate: string;
+    readonly servers?: readonly {
+        readonly description: Option.Option<string>;
+        readonly url: string;
+        readonly variables: Option.Option<{
+            readonly [x: string]: {
+                readonly default: string;
+                readonly description: Option.Option<string>;
+                readonly enum: Option.Option<readonly string[]>;
+            };
+        }>;
+    }[] | undefined;
+    readonly requiredScopeAlternatives?: readonly (readonly string[])[] | undefined;
+}, args: Record<string, unknown>, resolvedHeaders: Record<string, string>, integrationQueryParams?: Record<string, string> | undefined, options?: InvokeOptions | undefined) => Effect.Effect<{
+    readonly error: unknown;
+    readonly status: number;
+    readonly data: unknown;
+    readonly headers: {
+        readonly [x: string]: string;
+    };
+}, OpenApiInvocationError, HttpClient.HttpClient>;
+export declare const invokeWithLayer: (operation: OperationBinding, args: Record<string, unknown>, baseUrl: string, resolvedHeaders: Record<string, string>, integrationQueryParams: Record<string, string>, httpClientLayer: Layer.Layer<HttpClient.HttpClient, never, never>, options?: InvokeOptions) => Effect.Effect<{
+    readonly error: unknown;
+    readonly status: number;
+    readonly data: unknown;
+    readonly headers: {
+        readonly [x: string]: string;
+    };
+}, OpenApiInvocationError, never>;
+export declare const REQUIRE_APPROVAL: Set<string>;
+export declare const annotationsForOperation: (method: string, pathTemplate: string) => {
+    requiresApproval?: boolean;
+    approvalDescription?: string;
+};

package/dist/sdk/migrate-config.d.ts

@@ -0,0 +1,4 @@
+/** Rewrite a stored OpenAPI integration config blob into the canonical shape.
+ *  Returns the rewritten config, or `null` when no rewrite is needed (already
+ *  canonical, no auth templates, or not this plugin's shape). Idempotent. */
+export declare const migrateOpenApiAuthConfig: (config: unknown) => unknown | null;

package/dist/sdk/migrate-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/multi-scope-bearer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/multi-scope-oauth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/ndjson-output-migration.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import { DataMigrationError, type SqliteDataMigrationClient } from "@rafads/sdk/core";
+/** Stale-mark every connection whose integration has at least one stored
+ *  operation binding with an NDJSON response, so the next read rebuilds its
+ *  tool rows (with array-wrapped output schemas). Returns the number of
+ *  connections marked. Fresh databases may lack either table; nothing to
+ *  migrate. */
+export declare const runSqliteNdjsonOutputMigration: (client: SqliteDataMigrationClient) => Effect.Effect<number, DataMigrationError>;
+/** Registry entry for the boot-time data-migration ledger. */
+export declare const openApiNdjsonOutputDataMigration: {
+    name: string;
+    run: (client: SqliteDataMigrationClient) => Effect.Effect<void, DataMigrationError, never>;
+};

package/dist/sdk/ndjson-output-migration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/non-json-body.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/oauth-refresh.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/openapi-utils.d.ts

@@ -0,0 +1,65 @@
+import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+import type { ParsedDocument } from "./parse";
+import type { ServerVariable } from "./types";
+export type ParameterObject = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject;
+export type OperationObject = OpenAPIV3.OperationObject | OpenAPIV3_1.OperationObject;
+export type PathItemObject = OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject;
+export type RequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject;
+export type ResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
+export type MediaTypeObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject;
+export type ServerObject = OpenAPIV3.ServerObject | OpenAPIV3_1.ServerObject;
+export declare class DocResolver {
+    readonly doc: ParsedDocument;
+    constructor(doc: ParsedDocument);
+    /** Resolve a value that might be a $ref, returning the resolved object */
+    resolve<T>(value: T | OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject): T | null;
+    private resolvePointer;
+}
+/** Substitute `{var}` placeholders in a templated URL using a plain map. */
+export declare const substituteUrlVariables: (url: string, values: Record<string, string>) => string;
+/** Resolve a templated server URL, filling each `{var}` from `overrides` when
+ *  non-empty, otherwise the variable's spec default. URLs without placeholders
+ *  pass through unchanged. */
+export declare const resolveServerUrl: (templateUrl: string, variables: Record<string, ServerVariable> | undefined, overrides: Record<string, string>) => string;
+/**
+ * Return all declared media entries in spec order. `Object.entries` on a
+ * plain object preserves insertion order in modern engines, which matches
+ * spec declaration order as the parser produced it.
+ */
+export declare const declaredContents: (content: Record<string, MediaTypeObject> | undefined) => ReadonlyArray<{
+    mediaType: string;
+    media: MediaTypeObject;
+}>;
+/**
+ * Pick the default media type for a requestBody or response. Matches
+ * swagger-client behaviour: **first declared wins** (not JSON-first). Spec
+ * authors order content entries to signal intent (upload-heavy endpoints
+ * declare multipart first, JSON second); respecting that order avoids
+ * silently downgrading a multipart endpoint to JSON.
+ *
+ * For response bodies we still want a JSON preference because the server
+ * picks the response content type, not the client — the old `application/
+ * json` preference is preserved via `preferredResponseContent` below.
+ */
+export declare const preferredContent: (content: Record<string, MediaTypeObject> | undefined) => {
+    mediaType: string;
+    media: MediaTypeObject;
+} | undefined;
+/** Response-side content picker — still JSON-first because the server
+ *  picks the response media type, so we want to advertise a preference. */
+export declare const preferredResponseContent: (content: Record<string, MediaTypeObject> | undefined) => {
+    mediaType: string;
+    media: MediaTypeObject;
+} | undefined;
+export declare const normalizeMediaType: (mediaType: string | null | undefined) => string;
+/** Media types whose bodies are newline-delimited JSON documents. The invoke
+ *  path collects these streams and returns an ARRAY of parsed lines, so every
+ *  schema surface must describe that array: the spec convention is to declare
+ *  the schema of ONE line (e.g. Vercel's runtime-logs endpoint). */
+export declare const NDJSON_MEDIA_TYPES: ReadonlySet<string>;
+export declare const isNdjsonMediaType: (mediaType: string | null | undefined) => boolean;
+/** Wrap a per-line NDJSON response schema into the array the runtime actually
+ *  returns. The description rides into the compiled TypeScript preview as a
+ *  JSDoc comment, so agents learn the truncation and raw-text caveats where
+ *  they read the type. */
+export declare const ndjsonArrayOutputSchema: (lineSchema: unknown) => Record<string, unknown>;

package/dist/sdk/output-schema-migration.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import { DataMigrationError, type SqliteDataMigrationClient } from "@rafads/sdk/core";
+/**
+ * If `schema` is the retired transport envelope, return the payload schema
+ * to persist instead (`null` when the envelope carried an empty `{}` data
+ * schema — the new producer persists no output schema for those). Returns
+ * undefined when the schema is not an envelope and the row must be left
+ * untouched.
+ */
+export declare const unwrapOpenApiTransportEnvelope: (schema: unknown) => {
+    readonly outputSchema: unknown | null;
+} | undefined;
+/** Unwrap envelope-shaped openapi tool output schemas in a SQLite database.
+ *  Returns the number of rows rewritten. The `tool` table may not exist yet
+ *  on a fresh database — that counts as nothing to migrate. */
+export declare const runSqliteOpenApiOutputSchemaMigration: (client: SqliteDataMigrationClient) => Effect.Effect<number, DataMigrationError>;
+/** Registry entry for the boot-time data-migration ledger. */
+export declare const openApiOutputSchemaDataMigration: {
+    name: string;
+    run: (client: SqliteDataMigrationClient) => Effect.Effect<void, DataMigrationError, never>;
+};

package/dist/sdk/output-schema-migration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sdk/parse.d.ts

@@ -0,0 +1,33 @@
+import type { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
+import { Effect } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { OpenApiExtractionError, OpenApiParseError } from "./errors";
+export type ParsedDocument = OpenAPIV3.Document | OpenAPIV3_1.Document;
+export interface SpecFetchCredentials {
+    readonly headers?: Record<string, string>;
+    readonly queryParams?: Record<string, string>;
+}
+declare class OpenApiExtractionErrorFromParse extends OpenApiExtractionError {
+}
+/**
+ * Fetch an OpenAPI spec URL and return its body text. Uses the Effect
+ * HttpClient so the caller chooses the transport via layer — in Cloudflare
+ * Workers, `FetchHttpClient.layer` binds to the Workers-native `fetch`.
+ * Bounded by a 60s timeout.
+ */
+export declare const fetchSpecText: (url: string, credentials?: SpecFetchCredentials | undefined) => Effect.Effect<string, OpenApiParseError, HttpClient.HttpClient>;
+/**
+ * Resolve an input string to spec text — if it's a URL, fetch it via
+ * HttpClient; otherwise return it as-is.
+ */
+export declare const resolveSpecText: (input: string, credentials?: SpecFetchCredentials) => Effect.Effect<string, OpenApiParseError, HttpClient.HttpClient>;
+/**
+ * Parse an OpenAPI document from spec text and validate it's OpenAPI 3.x.
+ *
+ * NOTE: does NOT resolve `$ref`s. `DocResolver` + `normalizeOpenApiRefs`
+ * downstream work on refs lazily, so inlining them here would just waste
+ * memory — and for big specs (e.g. Cloudflare's API) that blows through
+ * the 128MB Cloudflare Workers memory cap.
+ */
+export declare const parse: (text: string) => Effect.Effect<ParsedDocument, OpenApiParseError | OpenApiExtractionErrorFromParse, never>;
+export {};

package/dist/sdk/parse.test.d.ts

@@ -0,0 +1 @@
+export {};