@particle-academy/prism 0.0.0

package/dist/schema/index.js

@@ -0,0 +1,192 @@
+/** The reference expresses "nullable" as a two-member type union, not a flag. */
+function schemaType(type, nullable) {
+    return nullable ? [type, 'null'] : type;
+}
+export class StringSchema {
+    name;
+    description;
+    nullable;
+    pattern;
+    format;
+    constructor(name, description, options = {}) {
+        this.name = name;
+        this.description = description;
+        this.nullable = options.nullable ?? false;
+        this.pattern = options.pattern ?? null;
+        this.format = options.format ?? null;
+    }
+    toObject() {
+        const schema = {
+            description: this.description,
+            type: schemaType('string', this.nullable),
+        };
+        if (this.pattern !== null) {
+            schema.pattern = this.pattern;
+        }
+        if (this.format !== null) {
+            schema.format = this.format;
+        }
+        return schema;
+    }
+}
+export class NumberSchema {
+    name;
+    description;
+    nullable;
+    multipleOf;
+    maximum;
+    exclusiveMaximum;
+    minimum;
+    exclusiveMinimum;
+    constructor(name, description, options = {}) {
+        this.name = name;
+        this.description = description;
+        this.nullable = options.nullable ?? false;
+        this.multipleOf = options.multipleOf ?? null;
+        this.maximum = options.maximum ?? null;
+        this.exclusiveMaximum = options.exclusiveMaximum ?? null;
+        this.minimum = options.minimum ?? null;
+        this.exclusiveMinimum = options.exclusiveMinimum ?? null;
+    }
+    toObject() {
+        const schema = {
+            description: this.description,
+            type: schemaType('number', this.nullable),
+        };
+        if (this.multipleOf !== null) {
+            schema.multipleOf = this.multipleOf;
+        }
+        if (this.maximum !== null) {
+            schema.maximum = this.maximum;
+        }
+        if (this.exclusiveMaximum !== null) {
+            schema.exclusiveMaximum = this.exclusiveMaximum;
+        }
+        if (this.minimum !== null) {
+            schema.minimum = this.minimum;
+        }
+        if (this.exclusiveMinimum !== null) {
+            schema.exclusiveMinimum = this.exclusiveMinimum;
+        }
+        return schema;
+    }
+}
+export class BooleanSchema {
+    name;
+    description;
+    nullable;
+    constructor(name, description, options = {}) {
+        this.name = name;
+        this.description = description;
+        this.nullable = options.nullable ?? false;
+    }
+    toObject() {
+        return {
+            description: this.description,
+            type: schemaType('boolean', this.nullable),
+        };
+    }
+}
+/**
+ * The schema a structured response is shaped by.
+ *
+ * `allowAdditionalProperties` DEFAULTS TO FALSE, matching the reference, and the
+ * default matters more here than it looks: OpenAI's strict schema mode REJECTS a
+ * schema that permits extra properties, so a permissive default would make the
+ * strongest structured mode unusable and silently push every request down to
+ * plain JSON mode.
+ */
+export class ObjectSchema {
+    name;
+    description;
+    properties;
+    requiredFields;
+    allowAdditionalProperties;
+    nullable;
+    constructor(name, description, properties = [], options = {}) {
+        this.name = name;
+        this.description = description;
+        this.properties = properties;
+        this.requiredFields = options.requiredFields ?? [];
+        this.allowAdditionalProperties = options.allowAdditionalProperties ?? false;
+        this.nullable = options.nullable ?? false;
+    }
+    toObject() {
+        const properties = {};
+        for (const property of this.properties) {
+            properties[property.name] = property.toObject();
+        }
+        // `properties` is dropped when empty rather than sent as `{}`, matching the
+        // reference's not-null filter. `required` and `additionalProperties` are
+        // always sent: `[]` and `false` are meaningful answers, not absences.
+        const schema = {
+            description: this.description,
+            type: schemaType('object', this.nullable),
+        };
+        if (this.properties.length > 0) {
+            schema.properties = properties;
+        }
+        schema.required = [...this.requiredFields];
+        schema.additionalProperties = this.allowAdditionalProperties;
+        return schema;
+    }
+}
+export class ArraySchema {
+    name;
+    description;
+    items;
+    minItems;
+    maxItems;
+    nullable;
+    constructor(name, description, items, options = {}) {
+        this.name = name;
+        this.description = description;
+        this.items = items;
+        this.minItems = options.minItems ?? null;
+        this.maxItems = options.maxItems ?? null;
+        this.nullable = options.nullable ?? false;
+    }
+    toObject() {
+        const schema = {
+            description: this.description,
+            type: schemaType('array', this.nullable),
+            items: this.items.toObject(),
+        };
+        // Present only when set. The reference appends these conditionally rather
+        // than emitting nulls, and a `minItems: null` is rejected by strict mode.
+        if (this.minItems !== null) {
+            schema.minItems = this.minItems;
+        }
+        if (this.maxItems !== null) {
+            schema.maxItems = this.maxItems;
+        }
+        return schema;
+    }
+}
+/**
+ * A closed set of allowed values.
+ *
+ * When nullable, the reference adds `null` to the OPTIONS as well as to the
+ * type union — a nullable enum whose options omit null describes a value that
+ * can be null and may not be, which no validator can satisfy.
+ */
+export class EnumSchema {
+    name;
+    description;
+    options;
+    nullable;
+    constructor(name, description, options, schemaOptions = {}) {
+        this.name = name;
+        this.description = description;
+        this.options = options;
+        this.nullable = schemaOptions.nullable ?? false;
+    }
+    toObject() {
+        return {
+            description: this.description,
+            enum: this.nullable ? [...this.options, null] : [...this.options],
+            type: schemaType('string', this.nullable),
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAcA,iFAAiF;AACjF,SAAS,UAAU,CAAC,IAAY,EAAE,QAAiB;IACjD,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1C,CAAC;AAQD,MAAM,OAAO,YAAY;IAQZ;IACA;IARF,QAAQ,CAAU;IAElB,OAAO,CAAgB;IAEvB,MAAM,CAAgB;IAE/B,YACW,IAAY,EACZ,WAAmB,EAC5B,UAA+B,EAAE;QAFxB,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAQ;QAG5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,IAAI,CAAC;IACvC,CAAC;IAED,QAAQ;QACN,MAAM,MAAM,GAAe;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;SAC1C,CAAC;QAEF,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YACzB,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC9B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAWD,MAAM,OAAO,YAAY;IAcZ;IACA;IAdF,QAAQ,CAAU;IAElB,UAAU,CAAgB;IAE1B,OAAO,CAAgB;IAEvB,gBAAgB,CAAgB;IAEhC,OAAO,CAAgB;IAEvB,gBAAgB,CAAgB;IAEzC,YACW,IAAY,EACZ,WAAmB,EAC5B,UAA+B,EAAE;QAFxB,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAQ;QAG5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,IAAI,CAAC;QAC7C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;QACvC,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,IAAI,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;QACvC,IAAI,CAAC,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,IAAI,CAAC;IAC3D,CAAC;IAED,QAAQ;QACN,MAAM,MAAM,GAAe;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;SAC1C,CAAC;QAEF,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;YAC7B,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACtC,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE,CAAC;YACnC,MAAM,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAClD,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC1B,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAChC,CAAC;QAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE,CAAC;YACnC,MAAM,CAAC,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAClD,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAMD,MAAM,OAAO,aAAa;IAIb;IACA;IAJF,QAAQ,CAAU;IAE3B,YACW,IAAY,EACZ,WAAmB,EAC5B,UAAgC,EAAE;QAFzB,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAQ;QAG5B,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC5C,CAAC;IAED,QAAQ;QACN,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC;SAC3C,CAAC;IACJ,CAAC;CACF;AAQD;;;;;;;;GAQG;AACH,MAAM,OAAO,YAAY;IAQZ;IACA;IACA;IATF,cAAc,CAAoB;IAElC,yBAAyB,CAAU;IAEnC,QAAQ,CAAU;IAE3B,YACW,IAAY,EACZ,WAAmB,EACnB,aAAgC,EAAE,EAC3C,UAA+B,EAAE;QAHxB,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAQ;QACnB,eAAU,GAAV,UAAU,CAAwB;QAG3C,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,IAAI,EAAE,CAAC;QACnD,IAAI,CAAC,yBAAyB,GAAG,OAAO,CAAC,yBAAyB,IAAI,KAAK,CAAC;QAC5E,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC5C,CAAC;IAED,QAAQ;QACN,MAAM,UAAU,GAAe,EAAE,CAAC;QAElC,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACvC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAClD,CAAC;QAED,4EAA4E;QAC5E,yEAAyE;QACzE,sEAAsE;QACtE,MAAM,MAAM,GAAe;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;SAC1C,CAAC;QAEF,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC;QACjC,CAAC;QAED,MAAM,CAAC,QAAQ,GAAG,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC;QAC3C,MAAM,CAAC,oBAAoB,GAAG,IAAI,CAAC,yBAAyB,CAAC;QAE7D,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAQD,MAAM,OAAO,WAAW;IAQX;IACA;IACA;IATF,QAAQ,CAAgB;IAExB,QAAQ,CAAgB;IAExB,QAAQ,CAAU;IAE3B,YACW,IAAY,EACZ,WAAmB,EACnB,KAAa,EACtB,UAA8B,EAAE;QAHvB,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAQ;QACnB,UAAK,GAAL,KAAK,CAAQ;QAGtB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;IAC5C,CAAC;IAED,QAAQ;QACN,MAAM,MAAM,GAAe;YACzB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC;YACxC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE;SAC7B,CAAC;QAEF,0EAA0E;QAC1E,0EAA0E;QAC1E,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC3B,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAClC,CAAC;QAED,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;YAC3B,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QAClC,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAMD;;;;;;GAMG;AACH,MAAM,OAAO,UAAU;IAIV;IACA;IACA;IALF,QAAQ,CAAU;IAE3B,YACW,IAAY,EACZ,WAAmB,EACnB,OAA4C,EACrD,gBAAmC,EAAE;QAH5B,SAAI,GAAJ,IAAI,CAAQ;QACZ,gBAAW,GAAX,WAAW,CAAQ;QACnB,YAAO,GAAP,OAAO,CAAqC;QAGrD,IAAI,CAAC,QAAQ,GAAG,aAAa,CAAC,QAAQ,IAAI,KAAK,CAAC;IAClD,CAAC;IAED,QAAQ;QACN,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;YACjE,IAAI,EAAE,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;SAC1C,CAAC;IACJ,CAAC;CACF"}

package/dist/streaming/events.d.ts

@@ -0,0 +1,90 @@
+import type { JsonObject } from '../json.js';
+import type { FinishReason } from '../enums.js';
+import type { ToolCall } from '../value-objects/tool-call.js';
+import type { Usage } from '../value-objects/usage.js';
+/**
+ * What a stream emits.
+ *
+ * The reference defines twenty event types; this port emits the seven that
+ * OpenAI and Anthropic actually produce through the paths implemented here.
+ * The enum lists ONLY those seven rather than all twenty, deliberately: a
+ * member nothing can ever emit reads to a consumer as a case they must handle,
+ * and writing a branch for an event that never arrives is worse than not
+ * knowing it exists. They are added when a provider can emit them.
+ */
+export declare enum StreamEventType {
+    StreamStart = "stream_start",
+    TextStart = "text_start",
+    TextDelta = "text_delta",
+    TextComplete = "text_complete",
+    ToolCall = "tool_call",
+    Error = "error",
+    StreamEnd = "stream_end"
+}
+/** Unique within a process, and cheap. Streams are correlated by run, not by this. */
+export declare function eventId(prefix?: string): string;
+export declare abstract class StreamEvent {
+    readonly id: string;
+    readonly timestamp: number;
+    constructor(id?: string, timestamp?: number);
+    abstract type(): StreamEventType;
+    abstract toObject(): JsonObject;
+    protected base(): JsonObject;
+}
+export declare class StreamStartEvent extends StreamEvent {
+    readonly model: string;
+    constructor(model: string, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+export declare class TextStartEvent extends StreamEvent {
+    readonly messageId: string;
+    constructor(messageId: string, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+/** The one a consumer renders. Everything else is bookkeeping around it. */
+export declare class TextDeltaEvent extends StreamEvent {
+    readonly delta: string;
+    readonly messageId: string;
+    constructor(delta: string, messageId: string, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+export declare class TextCompleteEvent extends StreamEvent {
+    readonly text: string;
+    readonly messageId: string;
+    constructor(text: string, messageId: string, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+export declare class ToolCallEvent extends StreamEvent {
+    readonly toolCall: ToolCall;
+    readonly messageId: string;
+    constructor(toolCall: ToolCall, messageId: string, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+/**
+ * The provider reported a failure MID-STREAM.
+ *
+ * Emitted rather than thrown, and the distinction is the reason this type
+ * exists: by the time it arrives the consumer has already rendered text, and
+ * throwing would discard a partial answer the user watched appear. The stream
+ * ends after it; the caller decides what the partial answer was worth.
+ */
+export declare class ErrorEvent extends StreamEvent {
+    readonly code: string;
+    readonly message: string;
+    constructor(code: string, message: string, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+export declare class StreamEndEvent extends StreamEvent {
+    readonly finishReason: FinishReason;
+    readonly usage: Usage | null;
+    constructor(finishReason: FinishReason, usage?: Usage | null, id?: string, timestamp?: number);
+    type(): StreamEventType;
+    toObject(): JsonObject;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/streaming/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/streaming/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAEvD;;;;;;;;;GASG;AACH,oBAAY,eAAe;IACzB,WAAW,iBAAiB;IAC5B,SAAS,eAAe;IACxB,SAAS,eAAe;IACxB,YAAY,kBAAkB;IAC9B,QAAQ,cAAc;IACtB,KAAK,UAAU;IACf,SAAS,eAAe;CACzB;AAID,sFAAsF;AACtF,wBAAgB,OAAO,CAAC,MAAM,SAAQ,GAAG,MAAM,CAI9C;AAED,8BAAsB,WAAW;IAC/B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAK3C,QAAQ,CAAC,IAAI,IAAI,eAAe;IAEhC,QAAQ,CAAC,QAAQ,IAAI,UAAU;IAE/B,SAAS,CAAC,IAAI,IAAI,UAAU;CAG7B;AAED,qBAAa,gBAAiB,SAAQ,WAAW;IAE7C,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM,EACtB,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAGvB;AAED,qBAAa,cAAe,SAAQ,WAAW;IAE3C,QAAQ,CAAC,SAAS,EAAE,MAAM;gBAAjB,SAAS,EAAE,MAAM,EAC1B,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAGvB;AAED,4EAA4E;AAC5E,qBAAa,cAAe,SAAQ,WAAW;IAE3C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM;gBADjB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EAC1B,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAGvB;AAED,qBAAa,iBAAkB,SAAQ,WAAW;IAE9C,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM;gBADjB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EAC1B,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAGvB;AAED,qBAAa,aAAc,SAAQ,WAAW;IAE1C,QAAQ,CAAC,QAAQ,EAAE,QAAQ;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM;gBADjB,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,MAAM,EAC1B,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAGvB;AAED;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,WAAW;IAEvC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM;gBADf,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACxB,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAGvB;AAED,qBAAa,cAAe,SAAQ,WAAW;IAE3C,QAAQ,CAAC,YAAY,EAAE,YAAY;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;gBADnB,YAAY,EAAE,YAAY,EAC1B,KAAK,GAAE,KAAK,GAAG,IAAW,EACnC,EAAE,CAAC,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM;IAKpB,IAAI,IAAI,eAAe;IAIvB,QAAQ,IAAI,UAAU;CAOvB"}

package/dist/streaming/events.js

@@ -0,0 +1,152 @@
+/**
+ * What a stream emits.
+ *
+ * The reference defines twenty event types; this port emits the seven that
+ * OpenAI and Anthropic actually produce through the paths implemented here.
+ * The enum lists ONLY those seven rather than all twenty, deliberately: a
+ * member nothing can ever emit reads to a consumer as a case they must handle,
+ * and writing a branch for an event that never arrives is worse than not
+ * knowing it exists. They are added when a provider can emit them.
+ */
+export var StreamEventType;
+(function (StreamEventType) {
+    StreamEventType["StreamStart"] = "stream_start";
+    StreamEventType["TextStart"] = "text_start";
+    StreamEventType["TextDelta"] = "text_delta";
+    StreamEventType["TextComplete"] = "text_complete";
+    StreamEventType["ToolCall"] = "tool_call";
+    StreamEventType["Error"] = "error";
+    StreamEventType["StreamEnd"] = "stream_end";
+})(StreamEventType || (StreamEventType = {}));
+let counter = 0;
+/** Unique within a process, and cheap. Streams are correlated by run, not by this. */
+export function eventId(prefix = 'evt') {
+    counter += 1;
+    return `${prefix}_${Date.now().toString(36)}${counter.toString(36)}`;
+}
+export class StreamEvent {
+    id;
+    timestamp;
+    constructor(id, timestamp) {
+        this.id = id ?? eventId();
+        this.timestamp = timestamp ?? Date.now();
+    }
+    base() {
+        return { id: this.id, timestamp: this.timestamp, type: this.type() };
+    }
+}
+export class StreamStartEvent extends StreamEvent {
+    model;
+    constructor(model, id, timestamp) {
+        super(id, timestamp);
+        this.model = model;
+    }
+    type() {
+        return StreamEventType.StreamStart;
+    }
+    toObject() {
+        return { ...this.base(), model: this.model };
+    }
+}
+export class TextStartEvent extends StreamEvent {
+    messageId;
+    constructor(messageId, id, timestamp) {
+        super(id, timestamp);
+        this.messageId = messageId;
+    }
+    type() {
+        return StreamEventType.TextStart;
+    }
+    toObject() {
+        return { ...this.base(), message_id: this.messageId };
+    }
+}
+/** The one a consumer renders. Everything else is bookkeeping around it. */
+export class TextDeltaEvent extends StreamEvent {
+    delta;
+    messageId;
+    constructor(delta, messageId, id, timestamp) {
+        super(id, timestamp);
+        this.delta = delta;
+        this.messageId = messageId;
+    }
+    type() {
+        return StreamEventType.TextDelta;
+    }
+    toObject() {
+        return { ...this.base(), delta: this.delta, message_id: this.messageId };
+    }
+}
+export class TextCompleteEvent extends StreamEvent {
+    text;
+    messageId;
+    constructor(text, messageId, id, timestamp) {
+        super(id, timestamp);
+        this.text = text;
+        this.messageId = messageId;
+    }
+    type() {
+        return StreamEventType.TextComplete;
+    }
+    toObject() {
+        return { ...this.base(), text: this.text, message_id: this.messageId };
+    }
+}
+export class ToolCallEvent extends StreamEvent {
+    toolCall;
+    messageId;
+    constructor(toolCall, messageId, id, timestamp) {
+        super(id, timestamp);
+        this.toolCall = toolCall;
+        this.messageId = messageId;
+    }
+    type() {
+        return StreamEventType.ToolCall;
+    }
+    toObject() {
+        return { ...this.base(), tool_call: this.toolCall.toObject(), message_id: this.messageId };
+    }
+}
+/**
+ * The provider reported a failure MID-STREAM.
+ *
+ * Emitted rather than thrown, and the distinction is the reason this type
+ * exists: by the time it arrives the consumer has already rendered text, and
+ * throwing would discard a partial answer the user watched appear. The stream
+ * ends after it; the caller decides what the partial answer was worth.
+ */
+export class ErrorEvent extends StreamEvent {
+    code;
+    message;
+    constructor(code, message, id, timestamp) {
+        super(id, timestamp);
+        this.code = code;
+        this.message = message;
+    }
+    type() {
+        return StreamEventType.Error;
+    }
+    toObject() {
+        return { ...this.base(), code: this.code, message: this.message };
+    }
+}
+export class StreamEndEvent extends StreamEvent {
+    finishReason;
+    usage;
+    constructor(finishReason, usage = null, id, timestamp) {
+        super(id, timestamp);
+        this.finishReason = finishReason;
+        this.usage = usage;
+    }
+    type() {
+        return StreamEventType.StreamEnd;
+    }
+    toObject() {
+        return {
+            ...this.base(),
+            finish_reason: this.finishReason,
+            usage: this.usage === null ? null : this.usage.toObject(),
+        };
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/streaming/events.js.map

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

package/dist/streaming/sse.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Server-sent events, reassembled from whatever the network handed over.
+ *
+ * THE TRANSPORT YIELDS CHUNKS, NOT LINES, and this is where that costs
+ * something and pays for itself. A chunk can end mid-line, mid-JSON, or mid
+ * anything — providers do not align their writes to the reader's convenience —
+ * so the buffer below is the whole point of the split. A transport that
+ * promised lines would have to do this internally, where no test could split a
+ * payload at an awkward place on purpose.
+ *
+ * Only `data:` lines are surfaced. SSE also carries `event:`, `id:` and
+ * comments; neither provider this port speaks to uses them for anything the
+ * payload does not already say, and inventing meaning for them would be
+ * guessing at a protocol rather than reading it.
+ */
+export declare function sseData(chunks: AsyncIterable<string>): AsyncGenerator<string>;
+//# sourceMappingURL=sse.d.ts.map

package/dist/streaming/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/streaming/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAuB,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,CAAC,CA+BpF"}

package/dist/streaming/sse.js

@@ -0,0 +1,50 @@
+/**
+ * Server-sent events, reassembled from whatever the network handed over.
+ *
+ * THE TRANSPORT YIELDS CHUNKS, NOT LINES, and this is where that costs
+ * something and pays for itself. A chunk can end mid-line, mid-JSON, or mid
+ * anything — providers do not align their writes to the reader's convenience —
+ * so the buffer below is the whole point of the split. A transport that
+ * promised lines would have to do this internally, where no test could split a
+ * payload at an awkward place on purpose.
+ *
+ * Only `data:` lines are surfaced. SSE also carries `event:`, `id:` and
+ * comments; neither provider this port speaks to uses them for anything the
+ * payload does not already say, and inventing meaning for them would be
+ * guessing at a protocol rather than reading it.
+ */
+export async function* sseData(chunks) {
+    let buffer = '';
+    for await (const chunk of chunks) {
+        buffer += chunk;
+        // `\n` rather than `\r\n`: the spec allows either, and splitting on the
+        // longer one leaves a stray `\r` on every line from a server that uses it.
+        let newline = buffer.indexOf('\n');
+        while (newline !== -1) {
+            const line = buffer.slice(0, newline).replace(/\r$/, '');
+            buffer = buffer.slice(newline + 1);
+            const payload = dataPayload(line);
+            if (payload !== null) {
+                yield payload;
+            }
+            newline = buffer.indexOf('\n');
+        }
+    }
+    // A final line with no trailing newline is still a line. Dropping it loses
+    // the last event of any stream a server closes without one.
+    const payload = dataPayload(buffer.replace(/\r$/, ''));
+    if (payload !== null) {
+        yield payload;
+    }
+}
+function dataPayload(line) {
+    if (!line.startsWith('data:')) {
+        return null;
+    }
+    // One optional space after the colon is part of the format, not content.
+    const payload = line.slice(5).replace(/^ /, '');
+    // `[DONE]` is OpenAI's sentinel, not JSON. Filtered here rather than left for
+    // the caller to parse and fail on.
+    return payload === '' || payload === '[DONE]' ? null : payload;
+}
+//# sourceMappingURL=sse.js.map

package/dist/streaming/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","sourceRoot":"","sources":["../../src/streaming/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,OAAO,CAAC,MAA6B;IAC1D,IAAI,MAAM,GAAG,EAAE,CAAC;IAEhB,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC;QAEhB,wEAAwE;QACxE,2EAA2E;QAC3E,IAAI,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEnC,OAAO,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YACzD,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC;YAEnC,MAAM,OAAO,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;YAElC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;gBACrB,MAAM,OAAO,CAAC;YAChB,CAAC;YAED,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,2EAA2E;IAC3E,4DAA4D;IAC5D,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC;IAEvD,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,OAAO,CAAC;IAChB,CAAC;AACH,CAAC;AAED,SAAS,WAAW,CAAC,IAAY;IAC/B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yEAAyE;IACzE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAEhD,8EAA8E;IAC9E,mCAAmC;IACnC,OAAO,OAAO,KAAK,EAAE,IAAI,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;AACjE,CAAC"}

package/dist/structured/extract.d.ts

@@ -0,0 +1,23 @@
+import type { JsonObject } from '../json.js';
+/**
+ * Make an object out of what the model said, or report that you could not.
+ *
+ * RETURNS NULL, NEVER THROWS. A model asked for JSON can answer with a refusal,
+ * an apology, or a correct object wrapped in commentary, and none of those is an
+ * exception — they are answers of a shape the caller did not want. Throwing here
+ * would destroy `text`, which is the only evidence of what actually happened and
+ * the only thing that explains the failure to whoever reads the log.
+ *
+ * Two attempts, in order:
+ *
+ *   1. Parse the whole string. This is the case that should happen.
+ *   2. Parse the contents of the FIRST fenced block. Models fence JSON even when
+ *      told not to, and the reference's own Anthropic prompt pleads against it
+ *      ("not in backticks or a code block") — a plea is not a guarantee.
+ *
+ * A JSON array or a bare scalar parses successfully and is still rejected: the
+ * schema describes an object, and returning `[1,2,3]` as "structured" would
+ * satisfy the type and break the first caller to read a property off it.
+ */
+export declare function extractStructured(text: string): JsonObject | null;
+//# sourceMappingURL=extract.d.ts.map

package/dist/structured/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/structured/extract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAUjE"}

package/dist/structured/extract.js

@@ -0,0 +1,43 @@
+import { isJsonObject } from '../json.js';
+/**
+ * Make an object out of what the model said, or report that you could not.
+ *
+ * RETURNS NULL, NEVER THROWS. A model asked for JSON can answer with a refusal,
+ * an apology, or a correct object wrapped in commentary, and none of those is an
+ * exception — they are answers of a shape the caller did not want. Throwing here
+ * would destroy `text`, which is the only evidence of what actually happened and
+ * the only thing that explains the failure to whoever reads the log.
+ *
+ * Two attempts, in order:
+ *
+ *   1. Parse the whole string. This is the case that should happen.
+ *   2. Parse the contents of the FIRST fenced block. Models fence JSON even when
+ *      told not to, and the reference's own Anthropic prompt pleads against it
+ *      ("not in backticks or a code block") — a plea is not a guarantee.
+ *
+ * A JSON array or a bare scalar parses successfully and is still rejected: the
+ * schema describes an object, and returning `[1,2,3]` as "structured" would
+ * satisfy the type and break the first caller to read a property off it.
+ */
+export function extractStructured(text) {
+    const direct = parseObject(text);
+    if (direct !== null) {
+        return direct;
+    }
+    const fenced = /```(?:json)?\s*\n?([\s\S]*?)```/i.exec(text);
+    return fenced === null ? null : parseObject(fenced[1] ?? '');
+}
+function parseObject(candidate) {
+    const trimmed = candidate.trim();
+    if (trimmed === '') {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isJsonObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=extract.js.map

package/dist/structured/extract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.js","sourceRoot":"","sources":["../../src/structured/extract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IAEjC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,MAAM,GAAG,kCAAkC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAE7D,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,WAAW,CAAC,SAAiB;IACpC,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAEjC,IAAI,OAAO,KAAK,EAAE,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC;QACH,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAE5C,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/structured/from-text.d.ts

@@ -0,0 +1,16 @@
+import type { TextResponse } from '../text/response.js';
+import { StructuredResponse } from './response.js';
+/**
+ * Turn a parsed text response into a structured one.
+ *
+ * Every provider that answers a structured request answers it as TEXT — OpenAI
+ * with a schema-constrained string, Anthropic with a message it was asked to
+ * keep to JSON. So the parsing, the finish-reason handling, the usage and the
+ * metadata are the text path's, and this adds the one thing that differs.
+ *
+ * Sharing it this way is what keeps a structured call from quietly diverging:
+ * when the text parser learns that a provider reports token limits differently,
+ * structured learns it in the same commit.
+ */
+export declare function structuredFromTextResponse(response: TextResponse): StructuredResponse;
+//# sourceMappingURL=from-text.d.ts.map

package/dist/structured/from-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-text.d.ts","sourceRoot":"","sources":["../../src/structured/from-text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,YAAY,GAAG,kBAAkB,CAWrF"}

package/dist/structured/from-text.js

@@ -0,0 +1,27 @@
+import { extractStructured } from './extract.js';
+import { StructuredResponse } from './response.js';
+/**
+ * Turn a parsed text response into a structured one.
+ *
+ * Every provider that answers a structured request answers it as TEXT — OpenAI
+ * with a schema-constrained string, Anthropic with a message it was asked to
+ * keep to JSON. So the parsing, the finish-reason handling, the usage and the
+ * metadata are the text path's, and this adds the one thing that differs.
+ *
+ * Sharing it this way is what keeps a structured call from quietly diverging:
+ * when the text parser learns that a provider reports token limits differently,
+ * structured learns it in the same commit.
+ */
+export function structuredFromTextResponse(response) {
+    return new StructuredResponse({
+        steps: response.steps,
+        text: response.text,
+        structured: extractStructured(response.text),
+        finishReason: response.finishReason,
+        usage: response.usage,
+        meta: response.meta,
+        additionalContent: response.additionalContent,
+        raw: response.raw,
+    });
+}
+//# sourceMappingURL=from-text.js.map

package/dist/structured/from-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-text.js","sourceRoot":"","sources":["../../src/structured/from-text.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,0BAA0B,CAAC,QAAsB;IAC/D,OAAO,IAAI,kBAAkB,CAAC;QAC5B,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,UAAU,EAAE,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC;QAC5C,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,iBAAiB,EAAE,QAAQ,CAAC,iBAAiB;QAC7C,GAAG,EAAE,QAAQ,CAAC,GAAG;KAClB,CAAC,CAAC;AACL,CAAC"}