@openkeyai/sdk 0.1.0 → 0.2.0

package/dist/index.d.cts

@@ -9,6 +9,19 @@
  */
 /** Scopes a tool may request and a JWT may carry. */
 type ToolJwtScope = "keys.read" | "user.read" | "billing.read";
+/**
+ * Issuance mode (Phase 13.4 / Phase 19).
+ *
+ *   production  — normal user launches an approved tool through the catalog
+ *   owner_test  — the tool's owner launching their own pre-approval scaffold
+ *                 to dogfood the build. Subscription gate waived; only the
+ *                 owner can mint these
+ *
+ * Tools that want to render a TEST MODE banner read this claim and check
+ * for `'owner_test'`. Backwards-compatible: tokens minted before Phase 13.4
+ * default to `'production'` on verify.
+ */
+type ToolJwtMode = "production" | "owner_test";
 /** Decoded + verified claim payload. */
 type ToolJwtClaims = {
     /** Always exactly "https://openkeyai.com". */
@@ -21,6 +34,8 @@ type ToolJwtClaims = {
     scopes: ToolJwtScope[];
     /** Whether the user has an active subscription at issuance time. */
     subscription_active: boolean;
+    /** Mode the JWT was issued under (Phase 13.4). Defaults to 'production'. */
+    mode: ToolJwtMode;
     /** Unix seconds. */
     iat: number;
     /** Unix seconds. Tokens default to iat + 900 (15 min). */
@@ -49,6 +64,33 @@ type HubCallOptions = {
      */
     signal?: AbortSignal;
 };
+/**
+ * Generic proxy call options. The proxy is the Phase 19 endpoint that
+ * forwards arbitrary requests to upstream providers with the user's key
+ * injected by the hub — the tool never sees the plaintext key.
+ */
+type ProxyCallOptions = HubCallOptions & {
+    /** Provider slug — matches the hub's provider registry. */
+    provider: ProviderSlug;
+    /** HTTP method to use against the upstream. */
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    /**
+     * Path portion of the upstream URL. Must start with `/`. The hub appends
+     * this to the provider's baseUrl. Example: `/v1/chat/completions`.
+     */
+    path: string;
+    /**
+     * Request body. If an object, sent as JSON. If a string / Blob /
+     * FormData / ReadableStream / ArrayBuffer, sent as-is. Omit for
+     * GET / DELETE.
+     */
+    body?: Record<string, unknown> | unknown[] | string | Blob | FormData | ArrayBuffer | ReadableStream<Uint8Array> | null;
+    /**
+     * Extra headers to forward upstream. The hub will strip a few it
+     * controls (authorization, host, cookie); the rest pass through.
+     */
+    headers?: Record<string, string>;
+};
 
 /**
  * `session.verify(jwt, opts?)`
@@ -163,6 +205,422 @@ declare class SecureKey {
  */
 declare function get(jwt: string, provider: ProviderSlug, opts?: HubCallOptions): Promise<SecureKey>;
 
+/**
+ * Generic proxy call — JSON in, JSON out. Most tools want this.
+ *
+ *   const completion = await proxy.call<ChatCompletionResponse>(token, {
+ *     provider: "openai",
+ *     method: "POST",
+ *     path: "/v1/chat/completions",
+ *     body: { model: "gpt-4o-mini", messages: [{ role: "user", content: "hi" }] },
+ *   });
+ *
+ * Throws typed HubSdkError subclasses for hub-side failures (missing
+ * scope, rate limited, etc.) and `ProviderError` for upstream non-2xx
+ * (wrong key, model gone, provider 5xx, etc.).
+ */
+declare function call<T = unknown>(token: string, opts: ProxyCallOptions): Promise<T>;
+/**
+ * Raw-response proxy call. Used when the upstream returns non-JSON —
+ * binary audio (TTS), image bytes (DALL-E with response_format=url is
+ * JSON, but other endpoints may stream binary), multipart, etc.
+ *
+ *   const response = await proxy.callRaw(token, {
+ *     provider: "openai",
+ *     method: "POST",
+ *     path: "/v1/audio/speech",
+ *     body: { model: "tts-1", input: "Hello", voice: "alloy" },
+ *   });
+ *   const audio = await response.arrayBuffer();
+ *
+ * Returns the upstream Response with status / headers intact — the tool
+ * decides how to consume the body. Throws on hub-side errors before the
+ * Response is returned.
+ */
+declare function callRaw(token: string, opts: ProxyCallOptions): Promise<Response>;
+/**
+ * Streaming proxy call — returns a ReadableStream of the upstream
+ * response body. Used for SSE (chat completion streaming), chunked
+ * downloads, large response bodies you want to process as they arrive.
+ *
+ *   const stream = await proxy.callStream(token, {
+ *     provider: "openai",
+ *     method: "POST",
+ *     path: "/v1/chat/completions",
+ *     body: { model: "gpt-4o", messages: [...], stream: true },
+ *   });
+ *   const reader = stream.getReader();
+ *   while (true) {
+ *     const { value, done } = await reader.read();
+ *     if (done) break;
+ *     // parse SSE chunks here — typed SSE iterator comes in M1.5
+ *   }
+ *
+ * Hub-side errors (auth, rate-limit) still throw before the stream is
+ * returned. Upstream errors are surfaced via the stream itself — the
+ * caller should check `response.status` before reading if a provider 4xx
+ * matters; in M1.5 we'll wrap this in `ProviderError` if the upstream
+ * status is non-2xx before any chunks are read.
+ */
+declare function callStream(token: string, opts: ProxyCallOptions): Promise<ReadableStream<Uint8Array>>;
+
+/**
+ * Typed convenience wrappers for OpenAI's most-used endpoints. Thin
+ * wrappers around `proxy.call(token, opts)` — same gates, same errors,
+ * just better DX for the common cases.
+ *
+ * Tools that need an endpoint not covered here can drop to the generic
+ * `proxy.call(token, { provider: "openai", method, path, body })`. The
+ * proxy supports every OpenAI endpoint without us shipping wrappers for
+ * each one.
+ *
+ * Types here are pragmatic, not exhaustive — we hit the fields the YT
+ * thumbnail tool and other early reference tools need. As more tools land
+ * we'll grow these. The escape hatch (`proxy.call`) means tools never wait
+ * on the SDK to update types when a new model ships.
+ */
+type OpenaiImageModel = "gpt-image-1" | "dall-e-3" | "dall-e-2" | (string & {});
+type OpenaiImageSize = "1024x1024" | "1024x1536" | "1536x1024" | "1792x1024" | "1024x1792" | "256x256" | "512x512" | "auto" | (string & {});
+type OpenaiImageQuality = "high" | "medium" | "low" | "auto" | "hd" | "standard" | (string & {});
+type OpenaiImageStyle = "vivid" | "natural" | (string & {});
+type OpenaiImageGenerateParams = {
+    model?: OpenaiImageModel;
+    prompt: string;
+    n?: number;
+    size?: OpenaiImageSize;
+    quality?: OpenaiImageQuality;
+    style?: OpenaiImageStyle;
+    /**
+     * `b64_json` returns base64-encoded image bytes inline in the response.
+     * `url` returns a hosted URL the client can fetch. gpt-image-1 always
+     * returns b64.
+     */
+    response_format?: "url" | "b64_json";
+    user?: string;
+    background?: "transparent" | "opaque" | "auto" | (string & {});
+    moderation?: "low" | "auto" | (string & {});
+    output_compression?: number;
+    output_format?: "png" | "jpeg" | "webp" | (string & {});
+};
+type OpenaiImageData = {
+    url?: string;
+    b64_json?: string;
+    revised_prompt?: string;
+};
+type OpenaiImageGenerateResponse = {
+    created: number;
+    data: OpenaiImageData[];
+    usage?: {
+        total_tokens?: number;
+        input_tokens?: number;
+        output_tokens?: number;
+        input_tokens_details?: {
+            text_tokens?: number;
+            image_tokens?: number;
+        };
+    };
+};
+type OpenaiChatRole = "system" | "user" | "assistant" | "tool";
+type OpenaiChatMessageContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+        detail?: "low" | "high" | "auto";
+    };
+};
+type OpenaiChatMessage = {
+    role: OpenaiChatRole;
+    content: string | OpenaiChatMessageContentPart[];
+    name?: string;
+    tool_call_id?: string;
+};
+type OpenaiChatCompletionParams = {
+    model: string;
+    messages: OpenaiChatMessage[];
+    temperature?: number;
+    top_p?: number;
+    n?: number;
+    max_tokens?: number;
+    max_completion_tokens?: number;
+    stream?: boolean;
+    stop?: string | string[];
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    seed?: number;
+    response_format?: {
+        type: "text" | "json_object" | "json_schema";
+    };
+    tools?: Array<{
+        type: "function";
+        function: {
+            name: string;
+            description?: string;
+            parameters?: unknown;
+        };
+    }>;
+    tool_choice?: "none" | "auto" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    user?: string;
+};
+type OpenaiChatCompletionResponse = {
+    id: string;
+    object: "chat.completion";
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: "assistant";
+            content: string | null;
+            tool_calls?: unknown[];
+        };
+        finish_reason: "stop" | "length" | "tool_calls" | "content_filter" | string;
+    }>;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+};
+type OpenaiEmbeddingsParams = {
+    model: string;
+    input: string | string[];
+    dimensions?: number;
+    encoding_format?: "float" | "base64";
+    user?: string;
+};
+type OpenaiEmbeddingsResponse = {
+    object: "list";
+    data: Array<{
+        object: "embedding";
+        index: number;
+        embedding: number[];
+    }>;
+    model: string;
+    usage: {
+        prompt_tokens: number;
+        total_tokens: number;
+    };
+};
+type OpenaiTranscriptionParams = {
+    file: Blob;
+    model: string;
+    language?: string;
+    prompt?: string;
+    response_format?: "json" | "text" | "srt" | "verbose_json" | "vtt";
+    temperature?: number;
+    /** Filename to attach to the multipart upload. Defaults to "audio.webm". */
+    filename?: string;
+};
+type OpenaiTranscriptionResponse = {
+    text: string;
+    language?: string;
+    duration?: number;
+    segments?: Array<{
+        id: number;
+        start: number;
+        end: number;
+        text: string;
+    }>;
+};
+type OpenaiSpeechParams = {
+    model: string;
+    input: string;
+    voice: "alloy" | "echo" | "fable" | "onyx" | "nova" | "shimmer" | (string & {});
+    response_format?: "mp3" | "opus" | "aac" | "flac" | "wav" | "pcm";
+    speed?: number;
+    instructions?: string;
+};
+/**
+ * The OpenAI typed convenience surface. Wraps `proxy.call` / `callRaw` /
+ * `callStream` with provider="openai" pre-set and per-endpoint typings.
+ *
+ *   const result = await openai.images.generate(token, {
+ *     model: "gpt-image-1",
+ *     prompt: "...",
+ *     n: 4,
+ *   });
+ */
+declare const openai: {
+    readonly images: {
+        readonly generate: (token: string, params: OpenaiImageGenerateParams, opts?: HubCallOptions) => Promise<OpenaiImageGenerateResponse>;
+    };
+    readonly chat: {
+        readonly completions: {
+            readonly create: (token: string, params: OpenaiChatCompletionParams, opts?: HubCallOptions) => Promise<OpenaiChatCompletionResponse>;
+            readonly stream: (token: string, params: Omit<OpenaiChatCompletionParams, "stream">, opts?: HubCallOptions) => Promise<ReadableStream<Uint8Array>>;
+        };
+    };
+    readonly embeddings: {
+        readonly create: (token: string, params: OpenaiEmbeddingsParams, opts?: HubCallOptions) => Promise<OpenaiEmbeddingsResponse>;
+    };
+    readonly audio: {
+        readonly transcriptions: {
+            readonly create: (token: string, params: OpenaiTranscriptionParams, opts?: HubCallOptions) => Promise<OpenaiTranscriptionResponse>;
+        };
+        readonly speech: {
+            readonly create: (token: string, params: OpenaiSpeechParams, opts?: HubCallOptions) => Promise<Response>;
+        };
+    };
+};
+
+/**
+ * Typed convenience wrappers for Anthropic's Messages API.
+ *
+ * Hub-side handles the per-provider auth quirk (Anthropic uses `x-api-key`
+ * not `Authorization: Bearer`) and injects the required
+ * `anthropic-version: 2023-06-01` header automatically — see
+ * `src/lib/proxy/providers.ts` on the hub for the config.
+ */
+type AnthropicTextBlock = {
+    type: "text";
+    text: string;
+};
+type AnthropicImageBlock = {
+    type: "image";
+    source: {
+        type: "base64";
+        media_type: string;
+        data: string;
+    } | {
+        type: "url";
+        url: string;
+    };
+};
+type AnthropicToolUseBlock = {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+};
+type AnthropicToolResultBlock = {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | AnthropicTextBlock[];
+    is_error?: boolean;
+};
+type AnthropicContentBlock = AnthropicTextBlock | AnthropicImageBlock | AnthropicToolUseBlock | AnthropicToolResultBlock;
+type AnthropicMessage = {
+    role: "user" | "assistant";
+    content: string | AnthropicContentBlock[];
+};
+type AnthropicMessagesParams = {
+    model: string;
+    messages: AnthropicMessage[];
+    max_tokens: number;
+    system?: string | AnthropicTextBlock[];
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    tools?: Array<{
+        name: string;
+        description?: string;
+        input_schema: Record<string, unknown>;
+    }>;
+    tool_choice?: {
+        type: "auto";
+    } | {
+        type: "any";
+    } | {
+        type: "tool";
+        name: string;
+    };
+    metadata?: {
+        user_id?: string;
+    };
+};
+type AnthropicMessagesResponse = {
+    id: string;
+    type: "message";
+    role: "assistant";
+    model: string;
+    content: AnthropicContentBlock[];
+    stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | string;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+    };
+};
+declare const anthropic: {
+    readonly messages: {
+        readonly create: (token: string, params: AnthropicMessagesParams, opts?: HubCallOptions) => Promise<AnthropicMessagesResponse>;
+        readonly stream: (token: string, params: Omit<AnthropicMessagesParams, "stream">, opts?: HubCallOptions) => Promise<ReadableStream<Uint8Array>>;
+    };
+};
+
+/**
+ * Typed convenience wrappers for Replicate's Predictions API.
+ *
+ * Replicate uses an async lifecycle: POST to create a prediction, GET to
+ * poll its status, optionally cancel. We surface all three plus a small
+ * `predictions.run()` helper that polls until the prediction is final.
+ *
+ * For per-model deployments (Replicate's hosted models with stable URLs),
+ * use `proxy.call(token, { provider: "replicate", path: "/v1/models/.../predictions", ... })`
+ * directly — the generic passthrough handles every Replicate endpoint we
+ * haven't typed here yet.
+ */
+type ReplicatePredictionStatus = "starting" | "processing" | "succeeded" | "failed" | "canceled";
+type ReplicatePrediction<TOutput = unknown> = {
+    id: string;
+    version: string;
+    status: ReplicatePredictionStatus;
+    input: Record<string, unknown>;
+    output: TOutput | null;
+    error: string | null;
+    logs: string;
+    created_at: string;
+    started_at: string | null;
+    completed_at: string | null;
+    urls: {
+        get: string;
+        cancel: string;
+        stream?: string;
+    };
+    metrics?: {
+        predict_time?: number;
+    };
+};
+type ReplicateCreatePredictionParams = {
+    /** Model version hash. Mutually exclusive with the model-deployment URL form. */
+    version: string;
+    input: Record<string, unknown>;
+    webhook?: string;
+    webhook_events_filter?: Array<"start" | "output" | "logs" | "completed">;
+    stream?: boolean;
+};
+declare const replicate: {
+    readonly predictions: {
+        readonly create: <TOutput = unknown>(token: string, params: ReplicateCreatePredictionParams, opts?: HubCallOptions) => Promise<ReplicatePrediction<TOutput>>;
+        readonly get: <TOutput = unknown>(token: string, predictionId: string, opts?: HubCallOptions) => Promise<ReplicatePrediction<TOutput>>;
+        readonly cancel: <TOutput = unknown>(token: string, predictionId: string, opts?: HubCallOptions) => Promise<ReplicatePrediction<TOutput>>;
+        /**
+         * Convenience: create + poll until the prediction reaches a terminal
+         * status. Polls every `pollIntervalMs` (default 1000ms) with the
+         * provided AbortSignal honoured.
+         *
+         * For long-running predictions consider using webhooks via
+         * `create({ webhook, webhook_events_filter })` instead so you're not
+         * holding open a long fetch.
+         */
+        readonly run: <TOutput = unknown>(token: string, params: ReplicateCreatePredictionParams, opts?: HubCallOptions & {
+            pollIntervalMs?: number;
+        }) => Promise<ReplicatePrediction<TOutput>>;
+    };
+};
+
 /**
  * Typed errors.
  *
@@ -183,7 +641,7 @@ declare function get(jwt: string, provider: ProviderSlug, opts?: HubCallOptions)
  *     else throw e;
  *   }
  */
-type HubSdkErrorCode = "missing_token" | "bad_token" | "missing_scope" | "subscription_inactive" | "tool_not_found" | "not_subscribed" | "provider_not_granted" | "rate_limited" | "key_not_found" | "internal" | "network" | "secure_key_consumed";
+type HubSdkErrorCode = "missing_token" | "bad_token" | "missing_scope" | "subscription_inactive" | "tool_not_found" | "not_subscribed" | "provider_not_granted" | "rate_limited" | "key_not_found" | "internal" | "network" | "secure_key_consumed" | "provider_error" | "provider_not_configured";
 /** Base class for every typed error in the SDK. */
 declare class HubSdkError extends Error {
     readonly code: HubSdkErrorCode;
@@ -228,28 +686,75 @@ declare class NetworkError extends HubSdkError {
 declare class SecureKeyConsumedError extends HubSdkError {
     constructor();
 }
+/**
+ * The proxy was asked to forward to a provider the hub doesn't have
+ * configured. Distinct from `provider_not_granted` (which means the tool
+ * isn't permitted to use a known provider). Fix: add the provider to
+ * `src/lib/proxy/providers.ts` on the hub, or use a registered slug.
+ */
+declare class ProviderNotConfiguredError extends HubSdkError {
+    constructor(provider: string);
+}
+/**
+ * The upstream provider (OpenAI / Anthropic / etc.) returned a non-2xx
+ * response. The hub relays it unchanged — `body` holds the parsed JSON
+ * body if the response was JSON, or the raw text otherwise, so the tool
+ * can inspect the provider's native error shape.
+ *
+ * This is the catch-all for "the platform did its job correctly; the
+ * upstream rejected the request" — wrong key (relayed 401), model not
+ * available (provider 400), upstream rate limit (provider 429), etc.
+ *
+ * Distinguish from `RateLimitedError` (hub-side rate limit) by checking
+ * `instanceof` first; the typed hub errors take precedence.
+ */
+declare class ProviderError extends HubSdkError {
+    /** The provider slug we tried to call. */
+    readonly provider: string;
+    /** The path on the provider that returned non-2xx. */
+    readonly path: string;
+    /**
+     * The upstream response body. Parsed as JSON when the upstream's
+     * content-type was JSON; raw text otherwise.
+     */
+    readonly body: unknown;
+    /** The upstream response status code (relayed unchanged). */
+    readonly upstreamStatus: number;
+    constructor(provider: string, path: string, upstreamStatus: number, body: unknown);
+}
 
 /**
  * `@openkeyai/sdk` — public entry.
  *
  * Tools install this and import only from the package root:
  *
- *   import { session, keys, SecureKey, SubscriptionInactiveError } from "@openkeyai/sdk";
+ *   import { session, openai, anthropic, proxy, ProviderError } from "@openkeyai/sdk";
  *
- * The five-module surface (session / keys / user / billing / webhooks) is
- * defined in
+ * The seven-module surface (session / keys / proxy / openai / anthropic /
+ * replicate / webhooks) is defined in
  * https://github.com/Scott-Builds-AI/hub/blob/main/docs/TOOL_SDK.md
  *
- * Status by module in 0.1.0:
+ * Status by module in 0.2.0:
  *   - session.verify ✓
- *   - keys.get → SecureKey ✓
- *   - user        — deferred until the hub ships /api/me (issue TBD)
+ *   - keys.get → SecureKey ✓ (kept for endpoints the proxy doesn't typeset yet)
+ *   - proxy.call / .callRaw / .callStream ✓     ← Phase 19 universal passthrough
+ *   - openai.{images,chat,embeddings,audio} ✓    ← typed convenience
+ *   - anthropic.messages ✓                       ← typed convenience
+ *   - replicate.predictions ✓                    ← typed convenience
+ *   - user        — deferred until the hub ships /api/me
  *   - billing     — deferred until the hub ships /api/billing/status
- *   - webhooks    — deferred until Phase 16 (the hub's webhook delivery layer)
+ *   - webhooks    — deferred until Phase 16 (hub's webhook delivery layer)
  *
  * Internal helpers live under `_internal/`. They are NOT part of the
  * public API and may change without notice — the tool-manifest scanner
  * (Phase 9) treats `@openkeyai/sdk/_internal` imports as a CI failure.
+ *
+ * Migration note (Phase 19):
+ *   The `keys.get(jwt, provider).use(callback)` SecureKey pattern still
+ *   works and is the only path for endpoints we haven't typed in the
+ *   proxy yet. For canonical model calls (images.generate, chat,
+ *   embeddings, etc.) prefer the proxy — the plaintext key never enters
+ *   your Worker process.
  */
 
 /** session module — JWT verification + (future) refresh. */
@@ -260,8 +765,18 @@ declare const session: {
 declare const keys: {
     readonly get: typeof get;
 };
+/**
+ * proxy module — Phase 19 zero-trust universal forwarder. Plaintext keys
+ * never leave the hub. Supports any HTTP method, any path on any
+ * registered provider, any body shape, streaming and binary responses.
+ */
+declare const proxy: {
+    readonly call: typeof call;
+    readonly callRaw: typeof callRaw;
+    readonly callStream: typeof callStream;
+};
 
 /** Bumped on each release. Tools log this on boot. */
-declare const SDK_VERSION = "0.1.0";
+declare const SDK_VERSION = "0.2.0";
 
-export { BadTokenError, type HubCallOptions, HubSdkError, type HubSdkErrorCode, InternalError, KeyNotFoundError, MissingScopeError, MissingTokenError, NetworkError, NotSubscribedError, ProviderNotGrantedError, type ProviderSlug, RateLimitedError, SDK_VERSION, SecureKey, SecureKeyConsumedError, SubscriptionInactiveError, type ToolJwtClaims, type ToolJwtScope, ToolNotFoundError, keys, session };
+export { type AnthropicContentBlock, type AnthropicImageBlock, type AnthropicMessage, type AnthropicMessagesParams, type AnthropicMessagesResponse, type AnthropicTextBlock, type AnthropicToolResultBlock, type AnthropicToolUseBlock, BadTokenError, type HubCallOptions, HubSdkError, type HubSdkErrorCode, InternalError, KeyNotFoundError, MissingScopeError, MissingTokenError, NetworkError, NotSubscribedError, type OpenaiChatCompletionParams, type OpenaiChatCompletionResponse, type OpenaiChatMessage, type OpenaiChatMessageContentPart, type OpenaiChatRole, type OpenaiEmbeddingsParams, type OpenaiEmbeddingsResponse, type OpenaiImageData, type OpenaiImageGenerateParams, type OpenaiImageGenerateResponse, type OpenaiImageModel, type OpenaiImageQuality, type OpenaiImageSize, type OpenaiImageStyle, type OpenaiSpeechParams, type OpenaiTranscriptionParams, type OpenaiTranscriptionResponse, ProviderError, ProviderNotConfiguredError, ProviderNotGrantedError, type ProviderSlug, type ProxyCallOptions, RateLimitedError, type ReplicateCreatePredictionParams, type ReplicatePrediction, type ReplicatePredictionStatus, SDK_VERSION, SecureKey, SecureKeyConsumedError, SubscriptionInactiveError, type ToolJwtClaims, type ToolJwtMode, type ToolJwtScope, ToolNotFoundError, anthropic, keys, openai, proxy, replicate, session };