@apifuse/provider-sdk 2.1.0-beta.5 → 2.1.0-beta.8

package/dist/dev.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderDefinition } from "./types";
+export interface DevServerOptions {
+    port?: number;
+    sessionDbPath?: string;
+}
+export declare function createDevServer(provider: ProviderDefinition, options?: DevServerOptions): {
+    start: () => void;
+};
+export declare function startDevServer(provider: ProviderDefinition, options?: DevServerOptions): void;

package/dist/dev.js

@@ -0,0 +1,15 @@
+import { serve } from "./server/serve";
+export function createDevServer(provider, options) {
+    const port = options?.port ?? 3900;
+    return {
+        start: () => {
+            void serve(provider, { port });
+            console.log(`[apifuse dev] ${provider.id}@${provider.version} running at http://localhost:${port}`);
+            console.log(`[apifuse dev] Operations: ${Object.keys(provider.operations).join(", ")}`);
+            console.log(`[apifuse dev] Health: http://localhost:${port}/health`);
+        },
+    };
+}
+export function startDevServer(provider, options) {
+    createDevServer(provider, options).start();
+}

package/dist/errors.d.ts

@@ -0,0 +1,59 @@
+import type { ProviderErrorCategory } from "./observability";
+export type ProviderErrorOptions = {
+    fix?: string;
+    code?: string;
+    details?: unknown;
+    cause?: Error;
+    category?: ProviderErrorCategory;
+    retryable?: boolean;
+};
+export declare class ProviderError extends Error {
+    readonly options?: ProviderErrorOptions | undefined;
+    constructor(message: string, options?: ProviderErrorOptions | undefined);
+    get fix(): string | undefined;
+    get code(): string | undefined;
+    get details(): unknown;
+}
+export declare class SDKError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class AuthError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class SessionExpiredError extends AuthError {
+    constructor(message?: string, options?: ProviderErrorOptions);
+}
+export type ValidationErrorOptions = ProviderErrorOptions & {
+    zodError?: unknown;
+};
+export declare class ValidationError extends ProviderError {
+    readonly zodError?: unknown;
+    constructor(message: string, options?: ValidationErrorOptions);
+}
+export type TransportErrorOptions = ProviderErrorOptions & {
+    status?: number;
+    upstreamStatus?: number;
+};
+export declare class TransportError extends ProviderError {
+    readonly status?: number;
+    readonly upstreamStatus?: number;
+    constructor(message: string, options?: TransportErrorOptions);
+}
+export declare class ProviderSecretError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class CredentialKeyError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class CredentialModeError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class FlowExpiredError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class TurnValidationError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}
+export declare class ContextAccessError extends ProviderError {
+    constructor(message: string, options?: ProviderErrorOptions);
+}

package/dist/errors.js

@@ -0,0 +1,97 @@
+export class ProviderError extends Error {
+    options;
+    constructor(message, options) {
+        super(message);
+        this.options = options;
+        this.name = "ProviderError";
+        if (options?.cause) {
+            this.cause = options.cause;
+        }
+    }
+    get fix() {
+        return this.options?.fix;
+    }
+    get code() {
+        return this.options?.code;
+    }
+    get details() {
+        return this.options?.details;
+    }
+}
+export class SDKError extends ProviderError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "SDKError";
+    }
+}
+export class AuthError extends ProviderError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AuthError";
+    }
+}
+export class SessionExpiredError extends AuthError {
+    constructor(message = "Provider session expired", options) {
+        super(message, {
+            code: "reauth_required",
+            category: "credential_expired",
+            retryable: false,
+            ...options,
+        });
+        this.name = "SessionExpiredError";
+    }
+}
+export class ValidationError extends ProviderError {
+    zodError;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ValidationError";
+        this.zodError = options?.zodError;
+    }
+}
+export class TransportError extends ProviderError {
+    status;
+    upstreamStatus;
+    constructor(message, options) {
+        super(message, options);
+        this.name = "TransportError";
+        this.status = options?.status;
+        this.upstreamStatus = options?.upstreamStatus ?? options?.status;
+    }
+}
+export class ProviderSecretError extends ProviderError {
+    constructor(message, options) {
+        super(message, { code: "provider_secret_error", ...options });
+        this.name = "ProviderSecretError";
+    }
+}
+export class CredentialKeyError extends ProviderError {
+    constructor(message, options) {
+        super(message, { code: "credential_key_error", ...options });
+        this.name = "CredentialKeyError";
+    }
+}
+export class CredentialModeError extends ProviderError {
+    constructor(message, options) {
+        super(message, { code: "credential_mode_error", ...options });
+        this.name = "CredentialModeError";
+    }
+}
+export class FlowExpiredError extends ProviderError {
+    constructor(message, options) {
+        super(message, { code: "flow_expired", ...options });
+        this.name = "FlowExpiredError";
+    }
+}
+export class TurnValidationError extends ProviderError {
+    constructor(message, options) {
+        super(message, { code: "turn_validation_error", ...options });
+        this.name = "TurnValidationError";
+    }
+}
+export class ContextAccessError extends ProviderError {
+    constructor(message, options) {
+        super(message, { code: "context_access_error", ...options });
+        this.name = "ContextAccessError";
+    }
+}

package/dist/i18n/catalog.d.ts

@@ -0,0 +1,29 @@
+import type { AuthTurn } from "../types";
+import { type ProviderLocale, type ProviderLocaleCatalog, type ProviderLocaleKey, type ProviderLocaleValue } from "./keys";
+export type ProviderLocaleCatalogMap = Record<ProviderLocale, ProviderLocaleCatalog>;
+export interface LoadProviderLocaleCatalogsOptions {
+    providerDir: string;
+    locales: readonly ProviderLocale[];
+}
+export interface ProviderLocaleValidationIssue {
+    locale: ProviderLocale;
+    key: string;
+    message: string;
+    severity: "error" | "warning";
+}
+export interface ProviderLocaleValidationResult {
+    ok: boolean;
+    issues: ProviderLocaleValidationIssue[];
+}
+export declare function loadProviderLocaleCatalogs(options: LoadProviderLocaleCatalogsOptions): ProviderLocaleCatalogMap;
+export declare function resolveProviderLocaleValue(catalogs: ProviderLocaleCatalogMap, key: ProviderLocaleKey | string, locale: ProviderLocale, fallbackLocale?: ProviderLocale): ProviderLocaleValue | undefined;
+export declare function localizeAuthTurn(turn: AuthTurn, options: {
+    catalogs: ProviderLocaleCatalogMap;
+    locale: ProviderLocale;
+    fallbackLocale?: ProviderLocale;
+}): AuthTurn;
+export declare function validateProviderLocaleCatalogs(options: {
+    catalogs: ProviderLocaleCatalogMap;
+    requiredLocales: readonly ProviderLocale[];
+    requiredKeys: readonly (ProviderLocaleKey | string)[];
+}): ProviderLocaleValidationResult;

package/dist/i18n/catalog.js

@@ -0,0 +1,159 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getProviderLocalePath, isProviderLocaleValue, providerLocaleKey, } from "./keys";
+export function loadProviderLocaleCatalogs(options) {
+    const catalogs = {};
+    for (const locale of options.locales) {
+        const filePath = join(options.providerDir, "locales", `${locale}.json`);
+        catalogs[locale] = JSON.parse(readFileSync(filePath, "utf8"));
+    }
+    return catalogs;
+}
+export function resolveProviderLocaleValue(catalogs, key, locale, fallbackLocale = "en") {
+    providerLocaleKey(key);
+    return (getProviderLocalePath(catalogs[locale] ?? {}, key) ??
+        getProviderLocalePath(catalogs[fallbackLocale] ?? {}, key));
+}
+function asStringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function isStringRecord(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.values(value).every((entry) => typeof entry === "string"));
+}
+function localizeAuthInputSchema(expectedInput, options) {
+    if (!expectedInput)
+        return undefined;
+    const schema = isRecord(expectedInput.schema)
+        ? expectedInput.schema
+        : expectedInput;
+    const localizedSchema = localizeAuthSchemaObject(schema, options);
+    if (localizedSchema === schema)
+        return undefined;
+    return isRecord(expectedInput.schema)
+        ? { ...expectedInput, schema: localizedSchema }
+        : localizedSchema;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function localizeAuthSchemaObject(schema, options) {
+    const properties = isRecord(schema.properties)
+        ? schema.properties
+        : undefined;
+    if (!properties)
+        return schema;
+    let changed = false;
+    const localizedProperties = Object.fromEntries(Object.entries(properties).map(([fieldName, property]) => {
+        if (!isRecord(property))
+            return [fieldName, property];
+        const nameKey = typeof property.nameKey === "string" ? property.nameKey : undefined;
+        const descriptionKey = typeof property.descriptionKey === "string"
+            ? property.descriptionKey
+            : undefined;
+        const title = nameKey
+            ? asStringValue(resolveProviderLocaleValue(options.catalogs, nameKey, options.locale, options.fallbackLocale))
+            : undefined;
+        const description = descriptionKey
+            ? asStringValue(resolveProviderLocaleValue(options.catalogs, descriptionKey, options.locale, options.fallbackLocale))
+            : undefined;
+        if (!title && !description)
+            return [fieldName, property];
+        changed = true;
+        return [
+            fieldName,
+            {
+                ...property,
+                ...(title ? { title } : {}),
+                ...(description ? { description } : {}),
+            },
+        ];
+    }));
+    return changed ? { ...schema, properties: localizedProperties } : schema;
+}
+export function localizeAuthTurn(turn, options) {
+    const fallbackLocale = options.fallbackLocale ?? "en";
+    const hint = turn.hintKey
+        ? asStringValue(resolveProviderLocaleValue(options.catalogs, turn.hintKey, options.locale, fallbackLocale))
+        : undefined;
+    const expectedInput = localizeAuthInputSchema(turn.expectedInput, {
+        catalogs: options.catalogs,
+        locale: options.locale,
+        fallbackLocale,
+    });
+    const fieldErrorKeys = turn.data?.fieldErrorKeys;
+    const fieldErrors = isStringRecord(fieldErrorKeys)
+        ? Object.fromEntries(Object.entries(fieldErrorKeys).flatMap(([fieldName, key]) => {
+            const message = asStringValue(resolveProviderLocaleValue(options.catalogs, key, options.locale, fallbackLocale));
+            return message ? [[fieldName, message]] : [];
+        }))
+        : undefined;
+    if (!hint && !fieldErrors && !expectedInput)
+        return turn;
+    return {
+        ...turn,
+        ...(hint ? { hint } : {}),
+        ...(expectedInput ? { expectedInput } : {}),
+        ...(fieldErrors
+            ? {
+                data: {
+                    ...(turn.data ?? {}),
+                    fieldErrors,
+                },
+            }
+            : {}),
+    };
+}
+export function validateProviderLocaleCatalogs(options) {
+    const issues = [];
+    const uniqueKeys = Array.from(new Set(options.requiredKeys.map((key) => {
+        providerLocaleKey(key);
+        return key;
+    })));
+    for (const locale of options.requiredLocales) {
+        const catalog = options.catalogs[locale];
+        if (!catalog) {
+            issues.push({
+                locale,
+                key: "*",
+                message: `Missing provider locale catalog for ${locale}`,
+                severity: "error",
+            });
+            continue;
+        }
+        for (const key of uniqueKeys) {
+            const value = getProviderLocalePath(catalog, key);
+            if (value === undefined) {
+                issues.push({
+                    locale,
+                    key,
+                    message: `Missing provider locale key ${key} in ${locale}`,
+                    severity: "error",
+                });
+                continue;
+            }
+            if (!isProviderLocaleValue(value)) {
+                issues.push({
+                    locale,
+                    key,
+                    message: `Provider locale key ${key} must resolve to a string or string array`,
+                    severity: "error",
+                });
+                continue;
+            }
+            for (const text of Array.isArray(value) ? value : [value]) {
+                if (text.trim().length === 0 || /\bTODO\b/i.test(text)) {
+                    issues.push({
+                        locale,
+                        key,
+                        message: `Provider locale key ${key} in ${locale} is empty or placeholder text`,
+                        severity: "error",
+                    });
+                }
+            }
+        }
+    }
+    return { ok: issues.every((issue) => issue.severity !== "error"), issues };
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./catalog";
+export * from "./keys";

package/dist/i18n/index.js

@@ -0,0 +1,2 @@
+export * from "./catalog";
+export * from "./keys";

package/dist/i18n/keys.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderLocaleKey } from "../types";
+export type { ProviderLocale, ProviderLocaleKey } from "../types";
+export declare function providerLocaleKey(key: string): ProviderLocaleKey;
+export declare function isProviderLocaleKey(value: unknown): value is ProviderLocaleKey;
+export declare function assertProviderLocaleKey(value: unknown): asserts value is ProviderLocaleKey;
+export declare function qualifyProviderLocaleKey(providerId: string, key: ProviderLocaleKey | string): string;
+export declare function getProviderLocalePath(catalog: ProviderLocaleCatalog, key: ProviderLocaleKey | string): ProviderLocaleValue | undefined;
+export type ProviderLocaleValue = string | readonly string[];
+export type ProviderLocaleCatalog = Record<string, unknown>;
+export declare function isProviderLocaleValue(value: unknown): value is ProviderLocaleValue;

package/dist/i18n/keys.js

@@ -0,0 +1,34 @@
+const PROVIDER_LOCALE_KEY_RE = /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]+)*(?:\.[a-z][a-z0-9]*(?:[A-Z][a-z0-9]+)*|\.[0-9]+)*$/;
+export function providerLocaleKey(key) {
+    assertProviderLocaleKey(key);
+    return key;
+}
+export function isProviderLocaleKey(value) {
+    return typeof value === "string" && PROVIDER_LOCALE_KEY_RE.test(value);
+}
+export function assertProviderLocaleKey(value) {
+    if (!isProviderLocaleKey(value)) {
+        throw new Error(`Provider locale key must be a dot path such as "meta.description" or "operations.search.description"; received ${JSON.stringify(value)}`);
+    }
+}
+export function qualifyProviderLocaleKey(providerId, key) {
+    assertProviderLocaleKey(key);
+    return `providers.${providerId}.${key}`;
+}
+export function getProviderLocalePath(catalog, key) {
+    assertProviderLocaleKey(key);
+    let cursor = catalog;
+    for (const segment of key.split(".")) {
+        if (!isRecord(cursor))
+            return undefined;
+        cursor = cursor[segment];
+    }
+    return isProviderLocaleValue(cursor) ? cursor : undefined;
+}
+export function isProviderLocaleValue(value) {
+    return (typeof value === "string" ||
+        (Array.isArray(value) && value.every((entry) => typeof entry === "string")));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+export * from "./ceremonies";
+export * from "./choice-token";
+export type { ApiFuseConfig, BrowserConfig, ProxyConfig, SessionConfig, } from "./config/loader";
+export { defineConfig, loadApiFuseConfig } from "./config/loader";
+export { canonicalJson, digestProviderContract, extractProviderContract, type JsonPrimitive, type JsonValue, PROVIDER_CONTRACT_SCHEMA_VERSION, type ProviderContractOperation, type ProviderContractSnapshot, } from "./contract";
+export { defineHealthJourney, defineOperation, defineProvider, defineSmsOtpMatcher, defineStreamOperation, every, type ProviderConfig, } from "./define";
+export type { DevServerOptions } from "./dev";
+export { createDevServer, startDevServer } from "./dev";
+export * from "./errors";
+export * from "./i18n";
+export { type LintDiagnostic, lintOperation, lintProvider, } from "./lint";
+export * from "./recipes/gov-api";
+export * from "./recipes/rest-api";
+export { createFlowContext, createScratchpad } from "./runtime/auth-flow";
+export type { BrowserClientOptions } from "./runtime/browser";
+export { BrowserClient, createBrowserClient } from "./runtime/browser";
+export { createBypassProviderCache, createProviderCache, type ProviderCacheOptions, resetProviderCacheForTests, } from "./runtime/cache";
+export { type CreateProviderChoiceContextOptions, createProviderChoiceContext, createTestProviderChoiceContext, PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV, } from "./runtime/choice";
+export { type CreateCredentialContextOptions, createCredentialContext, } from "./runtime/credential";
+export { createEnvContext } from "./runtime/env";
+export { executeOperation } from "./runtime/executor";
+export { createHttpClient } from "./runtime/http";
+export type { Insight, InsightSeverity } from "./runtime/insights";
+export { generateInsights } from "./runtime/insights";
+export { type InstrumentationOptions, type InstrumentedProviderContext, wrapWithInstrumentation, } from "./runtime/instrumentation";
+export { type PrevalidateResult, prevalidate } from "./runtime/prevalidate";
+export { getProviderBaseUrl } from "./runtime/provider";
+export { createUnsupportedProviderRuntimeState, UnsupportedProviderStateError, } from "./runtime/state";
+export { createStealthClient } from "./runtime/stealth";
+export { APIFUSE__STT__BACKEND_ENV, APIFUSE__STT__CLOUDFLARE_API_TOKEN_ENV, APIFUSE__STT__MODEL_ENV, createSttClientFromEnv, createUnsupportedSttClient, extractVerificationCode, resolveSttPrompt, } from "./runtime/stt";
+export { type CreateTraceContextOptions, createTraceContext, type Span, type TraceContext, } from "./runtime/trace";
+export { APIFUSE_DESCRIPTION_KEY_META_KEY, APIFUSE_REDACTION_MARKER, APIFUSE_SENSITIVE_KIND_META_KEY, APIFUSE_SENSITIVE_META_KEY, collectSensitivePaths, describeKey, field, fields, isSensitiveSchema, redactPayload, type SensitiveFieldKind, type SensitiveFieldOptions, type SensitivePath, sensitive, z, } from "./schema";
+export { createServerApp, type ServeOptions, serve } from "./server";
+export { getStealthProfile, listStealthProfiles } from "./stealth/profiles";
+export * from "./stream";
+export type { ApiFuseResponse, AuthConfig, AuthContext, AuthFlowDefinition, AuthFlowInputHandler, AuthFlowStartHandler, AuthMode, AuthTurn, Bcp47Locale, BrowserEngine, BrowserOptions, ConnectionMode, ContextDeclaration, ContextScratchpad, CredentialContext, CredentialDeclaration, E164PhoneNumber, EnvContext, FlowContext, FlowContextStore, HealthCheckAssertionContext, HealthCheckCase, HealthCheckCaseResult, HealthCheckSuite, HealthCheckUnsupported, HealthJourneyDefinition, HealthJourneyEventContext, HealthJourneyGatewayContext, HealthJourneyJournalContext, HealthJourneyManualTriggerPolicy, HealthJourneyRunContext, HealthJourneyRunResult, HealthJourneySchedule, HealthJourneySmsContext, HealthJourneyStep, HttpClient, HttpMethod, HttpResponse, HttpRetryOptions, HttpRetrySummary, HttpStreamResponse, IanaTimeZone, InferSchemaOutput, Iso3166Alpha2CountryCode, Iso4217CurrencyCode, Iso8601Duration, OperationAnnotations, OperationApprovalPolicy, OperationContractMetadata, OperationDefinition, OperationDeprecationMetadata, OperationDocMeta, OperationErrorCode, OperationHandlerResult, OperationInputExample, OperationLifecycle, OperationObservabilityConfig, OperationObservabilitySensitiveConfig, OperationRelationships, OperationRiskClass, OperationSensitivePath, OperationToolRouterMetadata, OperationTransport, OperationTransportKind, ProbeInterval, ProviderAccessConfig, ProviderAccessVisibility, ProviderCache, ProviderCacheGetOrSetOptions, ProviderCacheKeyOptions, ProviderCacheLookupMeta, ProviderCacheResponseMeta, ProviderCacheResult, ProviderChoiceBindingOptions, ProviderChoiceContext, ProviderChoiceIssueOptions, ProviderChoiceParseOptions, ProviderContext, ProviderDefinition, ProviderHealthMonitorConfig, ProviderLocale, ProviderLocaleKey, ProviderLocaleKeyInput, ProviderLogoProfile, ProviderLogoSource, ProviderMeta, ProviderProxyConfig, ProviderProxyMode, ProviderProxyPolicy, ProviderProxyProvider, ProviderProxySessionAffinity, ProviderPublicConnectionMode, ProviderPublicProfile, ProviderReviewed, ProviderRuntimeState, ProviderSecretDeclaration, ProviderStateDurationString, ProviderStateNamespace, ProviderStreamEvent, ProviderSttConfig, ProviderSttMode, ProviderSupportLevel, RequestOptions, Rfc3339Instant, SchemaLike, SmsOrigin, SmsOtpExtractionPattern, SmsOtpMatcherDefinition, SseMessage, StandardSchemaV1, StateCasResult, StateNamespaceOptions, StateValue, StateWriteOptions, StealthClient, StealthFetchOptions, StealthPlatform, StealthProfile, StealthResponse, StealthSession, SttAudioInput, SttContext, SttPromptPolicy, SttSegment, SttTranscribeMode, SttTranscribeRequest, SttTranscript, SttUnsupportedOptionPolicy, SttUsage, SttVerificationCodeOptions, SttWarning, TraceConfig, TraceSpan, VerificationCodeCandidate, VerificationCodeCandidateSource, VerificationCodeExtractionResult, } from "./types";
+export { DEFAULT_OPERATION_TRANSPORT, HttpRetryAfterPolicy, HttpRetryDelayStrategy, HttpRetryJitter, HttpRetryPreset, HttpRetryUnsafeMethodPolicy, PROBE_INTERVALS, STREAM_CHUNK_BYTES_MAX, STREAM_CHUNK_BYTES_MIN, STREAM_HEARTBEAT_MS_MAX, STREAM_HEARTBEAT_MS_MIN, STREAM_IDLE_TIMEOUT_MS_MAX, STREAM_IDLE_TIMEOUT_MS_MIN, STREAM_MAX_DURATION_MS_MAX, STREAM_MAX_DURATION_MS_MIN, } from "./types";
+export * from "./utils/date";
+export * from "./utils/parse";
+export * from "./utils/text";
+export * from "./utils/transform";

package/dist/index.js

@@ -0,0 +1,37 @@
+// @apifuse/provider-sdk
+export * from "./ceremonies";
+export * from "./choice-token";
+export { defineConfig, loadApiFuseConfig } from "./config/loader";
+export { canonicalJson, digestProviderContract, extractProviderContract, PROVIDER_CONTRACT_SCHEMA_VERSION, } from "./contract";
+export { defineHealthJourney, defineOperation, defineProvider, defineSmsOtpMatcher, defineStreamOperation, every, } from "./define";
+export { createDevServer, startDevServer } from "./dev";
+export * from "./errors";
+export * from "./i18n";
+export { lintOperation, lintProvider, } from "./lint";
+export * from "./recipes/gov-api";
+export * from "./recipes/rest-api";
+export { createFlowContext, createScratchpad } from "./runtime/auth-flow";
+export { BrowserClient, createBrowserClient } from "./runtime/browser";
+export { createBypassProviderCache, createProviderCache, resetProviderCacheForTests, } from "./runtime/cache";
+export { createProviderChoiceContext, createTestProviderChoiceContext, PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV, } from "./runtime/choice";
+export { createCredentialContext, } from "./runtime/credential";
+export { createEnvContext } from "./runtime/env";
+export { executeOperation } from "./runtime/executor";
+export { createHttpClient } from "./runtime/http";
+export { generateInsights } from "./runtime/insights";
+export { wrapWithInstrumentation, } from "./runtime/instrumentation";
+export { prevalidate } from "./runtime/prevalidate";
+export { getProviderBaseUrl } from "./runtime/provider";
+export { createUnsupportedProviderRuntimeState, UnsupportedProviderStateError, } from "./runtime/state";
+export { createStealthClient } from "./runtime/stealth";
+export { APIFUSE__STT__BACKEND_ENV, APIFUSE__STT__CLOUDFLARE_API_TOKEN_ENV, APIFUSE__STT__MODEL_ENV, createSttClientFromEnv, createUnsupportedSttClient, extractVerificationCode, resolveSttPrompt, } from "./runtime/stt";
+export { createTraceContext, } from "./runtime/trace";
+export { APIFUSE_DESCRIPTION_KEY_META_KEY, APIFUSE_REDACTION_MARKER, APIFUSE_SENSITIVE_KIND_META_KEY, APIFUSE_SENSITIVE_META_KEY, collectSensitivePaths, describeKey, field, fields, isSensitiveSchema, redactPayload, sensitive, z, } from "./schema";
+export { createServerApp, serve } from "./server";
+export { getStealthProfile, listStealthProfiles } from "./stealth/profiles";
+export * from "./stream";
+export { DEFAULT_OPERATION_TRANSPORT, HttpRetryAfterPolicy, HttpRetryDelayStrategy, HttpRetryJitter, HttpRetryPreset, HttpRetryUnsafeMethodPolicy, PROBE_INTERVALS, STREAM_CHUNK_BYTES_MAX, STREAM_CHUNK_BYTES_MIN, STREAM_HEARTBEAT_MS_MAX, STREAM_HEARTBEAT_MS_MIN, STREAM_IDLE_TIMEOUT_MS_MAX, STREAM_IDLE_TIMEOUT_MS_MIN, STREAM_MAX_DURATION_MS_MAX, STREAM_MAX_DURATION_MS_MIN, } from "./types";
+export * from "./utils/date";
+export * from "./utils/parse";
+export * from "./utils/text";
+export * from "./utils/transform";

package/dist/lint.d.ts

@@ -0,0 +1,73 @@
+type AuthModeLike = "none" | "platform-managed" | "credentials" | "oauth2" | "api-key";
+type ProviderAuthLike = {
+    mode?: AuthModeLike;
+    flow?: {
+        start?: unknown;
+        continue?: unknown;
+        poll?: unknown;
+        abort?: unknown;
+        refresh?: unknown;
+    };
+};
+type ProviderContractMetaLike = {
+    publicSchemaFieldNames?: "normalized";
+};
+export interface LintDiagnostic {
+    rule: string;
+    level: "error" | "warn";
+    message: string;
+    field?: string;
+}
+export type ProviderLintMode = "official" | "standalone";
+type ProviderLintOptions = {
+    mode?: ProviderLintMode;
+};
+export declare function lintOperation(op: {
+    description?: string;
+    descriptionKey?: string;
+    whenToUse?: readonly string[];
+    whenToUseKeys?: readonly string[];
+    whenNotToUse?: readonly string[];
+    whenNotToUseKeys?: readonly string[];
+    input: unknown;
+    output: unknown;
+    fixtures?: unknown;
+    inputExamples?: readonly unknown[];
+    derivations?: Record<string, string>;
+}): LintDiagnostic[];
+export declare function lintProvider(provider: {
+    id?: string;
+    allowedHosts?: readonly string[];
+    stealth?: unknown;
+    auth?: ProviderAuthLike;
+    credential?: {
+        keys?: readonly string[];
+        storesReusableSecret?: boolean;
+        justification?: string;
+    };
+    context?: {
+        keys?: readonly string[];
+    };
+    authFlowSource?: string;
+    providerSourceFiles?: Record<string, string>;
+    operations?: Record<string, {
+        description?: string;
+        descriptionKey?: string;
+        whenToUse?: readonly string[];
+        whenToUseKeys?: readonly string[];
+        whenNotToUse?: readonly string[];
+        whenNotToUseKeys?: readonly string[];
+        input: unknown;
+        output: unknown;
+        fixtures?: unknown;
+        inputExamples?: readonly unknown[];
+        derivations?: Record<string, string>;
+        handler?: unknown;
+        source?: string;
+    }>;
+    meta?: {
+        contract?: ProviderContractMetaLike;
+    };
+    reviewed?: string;
+}, options?: ProviderLintOptions): LintDiagnostic[];
+export {};