liminal 0.1.0-beta.25

package/src/providers/OpenAI/OpenAIResponseFormat.ts

@@ -0,0 +1,54 @@
+import type { ChatCompletion } from "openai/resources/chat/completions"
+import type { Type } from "../../core/mod.js"
+import { deserialize, L, toJSONSchema } from "../../mod.js"
+import { recombine } from "../../util/mod.js"
+import { unwrapOutput, unwrapRaw } from "./openai_util.js"
+
+export interface OpenAIResponseFormat<T> extends OpenAIFinalResponseFormat<T> {
+  (template: TemplateStringsArray, ...values: Array<number | string>): OpenAIFinalResponseFormat<T>
+}
+
+export interface OpenAIFinalResponseFormat<T> {
+  type: "json_schema"
+  json_schema: {
+    name: string
+    description?: string
+    schema: Record<string, unknown>
+    strict: true
+  }
+  deserialize: (completion: ChatCompletion) => T
+  toJSON(): Pick<OpenAIFinalResponseFormat<T>, "type" | "json_schema">
+}
+
+export function OpenAIResponseFormat<T>(name: string, type: Type<T>): OpenAIResponseFormat<T> {
+  return Object.assign(
+    (template: TemplateStringsArray, ...values: Array<number | string>) =>
+      OpenAIFinalResponseFormat(name, type, recombine(template, values)),
+    OpenAIFinalResponseFormat(name, type),
+  )
+}
+
+function OpenAIFinalResponseFormat<T>(
+  name: string,
+  type: Type<T>,
+  description?: string,
+): OpenAIFinalResponseFormat<T> {
+  if (type.declaration.factory !== L.object) {
+    type = L.transform(L.Tuple(type), ([value]) => value)
+  }
+  return {
+    type: "json_schema",
+    json_schema: {
+      name,
+      description,
+      schema: toJSONSchema(type),
+      strict: true,
+    },
+    deserialize: (completion: ChatCompletion): T =>
+      deserialize(type, unwrapRaw(unwrapOutput(completion))),
+    toJSON() {
+      const { type, json_schema } = this
+      return { type, json_schema }
+    },
+  }
+}

package/src/providers/OpenAI/TokenAllowance.ts

@@ -0,0 +1,29 @@
+import type { ChatCompletion } from "openai/resources/chat/completions"
+import type { PromiseOr } from "../../util/mod.js"
+
+export interface TokenAllowanceOptions {
+  /** Number of tokens in the generated completion. */
+  completion_tokens?: number
+  /** Number of tokens in the prompt. */
+  prompt_tokens?: number
+  /** Total number of tokens used in the request (prompt + completion). */
+  total_tokens?: number
+}
+
+export class TokenAllowance {
+  constructor(
+    readonly allowances: TokenAllowanceOptions,
+    readonly onExceeded?: (self: TokenAllowance) => PromiseOr<void>,
+  ) {}
+
+  ingest = (completion: ChatCompletion): void => {
+    const { usage } = completion
+    if (usage) {
+      Object.keys(this.allowances).forEach((key) => {
+        if (!(this.allowances[key as keyof TokenAllowanceOptions]! -= usage[key as never])) {
+          this.onExceeded?.(this)
+        }
+      })
+    }
+  }
+}

package/src/providers/OpenAI/mod.ts

@@ -0,0 +1,7 @@
+// moderate
+
+export * from "./openai_util.js"
+export * from "./OpenAIAdapter.js"
+export * from "./OpenAIResponseFormat.js"
+export * from "./refine.js"
+export * from "./TokenAllowance.js"

package/src/providers/OpenAI/openai_util.ts

@@ -0,0 +1,19 @@
+import { assert } from "../../deps/jsr.io/@std/assert/1.0.10/mod.js"
+import type { ChatCompletion, ChatCompletionMessage } from "openai/resources/chat/completions"
+
+export function unwrapOutput({ choices: [choice] }: ChatCompletion): ChatCompletionMessage {
+  assert(choice, "No choices contained within the completion response.")
+  const { finish_reason, message } = choice
+  assert(
+    finish_reason === "stop",
+    `Completion responded with "${finish_reason}" as finish reason; ${message}.`,
+  )
+  const { refusal } = message
+  assert(!refusal, `Openai refused to fulfill completion request; ${refusal}.`)
+  return message
+}
+
+export function unwrapRaw({ content }: ChatCompletionMessage): string {
+  assert(typeof content === "string")
+  return content
+}

package/src/providers/OpenAI/refine.ts

@@ -0,0 +1,171 @@
+export {}
+
+// import { assert } from "@std/assert"
+// import type Openai from "openai"
+// import type {
+//   ChatCompletionCreateParamsNonStreaming,
+//   ChatCompletionMessageParam,
+// } from "openai/resources/chat/completions"
+// import { deserialize, Diagnostic, T, type Type } from "../../../core/mod.ts"
+// import { tap } from "../../../util/mod.ts"
+// import { parseChoice, unwrapChoice } from "./oai_util.ts"
+// import { Prompt } from "./Prompt.ts"
+// import { ResponseFormat } from "./ResponseFormat.ts"
+// import type { TokenAllowance } from "./TokenAllowance.ts"
+
+// export interface RefineParams<T = any> extends
+//   Omit<
+//     ChatCompletionCreateParamsNonStreaming,
+//     "audio" | "modalities" | "response_format" | "stream" | "stream_options"
+//   >
+// {
+//   response_format: ResponseFormat<T>
+// }
+
+// export interface RefineOptions {
+//   signal?: AbortSignal
+//   max?: number
+//   allowance?: TokenAllowance
+// }
+
+// /** Get the completion and then loop refinement assertions and resubmission until all assertions pass. */
+// export async function refine<T>(
+//   client: Openai,
+//   params: RefineParams<T>,
+//   options?: RefineOptions,
+// ): Promise<T> {
+//   const { signal, max, allowance } = options ?? {}
+//   assert(
+//     max === undefined || (max >= 1 && Number.isInteger(max)),
+//     "`CheckedOptions.maxRefinements` must be an integer greater than 1.",
+//   )
+//   const completion = await client.chat.completions
+//     .create(params)
+//     .then(tap(allowance?.ingest))
+//   let diagnosticsPending: Array<Promise<Diagnostic | undefined>> = []
+//   const content = unwrapChoice(completion)
+//   const messages: ChatCompletionMessageParam[] = [...params.messages, {
+//     role: "assistant",
+//     content,
+//   }]
+//   const root = deserialize(
+//     params.response_format[""],
+//     parseChoice(content),
+//     diagnosticsPending,
+//   )
+//   let correctionsRemaining = max ?? Infinity
+//   let initialCorrection = true
+//   while (
+//     correctionsRemaining-- && !signal?.aborted && !allowance?.stop
+//     && diagnosticsPending.length
+//   ) {
+//     const diagnostics = await Promise
+//       .all(diagnosticsPending)
+//       .then((v) => v.filter((v) => v !== undefined))
+//     diagnosticsPending = []
+//     if (!diagnostics.length) {
+//       break
+//     }
+//     const CurrentCorrections = Corrections(diagnostics)
+//     const response_format = ResponseFormat("corrections", CurrentCorrections)
+//     messages.push({
+//       role: "user",
+//       content: initialCorrection
+//         ? prompt(params, diagnostics)
+//         : diagnostics.map(Diagnostic.toString).join("\n\n"),
+//     })
+//     initialCorrection = false
+//     messages.forEach((message) => console.log(message.content))
+//     const correctionsCompletion = await client.chat.completions.create({
+//       ...params,
+//       messages,
+//       response_format,
+//     }).then(tap(allowance?.ingest))
+//     const choice = unwrapChoice(correctionsCompletion)
+//     messages.push({
+//       role: "assistant",
+//       content: choice,
+//     })
+//     const corrections = deserialize(CurrentCorrections, parseChoice(choice))
+//     while (diagnostics.length) {
+//       const { setValue, valuePath, type } = diagnostics.shift()!
+//       setValue(
+//         deserialize(
+//           type as never,
+//           corrections[valuePath],
+//           (!correctionsRemaining || (signal && signal.aborted)) ? undefined : diagnosticsPending,
+//         ),
+//       )
+//     }
+//   }
+//   return root
+// }
+
+// function Corrections(diagnostics: Array<Diagnostic>): Type<any> {
+//   return T.object(
+//     Object.fromEntries(
+//       diagnostics.map(({ valuePath, type }) => [valuePath, type]),
+//     ),
+//   )`The corrections to be applied to a previously-generated structured output.`.widen()
+// }
+
+// function prompt(
+//   params: RefineParams,
+//   diagnostics: Array<Diagnostic>,
+// ): string {
+//   const prompt = new Prompt()
+//   prompt.h(1, "Overview")
+//   prompt.lineBreak(2)
+//   prompt.span`
+//     A chat completion request was submitted with a JSON schema describing structured
+//     output requirements. In the following sections, we'll cover the following.
+//   `
+//   prompt.lineBreak(2)
+//   const hasMessages = !!params.messages.length
+//     && params.messages.every((message) => {
+//       const { content } = message
+//       return (typeof content === "string" && !!content) || (
+//         Array.isArray(content) && !!content.length
+//         && content.every((part) => part.type === "text" && !!part.text)
+//       )
+//     })
+//   prompt.list([
+//     hasMessages && "The initial messages passed along to the completions endpoint.",
+//     "The JSON schema of the initially-requested structured output.",
+//     "The unmet constraints.",
+//   ])
+//   prompt.lineBreak(2)
+//   prompt.span`Offer new and correct values for each of the specified diagnostics.`
+//   prompt.lineBreak(2)
+//   if (hasMessages) {
+//     prompt.h(2, "Messages")
+//     prompt.lineBreak(2)
+//     params.messages.forEach((message, i) => {
+//       prompt.h(3, `Message ${i} (${message.role})`)
+//       const { content } = message
+//       if (typeof content === "string") {
+//         prompt.span(content)
+//       } else if (Array.isArray(content)) {
+//         content.forEach((part, i) => {
+//           if (i !== 0) {
+//             prompt.span(" ")
+//           }
+//           assert(
+//             part.type === "text",
+//             `${part.type} message content parts cannot be used in conjunction with structured outputs.`,
+//           )
+//           prompt.span(part.text)
+//         })
+//       }
+//     })
+//     prompt.lineBreak(2)
+//   }
+//   prompt.h(2, "Initial JSON Schema")
+//   prompt.lineBreak(2)
+//   prompt.json(params.response_format.json_schema)
+//   prompt.lineBreak(2)
+//   prompt.h(2, "Diagnostics")
+//   prompt.lineBreak(2)
+//   prompt.list(diagnostics.map(Diagnostic.toString))
+//   return prompt.toString()
+// }

package/src/util/ArrayOfLength.ts

@@ -0,0 +1,5 @@
+export type ArrayOfLength<
+  T,
+  L extends number,
+  A extends T[] = [],
+> = number extends L ? T[] : L extends A["length"] ? A : ArrayOfLength<T, L, [...A, T]>

package/src/util/PromiseOr.ts

@@ -0,0 +1 @@
+export type PromiseOr<T> = T | Promise<T>

package/src/util/WeakMemo.ts

@@ -0,0 +1,13 @@
+export class WeakMemo<K extends WeakKey, T> {
+  #cache = new WeakMap<K, T>()
+  constructor(private f: (key: K) => T) {}
+
+  getOrInit = (key: K): T => {
+    if (this.#cache.has(key)) {
+      return this.#cache.get(key)!
+    }
+    const value = this.f(key)
+    this.#cache.set(key, value)
+    return value
+  }
+}

package/src/util/collect.ts

@@ -0,0 +1,7 @@
+export async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
+  const result: Array<T> = []
+  for await (const item of iterable) {
+    result.push(item)
+  }
+  return result
+}

package/src/util/isPromise.ts

@@ -0,0 +1,8 @@
+export function isPromise(value: unknown): value is Promise<unknown> {
+  return (
+    value !== null
+    && (typeof value === "object" || typeof value === "function")
+    && "then" in value && typeof value.then === "function"
+    && "catch" in value && typeof value.catch === "function"
+  )
+}

package/src/util/isTemplateStringsArray.ts

@@ -0,0 +1,3 @@
+export function isTemplateStringsArray(value: unknown): value is TemplateStringsArray {
+  return Array.isArray(value) && "raw" in value && Array.isArray(value.raw)
+}

package/src/util/mod.ts

@@ -0,0 +1,11 @@
+// moderate
+
+export * from "./ArrayOfLength.js"
+export * from "./collect.js"
+export * from "./isPromise.js"
+export * from "./isTemplateStringsArray.js"
+export * from "./PromiseOr.js"
+export * from "./recombine.js"
+export * from "./splitLast.js"
+export * from "./type_util.js"
+export * from "./WeakMemo.js"

package/src/util/recombine.ts

@@ -0,0 +1,10 @@
+export function recombine(template: TemplateStringsArray, values: Array<unknown>): string {
+  const segments = []
+  for (let i = 0; i < template.length; i++) {
+    segments.push(template[i])
+    if (i < values.length) {
+      segments.push(String(values[i]))
+    }
+  }
+  return segments.join("")
+}

package/src/util/splitLast.ts

@@ -0,0 +1,7 @@
+export function splitLast(value: string, search: string): undefined | [string, string] {
+  const lastI = value.lastIndexOf(search)
+  if (lastI === -1) {
+    return undefined
+  }
+  return [value.slice(0, lastI), value.slice(lastI + search.length)]
+}

package/src/util/type_util.ts

@@ -0,0 +1,3 @@
+export type Expand<T> = T extends T ? { [K in keyof T]: T[K] } : never
+
+export type U2I<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never