@ank1015/providers 0.0.1 → 0.0.2

package/src/utils/event-stream.ts

@@ -1,60 +0,0 @@
-import { NativeAssistantMessage, AssistantMessageEvent } from "../types";
-
-// Generic event stream class for async iteration
-export class EventStream<T, R = T> implements AsyncIterable<T> {
-	private queue: T[] = [];
-	private waiting: ((value: IteratorResult<T>) => void)[] = [];
-	private done = false;
-	private finalResultPromise: Promise<R>;
-	private resolveFinalResult!: (result: R) => void;
-
-	constructor() {
-		this.finalResultPromise = new Promise((resolve) => {
-			this.resolveFinalResult = resolve;
-		});
-	}
-
-	push(event: T): void {
-		if (this.done) return;
-
-		// Deliver to waiting consumer or queue it
-		const waiter = this.waiting.shift();
-		if (waiter) {
-			waiter({ value: event, done: false });
-		} else {
-			this.queue.push(event);
-		}
-	}
-
-	end(result: R): void {
-		this.done = true;
-		// Always resolve the final result to prevent deadlock
-		this.resolveFinalResult(result);
-		// Notify all waiting consumers that we're done
-		while (this.waiting.length > 0) {
-			const waiter = this.waiting.shift()!;
-			// When done is true, value type is the return type (void for async generators)
-			waiter({ done: true, value: undefined! });
-		}
-	}
-
-	async *[Symbol.asyncIterator](): AsyncIterator<T> {
-		while (true) {
-			if (this.queue.length > 0) {
-				yield this.queue.shift()!;
-			} else if (this.done) {
-				return;
-			} else {
-				const result = await new Promise<IteratorResult<T>>((resolve) => this.waiting.push(resolve));
-				if (result.done) return;
-				yield result.value;
-			}
-		}
-	}
-
-	result(): Promise<R> {
-		return this.finalResultPromise;
-	}
-}
-
-export class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, NativeAssistantMessage> {}

package/src/utils/json-parse.ts

@@ -1,28 +0,0 @@
-import { parse as partialParse } from "partial-json";
-
-/**
- * Attempts to parse potentially incomplete JSON during streaming.
- * Always returns a valid object, even if the JSON is incomplete.
- *
- * @param partialJson The partial JSON string from streaming
- * @returns Parsed object or empty object if parsing fails
- */
-export function parseStreamingJson<T = any>(partialJson: string | undefined): T {
-	if (!partialJson || partialJson.trim() === "") {
-		return {} as T;
-	}
-
-	// Try standard parsing first (fastest for complete JSON)
-	try {
-		return JSON.parse(partialJson) as T;
-	} catch {
-		// Try partial-json for incomplete JSON
-		try {
-			const result = partialParse(partialJson);
-			return (result ?? {}) as T;
-		} catch {
-			// If all parsing fails, return empty object
-			return {} as T;
-		}
-	}
-}

package/src/utils/sanitize-unicode.ts

@@ -1,25 +0,0 @@
-/**
- * Removes unpaired Unicode surrogate characters from a string.
- *
- * Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
- * or vice versa) cause JSON serialization errors in many API providers.
- *
- * Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
- * surrogates and will NOT be affected by this function.
- *
- * @param text - The text to sanitize
- * @returns The sanitized text with unpaired surrogates removed
- *
- * @example
- * // Valid emoji (properly paired surrogates) are preserved
- * sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
- *
- * // Unpaired high surrogate is removed
- * const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
- * sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
- */
-export function sanitizeSurrogates(text: string): string {
-	// Replace unpaired high surrogates (0xD800-0xDBFF not followed by low surrogate)
-	// Replace unpaired low surrogates (0xDC00-0xDFFF not preceded by high surrogate)
-	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
-}

package/src/utils/validation.ts

@@ -1,69 +0,0 @@
-import AjvModule from "ajv";
-import addFormatsModule from "ajv-formats";
-
-// Handle both default and named exports
-const Ajv = (AjvModule as any).default || AjvModule;
-const addFormats = (addFormatsModule as any).default || addFormatsModule;
-
-import type { Tool, AssistantToolCall } from "../types.js";
-import type { TSchema, Static } from "@sinclair/typebox";
-
-// Detect if we're in a browser extension environment with strict CSP
-// Chrome extensions with Manifest V3 don't allow eval/Function constructor
-const isBrowserExtension = typeof globalThis !== "undefined" && (globalThis as any).chrome?.runtime?.id !== undefined;
-
-// Create a singleton AJV instance with formats (only if not in browser extension)
-// AJV requires 'unsafe-eval' CSP which is not allowed in Manifest V3
-let ajv: any = null;
-if (!isBrowserExtension) {
-	try {
-		ajv = new Ajv({
-			allErrors: true,
-			strict: false,
-		});
-		addFormats(ajv);
-	} catch (e) {
-		// AJV initialization failed (likely CSP restriction)
-		console.warn("AJV validation disabled due to CSP restrictions");
-	}
-}
-
-/**
- * Validates tool call arguments against the tool's TypeBox schema
- * @param tool The tool definition with TypeBox schema
- * @param toolCall The tool call from the LLM
- * @returns The validated arguments with proper typing
- * @throws Error with formatted message if validation fails
- */
-export function validateToolArguments<TParameters extends TSchema>(
-	tool: Tool<TParameters>,
-	toolCall: AssistantToolCall
-): Static<TParameters> {
-	// Skip validation in browser extension environment (CSP restrictions prevent AJV from working)
-	if (!ajv || isBrowserExtension) {
-		// Trust the LLM's output without validation
-		// Browser extensions can't use AJV due to Manifest V3 CSP restrictions
-		return toolCall.arguments as Static<TParameters>;
-	}
-
-	// Compile the schema
-	const validate = ajv.compile(tool.parameters);
-
-	// Validate the arguments
-	if (validate(toolCall.arguments)) {
-		return toolCall.arguments as Static<TParameters>;
-	}
-
-	// Format validation errors nicely
-	const errors =
-		validate.errors
-			?.map((err: any) => {
-				const path = err.instancePath ? err.instancePath.substring(1) : err.params.missingProperty || "root";
-				return `  - ${path}: ${err.message}`;
-			})
-			.join("\n") || "Unknown validation error";
-
-	const errorMessage = `Validation failed for tool "${toolCall.name}":\n${errors}\n\nReceived arguments:\n${JSON.stringify(toolCall.arguments, null, 2)}`;
-
-	throw new Error(errorMessage);
-}