@opencode/ai 0.0.0-reserved → 2.0.0

package/dist/protocols/utils/gemini-tool-schema.js

@@ -0,0 +1,103 @@
+import { isRecord } from "../../utils/record.js";
+// Gemini accepts a JSON Schema-like dialect for tool parameters, but rejects a
+// handful of common JSON Schema shapes. Keep this projection isolated so the
+// Gemini protocol file still reads like the other protocol modules.
+const SCHEMA_INTENT_KEYS = [
+    "type",
+    "properties",
+    "items",
+    "prefixItems",
+    "enum",
+    "const",
+    "$ref",
+    "additionalProperties",
+    "patternProperties",
+    "required",
+    "not",
+    "if",
+    "then",
+    "else",
+];
+const hasCombiner = (schema) => isRecord(schema) && (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf) || Array.isArray(schema.allOf));
+const hasSchemaIntent = (schema) => isRecord(schema) && (hasCombiner(schema) || SCHEMA_INTENT_KEYS.some((key) => key in schema));
+const sanitizeNode = (schema) => {
+    if (!isRecord(schema))
+        return Array.isArray(schema) ? schema.map(sanitizeNode) : schema;
+    const result = Object.fromEntries(Object.entries(schema).map(([key, value]) => [
+        key,
+        key === "enum" && Array.isArray(value) ? value.map(String) : sanitizeNode(value),
+    ]));
+    if (Array.isArray(result.enum) && (result.type === "integer" || result.type === "number"))
+        result.type = "string";
+    const properties = result.properties;
+    if (result.type === "object" && isRecord(properties) && Array.isArray(result.required)) {
+        result.required = result.required.filter((field) => typeof field === "string" && field in properties);
+    }
+    if (result.type === "array" && !hasCombiner(result)) {
+        result.items = result.items ?? {};
+        if (isRecord(result.items) && !hasSchemaIntent(result.items))
+            result.items = { ...result.items, type: "string" };
+    }
+    if (typeof result.type === "string" && result.type !== "object" && !hasCombiner(result)) {
+        delete result.properties;
+        delete result.required;
+    }
+    return result;
+};
+const emptyObjectSchema = (schema) => schema.type === "object" &&
+    (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
+    !schema.additionalProperties;
+const projectNode = (schema, nested = false) => {
+    if (!isRecord(schema))
+        return undefined;
+    if (!nested && emptyObjectSchema(schema))
+        return undefined;
+    const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined;
+    const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined;
+    const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false;
+    const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf;
+    const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined;
+    const result = Object.fromEntries([
+        ["description", schema.description],
+        ["required", schema.required],
+        ["format", schema.format],
+        ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
+        [
+            "nullable",
+            (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
+                ? true
+                : undefined,
+        ],
+        ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
+        [
+            "properties",
+            isRecord(schema.properties)
+                ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
+                : undefined,
+        ],
+        [
+            "items",
+            Array.isArray(schema.items)
+                ? schema.items.map((item) => projectNode(item, true))
+                : schema.items === undefined
+                    ? undefined
+                    : projectNode(schema.items, true),
+        ],
+        ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
+        [
+            "anyOf",
+            anyOfTypes
+                ? hasNullAnyOf && anyOfTypes.length === 1
+                    ? undefined
+                    : anyOfTypes.map((item) => projectNode(item, true))
+                : types && types.length > 0
+                    ? types.map((type) => ({ type }))
+                    : undefined,
+        ],
+        ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
+        ["minLength", schema.minLength],
+    ].filter((entry) => entry[1] !== undefined));
+    return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result;
+};
+export const convert = (schema) => projectNode(sanitizeNode(schema));
+export * as GeminiToolSchema from "./gemini-tool-schema.js";

package/dist/protocols/utils/image-input.d.ts

@@ -0,0 +1,21 @@
+import { Effect } from "effect";
+import type { ImageInput } from "../../image.js";
+import { AIError } from "../../schema/index.js";
+export declare const dataUrl: (input: Extract<ImageInput, {
+    readonly type: "bytes";
+}>) => string;
+export declare const decodeDataUrl: (url: string) => Effect.Effect<{
+    readonly mediaType: string;
+    readonly data: Uint8Array;
+} | undefined, AIError>;
+export declare const invalidImageInput: (message: string, cause?: unknown) => AIError;
+export declare const ImageInputs: {
+    readonly dataUrl: (input: Extract<ImageInput, {
+        readonly type: "bytes";
+    }>) => string;
+    readonly decodeDataUrl: (url: string) => Effect.Effect<{
+        readonly mediaType: string;
+        readonly data: Uint8Array;
+    } | undefined, AIError>;
+    readonly invalid: (message: string, cause?: unknown) => AIError;
+};

package/dist/protocols/utils/image-input.js

@@ -0,0 +1,20 @@
+import { Effect, Encoding } from "effect";
+import { InvalidRequestError, AIError } from "../../schema/index.js";
+const invalid = (message, cause) => new AIError({
+    reason: new InvalidRequestError({ message, cause }),
+});
+export const dataUrl = (input) => `data:${input.mediaType};base64,${Encoding.encodeBase64(input.data)}`;
+export const decodeDataUrl = (url) => {
+    if (!url.startsWith("data:"))
+        return Effect.undefined;
+    const match = /^data:([^;,]+);base64,(.*)$/s.exec(url);
+    if (!match)
+        return Effect.fail(invalid("Image data URLs must contain a MIME type and base64 data"));
+    return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(Effect.mapError((cause) => invalid("Image data URL contains invalid base64 data", cause)), Effect.map((data) => ({ mediaType: match[1], data })));
+};
+export const invalidImageInput = invalid;
+export const ImageInputs = {
+    dataUrl,
+    decodeDataUrl,
+    invalid: invalidImageInput,
+};

package/dist/protocols/utils/lifecycle.d.ts

@@ -0,0 +1,24 @@
+import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema/index.js";
+export interface State {
+    readonly stepStarted: boolean;
+    readonly text: ReadonlySet<string>;
+    readonly reasoning: ReadonlySet<string>;
+}
+export declare const initial: () => State;
+export declare const stepStart: (state: State, events: LLMEvent[]) => State;
+export declare const textStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const textDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningStart: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningDelta: (state: State, events: LLMEvent[], id: string, text: string, providerMetadata?: ProviderMetadata) => State;
+export declare const reasoningEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text?: string) => State;
+export declare const textEnd: (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text?: string) => State;
+export declare const finish: (state: State, events: LLMEvent[], input: {
+    readonly reason: FinishReasonDetails;
+    readonly usage?: Usage;
+    readonly providerMetadata?: ProviderMetadata;
+}) => State;
+export * as Lifecycle from "./lifecycle.js";

package/dist/protocols/utils/lifecycle.js

@@ -0,0 +1,72 @@
+import { LLMEvent } from "../../schema/index.js";
+export const initial = () => ({ stepStarted: false, text: new Set(), reasoning: new Set() });
+export const stepStart = (state, events) => {
+    if (state.stepStarted)
+        return state;
+    events.push(LLMEvent.stepStart({ index: 0 }));
+    return { ...state, stepStarted: true };
+};
+export const textStart = (state, events, id, providerMetadata) => {
+    if (state.text.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.textStart({ id, providerMetadata }));
+    return { ...stepped, text: new Set([...stepped.text, id]) };
+};
+export const textDelta = (state, events, id, text, providerMetadata) => {
+    const started = textStart(state, events, id);
+    events.push(LLMEvent.textDelta({ id, text, providerMetadata }));
+    return started;
+};
+export const reasoningStart = (state, events, id, providerMetadata) => {
+    if (state.reasoning.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.reasoningStart({ id, providerMetadata }));
+    return { ...stepped, reasoning: new Set([...stepped.reasoning, id]) };
+};
+export const reasoningDelta = (state, events, id, text, providerMetadata) => {
+    const started = reasoningStart(state, events, id, providerMetadata);
+    events.push(LLMEvent.reasoningDelta({ id, text, providerMetadata }));
+    return started;
+};
+export const reasoningEnd = (state, events, id, providerMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text) => {
+    if (!state.reasoning.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.reasoningEnd({ id, text, providerMetadata }));
+    const reasoning = new Set(stepped.reasoning);
+    reasoning.delete(id);
+    return { ...stepped, reasoning };
+};
+export const textEnd = (state, events, id, providerMetadata, 
+/** Authoritative complete value; replaces accumulated deltas when present. */
+text) => {
+    if (!state.text.has(id))
+        return state;
+    const stepped = stepStart(state, events);
+    events.push(LLMEvent.textEnd({ id, text, providerMetadata }));
+    const open = new Set(stepped.text);
+    open.delete(id);
+    return { ...stepped, text: open };
+};
+const closeOpenBlocks = (state, events) => {
+    for (const id of state.reasoning)
+        events.push(LLMEvent.reasoningEnd({ id }));
+    for (const id of state.text)
+        events.push(LLMEvent.textEnd({ id }));
+    return { ...state, text: new Set(), reasoning: new Set() };
+};
+export const finish = (state, events, input) => {
+    const stepped = closeOpenBlocks(stepStart(state, events), events);
+    events.push(LLMEvent.stepFinish({
+        index: 0,
+        reason: input.reason,
+        usage: input.usage,
+        providerMetadata: input.providerMetadata,
+    }), LLMEvent.finish(input));
+    return { ...stepped, stepStarted: false };
+};
+export * as Lifecycle from "./lifecycle.js";

package/dist/protocols/utils/meta-image.d.ts

@@ -0,0 +1,2 @@
+export declare const mediaType: (data: Uint8Array, format?: string) => string;
+export * as MetaImage from "./meta-image.js";

package/dist/protocols/utils/meta-image.js

@@ -0,0 +1,13 @@
+// Responses image items can omit output_format, including when PNG/JPEG was requested.
+export const mediaType = (data, format) => {
+    if (format !== undefined)
+        return `image/${format}`;
+    if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71)
+        return "image/png";
+    if (data[0] === 255 && data[1] === 216 && data[2] === 255)
+        return "image/jpeg";
+    if (new TextDecoder().decode(data.slice(0, 4)) === "RIFF" && new TextDecoder().decode(data.slice(8, 12)) === "WEBP")
+        return "image/webp";
+    return "application/octet-stream";
+};
+export * as MetaImage from "./meta-image.js";

package/dist/protocols/utils/open-responses-options.d.ts

@@ -0,0 +1,56 @@
+import { Schema } from "effect";
+import type { LLMRequest } from "../../schema/index.js";
+export declare const ReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {});
+export declare const ReasoningEffort: Schema.declare<ReasoningEffort, ReasoningEffort>;
+export declare const TextVerbosities: readonly ["low", "medium", "high"];
+export type TextVerbosity = (typeof TextVerbosities)[number] | (string & {});
+export declare const TextVerbosity: Schema.declare<TextVerbosity, TextVerbosity>;
+export declare const ResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
+export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string & {});
+export declare const ServiceTiers: readonly ["auto", "default", "flex", "priority"];
+export type ServiceTier = (typeof ServiceTiers)[number] | (string & {});
+export declare const ServiceTier: Schema.declare<ServiceTier, ServiceTier>;
+export declare const Truncations: readonly ["auto", "disabled"];
+export type Truncation = (typeof Truncations)[number];
+export declare const TextVerbositySchema: Schema.declare<TextVerbosity, TextVerbosity>;
+export declare const ResponseIncludableSchema: Schema.declare<ResponseIncludable, ResponseIncludable>;
+export declare const ServiceTierSchema: Schema.declare<ServiceTier, ServiceTier>;
+export declare const TruncationSchema: Schema.Literals<readonly ["auto", "disabled"]>;
+export declare const AllowedTools: Schema.Struct<{
+    readonly toolNames: Schema.$Array<Schema.String>;
+    readonly mode: Schema.optional<Schema.Literals<readonly ["auto", "none", "required"]>>;
+}>;
+export type AllowedTools = typeof AllowedTools.Type;
+export declare const StreamOptions: Schema.Struct<{
+    readonly includeObfuscation: Schema.optional<Schema.Boolean>;
+}>;
+export declare const Options: Schema.Struct<{
+    readonly store: Schema.optional<Schema.Boolean>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly safetyIdentifier: Schema.optional<Schema.String>;
+    readonly streamOptions: Schema.optional<Schema.Struct<{
+        readonly includeObfuscation: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly topLogprobs: Schema.optional<Schema.Int>;
+    readonly reasoningEffort: Schema.optional<Schema.declare<ReasoningEffort, ReasoningEffort>>;
+    readonly reasoningSummary: Schema.optional<Schema.Literals<readonly ["auto", "concise", "detailed"]>>;
+    readonly include: Schema.optional<Schema.$Array<Schema.declare<ResponseIncludable, ResponseIncludable>>>;
+    readonly textVerbosity: Schema.optional<Schema.declare<TextVerbosity, TextVerbosity>>;
+    readonly serviceTier: Schema.optional<Schema.declare<ServiceTier, ServiceTier>>;
+    readonly truncation: Schema.optional<Schema.Literals<readonly ["auto", "disabled"]>>;
+    readonly allowedTools: Schema.optional<Schema.Struct<{
+        readonly toolNames: Schema.$Array<Schema.String>;
+        readonly mode: Schema.optional<Schema.Literals<readonly ["auto", "none", "required"]>>;
+    }>>;
+    readonly maxToolCalls: Schema.optional<Schema.Int>;
+    readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
+}>;
+export type Options = typeof Options.Type;
+export type Resolved = Omit<Options, "allowedTools"> & {
+    readonly allowedTools?: AllowedTools & {
+        readonly mode: NonNullable<AllowedTools["mode"]>;
+    };
+};
+export declare const resolve: (request: LLMRequest) => Resolved;
+export * as OpenResponsesOptions from "./open-responses-options.js";

package/dist/protocols/utils/open-responses-options.js

@@ -0,0 +1,61 @@
+import { Option, Schema } from "effect";
+export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export const ReasoningEffort = Schema.declare((value) => typeof value === "string", { title: "ReasoningEffort" });
+export const TextVerbosities = ["low", "medium", "high"];
+export const TextVerbosity = Schema.declare((value) => typeof value === "string", { title: "TextVerbosity" });
+export const ResponseIncludables = [
+    "file_search_call.results",
+    "web_search_call.results",
+    "web_search_call.action.sources",
+    "message.input_image.image_url",
+    "computer_call_output.output.image_url",
+    "code_interpreter_call.outputs",
+    "reasoning.encrypted_content",
+    "message.output_text.logprobs",
+];
+export const ServiceTiers = ["auto", "default", "flex", "priority"];
+export const ServiceTier = Schema.declare((value) => typeof value === "string", {
+    title: "ServiceTier",
+});
+export const Truncations = ["auto", "disabled"];
+export const TextVerbositySchema = TextVerbosity;
+export const ResponseIncludableSchema = Schema.declare((value) => typeof value === "string", { title: "ResponseIncludable" });
+export const ServiceTierSchema = ServiceTier;
+export const TruncationSchema = Schema.Literals(Truncations);
+export const AllowedTools = Schema.Struct({
+    toolNames: Schema.Array(Schema.String),
+    mode: Schema.optional(Schema.Literals(["auto", "none", "required"])),
+});
+export const StreamOptions = Schema.Struct({
+    includeObfuscation: Schema.optional(Schema.Boolean),
+});
+export const Options = Schema.Struct({
+    store: Schema.optional(Schema.Boolean),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+    safetyIdentifier: Schema.optional(Schema.String),
+    streamOptions: Schema.optional(StreamOptions),
+    topLogprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
+    reasoningEffort: Schema.optional(ReasoningEffort),
+    reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
+    include: Schema.optional(Schema.Array(ResponseIncludableSchema)),
+    textVerbosity: Schema.optional(TextVerbositySchema),
+    serviceTier: Schema.optional(ServiceTierSchema),
+    truncation: Schema.optional(TruncationSchema),
+    allowedTools: Schema.optional(AllowedTools),
+    maxToolCalls: Schema.optional(Schema.Int),
+    parallelToolCalls: Schema.optional(Schema.Boolean),
+});
+const decodeOptions = Schema.decodeUnknownOption(Options);
+export const resolve = (request) => {
+    const input = Option.getOrUndefined(decodeOptions(request.providerOptions));
+    if (!input)
+        return {};
+    return {
+        ...input,
+        include: input.include?.length ? input.include : undefined,
+        allowedTools: input.allowedTools && input.allowedTools.toolNames.length > 0
+            ? { ...input.allowedTools, mode: input.allowedTools.mode ?? "auto" }
+            : undefined,
+    };
+};
+export * as OpenResponsesOptions from "./open-responses-options.js";

package/dist/protocols/utils/openai-image.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+export declare const Size: Schema.String;
+export declare const OpenAIImage: {
+    readonly Size: Schema.String;
+};

package/dist/protocols/utils/openai-image.js

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+const dimensions = (value) => {
+    const match = /^(\d+)x(\d+)$/.exec(value);
+    if (!match)
+        return undefined;
+    return { width: Number(match[1]), height: Number(match[2]) };
+};
+export const Size = Schema.String.check(Schema.makeFilter((value) => {
+    if (value === "auto")
+        return undefined;
+    const parsed = dimensions(value);
+    if (!parsed)
+        return "image size must be `auto` or `{width}x{height}`";
+    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers";
+}));
+export const OpenAIImage = {
+    Size,
+};

package/dist/protocols/utils/openai-options.d.ts

@@ -0,0 +1,16 @@
+import { OpenResponsesOptions } from "./open-responses-options.js";
+export declare const OpenAIReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
+export declare const OpenAITextVerbosities: readonly ["low", "medium", "high"];
+export type OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
+export declare const OpenAIResponseIncludables: readonly ["file_search_call.results", "web_search_call.results", "web_search_call.action.sources", "message.input_image.image_url", "computer_call_output.output.image_url", "code_interpreter_call.outputs", "reasoning.encrypted_content", "message.output_text.logprobs"];
+export type OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludable;
+export declare const OpenAIServiceTiers: readonly ["auto", "default", "flex", "priority", "scale"];
+export type OpenAIServiceTier = (typeof OpenAIServiceTiers)[number] | (string & {});
+export declare const OpenAIReasoningEffort: import("effect/Schema").declare<OpenResponsesOptions.ReasoningEffort, OpenResponsesOptions.ReasoningEffort>;
+export declare const OpenAITextVerbosity: import("effect/Schema").declare<OpenResponsesOptions.TextVerbosity, OpenResponsesOptions.TextVerbosity>;
+export declare const OpenAIResponseIncludable: import("effect/Schema").declare<OpenResponsesOptions.ResponseIncludable, OpenResponsesOptions.ResponseIncludable>;
+export declare const OpenAIServiceTier: import("effect/Schema").declare<OpenResponsesOptions.ServiceTier, OpenResponsesOptions.ServiceTier>;
+export declare const isReasoningEffort: (effort: unknown) => effort is OpenAIReasoningEffort;
+export declare const resolve: (request: import("../../index.js").LLMRequest) => OpenResponsesOptions.Resolved;
+export * as OpenAIOptions from "./openai-options.js";

package/dist/protocols/utils/openai-options.js

@@ -0,0 +1,14 @@
+import { OpenResponsesOptions } from "./open-responses-options.js";
+export const OpenAIReasoningEfforts = OpenResponsesOptions.ReasoningEfforts;
+export const OpenAITextVerbosities = OpenResponsesOptions.TextVerbosities;
+// Mirrors OpenAI's `ResponseIncludable` union from the official SDK. Keep this
+// in lockstep with `openai-node/src/resources/responses/responses.ts`.
+export const OpenAIResponseIncludables = OpenResponsesOptions.ResponseIncludables;
+export const OpenAIServiceTiers = [...OpenResponsesOptions.ServiceTiers, "scale"];
+export const OpenAIReasoningEffort = OpenResponsesOptions.ReasoningEffort;
+export const OpenAITextVerbosity = OpenResponsesOptions.TextVerbosity;
+export const OpenAIResponseIncludable = OpenResponsesOptions.ResponseIncludableSchema;
+export const OpenAIServiceTier = OpenResponsesOptions.ServiceTierSchema;
+export const isReasoningEffort = (effort) => typeof effort === "string";
+export const resolve = OpenResponsesOptions.resolve;
+export * as OpenAIOptions from "./openai-options.js";

package/dist/protocols/utils/partial-json-options.d.ts

@@ -0,0 +1,62 @@
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello `
+ */
+export declare const STR = 1;
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+export declare const NUM = 2;
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+export declare const ARR = 4;
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+export declare const OBJ = 8;
+/**
+ * allow `nu` to be parsed as `null`
+ */
+export declare const NULL = 16;
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+export declare const BOOL = 32;
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+export declare const NAN = 64;
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+export declare const INFINITY = 128;
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+export declare const _INFINITY = 256;
+export declare const INF: number;
+export declare const SPECIAL: number;
+export declare const ATOM: number;
+export declare const COLLECTION: number;
+export declare const ALL: number;
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most cases is the best option.
+ */
+export declare const Allow: {
+    STR: number;
+    NUM: number;
+    ARR: number;
+    OBJ: number;
+    NULL: number;
+    BOOL: number;
+    NAN: number;
+    INFINITY: number;
+    _INFINITY: number;
+    INF: number;
+    SPECIAL: number;
+    ATOM: number;
+    COLLECTION: number;
+    ALL: number;
+};
+export default Allow;

package/dist/protocols/utils/partial-json-options.js

@@ -0,0 +1,52 @@
+/*
+ * Adapted from partial-json by the Promplate Dev Team:
+ * https://github.com/promplate/partial-json-parser-js/blob/main/src/options.ts
+ * Licensed under the MIT License; see partial-json.ts for the complete notice.
+ */
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello `
+ */
+export const STR = 0b000000001;
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+export const NUM = 0b000000010;
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+export const ARR = 0b000000100;
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+export const OBJ = 0b000001000;
+/**
+ * allow `nu` to be parsed as `null`
+ */
+export const NULL = 0b000010000;
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+export const BOOL = 0b000100000;
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+export const NAN = 0b001000000;
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+export const INFINITY = 0b010000000;
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+export const _INFINITY = 0b100000000;
+export const INF = INFINITY | _INFINITY;
+export const SPECIAL = NULL | BOOL | INF | NAN;
+export const ATOM = STR | NUM | SPECIAL;
+export const COLLECTION = ARR | OBJ;
+export const ALL = ATOM | COLLECTION;
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most cases is the best option.
+ */
+export const Allow = { STR, NUM, ARR, OBJ, NULL, BOOL, NAN, INFINITY, _INFINITY, INF, SPECIAL, ATOM, COLLECTION, ALL };
+export default Allow;

package/dist/protocols/utils/partial-json.d.ts

@@ -0,0 +1,8 @@
+export * from "./partial-json-options.js";
+export declare class PartialJSON extends Error {
+}
+export declare class MalformedJSON extends Error {
+}
+/** Parse complete or incomplete JSON, restricted by the supplied partial-value flags. */
+export declare function parseJSON(jsonString: string, allowPartial?: number): unknown;
+export declare const parse: typeof parseJSON;