@arnilo/prism-provider-openai 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to @arnilo/prism-provider-openai will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Added `LICENSE` (MIT) and `CHANGELOG.md`.
+- Added npm package metadata: `license`, `repository`, `bugs`, `homepage`,
+  `keywords`, and `sideEffects`.
+
+### Changed
+
+- `files` whitelist now explicitly excludes `dist/__tests__/` and
+  `dist/**/*.map` from published tarballs.
+- Made `prism` a required peer dependency; it is no longer optional.
+
+## [0.0.1] - 2026-06-22
+
+### Added
+
+- Initial release of @arnilo/prism-provider-openai.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Prism contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+# @arnilo/prism-provider-openai
+
+OpenAI provider package for Prism.
+
+```ts
+import { createOpenAIProviderPackage } from "@arnilo/prism-provider-openai";
+
+api.registerProviderPackage(createOpenAIProviderPackage({ apiKey: "fake-openai-key" }));
+```
+
+Exports:
+- `createOpenAIProviderPackage()`
+- `createOpenAIResponsesProvider()`
+- `createOpenAICodexProvider()`
+- `openAIModels`, `openAICodexModels`
+- `createOpenAICodexOAuthProvider()`, `openAICodexOAuthProvider`
+
+Security defaults:
+- No network calls during import, setup, build, or default tests.
+- No automatic environment, file, keychain, or shell credential lookup.
+- API keys/access tokens are resolved per request from caller-supplied values or resolvers.
+- Live tests must stay opt-in behind `PRISM_LIVE_PROVIDER_TESTS=1` plus fake-safe provider-specific env names.

package/dist/cache.d.ts

@@ -0,0 +1,3 @@
+import type { CacheRetention, ProviderRequestOptions } from "@arnilo/prism";
+export declare function promptCacheKey(options: ProviderRequestOptions | undefined): string | undefined;
+export declare function promptCacheRetention(options: ProviderRequestOptions | undefined): CacheRetention | undefined;

package/dist/cache.js

@@ -0,0 +1,8 @@
+export function promptCacheKey(options) {
+    const key = options?.cacheKey ?? options?.sessionId;
+    return key ? key.slice(0, 64) : undefined;
+}
+export function promptCacheRetention(options) {
+    return options?.cacheRetention === "none" ? undefined : options?.cacheRetention;
+}
+//# sourceMappingURL=cache.js.map

package/dist/codex.d.ts

@@ -0,0 +1,7 @@
+import type { AIProvider, CredentialValueSource } from "@arnilo/prism";
+import { type OpenAIResponsesProviderOptions } from "./responses.js";
+export interface OpenAICodexProviderOptions extends Omit<OpenAIResponsesProviderOptions, "id" | "apiKey"> {
+    readonly id?: string;
+    readonly accessToken?: CredentialValueSource;
+}
+export declare function createOpenAICodexProvider(options?: OpenAICodexProviderOptions): AIProvider;

package/dist/codex.js

@@ -0,0 +1,12 @@
+import { createOpenAIResponsesProvider } from "./responses.js";
+export function createOpenAICodexProvider(options = {}) {
+    // ponytail: Codex subscription Responses endpoint is distinct from the plain
+    // API-key base URL; keep them separate so OAuth tokens never silently hit /v1.
+    return createOpenAIResponsesProvider({
+        id: options.id ?? "openai-codex",
+        baseUrl: options.baseUrl ?? "https://chatgpt.com/backend-api/codex",
+        apiKey: options.accessToken,
+        fetch: options.fetch,
+    });
+}
+//# sourceMappingURL=codex.js.map

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { type CredentialValueSource, type ProviderPackage } from "@arnilo/prism";
+export interface OpenAIProviderPackageOptions {
+    readonly apiKey?: CredentialValueSource;
+    readonly codexAccessToken?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+    readonly baseUrl?: string;
+    readonly codexBaseUrl?: string;
+}
+export declare function createOpenAIProviderPackage(options?: OpenAIProviderPackageOptions): ProviderPackage;
+export { createOpenAIResponsesProvider, type OpenAIResponsesProviderOptions } from "./responses.js";
+export { createOpenAICodexProvider, type OpenAICodexProviderOptions } from "./codex.js";
+export { openAIModels, openAICodexModels } from "./models.js";
+export { createOpenAICodexOAuthProvider, openAICodexOAuthProvider, type OpenAICodexOAuthOptions, createPkceVerifier, computeS256Challenge } from "./oauth.js";

package/dist/index.js

@@ -0,0 +1,27 @@
+import { defineProviderPackage } from "@arnilo/prism";
+import { createOpenAICodexProvider } from "./codex.js";
+import { openAICodexModels, openAIModels } from "./models.js";
+import { openAICodexOAuthProvider } from "./oauth.js";
+import { createOpenAIResponsesProvider } from "./responses.js";
+export function createOpenAIProviderPackage(options = {}) {
+    return defineProviderPackage({
+        name: "@arnilo/prism-provider-openai",
+        description: "OpenAI provider package for Prism.",
+        docs: { links: ["docs/providers/openai.md"] },
+        setup(api) {
+            api.registerProvider(createOpenAIResponsesProvider({ apiKey: options.apiKey, baseUrl: options.baseUrl, fetch: options.fetch }));
+            api.registerProvider(createOpenAICodexProvider({ accessToken: options.codexAccessToken, baseUrl: options.codexBaseUrl, fetch: options.fetch }));
+            for (const model of openAIModels)
+                api.registerModel(model);
+            for (const model of openAICodexModels)
+                api.registerModel(model);
+            api.registerAuthMethod({ kind: "api_key", provider: "openai", credentialName: "apiKey" });
+            api.registerAuthMethod({ kind: "oauth", provider: "openai-codex", oauth: openAICodexOAuthProvider });
+        },
+    });
+}
+export { createOpenAIResponsesProvider } from "./responses.js";
+export { createOpenAICodexProvider } from "./codex.js";
+export { openAIModels, openAICodexModels } from "./models.js";
+export { createOpenAICodexOAuthProvider, openAICodexOAuthProvider, createPkceVerifier, computeS256Challenge } from "./oauth.js";
+//# sourceMappingURL=index.js.map

package/dist/models.d.ts

@@ -0,0 +1,38 @@
+export declare const openAIModels: readonly [{
+    readonly provider: "openai";
+    readonly model: "gpt-5.1";
+    readonly displayName: "GPT-5.1";
+    readonly capabilities: {
+        readonly input: readonly ["text", "image"];
+        readonly output: readonly ["text"];
+        readonly reasoning: true;
+        readonly tools: true;
+        readonly streaming: true;
+    };
+    readonly limits: {
+        readonly contextWindow: 400000;
+        readonly maxOutputTokens: 128000;
+    };
+    readonly compat: {
+        readonly api: "openai-responses";
+    };
+}];
+export declare const openAICodexModels: readonly [{
+    readonly provider: "openai-codex";
+    readonly model: "gpt-5.1-codex";
+    readonly displayName: "GPT-5.1 Codex";
+    readonly capabilities: {
+        readonly input: readonly ["text"];
+        readonly output: readonly ["text"];
+        readonly reasoning: true;
+        readonly tools: true;
+        readonly streaming: true;
+    };
+    readonly limits: {
+        readonly contextWindow: 400000;
+        readonly maxOutputTokens: 128000;
+    };
+    readonly compat: {
+        readonly api: "openai-codex-responses";
+    };
+}];

package/dist/models.js

@@ -0,0 +1,21 @@
+export const openAIModels = [
+    {
+        provider: "openai",
+        model: "gpt-5.1",
+        displayName: "GPT-5.1",
+        capabilities: { input: ["text", "image"], output: ["text"], reasoning: true, tools: true, streaming: true },
+        limits: { contextWindow: 400_000, maxOutputTokens: 128_000 },
+        compat: { api: "openai-responses" },
+    },
+];
+export const openAICodexModels = [
+    {
+        provider: "openai-codex",
+        model: "gpt-5.1-codex",
+        displayName: "GPT-5.1 Codex",
+        capabilities: { input: ["text"], output: ["text"], reasoning: true, tools: true, streaming: true },
+        limits: { contextWindow: 400_000, maxOutputTokens: 128_000 },
+        compat: { api: "openai-codex-responses" },
+    },
+];
+//# sourceMappingURL=models.js.map

package/dist/oauth.d.ts

@@ -0,0 +1,19 @@
+import type { OAuthProvider } from "@arnilo/prism";
+export interface OpenAICodexOAuthOptions {
+    readonly clientId?: string;
+    readonly fetch?: typeof fetch;
+    readonly authorizeUrl?: string;
+    readonly tokenUrl?: string;
+    readonly deviceCodeUrl?: string;
+    readonly redirectUri?: string;
+    readonly scope?: string;
+}
+export declare const openAICodexOAuthProvider: OAuthProvider;
+/**
+ * RFC 7636 PKCE code verifier: 43-128 chars from the unreserved set.
+ * base64url(32 random bytes) yields exactly 43 chars, all unreserved.
+ */
+export declare function createPkceVerifier(bytes?: number): string;
+/** S256 code challenge: base64url(SHA-256(verifier)). */
+export declare function computeS256Challenge(verifier: string): string;
+export declare function createOpenAICodexOAuthProvider(options?: OpenAICodexOAuthOptions): OAuthProvider;

package/dist/oauth.js

@@ -0,0 +1,94 @@
+import { createHash, randomBytes } from "node:crypto";
+export const openAICodexOAuthProvider = createOpenAICodexOAuthProvider();
+const REDACTED = "[REDACTED]";
+/**
+ * RFC 7636 PKCE code verifier: 43-128 chars from the unreserved set.
+ * base64url(32 random bytes) yields exactly 43 chars, all unreserved.
+ */
+export function createPkceVerifier(bytes = 32) {
+    return randomBytes(bytes).toString("base64url");
+}
+/** S256 code challenge: base64url(SHA-256(verifier)). */
+export function computeS256Challenge(verifier) {
+    return createHash("sha256").update(verifier).digest("base64url");
+}
+export function createOpenAICodexOAuthProvider(options = {}) {
+    const clientId = options.clientId ?? "prism-codex";
+    const fetchImpl = options.fetch ?? fetch;
+    const tokenUrl = options.tokenUrl ?? "https://auth.openai.com/oauth/token";
+    const authorizeUrl = options.authorizeUrl ?? "https://auth.openai.com/oauth/authorize";
+    const deviceCodeUrl = options.deviceCodeUrl ?? "https://auth.openai.com/oauth/device/code";
+    return {
+        id: "openai-codex",
+        async login(callbacks) {
+            if (callbacks?.onDeviceCode) {
+                return deviceLogin({ callbacks, clientId, fetchImpl, tokenUrl, deviceCodeUrl, scope: options.scope });
+            }
+            const verifier = createPkceVerifier();
+            const challenge = computeS256Challenge(verifier);
+            const params = new URLSearchParams({
+                client_id: clientId,
+                code_challenge: challenge,
+                code_challenge_method: "S256",
+                response_type: "code",
+            });
+            if (options.redirectUri)
+                params.set("redirect_uri", options.redirectUri);
+            if (options.scope)
+                params.set("scope", options.scope);
+            await callbacks?.onAuth?.(`${authorizeUrl}?${params}`);
+            const code = await callbacks?.onPrompt?.("OpenAI authorization code");
+            if (!code)
+                throw new Error("OpenAI authorization code was not provided");
+            return tokenRequest(fetchImpl, tokenUrl, {
+                grant_type: "authorization_code",
+                client_id: clientId,
+                code,
+                code_verifier: verifier,
+                ...(options.redirectUri ? { redirect_uri: options.redirectUri } : {}),
+            });
+        },
+        refresh(credentials) {
+            if (!credentials.refresh)
+                return credentials;
+            return tokenRequest(fetchImpl, tokenUrl, { grant_type: "refresh_token", client_id: clientId, refresh_token: credentials.refresh }, [credentials.access, credentials.refresh].filter((s) => Boolean(s)));
+        },
+        getCredential(credentials) {
+            return credentials.access ? { type: "bearer", value: credentials.access, metadata: { accountId: credentials.accountId, expires: credentials.expires } } : undefined;
+        },
+    };
+}
+async function deviceLogin(options) {
+    const body = { client_id: options.clientId };
+    if (options.scope)
+        body.scope = options.scope;
+    const response = await options.fetchImpl(options.deviceCodeUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok)
+        throw new Error(`OpenAI device code failed: ${response.status} ${await response.text()}`);
+    const json = await response.json();
+    await options.callbacks.onDeviceCode?.({ userCode: json.user_code, verificationUri: json.verification_uri, expiresAt: json.expires_in ? new Date(Date.now() + json.expires_in * 1000).toISOString() : undefined });
+    return tokenRequest(options.fetchImpl, options.tokenUrl, {
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        client_id: options.clientId,
+        device_code: json.device_code,
+    });
+}
+async function tokenRequest(fetchImpl, url, body, secrets = []) {
+    const response = await fetchImpl(url, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+    if (!response.ok)
+        throw redact(new Error(`OpenAI token request failed: ${response.status} ${await response.text()}`), secrets);
+    const json = await response.json();
+    return { access: json.access_token, refresh: json.refresh_token, expires: json.expires_in ? Date.now() + json.expires_in * 1000 : undefined, accountId: json.account_id };
+}
+function redact(error, secrets) {
+    let message = error.message;
+    for (const secret of secrets)
+        if (secret)
+            message = message.split(secret).join(REDACTED);
+    return new Error(message);
+}
+//# sourceMappingURL=oauth.js.map

package/dist/responses.d.ts

@@ -0,0 +1,8 @@
+import type { AIProvider, CredentialValueSource } from "@arnilo/prism";
+export interface OpenAIResponsesProviderOptions {
+    readonly id?: string;
+    readonly baseUrl?: string;
+    readonly apiKey?: CredentialValueSource;
+    readonly fetch?: typeof fetch;
+}
+export declare function createOpenAIResponsesProvider(options?: OpenAIResponsesProviderOptions): AIProvider;

package/dist/responses.js

@@ -0,0 +1,155 @@
+import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, resolveCredentialValue, toolCallContent } from "@arnilo/prism";
+import { promptCacheKey, promptCacheRetention } from "./cache.js";
+import { readSseData } from "./sse.js";
+export function createOpenAIResponsesProvider(options = {}) {
+    const id = options.id ?? "openai";
+    return {
+        id,
+        async *generate(request) {
+            if (request.signal?.aborted)
+                throw request.signal.reason ?? new Error("aborted");
+            const token = await resolveCredentialValue(options.apiKey, { provider: id, name: "apiKey" });
+            const secrets = [token];
+            const tools = new Map();
+            let usage;
+            try {
+                const response = await (options.fetch ?? fetch)(`${(options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "")}/responses`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/json",
+                        ...request.options?.headers,
+                        ...(token ? { authorization: `Bearer ${token}` } : {}),
+                        ...(request.options?.sessionId ? { "x-client-request-id": request.options.sessionId } : {}),
+                    },
+                    body: JSON.stringify(toResponsesRequest(request)),
+                    signal: request.signal,
+                });
+                if (!response.ok)
+                    return yield providerError(new Error(`OpenAI request failed: ${response.status} ${await safeText(response)}`), secrets);
+                if (!response.body)
+                    return yield providerError(new Error("OpenAI response had no body"), secrets);
+                for await (const data of readSseData(response.body)) {
+                    if (data === "[DONE]")
+                        break;
+                    const event = JSON.parse(data);
+                    if (typeof event.delta === "string" && event.type?.includes("output_text"))
+                        yield providerTextDelta(event.delta);
+                    if (typeof event.delta === "string" && event.type?.includes("reasoning"))
+                        yield providerThinkingDelta(event.delta);
+                    const tool = event.item ?? event.delta;
+                    if (isToolDelta(tool)) {
+                        const index = tool.index ?? 0;
+                        const current = tools.get(index) ?? { argumentsText: "" };
+                        current.id = tool.id ?? current.id;
+                        current.name = tool.name ?? current.name;
+                        current.argumentsText += tool.arguments ?? tool.arguments_delta ?? "";
+                        tools.set(index, current);
+                        yield providerToolCallDelta({ index, id: tool.id, name: tool.name, argumentsText: tool.arguments ?? tool.arguments_delta });
+                    }
+                    usage = toUsage(event.response?.usage ?? event.usage) ?? usage;
+                    if (event.type?.endsWith("completed") && usage)
+                        yield providerUsage(usage);
+                }
+                for (const call of tools.values())
+                    if (call.id && call.name)
+                        yield providerToolCall(toolCallContent(call.id, call.name, parseArgs(call.argumentsText)));
+                yield providerDone(usage);
+            }
+            catch (error) {
+                yield providerError(error, secrets);
+            }
+        },
+    };
+}
+function toResponsesRequest(request) {
+    const payload = {
+        model: request.model.model,
+        input: request.messages.map((message) => toInputMessage(message, request.model.capabilities ?? {})),
+        tools: request.tools?.map(toTool),
+        stream: true,
+        store: false,
+        prompt_cache_key: promptCacheKey(request.options),
+        prompt_cache_retention: promptCacheRetention(request.options),
+        ...request.model.parameters,
+        ...(request.options?.compat ?? {}),
+        ...(request.options?.extra ?? {}),
+    };
+    return clean(payload);
+}
+function toInputMessage(message, capabilities = {}) {
+    if (message.role === "tool") {
+        const result = message.content.find((part) => part.type === "tool_result");
+        return clean({
+            type: "function_call_output",
+            call_id: result?.toolCallId ?? "",
+            output: result ? JSON.stringify(result.result ?? result.error ?? null) : "",
+        });
+    }
+    const items = [];
+    for (const part of message.content) {
+        if (part.type === "text" || part.type === "thinking") {
+            items.push({ type: "input_text", text: part.text });
+        }
+        else if (part.type === "image") {
+            if (!capabilities.input?.includes("image")) {
+                throw new Error(`OpenAI Responses request includes image but model does not declare image input capability`);
+            }
+            items.push(toResponsesImage(part));
+        }
+        else if (part.type === "tool_call") {
+            items.push({
+                type: "function_call",
+                id: part.id,
+                name: part.name,
+                arguments: JSON.stringify(part.arguments),
+            });
+        }
+        else if (part.type === "tool_result") {
+            throw new Error("OpenAI Responses tool_result blocks must appear in role=tool messages");
+        }
+    }
+    if (message.role === "assistant") {
+        return clean({ role: "assistant", content: items });
+    }
+    return clean({ role: message.role, content: items });
+}
+function toResponsesImage(part) {
+    const url = part.url ?? (part.data ? `data:${part.mimeType ?? "image/png"};base64,${part.data}` : undefined);
+    if (!url)
+        throw new Error("OpenAI Responses image block missing url or data");
+    return { type: "input_image", image_url: url };
+}
+function toTool(tool) {
+    return clean({ type: "function", name: tool.name, description: tool.description, parameters: tool.parameters ?? { type: "object" } });
+}
+function toUsage(usage) {
+    if (!usage)
+        return undefined;
+    return {
+        inputTokens: usage.input_tokens,
+        outputTokens: usage.output_tokens,
+        totalTokens: usage.total_tokens,
+        cacheReadTokens: usage.input_tokens_details?.cached_tokens,
+    };
+}
+function isToolDelta(value) {
+    return !!value && typeof value === "object" && ("arguments" in value || "arguments_delta" in value) && ("name" in value || "id" in value);
+}
+function parseArgs(text) {
+    if (!text)
+        return {};
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+function clean(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+async function safeText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return "";
+    }
+}
+//# sourceMappingURL=responses.js.map

package/dist/sse.d.ts

@@ -0,0 +1 @@
+export declare function readSseData(body: ReadableStream<Uint8Array>): AsyncIterable<string>;

package/dist/sse.js

@@ -0,0 +1,24 @@
+export async function* readSseData(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split(/\r?\n\r?\n/);
+        buffer = parts.pop() ?? "";
+        for (const part of parts)
+            yield* eventData(part);
+    }
+    buffer += decoder.decode();
+    if (buffer)
+        yield* eventData(buffer);
+}
+function* eventData(event) {
+    const lines = event.split(/\r?\n/).filter((line) => line.startsWith("data:"));
+    if (lines.length)
+        yield lines.map((line) => line.slice(5).trimStart()).join("\n").trim();
+}
+//# sourceMappingURL=sse.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@arnilo/prism-provider-openai",
+  "version": "0.0.1",
+  "description": "OpenAI provider package for Prism.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/__tests__",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test dist/__tests__/*.test.js",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "@arnilo/prism": "0.0.1"
+  },
+  "devDependencies": {
+    "@arnilo/prism": "file:../.."
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ashiqrniloy/prism.git",
+    "directory": "packages/provider-openai"
+  },
+  "bugs": {
+    "url": "https://github.com/ashiqrniloy/prism/issues"
+  },
+  "homepage": "https://github.com/ashiqrniloy/prism/tree/main/packages/provider-openai#readme",
+  "keywords": [
+    "prism",
+    "provider",
+    "openai",
+    "agent",
+    "llm"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}