structured-outputs 0.1.0-beta.11 → 0.1.0-beta.14

package/esm/std/Option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Option.js","sourceRoot":"","sources":["../../src/std/Option.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAKpD,MAAM,UAAU,MAAM,CAAe,IAAO;IAI1C,kEAAkE;IAClE,iGAAiG;IACjG,OAAO,WAAW,CAGf;QACD,IAAI;QACJ,IAAI,EAAE,IAAI;KACX,CAAC,CAAA,uCAAuC,CAAA;AAC3C,CAAC"}

package/esm/std/Wrapper.js

@@ -0,0 +1,5 @@
+import { struct } from "../core/mod.js";
+export function Wrapper(value) {
+    return struct({ value });
+}
+//# sourceMappingURL=Wrapper.js.map

package/esm/std/Wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wrapper.js","sourceRoot":"","sources":["../../src/std/Wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAW,MAAM,gBAAgB,CAAA;AAIhD,MAAM,UAAU,OAAO,CAAe,KAAQ;IAC5C,OAAO,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;AAC1B,CAAC"}

package/esm/std/mod.js

@@ -0,0 +1,3 @@
+export * from "./Option.js";
+export * from "./Wrapper.js";
+//# sourceMappingURL=mod.js.map

package/esm/std/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/std/mod.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/esm/util/phantoms.js

@@ -0,0 +1,4 @@
+export function phantoms() {
+    return {};
+}
+//# sourceMappingURL=phantoms.js.map

package/esm/util/phantoms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"phantoms.js","sourceRoot":"","sources":["../../src/util/phantoms.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,QAAQ;IACtB,OAAO,EAAO,CAAA;AAChB,CAAC"}

package/esm/util/recombineTaggedTemplateArgs.js

@@ -0,0 +1,4 @@
+export function recombineTaggedTemplateArgs(strings, values) {
+    return strings.reduce((acc, cur, i) => `${acc}${cur}${values[i] ?? ""}`, "");
+}
+//# sourceMappingURL=recombineTaggedTemplateArgs.js.map

package/esm/util/recombineTaggedTemplateArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recombineTaggedTemplateArgs.js","sourceRoot":"","sources":["../../src/util/recombineTaggedTemplateArgs.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,2BAA2B,CACzC,OAA6B,EAC7B,MAA8B;IAE9B,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;AAC9E,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "structured-outputs",
-  "version": "0.1.0-beta.11",
-  "description": "Lightweight virtual types for OpenAI structured outputs.",
+  "version": "0.1.0-beta.14",
+  "description": "Compose OpenAI structured output schemas.",
   "repository": "github:harrysolovay/structured-outputs.git",
   "license": "Apache-2.0",
   "main": "./esm/mod.js",
@@ -15,16 +15,9 @@
       }
     }
   },
-  "bin": {
-    "structured-outputs": "./esm/main.js"
-  },
   "dependencies": {
     "tslib": "^2.6.2",
-    "openai": "^4.68.1",
-    "@deno/shim-deno": "~0.18.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.9.0"
+    "openai": "^4.68.1"
   },
   "_generatedBy": "dnt@dev"
 }

package/src/ResponseFormat.ts

@@ -1,31 +1,82 @@
-import type { Ty } from "./_base.js"
-import type { ValidRootKey } from "./common.js"
-import { schema } from "./schema.js"
+import { assert } from "./deps/jsr.io/@std/assert/1.0.8/mod.js"
+import type Openai from "openai"
+import type { ResponseFormatJSONSchema } from "openai/resources/index.js"
+import type { RootTy } from "./core/mod.js"
+import { recombineTaggedTemplateArgs } from "./util/recombineTaggedTemplateArgs.js"
 
-export type ResponseFormat = {
-  type: "json_schema"
-  /** The desired return type in JSON Schema. */
-  json_schema: {
-    name: string
-    description: string
-    schema: Record<string, unknown>
-    strict: true
-  }
+export function ResponseFormat<T>(name: string, ty: RootTy<T, never>): ResponseFormat<T> {
+  return ResponseFormat_(name, ty)
 }
 
-export function ResponseFormat<M extends Record<string, Ty>>(
+function ResponseFormat_<T>(
   name: string,
-  description: string,
-  models: M,
-  rootKey: ValidRootKey<M>,
-): ResponseFormat {
-  return {
-    type: "json_schema",
-    json_schema: {
-      name,
-      description,
-      schema: schema(models, rootKey),
-      strict: true,
+  ty: RootTy<T, never>,
+  description?: string,
+): ResponseFormat<T> {
+  return Object.assign(
+    (template: TemplateStringsArray, ...quasis: Array<string>) =>
+      ResponseFormat_(
+        name,
+        ty,
+        description ? `${description} ${recombineTaggedTemplateArgs(template, quasis)}` : undefined,
+      ),
+    {
+      type: "json_schema" as const,
+      json_schema: {
+        name,
+        description,
+        schema: ty.schema(),
+        strict: true,
+      },
+      parse(completion: ChatCompletion): TypedChatCompletion<T> {
+        return {
+          ...completion,
+          choices: completion.choices.map((choice) => ({
+            ...choice,
+            message: {
+              ...choice.message,
+              content: choice.message.content ? JSON.parse(choice.message.content) : null,
+            },
+          })),
+        }
+      },
+      parseFirstOrThrow(completion: ChatCompletion): T {
+        const { choices: [firstChoice], usage } = completion
+        assert(firstChoice)
+        const { finish_reason, message } = firstChoice
+        const { content, refusal } = message
+        assert(content, JSON.stringify({ finish_reason, refusal, usage }))
+        return JSON.parse(content)
+      },
+      toJSON() {
+        const { type, json_schema } = this
+        return { type, json_schema }
+      },
     },
-  }
+  )
 }
+
+export interface ResponseFormat<T> {
+  (template: TemplateStringsArray, ...quasis: Array<string>): ResponseFormat<T>
+  type: "json_schema"
+  /** The desired return type in JSON Schema. */
+  json_schema: ResponseFormatJSONSchema.JSONSchema
+  /** Parse inner responses into a typed object. */
+  parse(completion: ChatCompletion): TypedChatCompletion<T>
+  /** Parse and return the first inner response into a typed object. */
+  parseFirstOrThrow(completion: ChatCompletion): T
+}
+
+export type TypedChatCompletion<T> = Omit<ChatCompletion, "choices"> & {
+  choices: Array<
+    Omit<ChatCompletionChoice, "message"> & {
+      message: Omit<ChatCompletionMessage, "content"> & {
+        content: T
+      }
+    }
+  >
+}
+
+type ChatCompletion = Openai.Chat.ChatCompletion
+type ChatCompletionChoice = Openai.Chat.ChatCompletion.Choice
+type ChatCompletionMessage = Openai.Chat.Completions.ChatCompletionMessage

package/src/Tool.ts

@@ -0,0 +1,38 @@
+import type { RootTy, Schema } from "./core/mod.js"
+import { recombineTaggedTemplateArgs } from "./util/recombineTaggedTemplateArgs.js"
+
+export function Tool<T>(name: string, ty: RootTy<T, never>): Tool<T> {
+  return Tool_(name, ty)
+}
+
+function Tool_<T>(name: string, ty: RootTy<T, never>, description?: string): Tool<T> {
+  return Object.assign(
+    (template: TemplateStringsArray, ...quasis: Array<string>) =>
+      Tool_(
+        name,
+        ty,
+        description ? `${description} ${recombineTaggedTemplateArgs(template, quasis)}` : undefined,
+      ),
+    {
+      type: "function" as const,
+      name,
+      description,
+      parameters: ty.schema(),
+      toJson() {
+        const { type, name, description, parameters } = this
+        return { type, name, description, parameters }
+      },
+    },
+  )
+}
+
+export interface Tool<T = any> {
+  (template: TemplateStringsArray, ...quasis: Array<string>): Tool<T>
+  type: "function"
+  /** The name with which OpenAI recognizes the tool. */
+  name: string
+  /** A description to inform the LLM of when/how to use the tool. */
+  description?: string
+  /** The tool implementation's argument type in JSON Schema. */
+  parameters?: Schema
+}

package/src/_dnt.polyfills.ts

@@ -1,149 +1,4 @@
-// taken from https://github.com/denoland/deno/blob/7281775381cda79ef61df27820387dc2c74e0384/cli/tsc/dts/lib.esnext.array.d.ts#L21
-declare global {
-  interface ArrayConstructor {
-    fromAsync<T>(
-        iterableOrArrayLike: AsyncIterable<T> | Iterable<T | Promise<T>> | ArrayLike<T | Promise<T>>,
-    ): Promise<T[]>;
-    
-    fromAsync<T, U>(
-        iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, 
-        mapFn: (value: Awaited<T>) => U, 
-        thisArg?: any,
-    ): Promise<Awaited<U>[]>;
-  }
-}
-
-// From https://github.com/es-shims/array-from-async/blob/4a5ff83947b861f35b380d5d4f20da2f07698638/index.mjs
-// Tried to have dnt depend on the package instead, but it distributes as an
-// ES module, so doesn't work with CommonJS.
-//
-// Code below:
-//
-// Copyright 2021 J. S. Choi
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// 1. Redistributions of source code must retain the above copyright
-//    notice, this list of conditions and the following disclaimer.
-//
-// 2. Redistributions in binary form must reproduce the above copyright
-//    notice, this list of conditions and the following disclaimer in the
-//    documentation and/or other materials provided with the distribution.
-//
-// 3. Neither the name of the copyright holder nor the names of its
-//    contributors may be used to endorse or promote products derived from
-//    this software without specific prior written permission.
-//
-// **This software is provided by the copyright holders and contributors
-// "as is" and any express or implied warranties, including, but not
-// limited to, the implied warranties of merchantability and fitness for a
-// particular purpose are disclaimed. In no event shall the copyright
-// holder or contributors be liable for any direct, indirect, incidental,
-// special, exemplary, or consequential damages (including, but not limited
-// to, procurement of substitute goods or services; loss of use, data, or
-// profits; or business interruption) however caused and on any theory of
-// liability, whether in contract, strict liability, or tort (including
-// negligence or otherwise) arising in any way out of the use of this
-// software, even if advised of the possibility of such damage.**
-
-const { MAX_SAFE_INTEGER } = Number;
-const iteratorSymbol = Symbol.iterator;
-const asyncIteratorSymbol = Symbol.asyncIterator;
-const IntrinsicArray = Array;
-const tooLongErrorMessage =
-  'Input is too long and exceeded Number.MAX_SAFE_INTEGER times.';
-
-function isConstructor(obj: any) {
-  if (obj != null) {
-    const prox: any = new Proxy(obj, {
-      construct () {
-        return prox;
-      },
-    });
-    try {
-      new prox;
-      return true;
-    } catch (err) {
-      return false;
-    }
-  } else {
-    return false;
-  }
-}
-
-async function fromAsync(this: any, items: any, mapfn: any, thisArg: any) {
-  const itemsAreIterable = (
-    asyncIteratorSymbol in items ||
-    iteratorSymbol in items
-  );
-
-  if (itemsAreIterable) {
-    const result = isConstructor(this)
-      ? new this
-      : IntrinsicArray(0);
-
-    let i = 0;
-
-    for await (const v of items) {
-      if (i > MAX_SAFE_INTEGER) {
-        throw TypeError(tooLongErrorMessage);
-      }
-
-      else if (mapfn) {
-        result[i] = await mapfn.call(thisArg, v, i);
-      }
-
-      else {
-        result[i] = v;
-      }
-
-      i ++;
-    }
-
-    result.length = i;
-    return result;
-  }
-
-  else {
-    // In this case, the items are assumed to be an arraylike object with
-    // a length property and integer properties for each element.
-    const { length } = items;
-    const result = isConstructor(this)
-      ? new this(length)
-      : IntrinsicArray(length);
-
-    let i = 0;
-
-    while (i < length) {
-      if (i > MAX_SAFE_INTEGER) {
-        throw TypeError(tooLongErrorMessage);
-      }
-
-      const v = await items[i];
-
-      if (mapfn) {
-        result[i] = await mapfn.call(thisArg, v, i);
-      }
-
-      else {
-        result[i] = v;
-      }
-
-      i ++;
-    }
-
-    result.length = i;
-    return result;
-  }
-}
-
-if (!Array.fromAsync) {
-  (Array as any).fromAsync = fromAsync;
-}
-
-export {};// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
 if (!Object.hasOwn) {
   Object.defineProperty(Object, "hasOwn", {
     value: function (object: any, property: any) {

package/src/_dnt.shims.ts

@@ -1,8 +1,4 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-
 const dntGlobals = {
-  Deno,
 };
 export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
 

package/src/core/Ref.ts

@@ -0,0 +1,16 @@
+import type { Applied, Schema, Ty } from "./Ty.js"
+import { recombineTaggedTemplateArgs } from "../util/recombineTaggedTemplateArgs.js"
+
+export type Ref = (ty: Ty) => Schema
+
+export function Ref(applied: Applied): Ref {
+  return (ty) => {
+    applied = { ...applied, ...ty.applied }
+    const description = ty.descriptions
+      .map(({ template, placeheld }) =>
+        recombineTaggedTemplateArgs(template, placeheld.map((k) => applied[k]!))
+      )
+      .join(" ")
+    return ty.toSchema(description, Ref(applied))
+  }
+}

package/src/core/RootTy.ts

@@ -0,0 +1,40 @@
+import { phantoms } from "../util/phantoms.js"
+import { Ref } from "./Ref.js"
+import type { Applied, Description, Schema, ToSchema, Ty } from "./Ty.js"
+
+export function RootTy<T, P extends string = never>(
+  toSchema: ToSchema,
+  descriptions: Array<Description> = [],
+  applied: Applied = {},
+): RootTy<T, P> {
+  return Object.assign(
+    <P2 extends Array<string>>(template: TemplateStringsArray, ...placeheld: P2) =>
+      RootTy<T, P | P2[number]>(toSchema, [{ template, placeheld }, ...descriptions], applied),
+    phantoms<{ [Ty.T]: T; [Ty.P]: P }>(),
+    {
+      toSchema,
+      descriptions,
+      applied,
+      apply: <A extends Partial<Record<P, string | number>>>(values: A) => {
+        return RootTy<T, Exclude<P, keyof A>>(toSchema, descriptions, { ...applied, ...values })
+      },
+      schema(this: RootTy<T, never>) {
+        return Ref({})(this)
+      },
+      isRoot(): this is RootTy {
+        return true
+      },
+    },
+  )
+}
+
+export interface RootTy<T = any, P extends string = string> extends Ty<T, P> {
+  <P2 extends Array<string>>(
+    template: TemplateStringsArray,
+    ...placeheld: P2
+  ): RootTy<T, P | P2[number]>
+  apply: <A extends Partial<Record<P, number | string>>>(
+    values: A,
+  ) => RootTy<T, Exclude<P, keyof A>>
+  schema(this: RootTy<T, never>): Schema
+}

package/src/core/Ty.ts

@@ -0,0 +1,57 @@
+import type { Ref } from "./Ref.js"
+import { phantoms } from "../util/phantoms.js"
+import type { RootTy } from "./RootTy.js"
+
+export function Ty<T, P extends string = never>(
+  toSchema: ToSchema,
+  descriptions: Array<Description> = [],
+  applied: Applied = {},
+): Ty<T, P> {
+  return Object.assign(
+    <P2 extends Array<string>>(template: TemplateStringsArray, ...placeheld: P2) =>
+      Ty<T, P | P2[number]>(toSchema, [{ template, placeheld }, ...descriptions], applied),
+    phantoms<{ [Ty.T]: T; [Ty.P]: P }>(),
+    {
+      toSchema,
+      descriptions,
+      applied,
+      apply: <A extends Partial<Record<P, string | number>>>(values: A) => {
+        return Ty<T, Exclude<P, keyof A>>(toSchema, descriptions, { ...applied, ...values })
+      },
+      isRoot(): this is RootTy {
+        return false
+      },
+    },
+  )
+}
+
+export interface Ty<T = any, P extends string = string> {
+  <P2 extends Array<string>>(
+    template: TemplateStringsArray,
+    ...placeheld: P2
+  ): Ty<T, P | P2[number]>
+  [Ty.T]: T
+  [Ty.P]: P
+  toSchema: ToSchema
+  descriptions: Array<Description>
+  applied: Applied
+  apply: <A extends Partial<Record<P, number | string>>>(values: A) => Ty<T, Exclude<P, keyof A>>
+  isRoot(): this is RootTy
+}
+
+export namespace Ty {
+  export type T = typeof T
+  export declare const T: unique symbol
+  export type P = typeof P
+  export declare const P: unique symbol
+}
+
+export type ToSchema = (description: string | undefined, ref: Ref) => Schema
+export type Schema = Record<string, unknown>
+
+export interface Description {
+  template: TemplateStringsArray
+  placeheld: Array<string>
+}
+
+export type Applied = Record<string, number | string>

package/src/core/constant.ts

@@ -0,0 +1,10 @@
+import { Ty } from "./Ty.js"
+
+export type constant<V extends number | string> = ReturnType<typeof constant<V>>
+
+export function constant<V extends number | string>(value: V): Ty<V, never> {
+  return Ty((description) => ({
+    const: value,
+    description,
+  }))
+}

package/src/core/constantUnion.ts

@@ -0,0 +1,29 @@
+import { partition } from "../deps/jsr.io/@std/collections/1.0.9/mod.js"
+import { Ty } from "./Ty.js"
+
+export type constantUnion<M extends Array<number | string>> = ReturnType<typeof constantUnion<M>>
+
+export function constantUnion<M extends Array<number | string>>(
+  ...members: M
+): Ty<M[number], never> {
+  const [strings, numbers] = partition(members, (v) => typeof v === "string")
+  return Ty((description) => {
+    return {
+      anyOf: [
+        ...strings.length
+          ? [{
+            type: "string",
+            enum: strings,
+          }]
+          : [],
+        ...numbers.length
+          ? [{
+            type: "number",
+            enum: numbers,
+          }]
+          : [],
+      ],
+      description,
+    }
+  })
+}

package/src/core/leaves.ts

@@ -0,0 +1,25 @@
+import { Ty } from "./Ty.js"
+
+export type none<P extends string = string> = Ty<null, P>
+export const none: Ty<null, never> = Ty((description) => ({
+  type: "null",
+  description,
+}))
+
+export type bool<P extends string = string> = Ty<boolean, P>
+export const bool: Ty<boolean, never> = Ty((description) => ({
+  type: "boolean",
+  description,
+}))
+
+export type num<P extends string = string> = Ty<number, P>
+export const num: Ty<number, never> = Ty((description) => ({
+  type: "number",
+  description,
+}))
+
+export type str<P extends string = string> = Ty<string, P>
+export const str: Ty<string, never> = Ty((description) => ({
+  type: "string",
+  description,
+}))

package/src/core/mod.ts

@@ -0,0 +1,9 @@
+export * from "./vec.js"
+export * from "./leaves.js"
+export * from "./constant.js"
+export * from "./constantUnion.js"
+export * from "./struct.js"
+export * from "./Ref.js"
+export * from "./taggedUnion.js"
+export * from "./Ty.js"
+export * from "./RootTy.js"

package/src/core/struct.ts

@@ -0,0 +1,19 @@
+import { RootTy } from "./RootTy.js"
+import type { Ty } from "./Ty.js"
+
+export type struct<F extends StructFields = StructFields> = ReturnType<typeof struct<F>>
+
+export function struct<F extends StructFields>(fields: F): RootTy<
+  { [K in keyof F]: F[K][Ty.T] },
+  F[keyof F][Ty.P]
+> {
+  return RootTy((description, ref) => ({
+    type: "object",
+    description,
+    properties: Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, ref(v)])),
+    additionalProperties: false,
+    required: Object.keys(fields),
+  }))
+}
+
+export type StructFields = Record<string, Ty>

package/src/core/taggedUnion.ts

@@ -0,0 +1,34 @@
+import { Ty } from "./Ty.js"
+
+export type taggedUnion<M extends TaggedUnionMembers = TaggedUnionMembers> = ReturnType<
+  typeof taggedUnion<M>
+>
+
+export function taggedUnion<M extends TaggedUnionMembers>(members: M): Ty<
+  {
+    [K in keyof M]: {
+      type: K
+      value: M[K][Ty.T]
+    }
+  }[keyof M],
+  M[keyof M][Ty.P]
+> {
+  return Ty((description, ref) => ({
+    description,
+    discriminator: "type",
+    anyOf: Object.entries(members).map(([k, v]) => ({
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          const: k,
+        },
+        value: ref(v),
+      },
+      required: ["type", "value"],
+      additionalProperties: false,
+    })),
+  }))
+}
+
+export type TaggedUnionMembers = Record<string, Ty>

package/src/core/vec.ts

@@ -0,0 +1,11 @@
+import { Ty } from "./Ty.js"
+
+export type vec<E extends Ty> = ReturnType<typeof vec<E>>
+
+export function vec<E extends Ty>(element: E): Ty<Array<E[Ty.T]>, E[Ty.P]> {
+  return Ty((description, ref) => ({
+    type: "array",
+    description,
+    items: ref(element),
+  }))
+}