@effect-uai/responses 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -1,525 +1,6 @@
-import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
-import { Context, Effect, Layer, Match, Option, Schema, Stream } from "effect";
-import { HttpClient, HttpClientRequest } from "effect/unstable/http";
-import * as AiError from "@effect-uai/core/AiError";
-import { matchType } from "@effect-uai/core/Match";
-import { LanguageModel } from "@effect-uai/core/LanguageModel";
-import * as SSE from "@effect-uai/core/SSE";
-//#region src/codec.ts
-var codec_exports = /* @__PURE__ */ __exportAll({
-	WireOutputItem: () => WireOutputItem,
-	WireResponseCompleted: () => WireResponseCompleted,
-	itemsToInput: () => itemsToInput,
-	turnFromCompleted: () => turnFromCompleted,
-	wireItemToItem: () => wireItemToItem
-});
-const WireUrlCitation = Schema.Struct({
-	type: Schema.Literal("url_citation"),
-	url: Schema.String,
-	start_index: Schema.Number,
-	end_index: Schema.Number,
-	title: Schema.String
-});
-const WireFileCitation = Schema.Struct({
-	type: Schema.Literal("file_citation"),
-	file_id: Schema.String,
-	index: Schema.Number
-});
-const WireContainerFileCitation = Schema.Struct({
-	type: Schema.Literal("container_file_citation"),
-	container_id: Schema.String,
-	file_id: Schema.String,
-	start_index: Schema.Number,
-	end_index: Schema.Number
-});
-const WireFilePath = Schema.Struct({
-	type: Schema.Literal("file_path"),
-	file_id: Schema.String,
-	index: Schema.Number
-});
-const WireAnnotation = Schema.Union([
-	WireUrlCitation,
-	WireFileCitation,
-	WireContainerFileCitation,
-	WireFilePath
-]);
-const WireOutputTextContent = Schema.Struct({
-	type: Schema.Literal("output_text"),
-	text: Schema.String,
-	annotations: Schema.optional(Schema.NullOr(Schema.Array(WireAnnotation)))
-});
-const WireRefusalContent = Schema.Struct({
-	type: Schema.Literal("refusal"),
-	refusal: Schema.String
-});
-const WireMessageContent = Schema.Union([WireOutputTextContent, WireRefusalContent]);
-const WireSummaryText = Schema.Struct({
-	type: Schema.Literal("summary_text"),
-	text: Schema.String
-});
-const WireMessage = Schema.Struct({
-	type: Schema.Literal("message"),
-	id: Schema.optional(Schema.String),
-	role: Schema.Literal("assistant"),
-	content: Schema.Array(WireMessageContent)
-});
-const WireFunctionCall = Schema.Struct({
-	type: Schema.Literal("function_call"),
-	id: Schema.optional(Schema.String),
-	call_id: Schema.String,
-	name: Schema.String,
-	arguments: Schema.String
-});
-const WireReasoning = Schema.Struct({
-	type: Schema.Literal("reasoning"),
-	id: Schema.optional(Schema.String),
-	summary: Schema.optional(Schema.Array(WireSummaryText)),
-	encrypted_content: Schema.optional(Schema.String)
-});
-const WireOutputItem = Schema.Union([
-	WireMessage,
-	WireFunctionCall,
-	WireReasoning
-]);
-const WireInputTokensDetails = Schema.Struct({ cached_tokens: Schema.optional(Schema.NullOr(Schema.Number)) });
-const WireOutputTokensDetails = Schema.Struct({ reasoning_tokens: Schema.optional(Schema.NullOr(Schema.Number)) });
-const WireUsage = Schema.Struct({
-	input_tokens: Schema.optional(Schema.Number),
-	output_tokens: Schema.optional(Schema.Number),
-	total_tokens: Schema.optional(Schema.Number),
-	input_tokens_details: Schema.optional(Schema.NullOr(WireInputTokensDetails)),
-	output_tokens_details: Schema.optional(Schema.NullOr(WireOutputTokensDetails))
-});
-const WireResponseError = Schema.Struct({
-	code: Schema.optional(Schema.NullOr(Schema.String)),
-	message: Schema.optional(Schema.NullOr(Schema.String))
-});
-const WireResponseCompleted = Schema.Struct({
-	id: Schema.optional(Schema.NullOr(Schema.String)),
-	status: Schema.optional(Schema.NullOr(Schema.String)),
-	output: Schema.optional(Schema.NullOr(Schema.Array(WireOutputItem))),
-	usage: Schema.optional(Schema.NullOr(WireUsage)),
-	incomplete_details: Schema.optional(Schema.NullOr(Schema.Struct({ reason: Schema.optional(Schema.NullOr(Schema.String)) }))),
-	error: Schema.optional(Schema.NullOr(WireResponseError))
-});
-/**
-* If an item carries `providerData` from a prior OpenAI turn, re-emit it
-* verbatim - preserves `encrypted_content`, item ids, and any field this
-* codec doesn't model.
-*/
-const passthrough = (item) => item.providerData !== void 0 && typeof item.providerData === "object" && item.providerData !== null ? item.providerData : void 0;
-const contentBlockToInput = Match.type().pipe(matchType("input_text", (b) => ({
-	type: "input_text",
-	text: b.text
-})), matchType("input_image", (b) => ({
-	type: "input_image",
-	image_url: b.source._tag === "url" ? b.source.url : `data:${b.source.media_type};base64,${b.source.data}`
-})), matchType("output_text", (b) => ({
-	type: "output_text",
-	text: b.text
-})), matchType("refusal", (b) => ({
-	type: "refusal",
-	refusal: b.text
-})), Match.exhaustive);
-const itemToInput = (item) => passthrough(item) ?? Match.value(item).pipe(matchType("message", (m) => ({
-	type: "message",
-	role: m.role,
-	content: m.content.map(contentBlockToInput)
-})), matchType("function_call", (f) => ({
-	type: "function_call",
-	call_id: f.call_id,
-	name: f.name,
-	arguments: f.arguments
-})), matchType("function_call_output", (o) => ({
-	type: "function_call_output",
-	call_id: o.call_id,
-	output: o.output
-})), matchType("reasoning", (r) => ({
-	type: "reasoning",
-	...r.id !== void 0 && { id: r.id },
-	...r.summary !== void 0 && { summary: [{
-		type: "summary_text",
-		text: r.summary
-	}] },
-	...r.signature !== void 0 && { encrypted_content: r.signature }
-})), Match.exhaustive);
-/** Convert our `Item[]` history into the Responses API `input` array. */
-const itemsToInput = (items) => items.map(itemToInput);
-const wireMessageContentToBlock = Match.type().pipe(matchType("output_text", (c) => ({
-	type: "output_text",
-	text: c.text,
-	...c.annotations !== void 0 && c.annotations !== null && { annotations: c.annotations }
-})), matchType("refusal", (c) => ({
-	type: "refusal",
-	text: c.refusal
-})), Match.exhaustive);
-const wireItemToItem = (wire) => Match.value(wire).pipe(matchType("message", (m) => ({
-	type: "message",
-	role: m.role,
-	content: m.content.map(wireMessageContentToBlock),
-	providerData: m
-})), matchType("function_call", (f) => ({
-	type: "function_call",
-	call_id: f.call_id,
-	name: f.name,
-	arguments: f.arguments,
-	providerData: f
-})), matchType("reasoning", (r) => ({
-	type: "reasoning",
-	...r.id !== void 0 && { id: r.id },
-	...r.summary !== void 0 && { summary: r.summary.map((s) => s.text).join("\n") },
-	...r.encrypted_content !== void 0 && { signature: r.encrypted_content },
-	providerData: r
-})), Match.exhaustive);
-const reasonToStop = Match.type().pipe(Match.when("max_output_tokens", () => "max_tokens"), Match.when("refusal", () => "refusal"), Match.when("content_filter", () => "content_filter"), Match.when("max_tool_calls", () => "max_tool_calls"), Match.option);
-const hasRefusalContent = (payload) => (payload.output ?? []).some((i) => i.type === "message" && i.content.some((c) => c.type === "refusal"));
-const stopReasonFromCompleted = (payload) => Option.match(reasonToStop(payload.incomplete_details?.reason ?? ""), {
-	onSome: (s) => s,
-	onNone: () => hasRefusalContent(payload) ? "refusal" : (payload.output ?? []).some((i) => i.type === "function_call") ? "tool_calls" : "stop"
-});
-const cachedTokens = (payload) => payload.usage?.input_tokens_details?.cached_tokens ?? void 0;
-const reasoningTokens = (payload) => payload.usage?.output_tokens_details?.reasoning_tokens ?? void 0;
-const turnFromCompleted = (payload) => {
-	const cached = cachedTokens(payload);
-	const reasoning = reasoningTokens(payload);
-	return {
-		items: (payload.output ?? []).map(wireItemToItem),
-		usage: {
-			...payload.usage?.input_tokens !== void 0 && { input_tokens: payload.usage.input_tokens },
-			...payload.usage?.output_tokens !== void 0 && { output_tokens: payload.usage.output_tokens },
-			...payload.usage?.total_tokens !== void 0 && { total_tokens: payload.usage.total_tokens },
-			...cached !== void 0 && { input_tokens_details: { cached_tokens: cached } },
-			...reasoning !== void 0 && { output_tokens_details: { reasoning_tokens: reasoning } }
-		},
-		stop_reason: stopReasonFromCompleted(payload)
-	};
-};
-//#endregion
-//#region src/streamEvents.ts
-var streamEvents_exports = /* @__PURE__ */ __exportAll({
-	KnownProviderEvent: () => KnownProviderEvent,
-	ProviderEvent: () => ProviderEvent,
-	eventToDeltas: () => eventToDeltas,
-	makeCallIdLookup: () => makeCallIdLookup
-});
-const OutputItemAdded = Schema.Struct({
-	type: Schema.Literal("response.output_item.added"),
-	item: WireOutputItem
-});
-const OutputTextDelta = Schema.Struct({
-	type: Schema.Literal("response.output_text.delta"),
-	delta: Schema.String
-});
-const FunctionArgsDelta = Schema.Struct({
-	type: Schema.Literal("response.function_call_arguments.delta"),
-	item_id: Schema.String,
-	delta: Schema.String
-});
-const ReasoningTextDelta = Schema.Struct({
-	type: Schema.Literal("response.reasoning_text.delta"),
-	delta: Schema.String
-});
-const ReasoningSummaryDelta = Schema.Struct({
-	type: Schema.Literal("response.reasoning_summary_text.delta"),
-	delta: Schema.String
-});
-const RefusalDelta = Schema.Struct({
-	type: Schema.Literal("response.refusal.delta"),
-	delta: Schema.String
-});
-const RefusalDone = Schema.Struct({
-	type: Schema.Literal("response.refusal.done"),
-	refusal: Schema.optional(Schema.String)
-});
-const Completed = Schema.Struct({
-	type: Schema.Literal("response.completed"),
-	response: WireResponseCompleted
-});
-const Incomplete = Schema.Struct({
-	type: Schema.Literal("response.incomplete"),
-	response: WireResponseCompleted
-});
-const Failed = Schema.Struct({
-	type: Schema.Literal("response.failed"),
-	response: WireResponseCompleted
-});
-const ErrorEvent = Schema.Struct({
-	type: Schema.Literal("error"),
-	message: Schema.optional(Schema.String),
-	code: Schema.optional(Schema.String)
-});
-/**
-* Catch-all variant for wire events that fail to decode against any known
-* schema, plus events that fail to JSON-parse. The decoder never produces
-* this directly - it's synthesized by `sseEventToProviderEvent` when
-* `decodeKnown` fails.
-*/
-const Unknown = Schema.Struct({
-	type: Schema.Literal("_unknown"),
-	raw: Schema.Unknown
-});
-/**
-* Internal: union of variants we actually know how to decode from the wire.
-* Used as the decode target; failures are caught and re-emitted as `Unknown`.
-*/
-const KnownProviderEvent = Schema.Union([
-	OutputItemAdded,
-	OutputTextDelta,
-	FunctionArgsDelta,
-	ReasoningTextDelta,
-	ReasoningSummaryDelta,
-	RefusalDelta,
-	RefusalDone,
-	Completed,
-	Incomplete,
-	Failed,
-	ErrorEvent
-]);
-/**
-* Public: every event the native stream can emit. Discriminated on `type`.
-* The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`
-* cannot silently miss a wire event we didn't model.
-*/
-const ProviderEvent = Schema.Union([
-	OutputItemAdded,
-	OutputTextDelta,
-	FunctionArgsDelta,
-	ReasoningTextDelta,
-	ReasoningSummaryDelta,
-	RefusalDelta,
-	RefusalDone,
-	Completed,
-	Incomplete,
-	Failed,
-	ErrorEvent,
-	Unknown
-]);
-const makeCallIdLookup = () => {
-	const map = /* @__PURE__ */ new Map();
-	return {
-		resolve: (id) => map.get(id),
-		remember: (id, callId) => {
-			map.set(id, callId);
-		}
-	};
-};
-/**
-* Translate a decoded provider event into zero-or-more `TurnEvent`s.
-* Mutates `lookup` to record `(item_id → call_id)` from `output_item.added`
-* so subsequent `function_call_arguments.delta` events can be tagged with
-* the right call id.
-*/
-const eventToDeltas = (event, lookup) => Match.value(event).pipe(matchType("response.output_item.added", ({ item }) => {
-	if (item.type !== "function_call") return [];
-	if (item.id !== void 0) lookup.remember(item.id, item.call_id);
-	return [{
-		type: "tool_call_start",
-		call_id: item.call_id,
-		name: item.name
-	}];
-}), matchType("response.output_text.delta", ({ delta }) => [{
-	type: "text_delta",
-	text: delta
-}]), matchType("response.function_call_arguments.delta", ({ item_id, delta }) => {
-	const call_id = lookup.resolve(item_id);
-	return call_id === void 0 ? [] : [{
-		type: "tool_call_args_delta",
-		call_id,
-		delta
-	}];
-}), matchType("response.reasoning_text.delta", ({ delta }) => [{
-	type: "reasoning_delta",
-	text: delta,
-	kind: "trace"
-}]), matchType("response.reasoning_summary_text.delta", ({ delta }) => [{
-	type: "reasoning_delta",
-	text: delta,
-	kind: "summary"
-}]), matchType("response.refusal.delta", ({ delta }) => [{
-	type: "refusal_delta",
-	text: delta
-}]), matchType("response.refusal.done", () => []), matchType("response.completed", ({ response }) => [{
-	type: "turn_complete",
-	turn: turnFromCompleted(response)
-}]), matchType("response.incomplete", ({ response }) => [{
-	type: "turn_complete",
-	turn: turnFromCompleted(response)
-}]), matchType("response.failed", () => []), matchType("error", () => []), matchType("_unknown", () => []), Match.exhaustive);
-//#endregion
-//#region src/Responses.ts
-/**
-* Provider-typed service tag. Yield this when you want Responses-specific
-* options (`reasoning.effort`, `store`, `previousResponseId`) at the call
-* site. Yield the generic `LanguageModel` tag for provider-portable code -
-* both are registered by `layer`.
-*/
-var Responses = class extends Context.Service()("@betalyra/effect-uai/providers/responses/Responses") {};
-const jsonSchemaFormat = (format) => ({
-	type: "json_schema",
-	name: format.name,
-	schema: format.schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }),
-	...format.description !== void 0 && { description: format.description },
-	...format.strict !== void 0 && { strict: format.strict }
-});
-const buildText = (request) => {
-	const format = request.structured !== void 0 ? jsonSchemaFormat(request.structured) : request.responseFormat;
-	const text = {};
-	if (format !== void 0) text.format = format;
-	if (request.verbosity !== void 0) text.verbosity = request.verbosity;
-	return Object.keys(text).length === 0 ? void 0 : text;
-};
-const buildBody = (request) => {
-	const text = buildText(request);
-	return {
-		model: request.model,
-		input: itemsToInput(request.history),
-		stream: true,
-		...request.tools !== void 0 && request.tools.length > 0 && { tools: request.tools.map((t) => ({
-			type: "function",
-			name: t.name,
-			description: t.description,
-			parameters: t.inputSchema,
-			...t.strict !== void 0 && { strict: t.strict }
-		})) },
-		...request.toolChoice !== void 0 && { tool_choice: request.toolChoice },
-		...request.temperature !== void 0 && { temperature: request.temperature },
-		...request.maxOutputTokens !== void 0 && { max_output_tokens: request.maxOutputTokens },
-		...request.reasoning !== void 0 && { reasoning: request.reasoning },
-		...request.store !== void 0 && { store: request.store },
-		...request.previousResponseId !== void 0 && { previous_response_id: request.previousResponseId },
-		...request.instructions !== void 0 && { instructions: request.instructions },
-		...request.topP !== void 0 && { top_p: request.topP },
-		...request.parallelToolCalls !== void 0 && { parallel_tool_calls: request.parallelToolCalls },
-		...request.metadata !== void 0 && { metadata: request.metadata },
-		...request.user !== void 0 && { user: request.user },
-		...request.safetyIdentifier !== void 0 && { safety_identifier: request.safetyIdentifier },
-		...request.promptCacheKey !== void 0 && { prompt_cache_key: request.promptCacheKey },
-		...request.truncation !== void 0 && { truncation: request.truncation },
-		...text !== void 0 && { text }
-	};
-};
-const decodeKnown = Schema.decodeUnknownEffect(KnownProviderEvent);
-const makeUnknown = (raw) => ({
-	type: "_unknown",
-	raw
-});
-/**
-* Lift events that carry a terminal failure signal (`error`,
-* `response.failed`) to a typed `AiError`. Other events are not failures
-* and produce `Option.none`.
-*/
-const eventToError = Match.type().pipe(matchType("error", (e) => new AiError.Unavailable({
-	provider: "responses",
-	raw: e
-})), matchType("response.failed", (e) => {
-	const code = e.response.error?.code;
-	const message = e.response.error?.message;
-	return new AiError.GenerationFailed({
-		provider: "responses",
-		...code !== void 0 && code !== null && { code },
-		...message !== void 0 && message !== null && { message },
-		raw: e
-	});
-}), Match.option);
-const sseEventToProviderEvent = (ev) => Effect.try({
-	try: () => JSON.parse(ev.data),
-	catch: () => ev.data
-}).pipe(Effect.flatMap((parsed) => decodeKnown(parsed).pipe(Effect.orElseSucceed(() => makeUnknown(parsed)))), Effect.orElseSucceed(() => makeUnknown(ev.data)));
-const httpStatusError = (status, body) => {
-	const provider = "responses";
-	const raw = body;
-	if (status === 429) return new AiError.RateLimited({
-		provider,
-		raw
-	});
-	if (status === 408 || status === 504) return new AiError.Timeout({
-		provider,
-		raw
-	});
-	if (status === 401) return new AiError.AuthFailed({
-		provider,
-		subtype: "auth",
-		raw
-	});
-	if (status === 403) return new AiError.AuthFailed({
-		provider,
-		subtype: "permission",
-		raw
-	});
-	if (status === 402) return new AiError.AuthFailed({
-		provider,
-		subtype: "billing",
-		raw
-	});
-	if (status === 413) return new AiError.ContextLengthExceeded({
-		provider,
-		raw
-	});
-	if (status >= 500) return new AiError.Unavailable({
-		provider,
-		status,
-		raw
-	});
-	return new AiError.InvalidRequest({
-		provider,
-		raw
-	});
-};
-const buildNativeStream = (cfg) => {
-	const url = `${cfg.baseUrl ?? "https://api.openai.com/v1"}/responses`;
-	return (request) => Stream.unwrap(Effect.gen(function* () {
-		const client = yield* HttpClient.HttpClient;
-		const httpRequest = HttpClientRequest.post(url).pipe(HttpClientRequest.bearerToken(cfg.apiKey), HttpClientRequest.bodyJsonUnsafe(buildBody(request)), HttpClientRequest.accept("text/event-stream"));
-		const response = yield* client.execute(httpRequest).pipe(Effect.mapError((cause) => new AiError.Unavailable({
-			provider: "responses",
-			raw: cause
-		})));
-		if (response.status >= 400) {
-			const body = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
-			return Stream.fail(httpStatusError(response.status, body));
-		}
-		return response.stream.pipe(Stream.mapError((cause) => new AiError.Unavailable({
-			provider: "responses",
-			raw: cause
-		})), SSE.fromBytes, Stream.mapEffect(sseEventToProviderEvent), Stream.flatMap((event) => Option.match(eventToError(event), {
-			onNone: () => Stream.succeed(event),
-			onSome: Stream.fail
-		})));
-	}));
-};
-/**
-* Project a stream of native `ProviderEvent`s into canonical `TurnEvent`s.
-* Threads a fresh `CallIdLookup` per stream so `function_call_arguments.delta`
-* can be tagged with the right `call_id`.
-*/
-const toCanonical = (s) => Stream.unwrap(Effect.sync(() => {
-	const lookup = makeCallIdLookup();
-	return s.pipe(Stream.flatMap((event) => Stream.fromIterable(eventToDeltas(event, lookup))));
-}));
-/**
-* Build a `ResponsesService` value. For Layer-based setup, prefer `layer`.
-*/
-const make = (cfg) => Effect.map(HttpClient.HttpClient.asEffect(), (client) => {
-	const streamNative = (request) => buildNativeStream(cfg)(request).pipe(Stream.provideService(HttpClient.HttpClient, client));
-	return {
-		streamNative,
-		streamTurn: (request) => toCanonical(streamNative(request)),
-		toCanonical
-	};
-});
-/**
-* Layer that registers both the provider-specific `Responses` tag and the
-* generic `LanguageModel` tag, sharing one underlying implementation.
-*
-* The generic tag accepts `CommonRequest`; the typed tag accepts the full
-* `ResponsesRequest` surface.
-*/
-const layer = (cfg) => {
-	const typed = Layer.effect(Responses, make(cfg));
-	const generic = Layer.effect(LanguageModel, Effect.map(make(cfg), (s) => ({ streamTurn: (request) => s.streamTurn(request) })));
-	return Layer.merge(typed, generic);
-};
-//#endregion
-export { Responses, codec_exports as codec, layer, make, streamEvents_exports as streamEvents, toCanonical };
-
-//# sourceMappingURL=index.mjs.map
+import { t as OpenAIEmbedding_exports } from "./OpenAIEmbedding.mjs";
+import { t as codec_exports } from "./codec.mjs";
+import { t as streamEvents_exports } from "./streamEvents.mjs";
+import { t as Responses_exports } from "./Responses.mjs";
+import "./models.mjs";
+export { OpenAIEmbedding_exports as OpenAIEmbedding, Responses_exports as Responses, codec_exports as codec, streamEvents_exports as streamEvents };

package/dist/models.d.mts

@@ -0,0 +1,25 @@
+//#region src/models.d.ts
+/**
+ * Known OpenAI model identifiers usable via the Responses API (as of
+ * April 2026). The `(string & {})` tail keeps autocomplete on the literals
+ * while still accepting any string, so newly-released models work without
+ * an SDK update.
+ *
+ * Reference: https://developers.openai.com/api/docs/models/all
+ */
+type OpenAIModel = "gpt-5.5" | "gpt-5.5-pro" | "gpt-5.4" | "gpt-5.4-pro" | "gpt-5.4-mini" | "gpt-5.4-nano" | "gpt-5" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5.3-codex" | "gpt-4.1" | "gpt-4.1-mini" | "gpt-4o-mini" | (string & {});
+/**
+ * Known OpenAI embedding model identifiers. The `-3-` line is still the
+ * current general-purpose lineup; `dimensions` parameter supports
+ * Matryoshka truncation up to the model's native dimensionality.
+ *
+ * - `text-embedding-3-small`: 1..1536 dimensions, default 1536
+ * - `text-embedding-3-large`: 1..3072 dimensions, default 3072
+ * - `text-embedding-ada-002`: legacy, 1536 dim, no Matryoshka
+ *
+ * Reference: https://developers.openai.com/api/docs/guides/embeddings
+ */
+type OpenAIEmbeddingModel = "text-embedding-3-small" | "text-embedding-3-large" | "text-embedding-ada-002" | (string & {});
+//#endregion
+export { OpenAIEmbeddingModel, OpenAIModel };
+//# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;AAQA;;;;;AA4BA;;KA5BY,WAAA;;;;;;;;;;;;KA4BA,oBAAA"}

package/dist/models.mjs

@@ -0,0 +1 @@
+export {};