bleam 0.0.5 → 0.0.6

package/dist/ai.cjs

@@ -0,0 +1,187 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let react_native = require("react-native");
+react_native = require_chunk.__toESM(react_native);
+
+//#region src/ai.ts
+var AIError = class extends Error {
+	constructor(code, message, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "AIError";
+	}
+};
+var ShapeError = class extends Error {
+	constructor(code, message, issues = []) {
+		super(message);
+		this.code = code;
+		this.issues = issues;
+		this.name = "ShapeError";
+	}
+};
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function issue(message, path = []) {
+	return {
+		message,
+		path
+	};
+}
+function validateDefinition(definition, value, path = []) {
+	if (definition === "string" || definition === "number" || definition === "boolean") {
+		if (typeof value === definition) return { value };
+		return { issues: [issue(`Expected ${path.join(".") || "value"} to be ${definition}`, path)] };
+	}
+	if (Array.isArray(definition)) {
+		if (!Array.isArray(value)) return { issues: [issue(`Expected ${path.join(".") || "value"} to be array`, path)] };
+		const itemDefinition = definition[0];
+		const issues$1 = [];
+		const output$1 = [];
+		for (const [index, item] of value.entries()) {
+			const result = validateDefinition(itemDefinition, item, [...path, index]);
+			if (result.issues !== void 0) issues$1.push(...result.issues);
+			else output$1.push(result.value);
+		}
+		if (issues$1.length > 0) return { issues: issues$1 };
+		return { value: output$1 };
+	}
+	if (!isRecord(value)) return { issues: [issue(`Expected ${path.join(".") || "value"} to be object`, path)] };
+	const output = {};
+	const issues = [];
+	for (const [key, field] of Object.entries(definition)) {
+		const result = validateDefinition(field, value[key], [...path, key]);
+		if (result.issues !== void 0) issues.push(...result.issues);
+		else output[key] = result.value;
+	}
+	if (issues.length > 0) return { issues };
+	return { value: output };
+}
+function bridgeSchema(definition) {
+	if (definition === "string" || definition === "number" || definition === "boolean") return { type: definition };
+	if (Array.isArray(definition)) return {
+		type: "array",
+		items: bridgeSchema(definition[0])
+	};
+	const properties = {};
+	const required = [];
+	for (const [key, value] of Object.entries(definition)) {
+		properties[key] = bridgeSchema(value);
+		required.push(key);
+	}
+	return {
+		type: "object",
+		properties,
+		required
+	};
+}
+function assertValidShape(definition, path = "shape") {
+	if (definition === "string" || definition === "number" || definition === "boolean") return;
+	if (Array.isArray(definition)) {
+		if (definition.length !== 1) throw new ShapeError("invalid_shape", `${path} arrays must contain exactly one item shape`);
+		assertValidShape(definition[0], `${path}[0]`);
+		return;
+	}
+	if (!isRecord(definition)) throw new ShapeError("invalid_shape", `${path} must be a shape object`);
+	for (const [key, value] of Object.entries(definition)) assertValidShape(value, `${path}.${key}`);
+}
+function createShape(definition) {
+	assertValidShape(definition);
+	const api = {
+		"~standard": {
+			version: 1,
+			vendor: "bleam",
+			validate(value) {
+				return api.safeParse(value);
+			}
+		},
+		parse(value) {
+			const result = api.safeParse(value);
+			if (result.issues !== void 0) throw new ShapeError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
+			return result.value;
+		},
+		safeParse(value) {
+			return validateDefinition(definition, value);
+		},
+		toJSONSchema() {
+			return bridgeSchema(definition);
+		}
+	};
+	return api;
+}
+function shape(definition) {
+	return createShape(definition);
+}
+function schemaToBridgeSchema(schema) {
+	const schemaWithBridge = schema;
+	if (typeof schemaWithBridge.toJSONSchema === "function") return schemaWithBridge.toJSONSchema();
+}
+function validateStructuredInput(input) {
+	const result = input.shape["~standard"].validate(input.value);
+	if (result.issues !== void 0) throw new AIError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
+	return result.value;
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+	return JSON.stringify(value) ?? "undefined";
+}
+function promptFromInput(options) {
+	const parts = [];
+	if (options.prompt) parts.push(options.prompt);
+	if (typeof options.input === "string") parts.push(options.input);
+	else if (options.input) parts.push(stableStringify(validateStructuredInput(options.input)));
+	if (parts.length === 0) throw new AIError("invalid_message", "Expected prompt or input");
+	return parts.join("\n\n");
+}
+function bridge() {
+	const nativeBridge = react_native.NativeModules.BleamAIBridge;
+	if (!nativeBridge) throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime");
+	return nativeBridge;
+}
+function mapNativeError(error) {
+	const code = isRecord(error) && typeof error.code === "string" ? error.code : "";
+	const message = error instanceof Error ? error.message : String(error);
+	if (code === "UNSUPPORTED_OS") return new AIError("unsupported_os", message, error);
+	if (code === "MODEL_UNAVAILABLE") return new AIError("model_unavailable", message, error);
+	if (code === "INVALID_SCHEMA") return new AIError("invalid_schema", message, error);
+	if (code === "INVALID_MESSAGE") return new AIError("invalid_message", message, error);
+	if (code === "CONTEXT_WINDOW_EXCEEDED") return new AIError("context_window_exceeded", message, error);
+	return new AIError("generation_failed", message, error);
+}
+async function isAvailable() {
+	try {
+		return await bridge().isAvailable?.() ?? false;
+	} catch {
+		return false;
+	}
+}
+async function generate(options) {
+	const output = options.output;
+	const request = {
+		system: options.system,
+		prompt: promptFromInput(options),
+		temperature: options.temperature,
+		maxTokens: options.maxTokens,
+		outputSchema: output ? schemaToBridgeSchema(output) : void 0
+	};
+	try {
+		const value = await bridge().generate?.(request);
+		if (output) {
+			const result = output["~standard"].validate(value);
+			if (result.issues !== void 0) throw new AIError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
+			return result.value;
+		}
+		if (typeof value !== "string") throw new AIError("generation_failed", "Expected generated text");
+		return value;
+	} catch (error) {
+		if (error instanceof AIError) throw error;
+		throw mapNativeError(error);
+	}
+}
+
+//#endregion
+exports.AIError = AIError;
+exports.generate = generate;
+exports.isAvailable = isAvailable;
+exports.shape = shape;

package/dist/ai.d.cts

@@ -0,0 +1,52 @@
+import { h as StandardSchema, p as SchemaResult, s as InferOutput } from "./schema-BOuUHcqo.cjs";
+
+//#region src/ai.d.ts
+type PrimitiveToken = 'string' | 'number' | 'boolean';
+type ShapeArray = readonly [ShapeDefinition];
+type ShapeObject = {
+  readonly [key: string]: ShapeDefinition;
+};
+type ShapeDefinition = PrimitiveToken | ShapeObject | ShapeArray;
+type InferShapeValue<Definition extends ShapeDefinition> = Definition extends 'string' ? string : Definition extends 'number' ? number : Definition extends 'boolean' ? boolean : Definition extends readonly [infer Item] ? Item extends ShapeDefinition ? Array<InferShapeValue<Item>> : never : Definition extends ShapeObject ? { [Key in keyof Definition]: InferShapeValue<Definition[Key]> } : never;
+type InferShape<Definition extends ShapeObject> = { [Key in keyof Definition]: InferShapeValue<Definition[Key]> };
+type BridgeSchema = {
+  type: PrimitiveToken;
+} | {
+  type: 'array';
+  items: BridgeSchema;
+} | {
+  type: 'object';
+  properties: Record<string, BridgeSchema>;
+  required: string[];
+};
+type GenerateOptions<Output$1 extends StructuredSchema | undefined = undefined> = {
+  system?: string;
+  prompt?: string;
+  input?: string | StructuredInput;
+  output?: Output$1;
+  temperature?: number;
+  maxTokens?: number;
+};
+type StructuredInput = {
+  shape: StructuredSchema;
+  value: unknown;
+};
+type StructuredSchema = BleamAIShape<unknown, unknown> | StandardSchema;
+type AIErrorCode = 'unsupported_runtime' | 'unsupported_os' | 'model_unavailable' | 'generation_failed' | 'invalid_message' | 'invalid_schema' | 'validation_failed' | 'context_window_exceeded';
+declare class AIError extends Error {
+  readonly code: AIErrorCode;
+  readonly cause?: unknown | undefined;
+  constructor(code: AIErrorCode, message: string, cause?: unknown | undefined);
+}
+interface BleamAIShape<Input, Output$1> extends StandardSchema<Input, Output$1> {
+  parse(value: unknown): Output$1;
+  safeParse(value: unknown): SchemaResult<Output$1>;
+  toJSONSchema(): BridgeSchema;
+}
+type InferShapeOutput<Value extends BleamAIShape<unknown, unknown>> = Value extends BleamAIShape<unknown, infer Output> ? Output : never;
+type GenerateResult<Output$1 extends StructuredSchema | undefined> = Output$1 extends BleamAIShape<unknown, infer ShapeOutput> ? ShapeOutput : Output$1 extends StandardSchema ? InferOutput<Output$1> : string;
+declare function shape<Definition extends ShapeObject>(definition: Definition): BleamAIShape<InferShape<Definition>, InferShape<Definition>>;
+declare function isAvailable(): Promise<boolean>;
+declare function generate<Output$1 extends StructuredSchema | undefined = undefined>(options: GenerateOptions<Output$1>): Promise<GenerateResult<Output$1>>;
+//#endregion
+export { AIError, AIErrorCode, BleamAIShape, InferShapeOutput, generate, isAvailable, shape };

package/dist/ai.d.ts

@@ -0,0 +1,52 @@
+import { h as StandardSchema, p as SchemaResult, s as InferOutput } from "./schema-ipsECAso.js";
+
+//#region src/ai.d.ts
+type PrimitiveToken = 'string' | 'number' | 'boolean';
+type ShapeArray = readonly [ShapeDefinition];
+type ShapeObject = {
+  readonly [key: string]: ShapeDefinition;
+};
+type ShapeDefinition = PrimitiveToken | ShapeObject | ShapeArray;
+type InferShapeValue<Definition extends ShapeDefinition> = Definition extends 'string' ? string : Definition extends 'number' ? number : Definition extends 'boolean' ? boolean : Definition extends readonly [infer Item] ? Item extends ShapeDefinition ? Array<InferShapeValue<Item>> : never : Definition extends ShapeObject ? { [Key in keyof Definition]: InferShapeValue<Definition[Key]> } : never;
+type InferShape<Definition extends ShapeObject> = { [Key in keyof Definition]: InferShapeValue<Definition[Key]> };
+type BridgeSchema = {
+  type: PrimitiveToken;
+} | {
+  type: 'array';
+  items: BridgeSchema;
+} | {
+  type: 'object';
+  properties: Record<string, BridgeSchema>;
+  required: string[];
+};
+type GenerateOptions<Output$1 extends StructuredSchema | undefined = undefined> = {
+  system?: string;
+  prompt?: string;
+  input?: string | StructuredInput;
+  output?: Output$1;
+  temperature?: number;
+  maxTokens?: number;
+};
+type StructuredInput = {
+  shape: StructuredSchema;
+  value: unknown;
+};
+type StructuredSchema = BleamAIShape<unknown, unknown> | StandardSchema;
+type AIErrorCode = 'unsupported_runtime' | 'unsupported_os' | 'model_unavailable' | 'generation_failed' | 'invalid_message' | 'invalid_schema' | 'validation_failed' | 'context_window_exceeded';
+declare class AIError extends Error {
+  readonly code: AIErrorCode;
+  readonly cause?: unknown | undefined;
+  constructor(code: AIErrorCode, message: string, cause?: unknown | undefined);
+}
+interface BleamAIShape<Input, Output$1> extends StandardSchema<Input, Output$1> {
+  parse(value: unknown): Output$1;
+  safeParse(value: unknown): SchemaResult<Output$1>;
+  toJSONSchema(): BridgeSchema;
+}
+type InferShapeOutput<Value extends BleamAIShape<unknown, unknown>> = Value extends BleamAIShape<unknown, infer Output> ? Output : never;
+type GenerateResult<Output$1 extends StructuredSchema | undefined> = Output$1 extends BleamAIShape<unknown, infer ShapeOutput> ? ShapeOutput : Output$1 extends StandardSchema ? InferOutput<Output$1> : string;
+declare function shape<Definition extends ShapeObject>(definition: Definition): BleamAIShape<InferShape<Definition>, InferShape<Definition>>;
+declare function isAvailable(): Promise<boolean>;
+declare function generate<Output$1 extends StructuredSchema | undefined = undefined>(options: GenerateOptions<Output$1>): Promise<GenerateResult<Output$1>>;
+//#endregion
+export { AIError, AIErrorCode, BleamAIShape, InferShapeOutput, generate, isAvailable, shape };

package/dist/ai.js

@@ -0,0 +1,182 @@
+import { NativeModules } from "react-native";
+
+//#region src/ai.ts
+var AIError = class extends Error {
+	constructor(code, message, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "AIError";
+	}
+};
+var ShapeError = class extends Error {
+	constructor(code, message, issues = []) {
+		super(message);
+		this.code = code;
+		this.issues = issues;
+		this.name = "ShapeError";
+	}
+};
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function issue(message, path = []) {
+	return {
+		message,
+		path
+	};
+}
+function validateDefinition(definition, value, path = []) {
+	if (definition === "string" || definition === "number" || definition === "boolean") {
+		if (typeof value === definition) return { value };
+		return { issues: [issue(`Expected ${path.join(".") || "value"} to be ${definition}`, path)] };
+	}
+	if (Array.isArray(definition)) {
+		if (!Array.isArray(value)) return { issues: [issue(`Expected ${path.join(".") || "value"} to be array`, path)] };
+		const itemDefinition = definition[0];
+		const issues$1 = [];
+		const output$1 = [];
+		for (const [index, item] of value.entries()) {
+			const result = validateDefinition(itemDefinition, item, [...path, index]);
+			if (result.issues !== void 0) issues$1.push(...result.issues);
+			else output$1.push(result.value);
+		}
+		if (issues$1.length > 0) return { issues: issues$1 };
+		return { value: output$1 };
+	}
+	if (!isRecord(value)) return { issues: [issue(`Expected ${path.join(".") || "value"} to be object`, path)] };
+	const output = {};
+	const issues = [];
+	for (const [key, field] of Object.entries(definition)) {
+		const result = validateDefinition(field, value[key], [...path, key]);
+		if (result.issues !== void 0) issues.push(...result.issues);
+		else output[key] = result.value;
+	}
+	if (issues.length > 0) return { issues };
+	return { value: output };
+}
+function bridgeSchema(definition) {
+	if (definition === "string" || definition === "number" || definition === "boolean") return { type: definition };
+	if (Array.isArray(definition)) return {
+		type: "array",
+		items: bridgeSchema(definition[0])
+	};
+	const properties = {};
+	const required = [];
+	for (const [key, value] of Object.entries(definition)) {
+		properties[key] = bridgeSchema(value);
+		required.push(key);
+	}
+	return {
+		type: "object",
+		properties,
+		required
+	};
+}
+function assertValidShape(definition, path = "shape") {
+	if (definition === "string" || definition === "number" || definition === "boolean") return;
+	if (Array.isArray(definition)) {
+		if (definition.length !== 1) throw new ShapeError("invalid_shape", `${path} arrays must contain exactly one item shape`);
+		assertValidShape(definition[0], `${path}[0]`);
+		return;
+	}
+	if (!isRecord(definition)) throw new ShapeError("invalid_shape", `${path} must be a shape object`);
+	for (const [key, value] of Object.entries(definition)) assertValidShape(value, `${path}.${key}`);
+}
+function createShape(definition) {
+	assertValidShape(definition);
+	const api = {
+		"~standard": {
+			version: 1,
+			vendor: "bleam",
+			validate(value) {
+				return api.safeParse(value);
+			}
+		},
+		parse(value) {
+			const result = api.safeParse(value);
+			if (result.issues !== void 0) throw new ShapeError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
+			return result.value;
+		},
+		safeParse(value) {
+			return validateDefinition(definition, value);
+		},
+		toJSONSchema() {
+			return bridgeSchema(definition);
+		}
+	};
+	return api;
+}
+function shape(definition) {
+	return createShape(definition);
+}
+function schemaToBridgeSchema(schema) {
+	const schemaWithBridge = schema;
+	if (typeof schemaWithBridge.toJSONSchema === "function") return schemaWithBridge.toJSONSchema();
+}
+function validateStructuredInput(input) {
+	const result = input.shape["~standard"].validate(input.value);
+	if (result.issues !== void 0) throw new AIError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
+	return result.value;
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (isRecord(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+	return JSON.stringify(value) ?? "undefined";
+}
+function promptFromInput(options) {
+	const parts = [];
+	if (options.prompt) parts.push(options.prompt);
+	if (typeof options.input === "string") parts.push(options.input);
+	else if (options.input) parts.push(stableStringify(validateStructuredInput(options.input)));
+	if (parts.length === 0) throw new AIError("invalid_message", "Expected prompt or input");
+	return parts.join("\n\n");
+}
+function bridge() {
+	const nativeBridge = NativeModules.BleamAIBridge;
+	if (!nativeBridge) throw new AIError("unsupported_runtime", "bleam/ai requires the Bleam native runtime");
+	return nativeBridge;
+}
+function mapNativeError(error) {
+	const code = isRecord(error) && typeof error.code === "string" ? error.code : "";
+	const message = error instanceof Error ? error.message : String(error);
+	if (code === "UNSUPPORTED_OS") return new AIError("unsupported_os", message, error);
+	if (code === "MODEL_UNAVAILABLE") return new AIError("model_unavailable", message, error);
+	if (code === "INVALID_SCHEMA") return new AIError("invalid_schema", message, error);
+	if (code === "INVALID_MESSAGE") return new AIError("invalid_message", message, error);
+	if (code === "CONTEXT_WINDOW_EXCEEDED") return new AIError("context_window_exceeded", message, error);
+	return new AIError("generation_failed", message, error);
+}
+async function isAvailable() {
+	try {
+		return await bridge().isAvailable?.() ?? false;
+	} catch {
+		return false;
+	}
+}
+async function generate(options) {
+	const output = options.output;
+	const request = {
+		system: options.system,
+		prompt: promptFromInput(options),
+		temperature: options.temperature,
+		maxTokens: options.maxTokens,
+		outputSchema: output ? schemaToBridgeSchema(output) : void 0
+	};
+	try {
+		const value = await bridge().generate?.(request);
+		if (output) {
+			const result = output["~standard"].validate(value);
+			if (result.issues !== void 0) throw new AIError("validation_failed", result.issues.map((nextIssue) => nextIssue.message).join("\n"), result.issues);
+			return result.value;
+		}
+		if (typeof value !== "string") throw new AIError("generation_failed", "Expected generated text");
+		return value;
+	} catch (error) {
+		if (error instanceof AIError) throw error;
+		throw mapNativeError(error);
+	}
+}
+
+//#endregion
+export { AIError, generate, isAvailable, shape };