baml-sap-ts 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2025-02-14
+
+### Added
+- Initial release of baml-sap-ts
+- Schema-Aligned Parsing (SAP) algorithm implementation
+- TypeBox integration for schema definition
+- JSON extraction from markdown code blocks
+- Automatic JSON fixing (trailing commas, missing quotes)
+- Chain-of-thought reasoning filtering
+- Type coercion and validation
+- Union type matching
+- Optional field handling with defaults
+- Support for partial/streaming responses
+- Comprehensive test suite (24 tests)
+- Biome linting and formatting
+- Full TypeScript support with type declarations
+
+### Features
+- `parseResponse()` - Main parsing function
+- `createPromptWithSchema()` - Generate prompts with schema instructions
+- `extractJson()` - Low-level JSON extraction
+- `coerceValue()` - Type coercion against schemas
+- `renderSchema()` - Schema to prompt text conversion
+- Support for complex nested schemas
+- Enum and literal type handling
+- Record/map type support
+- Tuple type support
+
+[0.1.0]: https://github.com/yourusername/baml-sap-ts/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 aiamblichus
+
+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,355 @@
+# baml-sap-ts
+
+[![npm version](https://badge.fury.io/js/baml-sap-ts.svg)](https://www.npmjs.com/package/baml-sap-ts)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A TypeScript implementation of BAML's **Schema-Aligned Parsing (SAP)** algorithm using [TypeBox](https://github.com/sinclairzx81/typebox) for schema definition.
+
+> **Note:** This is an unofficial community migration of BAML's core SAP algorithm. For the official BAML project, visit [boundaryml.com](https://www.boundaryml.com).
+
+## Overview
+
+This package provides **LLM framework independent** structured output parsing - use it with any LLM client (OpenAI, Anthropic, Ollama, etc.).
+
+### What is Schema-Aligned Parsing (SAP)?
+
+SAP is BAML's algorithm for reliably extracting structured outputs from LLMs:
+
+1. **Prompt Rendering**: Auto-generates schema instructions for the LLM
+2. **Response Parsing**: Handles malformed JSON, markdown extraction, chain-of-thought filtering
+3. **Type Coercion**: Validates and coerces parsed data to the target schema
+
+### Key Features
+
+- ✅ **Markdown code block extraction** - Extract JSON from ` ```json ` blocks
+- ✅ **JSON fixing** - Auto-fix trailing commas, missing quotes, etc.
+- ✅ **Chain-of-thought filtering** - Remove reasoning text before JSON
+- ✅ **Union type matching** - Automatically select best matching variant
+- ✅ **Optional fields with defaults** - Handle missing fields gracefully
+- ✅ **Type coercion** - Convert strings to numbers, etc.
+- ✅ **Partial/streaming support** - Parse incomplete responses
+- ✅ **Detailed error reporting** - Know exactly what went wrong
+- ✅ **Full TypeScript support** - Type-safe schemas and responses
+
+## Installation
+
+```bash
+npm install baml-sap-ts @sinclair/typebox
+```
+
+## Quick Start
+
+````typescript
+import { Type } from "@sinclair/typebox";
+import { createPromptWithSchema, parseResponse } from "baml-sap-ts";
+
+// 1. Define your schema
+const UserSchema = Type.Object({
+  name: Type.String(),
+  age: Type.Number(),
+  email: Type.Optional(Type.String()),
+});
+
+// 2. Create a prompt with schema instructions
+const prompt = createPromptWithSchema(
+  'Extract user information from: "Alice is 30 years old"',
+  UserSchema
+);
+
+console.log(prompt);
+// Output:
+// Extract user information from: "Alice is 30 years old"
+//
+// Respond with a JSON object in the following format:
+//
+// ```json
+// {
+//   "name": string,
+//   "age": number,
+//   "email": string (optional)
+// }
+// ```
+
+// 3. Send prompt to LLM and parse response
+const response = `Here's the information:
+
+\`\`\`json
+{
+  "name": "Alice",
+  "age": 30
+}
+\`\`\``;
+
+const result = parseResponse(response, UserSchema);
+
+if (result.success) {
+  console.log(result.value); // { name: "Alice", age: 30 }
+} else {
+  console.error(result.errors);
+}
+````
+
+## API Reference
+
+### `createPromptWithSchema(basePrompt, schema, options?)`
+
+Appends schema instructions to a base prompt to guide the LLM toward producing correctly structured output.
+
+**Parameters:**
+
+- `basePrompt: string` - Your prompt text
+- `schema: TSchema` - TypeBox schema
+- `options?: SchemaRenderOptions` - Optional rendering options
+
+**Returns:** `string` - Complete prompt with schema instructions
+
+---
+
+### `parseResponse(response, schema, options?)`
+
+Parse an LLM response into a typed value. This is the main entry point for the SAP algorithm.
+
+**Parameters:**
+
+- `response: string` - Raw LLM response text
+- `schema: TSchema` - TypeBox schema to validate against
+- `options?: ParseOptions` - Optional parsing options
+
+**Returns:** `ParseResult<T>` - Parsed value with metadata
+
+```typescript
+interface ParseResult<T> {
+  success: boolean;
+  value: T;
+  errors: Array<{ path: string; message: string }>;
+  isPartial: boolean;
+  meta: {
+    raw: string;
+    fromMarkdown?: boolean;
+    chainOfThoughtFiltered?: boolean;
+    fixes?: string[];
+    coercions?: string[];
+  };
+}
+```
+
+---
+
+### `parsePartialResponse(response, schema, options?)`
+
+For streaming scenarios - parses partial responses with `allowPartials: true`.
+
+---
+
+### `extractJson(text, options?)`
+
+Low-level JSON extraction from text. Handles markdown blocks and malformed JSON.
+
+---
+
+### `coerceValue(value, schema, options?)`
+
+Low-level type coercion and validation against a TypeBox schema.
+
+---
+
+### `validateValue(value, schema)`
+
+Validates a value against a schema without coercion. Returns validation errors.
+
+## Usage Examples
+
+### Chain-of-Thought Reasoning
+
+Automatically detected and filtered:
+
+```typescript
+const response = `Let me think step by step...
+
+First, I'll analyze the input. The user mentions they are 25.
+
+Therefore the output JSON is:
+\`\`\`json
+{"name": "John", "age": 25}
+\`\`\``;
+
+const result = parseResponse(response, schema);
+console.log(result.meta.chainOfThoughtFiltered); // true
+console.log(result.value); // { name: "John", age: 25 }
+```
+
+### Malformed JSON
+
+Auto-fixes common issues:
+
+```typescript
+const response = '{"name": "test", "age": 25,}'; // trailing comma
+const result = parseResponse(response, schema);
+console.log(result.meta.fixes); // ['applied_auto_fixes']
+console.log(result.value); // { name: "test", age: 25 }
+```
+
+### Markdown Code Blocks
+
+Extracts JSON from markdown:
+
+````typescript
+const response = '```json\n{"key": "value"}\n```';
+const result = parseResponse(response, schema);
+console.log(result.meta.fromMarkdown); // true
+````
+
+### Union Types
+
+Selects best matching variant:
+
+```typescript
+const Schema = Type.Union([
+  Type.Object({ type: Type.Literal("user"), name: Type.String() }),
+  Type.Object({ type: Type.Literal("bot"), id: Type.Number() }),
+]);
+
+const result = parseResponse('{"type": "user", "name": "Alice"}', Schema);
+// Automatically matches the first variant
+```
+
+### Complex Nested Schema
+
+```typescript
+const OrderSchema = Type.Object({
+  orderId: Type.String(),
+  status: Type.Enum({ ORDERED: "ORDERED", SHIPPED: "SHIPPED" }),
+  items: Type.Array(
+    Type.Object({
+      name: Type.String(),
+      quantity: Type.Integer({ minimum: 1 }),
+      price: Type.Number({ minimum: 0 }),
+    })
+  ),
+  total: Type.Number({ minimum: 0 }),
+});
+
+const response = await openai.chat.completions.create({
+  model: "gpt-4",
+  messages: [
+    {
+      role: "user",
+      content: createPromptWithSchema("Extract order info", OrderSchema),
+    },
+  ],
+});
+
+const result = parseResponse(response.choices[0].message.content, OrderSchema);
+```
+
+## Options
+
+### ParseOptions
+
+```typescript
+interface ParseOptions {
+  // Extraction options
+  allowMarkdownJson?: boolean; // Extract from markdown blocks (default: true)
+  allowFixes?: boolean; // Fix malformed JSON (default: true)
+  allowAsString?: boolean; // Return string if all fails (default: true)
+  findAllJsonObjects?: boolean; // Find multiple JSON objects (default: true)
+  maxDepth?: number; // Max parsing depth (default: 100)
+
+  // Coercion options
+  allowPartials?: boolean; // Allow incomplete objects (default: false)
+  useDefaults?: boolean; // Use default values (default: true)
+  strict?: boolean; // No type coercion (default: false)
+  trackCoercions?: boolean; // Track applied coercions (default: false)
+
+  // Parse options
+  filterChainOfThought?: boolean; // Filter reasoning text (default: true)
+  returnAllCandidates?: boolean; // Return all candidate parses (default: false)
+}
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         parseResponse                       │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│  ┌─────────────────────┐    ┌───────────────────────────┐   │
+│  │ 1. Filter CoT Text  │───▶│ 2. Extract JSON           │   │
+│  │    (if detected)    │    │    - Markdown blocks      │   │
+│  └─────────────────────┘    │    - Direct JSON          │   │
+│                             │    - Fix malformed        │   │
+│                             └───────────────────────────┘   │
+│                                          │                  │
+│                                          ▼                  │
+│                             ┌───────────────────────────┐   │
+│                             │ 3. Type Coercion          │   │
+│                             │    - Union matching       │   │
+│                             │    - Field validation     │   │
+│                             │    - Default values       │   │
+│                             └───────────────────────────┘   │
+│                                          │                  │
+│                                          ▼                  │
+│                             ┌───────────────────────────┐   │
+│                             │ 4. Return ParseResult     │   │
+│                             │    with metadata          │   │
+│                             └───────────────────────────┘   │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Comparison with Original BAML
+
+| Feature           | Original BAML (Rust) | This Migration (TS) |
+| ----------------- | -------------------- | ------------------- |
+| Schema Definition | BAML DSL             | TypeBox             |
+| Prompt Rendering  | `ctx.output_format`  | `renderSchema()`    |
+| JSON Extraction   | jsonish parser       | `extractJson()`     |
+| Type Coercion     | Coercer IR           | `coerceValue()`     |
+| Streaming         | Native               | Supported           |
+| Partial Results   | Native               | Supported           |
+| Error Reporting   | Detailed             | Detailed            |
+| Performance       | Native Rust          | JavaScript          |
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/aiamblichus/baml-sap-ts.git
+cd baml-sap-ts
+
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run tests
+npm test
+
+# Run example
+npm run example
+
+# Lint and format
+npm run check
+npm run check:fix
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## License
+
+MIT © [Your Name](https://github.com/yourusername)
+
+## Acknowledgments
+
+- Original BAML project by [BoundaryML](https://www.boundaryml.com)
+- [TypeBox](https://github.com/sinclairzx81/typebox) for the excellent schema validation library

package/dist/index.d.ts

@@ -0,0 +1,180 @@
+/**
+ * BAML SAP TypeScript Migration
+ *
+ * Schema-Aligned Parsing (SAP) for TypeScript using TypeBox
+ *
+ * This is a TypeScript port of BAML's core algorithm for structured
+ * data extraction from LLM responses.
+ *
+ * Usage:
+ * ```typescript
+ * import { Type } from '@sinclair/typebox';
+ * import { createPromptWithSchema, parseResponse } from 'baml-sap-ts';
+ *
+ * const schema = Type.Object({
+ *   name: Type.String(),
+ *   age: Type.Number(),
+ * });
+ *
+ * // Create a prompt with schema instructions
+ * const prompt = createPromptWithSchema(
+ *   'Extract user information from: John is 25 years old',
+ *   schema
+ * );
+ *
+ * // After getting LLM response, parse it
+ * const response = `{ "name": "John", "age": 25 }`;
+ * const result = parseResponse(response, schema);
+ *
+ * if (result.success) {
+ *   console.log(result.value); // { name: "John", age: 25 }
+ * }
+ * ```
+ */
+import type { Static, TSchema } from "@sinclair/typebox";
+import { type ExtractionOptions, extractJson, filterChainOfThought, hasChainOfThought } from "./json-extractor.js";
+import { createJsonSchemaPrompt, renderSchema, type SchemaRenderOptions } from "./schema-renderer.js";
+import { type CoercionOptions, type CoercionResult, coerceValue, validateValue } from "./type-coercer.js";
+export { extractAllCandidates, extractJson, filterChainOfThought, hasChainOfThought, } from "./json-extractor.js";
+export { createJsonSchemaPrompt, renderSchema } from "./schema-renderer.js";
+export { type CoercionError, type CoercionOptions, type CoercionResult, coerceValue, validateValue, } from "./type-coercer.js";
+export type { SchemaRenderOptions, ExtractionOptions };
+/**
+ * Main options for parseResponse
+ */
+export interface ParseOptions extends ExtractionOptions, CoercionOptions {
+    /** Filter out chain-of-thought reasoning before parsing */
+    filterChainOfThought?: boolean;
+    /** Return all candidate parses (useful for debugging) */
+    returnAllCandidates?: boolean;
+}
+/**
+ * Result from parsing an LLM response
+ */
+export interface ParseResult<T = unknown> {
+    /** Whether parsing was successful */
+    success: boolean;
+    /** The parsed and validated value */
+    value: T;
+    /** Errors encountered during parsing */
+    errors: Array<{
+        path: string;
+        message: string;
+    }>;
+    /** Whether the result is partial (for streaming) */
+    isPartial: boolean;
+    /** Metadata about the parsing process */
+    meta: {
+        /** Raw text that was parsed */
+        raw: string;
+        /** Whether text was extracted from markdown */
+        fromMarkdown?: boolean;
+        /** Whether chain-of-thought was detected and filtered */
+        chainOfThoughtFiltered?: boolean;
+        /** Fixes applied during JSON extraction */
+        fixes?: string[];
+        /** Coercions applied during type validation */
+        coercions?: string[];
+    };
+}
+/**
+ * Parse an LLM response into a typed value
+ *
+ * This is the main entry point for the SAP algorithm.
+ * It handles:
+ * 1. Chain-of-thought filtering
+ * 2. JSON extraction from markdown/text
+ * 3. Type coercion and validation
+ *
+ * @param response - The raw LLM response text
+ * @param schema - TypeBox schema to validate against
+ * @param options - Parsing options
+ * @returns ParseResult with the typed value or errors
+ */
+export declare function parseResponse<T extends TSchema>(response: string, schema: T, options?: ParseOptions): ParseResult<Static<T>>;
+/**
+ * Stream parser for handling partial LLM responses
+ *
+ * This is useful for streaming scenarios where you want to
+ * show partial results as they arrive.
+ *
+ * @param partialResponse - The partial response text so far
+ * @param schema - TypeBox schema to validate against
+ * @param options - Parsing options
+ * @returns ParseResult with the best-effort typed value
+ */
+export declare function parsePartialResponse<T extends TSchema>(partialResponse: string, schema: T, options?: ParseOptions): ParseResult<Static<T>>;
+/**
+ * Create a prompt with schema instructions
+ *
+ * Appends schema instructions to a base prompt to guide
+ * the LLM toward producing correctly structured output.
+ *
+ * @param basePrompt - The base prompt text
+ * @param schema - TypeBox schema describing expected output
+ * @param options - Schema rendering options
+ * @returns Complete prompt with schema instructions
+ */
+export declare function createPromptWithSchema(basePrompt: string, schema: TSchema, options?: SchemaRenderOptions): string;
+/**
+ * Parse multiple candidates from a response
+ *
+ * Useful when the LLM might have provided multiple JSON objects
+ * and you want to try them all.
+ *
+ * @param response - The raw LLM response text
+ * @param schema - TypeBox schema to validate against
+ * @param options - Parsing options
+ * @returns Array of ParseResults for each candidate
+ */
+export declare function parseAllCandidates<T extends TSchema>(response: string, schema: T, options?: ParseOptions): ParseResult<Static<T>>[];
+/**
+ * Get the best candidate from multiple options
+ *
+ * Returns the candidate with the fewest errors.
+ *
+ * @param response - The raw LLM response text
+ * @param schema - TypeBox schema to validate against
+ * @param options - Parsing options
+ * @returns The best ParseResult or null if none valid
+ */
+export declare function parseBestCandidate<T extends TSchema>(response: string, schema: T, options?: ParseOptions): ParseResult<Static<T>> | null;
+/**
+ * Check if a response is valid against a schema without full parsing
+ *
+ * @param response - The raw LLM response text
+ * @param schema - TypeBox schema to validate against
+ * @returns Whether the response is valid
+ */
+export declare function isValidResponse(response: string, schema: TSchema): boolean;
+/**
+ * Debug helper to see what the parser is doing
+ *
+ * @param response - The raw LLM response text
+ * @param schema - TypeBox schema to validate against
+ * @returns Debug information
+ */
+export declare function debugParse(response: string, schema: TSchema): {
+    filteredText: string;
+    extractedValue: unknown;
+    extractionErrors: string[];
+    coercionResult: CoercionResult<unknown>;
+};
+declare const _default: {
+    parseResponse: typeof parseResponse;
+    parsePartialResponse: typeof parsePartialResponse;
+    createPromptWithSchema: typeof createPromptWithSchema;
+    parseAllCandidates: typeof parseAllCandidates;
+    parseBestCandidate: typeof parseBestCandidate;
+    isValidResponse: typeof isValidResponse;
+    debugParse: typeof debugParse;
+    renderSchema: typeof renderSchema;
+    createJsonSchemaPrompt: typeof createJsonSchemaPrompt;
+    extractJson: typeof extractJson;
+    filterChainOfThought: typeof filterChainOfThought;
+    hasChainOfThought: typeof hasChainOfThought;
+    coerceValue: typeof coerceValue;
+    validateValue: typeof validateValue;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}