effect-vercel 0.3.0 → 0.5.0

package/dist/ai-gateway.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-gateway.js","names":["VercelOidc.hints","layer","AiGatewayCredentials.AiGatewayCredentials","AiGatewayCredentials.layer","AiGatewayCredentials.formatHeaders"],"sources":["../src/AiGatewayCredentials.ts","../src/AiGateway.ts"],"sourcesContent":["/**\n * How gateway requests authenticate.\n *\n * `AiGatewayCredentials` holds an effect that produces the credential for one\n * request. It runs per request rather than once at startup: on Vercel the OIDC\n * token arrives on the request context and rotates, so it must not be cached.\n * `layer` is the default; pick a `layerFrom*` layer to use one source only.\n *\n * @example\n * ```ts\n * import { AiGatewayCredentials } from \"effect-vercel/ai-gateway\"\n *\n * AiGatewayCredentials.layer           // AI_GATEWAY_API_KEY, else the Vercel OIDC token\n * AiGatewayCredentials.layerFromEnv         // AI_GATEWAY_API_KEY only\n * AiGatewayCredentials.layerFromVercelOidc  // the Vercel OIDC token only\n * AiGatewayCredentials.layerFromApiKey(\"…\") // a fixed value\n * ```\n */\n\nimport { Config, Context, Data, Effect, Layer, Option, Redacted } from \"effect\"\nimport * as VercelOidc from \"./VercelOidc.js\"\n\n/** The environment variable `layerFromEnv` reads. */\nexport const API_KEY_ENV = \"AI_GATEWAY_API_KEY\"\n\n/** Which layer produced or failed to produce a credential. */\nexport type Source = \"api-key\" | \"env\" | \"vercel-oidc\" | \"default\"\n\n/**\n * A credential ready to put on a request. `method` is what the gateway\n * records as the auth method; it matches the values Vercel's own SDK sends.\n */\nexport interface Resolved {\n  readonly method: \"api-key\" | \"oidc\"\n  readonly token: Redacted.Redacted<string>\n}\n\n/** No credential could be produced for a gateway request. */\nexport class AiGatewayCredentialsError extends Data.TaggedError(\"AiGatewayCredentialsError\")<{\n  readonly message: string\n  readonly source: Source\n  readonly hints: ReadonlyArray<string>\n  readonly cause?: unknown\n}> {}\n\nexport class AiGatewayCredentials extends Context.Service<\n  AiGatewayCredentials,\n  Effect.Effect<Resolved, AiGatewayCredentialsError>\n>()(\"effect-vercel/ai-gateway/AiGatewayCredentials\") {}\n\n/** The request headers that carry `credentials`. */\nexport const formatHeaders = (credentials: Resolved): Record<string, string> => ({\n  \"x-api-key\": Redacted.value(credentials.token),\n  \"ai-gateway-auth-method\": credentials.method,\n})\n\nconst hints: Record<Source, ReadonlyArray<string>> = {\n  \"api-key\": [],\n  env: [`Set ${API_KEY_ENV} to an AI Gateway API key.`],\n  \"vercel-oidc\": VercelOidc.hints,\n  default: [\n    `Set ${API_KEY_ENV} to an AI Gateway API key.`,\n    \"Or run on Vercel / `vercel env pull` so an OIDC token is available.\",\n  ],\n}\n\n/**\n * Where a credential may come from. `None` means the place is not configured,\n * so a chain can move on; a failure means it is configured but unusable.\n */\ntype Lookup = Effect.Effect<Option.Option<Resolved>, AiGatewayCredentialsError>\n\nconst apiKeyLookup: Lookup = Config.option(Config.Redacted(API_KEY_ENV)).pipe(\n  Effect.map(Option.map((token) => ({ method: \"api-key\" as const, token }))),\n  Effect.catchTag(\n    \"ConfigError\",\n    (cause) =>\n      new AiGatewayCredentialsError({\n        message: `Failed to read ${API_KEY_ENV}.`,\n        source: \"env\",\n        hints: hints.env,\n        cause,\n      }),\n  ),\n)\n\nconst vercelOidcLookup: Lookup = VercelOidc.find.pipe(\n  Effect.map(Option.map((token) => ({ method: \"oidc\" as const, token }))),\n  Effect.mapError(\n    (cause) =>\n      new AiGatewayCredentialsError({\n        message: cause.message,\n        source: \"vercel-oidc\",\n        hints: cause.hints,\n        cause,\n      }),\n  ),\n)\n\nconst firstOf = (lookups: ReadonlyArray<Lookup>): Lookup =>\n  Effect.gen(function* () {\n    for (const lookup of lookups) {\n      const found = yield* lookup\n      if (Option.isSome(found)) return found\n    }\n    return Option.none()\n  })\n\nconst toLayer = (lookup: Lookup, source: Source, message: string) =>\n  Layer.succeed(AiGatewayCredentials)(\n    Effect.flatMap(lookup, (found) =>\n      Option.isSome(found)\n        ? Effect.succeed(found.value)\n        : Effect.fail(new AiGatewayCredentialsError({ message, source, hints: hints[source] })),\n    ),\n  )\n\n/** A fixed API key. */\nexport const layerFromApiKey = (\n  apiKey: string | Redacted.Redacted<string>,\n): Layer.Layer<AiGatewayCredentials> =>\n  Layer.succeed(AiGatewayCredentials)(\n    Effect.succeed({\n      method: \"api-key\",\n      token: Redacted.isRedacted(apiKey) ? apiKey : Redacted.make(apiKey),\n    }),\n  )\n\n/** `AI_GATEWAY_API_KEY`: local dev, CI, or anywhere off Vercel. */\nexport const layerFromEnv: Layer.Layer<AiGatewayCredentials> = toLayer(\n  apiKeyLookup,\n  \"env\",\n  `${API_KEY_ENV} is not set.`,\n)\n\n/** The Vercel OIDC token (see `VercelOidc.find`). Not refreshed when it expires locally. */\nexport const layerFromVercelOidc: Layer.Layer<AiGatewayCredentials> = toLayer(\n  vercelOidcLookup,\n  \"vercel-oidc\",\n  \"No Vercel OIDC token is available.\",\n)\n\n/**\n * The default: `layerFromEnv`, then `layerFromVercelOidc`. Same order as\n * Vercel's own SDK, so it works locally with an API key and on Vercel without\n * one.\n */\nexport const layer: Layer.Layer<AiGatewayCredentials> = toLayer(\n  firstOf([apiKeyLookup, vercelOidcLookup]),\n  \"default\",\n  \"No AI Gateway credential found.\",\n)\n","/**\n * Vercel AI Gateway as an Anthropic Messages API client for Effect AI.\n *\n * The gateway serves the Anthropic Messages API at its root URL and accepts\n * any model it lists, named `provider/model` (for example\n * `anthropic/claude-sonnet-4.5` or `google/gemini-2.5-flash`). Effect AI's\n * Anthropic provider only needs the base URL and the credential swapped, plus\n * two small dialect fixes (see `dropNullCacheControl` and\n * `fillMissingResponseKeys`), so this module is the one place the gateway is\n * configured.\n *\n * Structured output (`output_config.format`) works for every provider behind\n * the gateway, so the Anthropic provider's default of native structured\n * output holds for models it does not recognise.\n *\n * @example\n * ```ts\n * import { AiGateway } from \"effect-vercel/ai-gateway\"\n * import { AnthropicLanguageModel } from \"@effect/ai-anthropic\"\n * import { Layer } from \"effect\"\n * import { FetchHttpClient } from \"effect/http\"\n *\n * const Model = AnthropicLanguageModel.layer({ model: \"anthropic/claude-sonnet-4.5\" }).pipe(\n *   Layer.provide(AiGateway.layer),\n *   Layer.provide(FetchHttpClient.layer),\n * )\n * ```\n */\n\nimport { AnthropicClient } from \"@effect/ai-anthropic\"\nimport { Effect, Layer } from \"effect\"\nimport {\n  HttpBody,\n  HttpClient,\n  HttpClientError,\n  HttpClientRequest,\n  HttpClientResponse,\n} from \"effect/http\"\nimport * as AiGatewayCredentials from \"./AiGatewayCredentials.js\"\n\n/** Base URL of the Vercel AI Gateway. */\nexport const AI_GATEWAY_URL = \"https://ai-gateway.vercel.sh\"\n\n/**\n * Builds the Anthropic client against the gateway, authenticating each\n * request with `credentials`. A credential failure fails that request as an\n * `HttpClientError`, which Effect AI surfaces as a network `AiError`.\n */\nexport const make = (credentials: typeof AiGatewayCredentials.AiGatewayCredentials.Service) =>\n  AnthropicClient.make({\n    apiUrl: AI_GATEWAY_URL,\n    transformClient: (client) =>\n      client.pipe(\n        HttpClient.mapRequestEffect(authenticate(credentials)),\n        HttpClient.mapRequest(dropNullCacheControl),\n        HttpClient.transformResponse(Effect.flatMap(fillMissingResponseKeys)),\n      ),\n  })\n\n/**\n * `AnthropicClient` backed by the gateway, authenticating with the\n * `AiGatewayCredentials` you provide (see that module's `layerFrom*` layers).\n * Needs an `HttpClient` too.\n */\nexport const layerWithoutCredentials: Layer.Layer<\n  AnthropicClient.AnthropicClient,\n  never,\n  AiGatewayCredentials.AiGatewayCredentials | HttpClient.HttpClient\n> = Layer.effect(AnthropicClient.AnthropicClient)(\n  Effect.flatMap(Effect.service(AiGatewayCredentials.AiGatewayCredentials), make),\n)\n\n/**\n * `layerWithoutCredentials` with the default `AiGatewayCredentials.layer`:\n * `AI_GATEWAY_API_KEY`, else the Vercel OIDC token. Needs an `HttpClient`.\n * Building never fails; without a usable credential, the requests fail.\n */\nexport const layer: Layer.Layer<AnthropicClient.AnthropicClient, never, HttpClient.HttpClient> =\n  layerWithoutCredentials.pipe(Layer.provide(AiGatewayCredentials.layer))\n\nfunction authenticate(credentials: typeof AiGatewayCredentials.AiGatewayCredentials.Service) {\n  return (request: HttpClientRequest.HttpClientRequest) =>\n    credentials.pipe(\n      Effect.map((resolved) =>\n        HttpClientRequest.setHeaders(request, AiGatewayCredentials.formatHeaders(resolved)),\n      ),\n      Effect.mapError(\n        (error) =>\n          new HttpClientError.HttpClientError({\n            reason: new HttpClientError.TransportError({\n              request,\n              cause: error,\n              description: \"AI Gateway credential unavailable\",\n            }),\n          }),\n      ),\n    )\n}\n\n/**\n * The Effect provider writes `\"cache_control\": null` on every content block\n * it has no cache setting for. Anthropic accepts that; the gateway rejects\n * the request with `messages.0.content: Invalid input`. Remove the null keys.\n */\nexport function dropNullCacheControl(\n  request: HttpClientRequest.HttpClientRequest,\n): HttpClientRequest.HttpClientRequest {\n  const body = request.body\n  if (body._tag !== \"Uint8Array\" || !isJson(body.contentType)) {\n    return request\n  }\n  const json: unknown = JSON.parse(new TextDecoder().decode(body.body))\n  return HttpClientRequest.setBody(\n    request,\n    HttpBody.jsonUnsafe(withoutNullCacheControl(json), body.contentType),\n  )\n}\n\nfunction withoutNullCacheControl(value: unknown): unknown {\n  if (Array.isArray(value)) return value.map(withoutNullCacheControl)\n  if (value === null || typeof value !== \"object\") return value\n  const result: Record<string, unknown> = {}\n  for (const [key, entry] of Object.entries(value)) {\n    if (key === \"cache_control\" && entry === null) continue\n    result[key] = withoutNullCacheControl(entry)\n  }\n  return result\n}\n\n/**\n * The gateway's Anthropic-shaped responses leave out keys that Anthropic\n * always sends and the Effect provider's schema requires: the cache and\n * service-tier usage fields, the `signature` of a thinking block from a\n * non-Anthropic model, and `type`/`request_id` on error envelopes, whose\n * `error.type` may also be a gateway-specific value. Fill them with the values\n * Anthropic uses when there is nothing to report. Streaming responses are not\n * JSON and pass through untouched.\n */\nexport function fillMissingResponseKeys(\n  response: HttpClientResponse.HttpClientResponse,\n): Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError> {\n  if (!isJson(response.headers[\"content-type\"] ?? \"\")) {\n    return Effect.succeed(response)\n  }\n  return Effect.map(response.text, (text) => {\n    const body = JSON.parse(text) as Record<string, unknown>\n    return HttpClientResponse.fromWeb(\n      response.request,\n      new Response(JSON.stringify(patchResponseBody(body)), {\n        status: response.status,\n        headers: response.headers,\n      }),\n    )\n  })\n}\n\nexport function patchResponseBody(body: Record<string, unknown>): Record<string, unknown> {\n  if (body.type === \"message\") {\n    const usage = (body.usage ?? {}) as Record<string, unknown>\n    body.usage = {\n      cache_creation: null,\n      cache_creation_input_tokens: null,\n      cache_read_input_tokens: null,\n      inference_geo: null,\n      service_tier: null,\n      ...usage,\n    }\n    if (Array.isArray(body.content)) {\n      body.content = body.content.map((block: unknown) =>\n        isRecord(block) && block.type === \"thinking\" ? { signature: \"\", ...block } : block,\n      )\n    }\n    return body\n  }\n  if (isRecord(body.error)) {\n    const error = ANTHROPIC_ERROR_TYPES.has(String(body.error.type))\n      ? body.error\n      : { ...body.error, type: \"api_error\" }\n    return { type: \"error\", request_id: null, ...body, error }\n  }\n  return body\n}\n\nconst ANTHROPIC_ERROR_TYPES = new Set([\n  \"invalid_request_error\",\n  \"authentication_error\",\n  \"billing_error\",\n  \"permission_error\",\n  \"not_found_error\",\n  \"rate_limit_error\",\n  \"timeout_error\",\n  \"api_error\",\n  \"overloaded_error\",\n])\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value)\n}\n\nfunction isJson(contentType: string): boolean {\n  return contentType.startsWith(\"application/json\")\n}\n"],"mappings":"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"}

package/dist/oidc.d.ts

@@ -1,27 +0,0 @@
-import { Effect, Option, Redacted } from "effect";
-declare namespace VercelOidc_d_exports {
-  export { TOKEN_ENV, VercelOidcError, find, hints, token };
-}
-/** The environment variable read when no request carries a token. */
-declare const TOKEN_ENV = "VERCEL_OIDC_TOKEN";
-declare const VercelOidcError_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: "VercelOidcError";
-} & Readonly<A>;
-/** No usable OIDC token. */
-declare class VercelOidcError extends VercelOidcError_base<{
-  readonly message: string;
-  readonly hints: ReadonlyArray<string>;
-  readonly cause?: unknown;
-}> {}
-/** How to make a token available. */
-declare const hints: ReadonlyArray<string>;
-/**
- * The token if one is available: the request header, else `VERCEL_OIDC_TOKEN`.
- * `None` means neither is set, so a caller can fall back to something else.
- */
-declare const find: Effect.Effect<Option.Option<Redacted.Redacted<string>>, VercelOidcError>;
-/** Like `find`, but fails when no token is available. */
-declare const token: Effect.Effect<Redacted.Redacted<string>, VercelOidcError>;
-//#endregion
-export { VercelOidc_d_exports as VercelOidc };
-//# sourceMappingURL=oidc.d.ts.map

package/dist/oidc.js

@@ -1,2 +0,0 @@
-import { t as VercelOidc_exports } from "./VercelOidc-DCkdXW3E.js";
-export { VercelOidc_exports as VercelOidc };

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -1,13 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll as t };

package/dist/runtime-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-cache.js","names":[],"sources":["../src/VercelRuntimeCache.ts"],"sourcesContent":["/**\n * Effect `Persistence` backed by the Vercel Runtime Cache, so a\n * `PersistedCache` shares results across Function instances in a region.\n *\n * Outside Vercel, `getCache` falls back to an in-memory cache, so the same\n * layer works in local dev and tests.\n *\n * @example\n * ```ts\n * import { VercelRuntimeCache } from \"effect-vercel/runtime-cache\"\n * import { Effect } from \"effect\"\n * import { PersistedCache } from \"effect/persistence\"\n *\n * const program = Effect.gen(function* () {\n *   const users = yield* PersistedCache.make(fetchUser, {\n *     storeId: \"users\",\n *     timeToLive: () => \"1 hour\",\n *   })\n *   return yield* users.get(new GetUser({ id: 1 }))\n * }).pipe(Effect.scoped, Effect.provide(VercelRuntimeCache.layer))\n * ```\n */\n\nimport { createHash } from \"node:crypto\"\nimport { getCache, type RuntimeCache } from \"@vercel/functions\"\nimport { Duration, Effect, Layer } from \"effect\"\nimport { Persistence } from \"effect/persistence\"\n\nconst sha256 = (key: string) => createHash(\"sha256\").update(key).digest(\"hex\")\n\n/**\n * A `BackingPersistence` over `cache`.\n *\n * Entries are keyed by the JSON pair `[storeId, key]`, so no two stores share\n * a key. Each entry is tagged with a hash of the store id, since tags are\n * joined with `,` and sent unescaped, and `clear` expires that tag. Entries\n * are sent without a name, so keys don't reach Vercel's o11y or the request\n * headers, where non-Latin-1 characters would make the write fail. TTLs round\n * up to whole seconds, the cache's resolution.\n *\n * `getCache()` hashes keys with a 32-bit hash by default, which can collide.\n * Pass a cache made with a stronger `keyHashFunction`, as `layerBacking` does.\n */\nexport const makeBacking = (cache: RuntimeCache): Persistence.BackingPersistence[\"Service\"] =>\n  Persistence.BackingPersistence.of({\n    make: (storeId) =>\n      Effect.sync(() => {\n        const prefixed = (key: string) => JSON.stringify([storeId, key])\n        const tag = `effect-persistence:${sha256(storeId)}`\n\n        const get = (key: string) =>\n          Effect.tryPromise({\n            try: () => cache.get(prefixed(key)),\n            catch: (cause) =>\n              new Persistence.PersistenceError({ message: `Failed to get key ${key}`, cause }),\n          }).pipe(\n            Effect.map((value) =>\n              typeof value === \"object\" && value !== null ? value : undefined,\n            ),\n          )\n\n        const set = (key: string, value: object, ttl: Duration.Duration | undefined) =>\n          Effect.tryPromise({\n            try: () =>\n              cache.set(prefixed(key), value, {\n                name: \"\",\n                tags: [tag],\n                ...(ttl && { ttl: Math.max(1, Math.ceil(Duration.toSeconds(ttl))) }),\n              }),\n            catch: (cause) =>\n              new Persistence.PersistenceError({ message: `Failed to set key ${key}`, cause }),\n          })\n\n        return {\n          get,\n          getMany: (keys) => Effect.forEach(keys, get, { concurrency: \"unbounded\" }),\n          set,\n          // Writes run concurrently, so keep only the last entry for each key.\n          setMany: (entries) =>\n            Effect.forEach(\n              new Map(entries.map(([key, value, ttl]) => [key, [value, ttl] as const])),\n              ([key, [value, ttl]]) => set(key, value, ttl),\n              { concurrency: \"unbounded\", discard: true },\n            ),\n          remove: (key) =>\n            Effect.tryPromise({\n              try: () => cache.delete(prefixed(key)),\n              catch: (cause) =>\n                new Persistence.PersistenceError({ message: `Failed to remove key ${key}`, cause }),\n            }),\n          clear: Effect.tryPromise({\n            try: () => cache.expireTag(tag),\n            catch: (cause) =>\n              new Persistence.PersistenceError({ message: `Failed to clear ${storeId}`, cause }),\n          }),\n        }\n      }),\n  })\n\n/** `BackingPersistence` over `getCache()`, with SHA-256 key hashing. */\nexport const layerBacking: Layer.Layer<Persistence.BackingPersistence> = Layer.sync(\n  Persistence.BackingPersistence,\n)(() => makeBacking(getCache({ keyHashFunction: sha256 })))\n\n/** `Persistence` backed by the Vercel Runtime Cache. */\nexport const layer: Layer.Layer<Persistence.Persistence> = Persistence.layer.pipe(\n  Layer.provide(layerBacking),\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAM,UAAU,QAAgB,WAAW,QAAQ,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,KAAK;;;;;;;;;;;;;;AAe7E,MAAa,eAAe,UAC1B,YAAY,mBAAmB,GAAG,EAChC,OAAO,YACL,OAAO,WAAW;CAChB,MAAM,YAAY,QAAgB,KAAK,UAAU,CAAC,SAAS,GAAG,CAAC;CAC/D,MAAM,MAAM,sBAAsB,OAAO,OAAO;CAEhD,MAAM,OAAO,QACX,OAAO,WAAW;EAChB,WAAW,MAAM,IAAI,SAAS,GAAG,CAAC;EAClC,QAAQ,UACN,IAAI,YAAY,iBAAiB;GAAE,SAAS,qBAAqB;GAAO;EAAM,CAAC;CACnF,CAAC,CAAC,CAAC,KACD,OAAO,KAAK,UACV,OAAO,UAAU,YAAY,UAAU,OAAO,QAAQ,KAAA,CACxD,CACF;CAEF,MAAM,OAAO,KAAa,OAAe,QACvC,OAAO,WAAW;EAChB,WACE,MAAM,IAAI,SAAS,GAAG,GAAG,OAAO;GAC9B,MAAM;GACN,MAAM,CAAC,GAAG;GACV,GAAI,OAAO,EAAE,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,SAAS,UAAU,GAAG,CAAC,CAAC,EAAE;EACpE,CAAC;EACH,QAAQ,UACN,IAAI,YAAY,iBAAiB;GAAE,SAAS,qBAAqB;GAAO;EAAM,CAAC;CACnF,CAAC;CAEH,OAAO;EACL;EACA,UAAU,SAAS,OAAO,QAAQ,MAAM,KAAK,EAAE,aAAa,YAAY,CAAC;EACzE;EAEA,UAAU,YACR,OAAO,QACL,IAAI,IAAI,QAAQ,KAAK,CAAC,KAAK,OAAO,SAAS,CAAC,KAAK,CAAC,OAAO,GAAG,CAAU,CAAC,CAAC,IACvE,CAAC,KAAK,CAAC,OAAO,UAAU,IAAI,KAAK,OAAO,GAAG,GAC5C;GAAE,aAAa;GAAa,SAAS;EAAK,CAC5C;EACF,SAAS,QACP,OAAO,WAAW;GAChB,WAAW,MAAM,OAAO,SAAS,GAAG,CAAC;GACrC,QAAQ,UACN,IAAI,YAAY,iBAAiB;IAAE,SAAS,wBAAwB;IAAO;GAAM,CAAC;EACtF,CAAC;EACH,OAAO,OAAO,WAAW;GACvB,WAAW,MAAM,UAAU,GAAG;GAC9B,QAAQ,UACN,IAAI,YAAY,iBAAiB;IAAE,SAAS,mBAAmB;IAAW;GAAM,CAAC;EACrF,CAAC;CACH;AACF,CAAC,EACL,CAAC;;AAGH,MAAa,eAA4D,MAAM,KAC7E,YAAY,kBACd,CAAC,OAAO,YAAY,SAAS,EAAE,iBAAiB,OAAO,CAAC,CAAC,CAAC;;AAG1D,MAAa,QAA8C,YAAY,MAAM,KAC3E,MAAM,QAAQ,YAAY,CAC5B"}

package/src/VercelOidc.ts

@@ -1,86 +0,0 @@
-/**
- * The OIDC token Vercel issues to a deployment.
- *
- * In Functions the token arrives on each request as the `x-vercel-oidc-token`
- * header and rotates, so it is read on every run of `token`/`find`, never
- * cached. In builds and after `vercel env pull` it is `VERCEL_OIDC_TOKEN`.
- * Use it to authenticate to the AI Gateway, or exchange it for cloud
- * credentials (AWS `AssumeRoleWithWebIdentity`, GCP workload identity
- * federation).
- *
- * @example
- * ```ts
- * import { VercelOidc } from "effect-vercel/oidc"
- * import { Effect, Redacted } from "effect"
- *
- * const program = Effect.gen(function* () {
- *   const token = yield* VercelOidc.token
- *   // pass Redacted.value(token) as the web identity token
- * })
- * ```
- */
-
-import { Config, Data, Effect, Option, Redacted } from "effect"
-
-/** The environment variable read when no request carries a token. */
-export const TOKEN_ENV = "VERCEL_OIDC_TOKEN"
-
-/** No usable OIDC token. */
-export class VercelOidcError extends Data.TaggedError("VercelOidcError")<{
-  readonly message: string
-  readonly hints: ReadonlyArray<string>
-  readonly cause?: unknown
-}> {}
-
-/** How to make a token available. */
-export const hints: ReadonlyArray<string> = [
-  "Run on Vercel, where each request carries an OIDC token.",
-  `Or run \`vercel env pull\` locally to populate ${TOKEN_ENV}.`,
-]
-
-/**
- * Vercel exposes the current request's context on a well-known global symbol.
- * In Functions, the `x-vercel-oidc-token` header of the request lives there.
- * Mirrors `@vercel/oidc`'s `getVercelOidcTokenSync`, minus the dev-time
- * refresh that package also offers.
- */
-const REQUEST_CONTEXT = Symbol.for("@vercel/request-context")
-
-type RequestContext = { readonly headers?: Record<string, string | undefined> }
-
-const fromRequestContext = Effect.sync(() => {
-  const holder = globalThis as typeof globalThis & {
-    [REQUEST_CONTEXT]?: { get?: () => RequestContext | undefined }
-  }
-  return Option.fromNullishOr(
-    holder[REQUEST_CONTEXT]?.get?.()?.headers?.["x-vercel-oidc-token"],
-  ).pipe(Option.map(Redacted.make))
-})
-
-const fromEnv = Config.option(Config.Redacted(TOKEN_ENV)).pipe(
-  Effect.catchTag(
-    "ConfigError",
-    (cause) => new VercelOidcError({ message: `Failed to read ${TOKEN_ENV}.`, hints, cause }),
-  ),
-)
-
-/**
- * The token if one is available: the request header, else `VERCEL_OIDC_TOKEN`.
- * `None` means neither is set, so a caller can fall back to something else.
- */
-export const find: Effect.Effect<
-  Option.Option<Redacted.Redacted<string>>,
-  VercelOidcError
-> = Effect.flatMap(fromRequestContext, (found) =>
-  Option.isSome(found) ? Effect.succeed(found) : fromEnv,
-)
-
-/** Like `find`, but fails when no token is available. */
-export const token: Effect.Effect<Redacted.Redacted<string>, VercelOidcError> = Effect.flatMap(
-  find,
-  Option.match({
-    onNone: () =>
-      Effect.fail(new VercelOidcError({ message: "No Vercel OIDC token is available.", hints })),
-    onSome: Effect.succeed,
-  }),
-)

package/src/ai-gateway.ts

@@ -1,2 +0,0 @@
-export * as AiGateway from "./AiGateway.js"
-export * as AiGatewayCredentials from "./AiGatewayCredentials.js"

package/src/oidc.ts

@@ -1 +0,0 @@
-export * as VercelOidc from "./VercelOidc.js"

package/src/runtime-cache.ts

@@ -1 +0,0 @@
-export * as VercelRuntimeCache from "./VercelRuntimeCache.js"