@tokenite/sdk 2.4.0 → 2.6.0

package/README.md

@@ -193,6 +193,36 @@ switch (result.reason) {
 
 `expectedState` is optional. When you provide it, a mismatch returns `{ ok: false, reason: 'invalid_state' }` even if a `code` is present — treating a stolen code paired with a forged state as a CSRF attempt.
 
+### Vendor-agnostic calls (any provider behind one SDK)
+
+The `/agnostic/{flavor}` route lets you keep using your favourite vendor SDK while letting the user's keys decide which provider actually runs the request. You write code once in (say) OpenAI shape; the proxy translates the request and the response so the SDK still sees its own format. The model name in the body is looked up across every provider's catalog, so a Claude model is fine in an OpenAI-shaped call.
+
+```typescript
+import OpenAI from 'openai';
+
+const openai = new OpenAI({
+  apiKey:  accessToken,
+  baseURL: tk.agnosticUrl('openai') + '/v1',   // ← agnostic, OpenAI wire shape
+});
+
+// Same SDK, any model the user has access to — Claude here, served by
+// the user's Anthropic key. Tokenite translates the envelope both ways.
+const r = await openai.chat.completions.create({
+  model: 'claude-sonnet-4-6',
+  messages: [{ role: 'user', content: 'hi' }],
+  max_tokens: 256,
+});
+```
+
+The same works mirrored — Anthropic SDK naming an OpenAI model, etc. Pair it with `tk.getAccessContext()` to render a picker scoped to what the user can actually run (`models[].callableNow`).
+
+**Caveats:**
+- Non-streaming only. For `stream: true` keep using `tk.proxyUrl(provider)` (same-provider streaming passthrough).
+- Pricing is the *resolved* provider's pricing (a Claude call via `/agnostic/openai` bills at Anthropic's rate). The proxy records `provider: anthropic` in your usage logs regardless of the URL.
+- The app's `modelStrategy` still applies — a `models`-pinned app limits which slugs are valid; `tier`-pinned limits them by tier.
+
+For provider-bound calls keep using `tk.proxyUrl()`. `agnosticUrl()` only opts into cross-provider routing — it's not a default.
+
 ### Streaming responses
 
 `tk.call()` is for non-streaming requests. Streaming responses bypass the unified envelope and are forwarded as-is, so use any vendor SDK with `baseURL: tk.proxyUrl(...)`:
@@ -241,6 +271,10 @@ Make an authenticated, non-streaming request through the proxy. Returns a unifie
 
 Get the proxy URL for a specific provider. Use as `baseURL` in a vendor SDK for streaming requests, which bypass the unified envelope.
 
+### `.agnosticUrl(flavor: InboundFlavor) => string`
+
+Base URL for the *agnostic* proxy route — same SDK shape (`flavor`), but the model named in the body is looked up globally across every provider. The user's keys decide which one actually runs the request; the proxy translates the request and response envelopes so your vendor SDK still sees its own shape.
+
 ### `.baseUrl`: `string`
 
 The Tokenite dashboard base URL
@@ -394,6 +428,14 @@ export type TokenResponse = {
 
 export type Provider = 'anthropic' | 'openai' | 'google' | 'grok' | 'bedrock';
 
+/**
+ * The wire flavor a vendor SDK speaks — pick the one matching the SDK
+ * you're using. Used by `tk.agnosticUrl(flavor)` to declare "I want the
+ * shape of flavor X, but I don't care which vendor actually runs the
+ * model I name."
+ */
+export type InboundFlavor = 'anthropic' | 'openai' | 'gemini';
+
 export type ProxyCallOptions = {
   /** The user's Tokenite access token (returned by `tk.exchangeCode()`) */
   readonly accessToken: string;
@@ -549,6 +591,8 @@ export type ModelInfo = {
   readonly displayName: string;
   /** The lab that built the model */
   readonly creator: 'anthropic' | 'openai' | 'google' | 'grok';
+  /** Absolute URL to the creator's logo — use it as the model's icon in a picker */
+  readonly creatorLogoUrl: string;
   /** Capability tiers this model satisfies (cheap / fast / smart / reasoning) */
   readonly tiers: readonly string[];
   /** Feature capabilities, e.g. "vision", "tools", "thinking" */

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { TokeniteConfig, AuthorizeOptions, PopupOptions, PopupResult, TokenResponse, Provider, ProxyCallOptions, ProxyResponse, AccessContext, TopUpOptions, TopUpResult, CallWithRecoveryOptions } from './types.js';
+import type { TokeniteConfig, AuthorizeOptions, PopupOptions, PopupResult, TokenResponse, Provider, ProxyCallOptions, ProxyResponse, AccessContext, InboundFlavor, TopUpOptions, TopUpResult, CallWithRecoveryOptions } from './types.js';
 /**
  * Tokenite client.
  *
@@ -134,6 +134,23 @@ export declare const Tokenite: (config: TokeniteConfig) => {
      * bypass the unified envelope.
      */
     proxyUrl: (provider: Provider) => string;
+    /**
+     * Base URL for the *agnostic* proxy route — same SDK shape (`flavor`),
+     * but the model named in the body is looked up globally across every
+     * provider. The user's keys decide which one actually runs the request;
+     * the proxy translates the request and response envelopes so your
+     * vendor SDK still sees its own shape.
+     *
+     * Useful when you want to write code once against, say, the OpenAI SDK,
+     * but accept any model the user has access to. Point the SDK at:
+     *
+     *   - `agnosticUrl('anthropic')` for `@anthropic-ai/sdk`
+     *   - `agnosticUrl('openai') + '/v1'` for `openai`
+     *   - `agnosticUrl('gemini')` for `@google/genai`
+     *
+     * Non-streaming only. For provider-bound calls keep using `proxyUrl()`.
+     */
+    agnosticUrl: (flavor: InboundFlavor) => string;
     /**
      * Open a Tokenite-hosted "raise budget" popup for this app.
      *

package/dist/client.js

@@ -235,6 +235,10 @@ export const Tokenite = (config) => {
                     ...p,
                     logoUrl: absoluteUrl(p.logoUrl, baseUrl),
                 })),
+                models: data.models.map((m) => ({
+                    ...m,
+                    creatorLogoUrl: absoluteUrl(m.creatorLogoUrl, baseUrl),
+                })),
             };
         },
         /**
@@ -243,6 +247,23 @@ export const Tokenite = (config) => {
          * bypass the unified envelope.
          */
         proxyUrl: (provider) => `${proxyBase}/${provider}`,
+        /**
+         * Base URL for the *agnostic* proxy route — same SDK shape (`flavor`),
+         * but the model named in the body is looked up globally across every
+         * provider. The user's keys decide which one actually runs the request;
+         * the proxy translates the request and response envelopes so your
+         * vendor SDK still sees its own shape.
+         *
+         * Useful when you want to write code once against, say, the OpenAI SDK,
+         * but accept any model the user has access to. Point the SDK at:
+         *
+         *   - `agnosticUrl('anthropic')` for `@anthropic-ai/sdk`
+         *   - `agnosticUrl('openai') + '/v1'` for `openai`
+         *   - `agnosticUrl('gemini')` for `@google/genai`
+         *
+         * Non-streaming only. For provider-bound calls keep using `proxyUrl()`.
+         */
+        agnosticUrl: (flavor) => `${proxyBase}/agnostic/${flavor}`,
         /**
          * Open a Tokenite-hosted "raise budget" popup for this app.
          *

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Tokenite } from './client.js';
-export type { TokeniteConfig, AuthorizeOptions, OAuthPrompt, PopupOptions, PopupResult, TokenResponse, Provider, ProxyCallOptions, ProxyUsage, ProxySuccess, ProxyError, ProxyResponse, ErrorSource, ProviderInfo, ModelInfo, TierInfo, AppInfo, UserInfo, AccessContext, TopUpOptions, TopUpResult, CallWithRecoveryOptions, } from './types.js';
+export type { TokeniteConfig, AuthorizeOptions, OAuthPrompt, PopupOptions, PopupResult, TokenResponse, Provider, ProxyCallOptions, ProxyUsage, ProxySuccess, ProxyError, ProxyResponse, ErrorSource, ProviderInfo, ModelInfo, TierInfo, InboundFlavor, AppInfo, UserInfo, AccessContext, TopUpOptions, TopUpResult, CallWithRecoveryOptions, } from './types.js';
 export { isProxyError, isProxySuccess } from './types.js';
 export { parseCallback } from './parse-callback.js';
 export type { CallbackResult, CallbackSuccess, CallbackError, CallbackReason, ParseCallbackOptions, } from './parse-callback.js';

package/dist/types.d.ts

@@ -133,6 +133,13 @@ export type TokenResponse = {
     readonly token_type: string;
 };
 export type Provider = 'anthropic' | 'openai' | 'google' | 'grok' | 'bedrock';
+/**
+ * The wire flavor a vendor SDK speaks — pick the one matching the SDK
+ * you're using. Used by `tk.agnosticUrl(flavor)` to declare "I want the
+ * shape of flavor X, but I don't care which vendor actually runs the
+ * model I name."
+ */
+export type InboundFlavor = 'anthropic' | 'openai' | 'gemini';
 export type ProxyCallOptions = {
     /** The user's Tokenite access token (returned by `tk.exchangeCode()`) */
     readonly accessToken: string;
@@ -268,6 +275,8 @@ export type ModelInfo = {
     readonly displayName: string;
     /** The lab that built the model */
     readonly creator: 'anthropic' | 'openai' | 'google' | 'grok';
+    /** Absolute URL to the creator's logo — use it as the model's icon in a picker */
+    readonly creatorLogoUrl: string;
     /** Capability tiers this model satisfies (cheap / fast / smart / reasoning) */
     readonly tiers: readonly string[];
     /** Feature capabilities, e.g. "vision", "tools", "thinking" */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokenite/sdk",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "SDK for integrating \"Login with Tokenite\" into your app. Your users bring their own AI tokens — you pay nothing.",
   "type": "module",
   "exports": {