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

package/src/deps/jsr.io/@std/collections/1.0.9/sort_by.ts

@@ -0,0 +1,219 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Order option for {@linkcode SortByOptions}. */
+export type Order = "asc" | "desc";
+
+/** Options for {@linkcode sortBy}. */
+export type SortByOptions = {
+  /**
+   * The order to sort the elements in.
+   *
+   * @default {"asc"}
+   */
+  order: Order;
+};
+
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * Note: If you want to process any iterable, use the new version of
+ * `sortBy` from `@std/collections/unstable-sort-by`.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ * const sortedByAge = sortBy(people, (person) => person.age);
+ *
+ * assertEquals(sortedByAge, [
+ *   { name: "John", age: 23 },
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ * ]);
+ *
+ * const sortedByAgeDesc = sortBy(people, (person) => person.age, { order: "desc" });
+ *
+ * assertEquals(sortedByAgeDesc, [
+ *   { name: "Kim", age: 42 },
+ *   { name: "Anna", age: 34 },
+ *   { name: "John", age: 23 },
+ * ]);
+ * ```
+ */
+export function sortBy<T>(
+  array: readonly T[],
+  selector: (el: T) => number,
+  options?: SortByOptions,
+): T[];
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna" },
+ *   { name: "Kim" },
+ *   { name: "John" },
+ * ];
+ * const sortedByName = sortBy(people, (it) => it.name);
+ *
+ * assertEquals(sortedByName, [
+ *   { name: "Anna" },
+ *   { name: "John" },
+ *   { name: "Kim" },
+ * ]);
+ * ```
+ */
+export function sortBy<T>(
+  array: readonly T[],
+  selector: (el: T) => string,
+  options?: SortByOptions,
+): T[];
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ *   { name: "John", age: 23n },
+ * ];
+ *
+ * const sortedByAge = sortBy(people, (person) => person.age);
+ *
+ * assertEquals(sortedByAge, [
+ *   { name: "John", age: 23n },
+ *   { name: "Anna", age: 34n },
+ *   { name: "Kim", age: 42n },
+ * ]);
+ * ```
+ */
+
+export function sortBy<T>(
+  array: readonly T[],
+  selector: (el: T) => bigint,
+  options?: SortByOptions,
+): T[];
+/**
+ * Returns all elements in the given collection, sorted by their result using
+ * the given selector. The selector function is called only once for each
+ * element. Ascending or descending order can be specified through the `order`
+ * option. By default, the elements are sorted in ascending order.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to sort.
+ * @param selector The selector function to get the value to sort by.
+ * @param options The options for sorting.
+ *
+ * @returns A new array containing all elements sorted by the selector.
+ *
+ * @example Usage
+ * ```ts
+ * import { sortBy } from "@std/collections/sort-by";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2020-03-01") },
+ *   { name: "John", startedAt: new Date("2020-06-01") },
+ * ];
+ *
+ * const sortedByStartedAt = sortBy(people, (people) => people.startedAt);
+ *
+ * assertEquals(sortedByStartedAt, [
+ *   { name: "Anna", startedAt: new Date("2020-01-01") },
+ *   { name: "Kim", startedAt: new Date("2020-03-01") },
+ *   { name: "John", startedAt: new Date("2020-06-01") },
+ * ]);
+ * ```
+ */
+export function sortBy<T>(
+  array: readonly T[],
+  selector: (el: T) => Date,
+  options?: SortByOptions,
+): T[];
+export function sortBy<T>(
+  array: readonly T[],
+  selector:
+    | ((el: T) => number)
+    | ((el: T) => string)
+    | ((el: T) => bigint)
+    | ((el: T) => Date),
+  options?: SortByOptions,
+): T[] {
+  const len = array.length;
+  const indexes = new Array<number>(len);
+  const selectors = new Array<ReturnType<typeof selector> | null>(len);
+  const order = options?.order ?? "asc";
+
+  array.forEach((element, index) => {
+    indexes[index] = index;
+    const selected = selector(element);
+    selectors[index] = Number.isNaN(selected) ? null : selected;
+  });
+
+  indexes.sort((ai, bi) => {
+    let a = selectors[ai]!;
+    let b = selectors[bi]!;
+    if (order === "desc") {
+      [a, b] = [b, a];
+    }
+    if (a === null) return 1;
+    if (b === null) return -1;
+    return a > b ? 1 : a < b ? -1 : 0;
+  });
+
+  for (let i = 0; i < len; i++) {
+    (indexes as unknown as T[])[i] = array[indexes[i]!] as T;
+  }
+
+  return indexes as unknown as T[];
+}

package/src/deps/jsr.io/@std/collections/1.0.9/sum_of.ts

@@ -0,0 +1,42 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Applies the given selector to all elements in the given collection and
+ * calculates the sum of the results.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to calculate the sum of.
+ * @param selector The selector function to get the value to sum.
+ *
+ * @returns The sum of all elements in the collection.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { sumOf } from "@std/collections/sum-of";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const people = [
+ *   { name: "Anna", age: 34 },
+ *   { name: "Kim", age: 42 },
+ *   { name: "John", age: 23 },
+ * ];
+ *
+ * const totalAge = sumOf(people, (person) => person.age);
+ *
+ * assertEquals(totalAge, 99);
+ * ```
+ */
+export function sumOf<T>(
+  array: Iterable<T>,
+  selector: (el: T) => number,
+): number {
+  let sum = 0;
+
+  for (const i of array) {
+    sum += selector(i);
+  }
+
+  return sum;
+}

package/src/deps/jsr.io/@std/collections/1.0.9/take_last_while.ts

@@ -0,0 +1,37 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns all elements in the given array after the last element that does not
+ * match the given predicate.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to take elements from.
+ * @param predicate The predicate function to determine if an element should be
+ * included.
+ *
+ * @returns A new array containing all elements after the last element that does
+ * not match the predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { takeLastWhile } from "@std/collections/take-last-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6];
+ *
+ * const result = takeLastWhile(numbers, (number) => number > 4);
+ *
+ * assertEquals(result, [5, 6]);
+ * ```
+ */
+export function takeLastWhile<T>(
+  array: readonly T[],
+  predicate: (el: T) => boolean,
+): T[] {
+  let offset = array.length;
+  while (0 < offset && predicate(array[offset - 1] as T)) offset--;
+
+  return array.slice(offset, array.length);
+}

package/src/deps/jsr.io/@std/collections/1.0.9/take_while.ts

@@ -0,0 +1,44 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns all elements in the given collection until the first element that
+ * does not match the given predicate.
+ *
+ * Note: If you want to process any iterable, use the new version of
+ * `takeWhile` from `@std/collections/unstable-take-while`.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to take elements from.
+ * @param predicate The predicate function to determine if an element should be
+ * included.
+ *
+ * @returns A new array containing all elements until the first element that
+ * does not match the predicate.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { takeWhile } from "@std/collections/take-while";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4, 5, 6];
+ *
+ * const result = takeWhile(numbers, (number) => number < 4);
+ *
+ * assertEquals(result, [1, 2, 3]);
+ * ```
+ */
+export function takeWhile<T>(
+  array: readonly T[],
+  predicate: (el: T) => boolean,
+): T[] {
+  let offset = 0;
+  const length = array.length;
+
+  while (length > offset && predicate(array[offset] as T)) {
+    offset++;
+  }
+
+  return array.slice(0, offset);
+}

package/src/deps/jsr.io/@std/collections/1.0.9/union.ts

@@ -0,0 +1,36 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns all distinct elements that appear in any of the given arrays.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param arrays The arrays to get the union of.
+ *
+ * @returns A new array containing all distinct elements from the given arrays.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { union } from "@std/collections/union";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const soupIngredients = ["Pepper", "Carrots", "Leek"];
+ * const saladIngredients = ["Carrots", "Radicchio", "Pepper"];
+ *
+ * const shoppingList = union(soupIngredients, saladIngredients);
+ *
+ * assertEquals(shoppingList, ["Pepper", "Carrots", "Leek", "Radicchio"]);
+ * ```
+ */
+export function union<T>(...arrays: Iterable<T>[]): T[] {
+  const set = new Set<T>();
+
+  for (const array of arrays) {
+    for (const element of array) {
+      set.add(element);
+    }
+  }
+
+  return Array.from(set);
+}

package/src/deps/jsr.io/@std/collections/1.0.9/unzip.ts

@@ -0,0 +1,50 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Builds two separate arrays from the given array of 2-tuples, with the first
+ * returned array holding all first tuple elements and the second one holding
+ * all the second elements.
+ *
+ * @typeParam T The type of the first tuple elements.
+ * @typeParam U The type of the second tuple elements.
+ *
+ * @param pairs The array of 2-tuples to unzip.
+ *
+ * @returns A tuple containing two arrays, the first one holding all first tuple
+ * elements and the second one holding all second elements.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { unzip } from "@std/collections/unzip";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const parents = [
+ *   ["Maria", "Jeff"],
+ *   ["Anna", "Kim"],
+ *   ["John", "Leroy"],
+ * ] as [string, string][];
+ *
+ * const [moms, dads] = unzip(parents);
+ *
+ * assertEquals(moms, ["Maria", "Anna", "John"]);
+ * assertEquals(dads, ["Jeff", "Kim", "Leroy"]);
+ * ```
+ */
+export function unzip<T, U>(pairs: readonly [T, U][]): [T[], U[]] {
+  const { length } = pairs;
+
+  const result: [T[], U[]] = [
+    new Array<T>(length),
+    new Array<U>(length),
+  ];
+
+  for (let i = 0; i < length; ++i) {
+    const pair = pairs[i] as [T, U];
+
+    result[0][i] = pair[0];
+    result[1][i] = pair[1];
+  }
+
+  return result;
+}

package/src/deps/jsr.io/@std/collections/1.0.9/without_all.ts

@@ -0,0 +1,28 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Returns an array excluding all given values.
+ *
+ * @typeParam T The type of the array elements.
+ *
+ * @param array The array to exclude values from.
+ * @param values The values to exclude from the array.
+ *
+ * @returns A new array containing all elements from the given array except the
+ * ones that are in the values array.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { withoutAll } from "@std/collections/without-all";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const withoutList = withoutAll([2, 1, 2, 3], [1, 2]);
+ *
+ * assertEquals(withoutList, [3]);
+ * ```
+ */
+export function withoutAll<T>(array: readonly T[], values: readonly T[]): T[] {
+  const toExclude = new Set(values);
+  return array.filter((it) => !toExclude.has(it));
+}

package/src/deps/jsr.io/@std/collections/1.0.9/zip.ts

@@ -0,0 +1,49 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { minOf } from "./min_of.js";
+
+/**
+ * Builds N-tuples of elements from the given N arrays with matching indices,
+ * stopping when the smallest array's end is reached.
+ *
+ * @typeParam T the type of the tuples produced by this function.
+ *
+ * @param arrays The arrays to zip.
+ *
+ * @returns A new array containing N-tuples of elements from the given arrays.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { zip } from "@std/collections/zip";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const numbers = [1, 2, 3, 4];
+ * const letters = ["a", "b", "c", "d"];
+ * const pairs = zip(numbers, letters);
+ *
+ * assertEquals(
+ *   pairs,
+ *   [
+ *     [1, "a"],
+ *     [2, "b"],
+ *     [3, "c"],
+ *     [4, "d"],
+ *   ],
+ * );
+ * ```
+ */
+export function zip<T extends unknown[]>(
+  ...arrays: { [K in keyof T]: ReadonlyArray<T[K]> }
+): T[] {
+  const minLength = minOf(arrays, (element) => element.length) ?? 0;
+
+  const result: T[] = new Array(minLength);
+
+  for (let i = 0; i < minLength; i += 1) {
+    const arr = arrays.map((it) => it[i]);
+    result[i] = arr as T;
+  }
+
+  return result;
+}

package/src/mod.ts

@@ -1,14 +1,5 @@
-// moderate --exclude _base.ts code_critique.ts
 import "./_dnt.polyfills.js";
-
-
-export * from "./array.js"
-export * from "./common.js"
-export * from "./F.js"
-export * from "./literal.js"
-export * from "./number.js"
-export * from "./object.js"
+export * as T from "./core/mod.js"
+export * as std from "./std/mod.js"
 export * from "./ResponseFormat.js"
-export * from "./schema.js"
-export * from "./string.js"
-export * from "./union.js"
+export * from "./Tool.js"

package/src/std/Option.ts

@@ -0,0 +1,20 @@
+import { none } from "../core/leaves.js"
+import { taggedUnion } from "../core/taggedUnion.js"
+import type { Ty } from "../core/Ty.js"
+
+export type Option<S extends Ty> = ReturnType<typeof Option<S>>
+
+export function Option<S extends Ty>(Some: S): taggedUnion<{
+  Some: S
+  None: none<never>
+}> {
+  // TODO: There should be no need to supply the following type arg.
+  //       Determine where inference isn't smart enough to avoid widening `none`'s `P` to `string`.
+  return taggedUnion<{
+    Some: S
+    None: none<never>
+  }>({
+    Some,
+    None: none,
+  })`An option of specified \`some\` type.`
+}

package/src/std/Wrapper.ts

@@ -0,0 +1,7 @@
+import { struct, type Ty } from "../core/mod.js"
+
+export type Wrapper<X extends Ty = Ty> = ReturnType<typeof Wrapper<X>>
+
+export function Wrapper<X extends Ty>(value: X): struct<{ value: X }> {
+  return struct({ value })
+}

package/src/std/mod.ts

@@ -0,0 +1,2 @@
+export * from "./Option.js"
+export * from "./Wrapper.js"

package/src/util/phantoms.ts

@@ -0,0 +1,3 @@
+export function phantoms<T>(): T {
+  return {} as T
+}

package/src/util/recombineTaggedTemplateArgs.ts

@@ -0,0 +1,6 @@
+export function recombineTaggedTemplateArgs(
+  strings: TemplateStringsArray,
+  values: Array<number | string>,
+): string {
+  return strings.reduce((acc, cur, i) => `${acc}${cur}${values[i] ?? ""}`, "")
+}

package/types/ResponseFormat.d.ts

@@ -1,14 +1,26 @@
-import type { Ty } from "./_base.js";
-import type { ValidRootKey } from "./common.js";
-export type ResponseFormat = {
+import type Openai from "openai";
+import type { ResponseFormatJSONSchema } from "openai/resources/index.js";
+import type { RootTy } from "./core/mod.js";
+export declare function ResponseFormat<T>(name: string, ty: RootTy<T, never>): ResponseFormat<T>;
+export interface ResponseFormat<T> {
+    (template: TemplateStringsArray, ...quasis: Array<string>): ResponseFormat<T>;
     type: "json_schema";
     /** The desired return type in JSON Schema. */
-    json_schema: {
-        name: string;
-        description: string;
-        schema: Record<string, unknown>;
-        strict: true;
-    };
+    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;
+        };
+    }>;
 };
-export declare function ResponseFormat<M extends Record<string, Ty>>(name: string, description: string, models: M, rootKey: ValidRootKey<M>): ResponseFormat;
+type ChatCompletion = Openai.Chat.ChatCompletion;
+type ChatCompletionChoice = Openai.Chat.ChatCompletion.Choice;
+type ChatCompletionMessage = Openai.Chat.Completions.ChatCompletionMessage;
+export {};
 //# sourceMappingURL=ResponseFormat.d.ts.map

package/types/ResponseFormat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ResponseFormat.d.ts","sourceRoot":"","sources":["../src/ResponseFormat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,YAAY,CAAA;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG/C,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,aAAa,CAAA;IACnB,8CAA8C;IAC9C,WAAW,EAAE;QACX,IAAI,EAAE,MAAM,CAAA;QACZ,WAAW,EAAE,MAAM,CAAA;QACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,MAAM,EAAE,IAAI,CAAA;KACb,CAAA;CACF,CAAA;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EACzD,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,cAAc,CAUhB"}
+{"version":3,"file":"ResponseFormat.d.ts","sourceRoot":"","sources":["../src/ResponseFormat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAA;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAG3C,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAEvF;AAkDD,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAA;IAC7E,IAAI,EAAE,aAAa,CAAA;IACnB,8CAA8C;IAC9C,WAAW,EAAE,wBAAwB,CAAC,UAAU,CAAA;IAChD,iDAAiD;IACjD,KAAK,CAAC,UAAU,EAAE,cAAc,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAA;IACzD,qEAAqE;IACrE,iBAAiB,CAAC,UAAU,EAAE,cAAc,GAAG,CAAC,CAAA;CACjD;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,GAAG;IACrE,OAAO,EAAE,KAAK,CACZ,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,GAAG;QACtC,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,GAAG;YAChD,OAAO,EAAE,CAAC,CAAA;SACX,CAAA;KACF,CACF,CAAA;CACF,CAAA;AAED,KAAK,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAA;AAChD,KAAK,oBAAoB,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAA;AAC7D,KAAK,qBAAqB,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAA"}

package/types/Tool.d.ts

@@ -0,0 +1,13 @@
+import type { RootTy, Schema } from "./core/mod.js";
+export declare function Tool<T>(name: string, ty: RootTy<T, never>): Tool<T>;
+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;
+}
+//# sourceMappingURL=Tool.d.ts.map

package/types/Tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tool.d.ts","sourceRoot":"","sources":["../src/Tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAGnD,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAEnE;AAuBD,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,GAAG;IAC3B,CAAC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;IACnE,IAAI,EAAE,UAAU,CAAA;IAChB,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAA;IACZ,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB"}

package/types/_dnt.polyfills.d.ts

@@ -1,10 +1,3 @@
-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>[]>;
-    }
-}
-export {};
 declare global {
     interface Object {
         /**

package/types/_dnt.polyfills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,gBAAgB;QACxB,SAAS,CAAC,CAAC,EACP,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAC7F,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;QAEhB,SAAS,CAAC,CAAC,EAAE,CAAC,EACV,mBAAmB,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAClE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,EAC/B,OAAO,CAAC,EAAE,GAAG,GACd,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;KAC1B;CACF;AAoID,OAAO,EAAE,CAAC;AAeV,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC"}
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"AAeA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd;;;;WAIG;QACH,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC;KAC5C;CACF;AAED,OAAO,EAAE,CAAC"}

package/types/_dnt.shims.d.ts

@@ -1,6 +1,2 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
-    Deno: typeof Deno;
-};
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
 //# sourceMappingURL=_dnt.shims.d.ts.map

package/types/_dnt.shims.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}