Add files using upload-large-folder tool

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/partial-json-parser/README.md

@@ -0,0 +1,3 @@
+# Partial JSON Parser
+
+Vendored from https://www.npmjs.com/package/partial-json with some modifications

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/partial-json-parser/parser.ts

@@ -0,0 +1,247 @@
+const STR = 0b000000001;
+const NUM = 0b000000010;
+const ARR = 0b000000100;
+const OBJ = 0b000001000;
+const NULL = 0b000010000;
+const BOOL = 0b000100000;
+const NAN = 0b001000000;
+const INFINITY = 0b010000000;
+const MINUS_INFINITY = 0b100000000;
+
+const INF = INFINITY | MINUS_INFINITY;
+const SPECIAL = NULL | BOOL | INF | NAN;
+const ATOM = STR | NUM | SPECIAL;
+const COLLECTION = ARR | OBJ;
+const ALL = ATOM | COLLECTION;
+
+const Allow = {
+  STR,
+  NUM,
+  ARR,
+  OBJ,
+  NULL,
+  BOOL,
+  NAN,
+  INFINITY,
+  MINUS_INFINITY,
+  INF,
+  SPECIAL,
+  ATOM,
+  COLLECTION,
+  ALL,
+};
+
+// The JSON string segment was unable to be parsed completely
+class PartialJSON extends Error {}
+
+class MalformedJSON extends Error {}
+
+/**
+ * Parse incomplete JSON
+ * @param {string} jsonString Partial JSON to be parsed
+ * @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details
+ * @returns The parsed JSON
+ * @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter)
+ * @throws {MalformedJSON} If the JSON is malformed
+ */
+function parseJSON(jsonString: string, allowPartial: number = Allow.ALL): any {
+  if (typeof jsonString !== 'string') {
+    throw new TypeError(`expecting str, got ${typeof jsonString}`);
+  }
+  if (!jsonString.trim()) {
+    throw new Error(`${jsonString} is empty`);
+  }
+  return _parseJSON(jsonString.trim(), allowPartial);
+}
+
+const _parseJSON = (jsonString: string, allow: number) => {
+  const length = jsonString.length;
+  let index = 0;
+
+  const markPartialJSON = (msg: string) => {
+    throw new PartialJSON(`${msg} at position ${index}`);
+  };
+
+  const throwMalformedError = (msg: string) => {
+    throw new MalformedJSON(`${msg} at position ${index}`);
+  };
+
+  const parseAny: () => any = () => {
+    skipBlank();
+    if (index >= length) markPartialJSON('Unexpected end of input');
+    if (jsonString[index] === '"') return parseStr();
+    if (jsonString[index] === '{') return parseObj();
+    if (jsonString[index] === '[') return parseArr();
+    if (
+      jsonString.substring(index, index + 4) === 'null' ||
+      (Allow.NULL & allow && length - index < 4 && 'null'.startsWith(jsonString.substring(index)))
+    ) {
+      index += 4;
+      return null;
+    }
+    if (
+      jsonString.substring(index, index + 4) === 'true' ||
+      (Allow.BOOL & allow && length - index < 4 && 'true'.startsWith(jsonString.substring(index)))
+    ) {
+      index += 4;
+      return true;
+    }
+    if (
+      jsonString.substring(index, index + 5) === 'false' ||
+      (Allow.BOOL & allow && length - index < 5 && 'false'.startsWith(jsonString.substring(index)))
+    ) {
+      index += 5;
+      return false;
+    }
+    if (
+      jsonString.substring(index, index + 8) === 'Infinity' ||
+      (Allow.INFINITY & allow && length - index < 8 && 'Infinity'.startsWith(jsonString.substring(index)))
+    ) {
+      index += 8;
+      return Infinity;
+    }
+    if (
+      jsonString.substring(index, index + 9) === '-Infinity' ||
+      (Allow.MINUS_INFINITY & allow &&
+        1 < length - index &&
+        length - index < 9 &&
+        '-Infinity'.startsWith(jsonString.substring(index)))
+    ) {
+      index += 9;
+      return -Infinity;
+    }
+    if (
+      jsonString.substring(index, index + 3) === 'NaN' ||
+      (Allow.NAN & allow && length - index < 3 && 'NaN'.startsWith(jsonString.substring(index)))
+    ) {
+      index += 3;
+      return NaN;
+    }
+    return parseNum();
+  };
+
+  const parseStr: () => string = () => {
+    const start = index;
+    let escape = false;
+    index++; // skip initial quote
+    while (index < length && (jsonString[index] !== '"' || (escape && jsonString[index - 1] === '\\'))) {
+      escape = jsonString[index] === '\\' ? !escape : false;
+      index++;
+    }
+    if (jsonString.charAt(index) == '"') {
+      try {
+        return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+      } catch (e) {
+        throwMalformedError(String(e));
+      }
+    } else if (Allow.STR & allow) {
+      try {
+        return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
+      } catch (e) {
+        // SyntaxError: Invalid escape sequence
+        return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf('\\')) + '"');
+      }
+    }
+    markPartialJSON('Unterminated string literal');
+  };
+
+  const parseObj = () => {
+    index++; // skip initial brace
+    skipBlank();
+    const obj: Record<string, any> = {};
+    try {
+      while (jsonString[index] !== '}') {
+        skipBlank();
+        if (index >= length && Allow.OBJ & allow) return obj;
+        const key = parseStr();
+        skipBlank();
+        index++; // skip colon
+        try {
+          const value = parseAny();
+          Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+        } catch (e) {
+          if (Allow.OBJ & allow) return obj;
+          else throw e;
+        }
+        skipBlank();
+        if (jsonString[index] === ',') index++; // skip comma
+      }
+    } catch (e) {
+      if (Allow.OBJ & allow) return obj;
+      else markPartialJSON("Expected '}' at end of object");
+    }
+    index++; // skip final brace
+    return obj;
+  };
+
+  const parseArr = () => {
+    index++; // skip initial bracket
+    const arr = [];
+    try {
+      while (jsonString[index] !== ']') {
+        arr.push(parseAny());
+        skipBlank();
+        if (jsonString[index] === ',') {
+          index++; // skip comma
+        }
+      }
+    } catch (e) {
+      if (Allow.ARR & allow) {
+        return arr;
+      }
+      markPartialJSON("Expected ']' at end of array");
+    }
+    index++; // skip final bracket
+    return arr;
+  };
+
+  const parseNum = () => {
+    if (index === 0) {
+      if (jsonString === '-' && Allow.NUM & allow) markPartialJSON("Not sure what '-' is");
+      try {
+        return JSON.parse(jsonString);
+      } catch (e) {
+        if (Allow.NUM & allow) {
+          try {
+            if ('.' === jsonString[jsonString.length - 1])
+              return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf('.')));
+            return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf('e')));
+          } catch (e) {}
+        }
+        throwMalformedError(String(e));
+      }
+    }
+
+    const start = index;
+
+    if (jsonString[index] === '-') index++;
+    while (jsonString[index] && !',]}'.includes(jsonString[index]!)) index++;
+
+    if (index == length && !(Allow.NUM & allow)) markPartialJSON('Unterminated number literal');
+
+    try {
+      return JSON.parse(jsonString.substring(start, index));
+    } catch (e) {
+      if (jsonString.substring(start, index) === '-' && Allow.NUM & allow)
+        markPartialJSON("Not sure what '-' is");
+      try {
+        return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf('e')));
+      } catch (e) {
+        throwMalformedError(String(e));
+      }
+    }
+  };
+
+  const skipBlank = () => {
+    while (index < length && ' \n\r\t'.includes(jsonString[index]!)) {
+      index++;
+    }
+  };
+
+  return parseAny();
+};
+
+// using this function with malformed JSON is undefined behavior
+const partialParse = (input: string) => parseJSON(input, Allow.ALL ^ Allow.NUM);
+
+export { partialParse, PartialJSON, MalformedJSON };

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2020, Stefan Terdell
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/Options.ts

@@ -0,0 +1,80 @@
+import { ZodSchema, ZodTypeDef } from 'zod';
+import { Refs, Seen } from './Refs';
+import { JsonSchema7Type } from './parseDef';
+
+export type Targets = 'jsonSchema7' | 'jsonSchema2019-09' | 'openApi3';
+
+export type DateStrategy = 'format:date-time' | 'format:date' | 'string' | 'integer';
+
+export const ignoreOverride = Symbol('Let zodToJsonSchema decide on which parser to use');
+
+export type Options<Target extends Targets = 'jsonSchema7'> = {
+  name: string | undefined;
+  $refStrategy: 'root' | 'relative' | 'none' | 'seen' | 'extract-to-root';
+  basePath: string[];
+  effectStrategy: 'input' | 'any';
+  pipeStrategy: 'input' | 'output' | 'all';
+  dateStrategy: DateStrategy | DateStrategy[];
+  mapStrategy: 'entries' | 'record';
+  removeAdditionalStrategy: 'passthrough' | 'strict';
+  nullableStrategy: 'from-target' | 'property';
+  target: Target;
+  strictUnions: boolean;
+  definitionPath: string;
+  definitions: Record<string, ZodSchema | ZodTypeDef>;
+  errorMessages: boolean;
+  markdownDescription: boolean;
+  patternStrategy: 'escape' | 'preserve';
+  applyRegexFlags: boolean;
+  emailStrategy: 'format:email' | 'format:idn-email' | 'pattern:zod';
+  base64Strategy: 'format:binary' | 'contentEncoding:base64' | 'pattern:zod';
+  nameStrategy: 'ref' | 'duplicate-ref' | 'title';
+  override?: (
+    def: ZodTypeDef,
+    refs: Refs,
+    seen: Seen | undefined,
+    forceResolution?: boolean,
+  ) => JsonSchema7Type | undefined | typeof ignoreOverride;
+  openaiStrictMode?: boolean;
+};
+
+const defaultOptions: Omit<Options, 'definitions' | 'basePath'> = {
+  name: undefined,
+  $refStrategy: 'root',
+  effectStrategy: 'input',
+  pipeStrategy: 'all',
+  dateStrategy: 'format:date-time',
+  mapStrategy: 'entries',
+  nullableStrategy: 'from-target',
+  removeAdditionalStrategy: 'passthrough',
+  definitionPath: 'definitions',
+  target: 'jsonSchema7',
+  strictUnions: false,
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: 'escape',
+  applyRegexFlags: false,
+  emailStrategy: 'format:email',
+  base64Strategy: 'contentEncoding:base64',
+  nameStrategy: 'ref',
+};
+
+export const getDefaultOptions = <Target extends Targets>(
+  options: Partial<Options<Target>> | string | undefined,
+) => {
+  // We need to add `definitions` here as we may mutate it
+  return (
+    typeof options === 'string' ?
+      {
+        ...defaultOptions,
+        basePath: ['#'],
+        definitions: {},
+        name: options,
+      }
+    : {
+        ...defaultOptions,
+        basePath: ['#'],
+        definitions: {},
+        ...options,
+      }) as Options<Target>;
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/README.md

@@ -0,0 +1,3 @@
+# Zod to Json Schema
+
+Vendored version of https://github.com/StefanTerdell/zod-to-json-schema that has been updated to generate JSON Schemas that are compatible with OpenAI's [strict mode](https://platform.openai.com/docs/guides/structured-outputs/supported-schemas)

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/Refs.ts

@@ -0,0 +1,47 @@
+import type { ZodTypeDef } from 'zod';
+import { getDefaultOptions, Options, Targets } from './Options';
+import { JsonSchema7Type } from './parseDef';
+import { zodDef } from './util';
+
+export type Refs = {
+  seen: Map<ZodTypeDef, Seen>;
+  /**
+   * Set of all the `$ref`s we created, e.g. `Set(['#/$defs/ui'])`
+   * this notable does not include any `definitions` that were
+   * explicitly given as an option.
+   */
+  seenRefs: Set<string>;
+  currentPath: string[];
+  propertyPath: string[] | undefined;
+} & Options<Targets>;
+
+export type Seen = {
+  def: ZodTypeDef;
+  path: string[];
+  jsonSchema: JsonSchema7Type | undefined;
+};
+
+export const getRefs = (options?: string | Partial<Options<Targets>>): Refs => {
+  const _options = getDefaultOptions(options);
+  const currentPath =
+    _options.name !== undefined ?
+      [..._options.basePath, _options.definitionPath, _options.name]
+    : _options.basePath;
+  return {
+    ..._options,
+    currentPath: currentPath,
+    propertyPath: undefined,
+    seenRefs: new Set(),
+    seen: new Map(
+      Object.entries(_options.definitions).map(([name, def]) => [
+        zodDef(def),
+        {
+          def: zodDef(def),
+          path: [..._options.basePath, _options.definitionPath, name],
+          // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+          jsonSchema: undefined,
+        },
+      ]),
+    ),
+  };
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/errorMessages.ts

@@ -0,0 +1,31 @@
+import { JsonSchema7TypeUnion } from './parseDef';
+import { Refs } from './Refs';
+
+export type ErrorMessages<T extends JsonSchema7TypeUnion, OmitProperties extends string = ''> = Partial<
+  Omit<{ [key in keyof T]: string }, OmitProperties | 'type' | 'errorMessages'>
+>;
+
+export function addErrorMessage<T extends { errorMessage?: ErrorMessages<any> }>(
+  res: T,
+  key: keyof T,
+  errorMessage: string | undefined,
+  refs: Refs,
+) {
+  if (!refs?.errorMessages) return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage,
+    };
+  }
+}
+
+export function setResponseValueAndErrors<
+  Json7Type extends JsonSchema7TypeUnion & {
+    errorMessage?: ErrorMessages<Json7Type>;
+  },
+  Key extends keyof Omit<Json7Type, 'errorMessage'>,
+>(res: Json7Type, key: Key, value: Json7Type[Key], errorMessage: string | undefined, refs: Refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/index.ts

@@ -0,0 +1,37 @@
+export * from './Options';
+export * from './Refs';
+export * from './errorMessages';
+export * from './parseDef';
+export * from './parsers/any';
+export * from './parsers/array';
+export * from './parsers/bigint';
+export * from './parsers/boolean';
+export * from './parsers/branded';
+export * from './parsers/catch';
+export * from './parsers/date';
+export * from './parsers/default';
+export * from './parsers/effects';
+export * from './parsers/enum';
+export * from './parsers/intersection';
+export * from './parsers/literal';
+export * from './parsers/map';
+export * from './parsers/nativeEnum';
+export * from './parsers/never';
+export * from './parsers/null';
+export * from './parsers/nullable';
+export * from './parsers/number';
+export * from './parsers/object';
+export * from './parsers/optional';
+export * from './parsers/pipeline';
+export * from './parsers/promise';
+export * from './parsers/readonly';
+export * from './parsers/record';
+export * from './parsers/set';
+export * from './parsers/string';
+export * from './parsers/tuple';
+export * from './parsers/undefined';
+export * from './parsers/union';
+export * from './parsers/unknown';
+export * from './zodToJsonSchema';
+import { zodToJsonSchema } from './zodToJsonSchema';
+export default zodToJsonSchema;

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parseDef.ts

@@ -0,0 +1,258 @@
+import { ZodFirstPartyTypeKind, ZodTypeDef } from 'zod';
+import { JsonSchema7AnyType, parseAnyDef } from './parsers/any';
+import { JsonSchema7ArrayType, parseArrayDef } from './parsers/array';
+import { JsonSchema7BigintType, parseBigintDef } from './parsers/bigint';
+import { JsonSchema7BooleanType, parseBooleanDef } from './parsers/boolean';
+import { parseBrandedDef } from './parsers/branded';
+import { parseCatchDef } from './parsers/catch';
+import { JsonSchema7DateType, parseDateDef } from './parsers/date';
+import { parseDefaultDef } from './parsers/default';
+import { parseEffectsDef } from './parsers/effects';
+import { JsonSchema7EnumType, parseEnumDef } from './parsers/enum';
+import { JsonSchema7AllOfType, parseIntersectionDef } from './parsers/intersection';
+import { JsonSchema7LiteralType, parseLiteralDef } from './parsers/literal';
+import { JsonSchema7MapType, parseMapDef } from './parsers/map';
+import { JsonSchema7NativeEnumType, parseNativeEnumDef } from './parsers/nativeEnum';
+import { JsonSchema7NeverType, parseNeverDef } from './parsers/never';
+import { JsonSchema7NullType, parseNullDef } from './parsers/null';
+import { JsonSchema7NullableType, parseNullableDef } from './parsers/nullable';
+import { JsonSchema7NumberType, parseNumberDef } from './parsers/number';
+import { JsonSchema7ObjectType, parseObjectDef } from './parsers/object';
+import { parseOptionalDef } from './parsers/optional';
+import { parsePipelineDef } from './parsers/pipeline';
+import { parsePromiseDef } from './parsers/promise';
+import { JsonSchema7RecordType, parseRecordDef } from './parsers/record';
+import { JsonSchema7SetType, parseSetDef } from './parsers/set';
+import { JsonSchema7StringType, parseStringDef } from './parsers/string';
+import { JsonSchema7TupleType, parseTupleDef } from './parsers/tuple';
+import { JsonSchema7UndefinedType, parseUndefinedDef } from './parsers/undefined';
+import { JsonSchema7UnionType, parseUnionDef } from './parsers/union';
+import { JsonSchema7UnknownType, parseUnknownDef } from './parsers/unknown';
+import { Refs, Seen } from './Refs';
+import { parseReadonlyDef } from './parsers/readonly';
+import { ignoreOverride } from './Options';
+
+type JsonSchema7RefType = { $ref: string };
+type JsonSchema7Meta = {
+  title?: string;
+  default?: any;
+  description?: string;
+  markdownDescription?: string;
+};
+
+export type JsonSchema7TypeUnion =
+  | JsonSchema7StringType
+  | JsonSchema7ArrayType
+  | JsonSchema7NumberType
+  | JsonSchema7BigintType
+  | JsonSchema7BooleanType
+  | JsonSchema7DateType
+  | JsonSchema7EnumType
+  | JsonSchema7LiteralType
+  | JsonSchema7NativeEnumType
+  | JsonSchema7NullType
+  | JsonSchema7NumberType
+  | JsonSchema7ObjectType
+  | JsonSchema7RecordType
+  | JsonSchema7TupleType
+  | JsonSchema7UnionType
+  | JsonSchema7UndefinedType
+  | JsonSchema7RefType
+  | JsonSchema7NeverType
+  | JsonSchema7MapType
+  | JsonSchema7AnyType
+  | JsonSchema7NullableType
+  | JsonSchema7AllOfType
+  | JsonSchema7UnknownType
+  | JsonSchema7SetType;
+
+export type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
+
+export function parseDef(
+  def: ZodTypeDef,
+  refs: Refs,
+  forceResolution = false, // Forces a new schema to be instantiated even though its def has been seen. Used for improving refs in definitions. See https://github.com/StefanTerdell/zod-to-json-schema/pull/61.
+): JsonSchema7Type | undefined {
+  const seenItem = refs.seen.get(def);
+
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+
+    if (seenSchema !== undefined) {
+      if ('$ref' in seenSchema) {
+        refs.seenRefs.add(seenSchema.$ref);
+      }
+
+      return seenSchema;
+    }
+  }
+
+  const newItem: Seen = { def, path: refs.currentPath, jsonSchema: undefined };
+
+  refs.seen.set(def, newItem);
+
+  const jsonSchema = selectParser(def, (def as any).typeName, refs, forceResolution);
+
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+
+  newItem.jsonSchema = jsonSchema;
+
+  return jsonSchema;
+}
+
+const get$ref = (
+  item: Seen,
+  refs: Refs,
+):
+  | {
+      $ref: string;
+    }
+  | {}
+  | undefined => {
+  switch (refs.$refStrategy) {
+    case 'root':
+      return { $ref: item.path.join('/') };
+    // this case is needed as OpenAI strict mode doesn't support top-level `$ref`s, i.e.
+    // the top-level schema *must* be `{"type": "object", "properties": {...}}` but if we ever
+    // need to define a `$ref`, relative `$ref`s aren't supported, so we need to extract
+    // the schema to `#/definitions/` and reference that.
+    //
+    // e.g. if we need to reference a schema at
+    // `["#","definitions","contactPerson","properties","person1","properties","name"]`
+    // then we'll extract it out to `contactPerson_properties_person1_properties_name`
+    case 'extract-to-root':
+      const name = item.path.slice(refs.basePath.length + 1).join('_');
+
+      // we don't need to extract the root schema in this case, as it's already
+      // been added to the definitions
+      if (name !== refs.name && refs.nameStrategy === 'duplicate-ref') {
+        refs.definitions[name] = item.def;
+      }
+
+      return { $ref: [...refs.basePath, refs.definitionPath, name].join('/') };
+    case 'relative':
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case 'none':
+    case 'seen': {
+      if (
+        item.path.length < refs.currentPath.length &&
+        item.path.every((value, index) => refs.currentPath[index] === value)
+      ) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join('/')}! Defaulting to any`);
+
+        return {};
+      }
+
+      return refs.$refStrategy === 'seen' ? {} : undefined;
+    }
+  }
+};
+
+const getRelativePath = (pathA: string[], pathB: string[]) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i]) break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join('/');
+};
+
+const selectParser = (
+  def: any,
+  typeName: ZodFirstPartyTypeKind,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7Type | undefined => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNumber:
+      return parseNumberDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUndefined:
+      return parseUndefinedDef();
+    case ZodFirstPartyTypeKind.ZodNull:
+      return parseNullDef(refs);
+    case ZodFirstPartyTypeKind.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodLazy:
+      return parseDef(def.getter()._def, refs);
+    case ZodFirstPartyTypeKind.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodNaN:
+    case ZodFirstPartyTypeKind.ZodNever:
+      return parseNeverDef();
+    case ZodFirstPartyTypeKind.ZodEffects:
+      return parseEffectsDef(def, refs, forceResolution);
+    case ZodFirstPartyTypeKind.ZodAny:
+      return parseAnyDef();
+    case ZodFirstPartyTypeKind.ZodUnknown:
+      return parseUnknownDef();
+    case ZodFirstPartyTypeKind.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind.ZodFunction:
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodSymbol:
+      return undefined;
+    default:
+      return ((_: never) => undefined)(typeName);
+  }
+};
+
+const addMeta = (def: ZodTypeDef, refs: Refs, jsonSchema: JsonSchema7Type): JsonSchema7Type => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/any.ts

@@ -0,0 +1,5 @@
+export type JsonSchema7AnyType = {};
+
+export function parseAnyDef(): JsonSchema7AnyType {
+  return {};
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/array.ts

@@ -0,0 +1,36 @@
+import { ZodArrayDef, ZodFirstPartyTypeKind } from 'zod';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export type JsonSchema7ArrayType = {
+  type: 'array';
+  items?: JsonSchema7Type | undefined;
+  minItems?: number;
+  maxItems?: number;
+  errorMessages?: ErrorMessages<JsonSchema7ArrayType, 'items'>;
+};
+
+export function parseArrayDef(def: ZodArrayDef, refs: Refs) {
+  const res: JsonSchema7ArrayType = {
+    type: 'array',
+  };
+  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items'],
+    });
+  }
+
+  if (def.minLength) {
+    setResponseValueAndErrors(res, 'minItems', def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, 'maxItems', def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, 'minItems', def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, 'maxItems', def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/bigint.ts

@@ -0,0 +1,60 @@
+import { ZodBigIntDef } from 'zod';
+import { Refs } from '../Refs';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+
+export type JsonSchema7BigintType = {
+  type: 'integer';
+  format: 'int64';
+  minimum?: BigInt;
+  exclusiveMinimum?: BigInt;
+  maximum?: BigInt;
+  exclusiveMaximum?: BigInt;
+  multipleOf?: BigInt;
+  errorMessage?: ErrorMessages<JsonSchema7BigintType>;
+};
+
+export function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7BigintType {
+  const res: JsonSchema7BigintType = {
+    type: 'integer',
+    format: 'int64',
+  };
+
+  if (!def.checks) return res;
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'min':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMinimum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true as any;
+          }
+          setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+        }
+        break;
+      case 'max':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMaximum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true as any;
+          }
+          setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+        }
+        break;
+      case 'multipleOf':
+        setResponseValueAndErrors(res, 'multipleOf', check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/boolean.ts

@@ -0,0 +1,9 @@
+export type JsonSchema7BooleanType = {
+  type: 'boolean';
+};
+
+export function parseBooleanDef(): JsonSchema7BooleanType {
+  return {
+    type: 'boolean',
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/branded.ts

@@ -0,0 +1,7 @@
+import { ZodBrandedDef } from 'zod';
+import { parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs) {
+  return parseDef(_def.type._def, refs);
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/catch.ts

@@ -0,0 +1,7 @@
+import { ZodCatchDef } from 'zod';
+import { parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export const parseCatchDef = (def: ZodCatchDef<any>, refs: Refs) => {
+  return parseDef(def.innerType._def, refs);
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/date.ts

@@ -0,0 +1,83 @@
+import { ZodDateDef } from 'zod';
+import { Refs } from '../Refs';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { JsonSchema7NumberType } from './number';
+import { DateStrategy } from '../Options';
+
+export type JsonSchema7DateType =
+  | {
+      type: 'integer' | 'string';
+      format: 'unix-time' | 'date-time' | 'date';
+      minimum?: number;
+      maximum?: number;
+      errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+    }
+  | {
+      anyOf: JsonSchema7DateType[];
+    };
+
+export function parseDateDef(
+  def: ZodDateDef,
+  refs: Refs,
+  overrideDateStrategy?: DateStrategy,
+): JsonSchema7DateType {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
+    };
+  }
+
+  switch (strategy) {
+    case 'string':
+    case 'format:date-time':
+      return {
+        type: 'string',
+        format: 'date-time',
+      };
+    case 'format:date':
+      return {
+        type: 'string',
+        format: 'date',
+      };
+    case 'integer':
+      return integerDateParser(def, refs);
+  }
+}
+
+const integerDateParser = (def: ZodDateDef, refs: Refs) => {
+  const res: JsonSchema7DateType = {
+    type: 'integer',
+    format: 'unix-time',
+  };
+
+  if (refs.target === 'openApi3') {
+    return res;
+  }
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'min':
+        setResponseValueAndErrors(
+          res,
+          'minimum',
+          check.value, // This is in milliseconds
+          check.message,
+          refs,
+        );
+        break;
+      case 'max':
+        setResponseValueAndErrors(
+          res,
+          'maximum',
+          check.value, // This is in milliseconds
+          check.message,
+          refs,
+        );
+        break;
+    }
+  }
+
+  return res;
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/default.ts

@@ -0,0 +1,10 @@
+import { ZodDefaultDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & { default: any } {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue(),
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/effects.ts

@@ -0,0 +1,11 @@
+import { ZodEffectsDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export function parseEffectsDef(
+  _def: ZodEffectsDef,
+  refs: Refs,
+  forceResolution: boolean,
+): JsonSchema7Type | undefined {
+  return refs.effectStrategy === 'input' ? parseDef(_def.schema._def, refs, forceResolution) : {};
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/enum.ts

@@ -0,0 +1,13 @@
+import { ZodEnumDef } from 'zod';
+
+export type JsonSchema7EnumType = {
+  type: 'string';
+  enum: string[];
+};
+
+export function parseEnumDef(def: ZodEnumDef): JsonSchema7EnumType {
+  return {
+    type: 'string',
+    enum: [...def.values],
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/intersection.ts

@@ -0,0 +1,64 @@
+import { ZodIntersectionDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7StringType } from './string';
+
+export type JsonSchema7AllOfType = {
+  allOf: JsonSchema7Type[];
+  unevaluatedProperties?: boolean;
+};
+
+const isJsonSchema7AllOfType = (
+  type: JsonSchema7Type | JsonSchema7StringType,
+): type is JsonSchema7AllOfType => {
+  if ('type' in type && type.type === 'string') return false;
+  return 'allOf' in type;
+};
+
+export function parseIntersectionDef(
+  def: ZodIntersectionDef,
+  refs: Refs,
+): JsonSchema7AllOfType | JsonSchema7Type | undefined {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'allOf', '0'],
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'allOf', '1'],
+    }),
+  ].filter((x): x is JsonSchema7Type => !!x);
+
+  let unevaluatedProperties: Pick<JsonSchema7AllOfType, 'unevaluatedProperties'> | undefined =
+    refs.target === 'jsonSchema2019-09' ? { unevaluatedProperties: false } : undefined;
+
+  const mergedAllOf: JsonSchema7Type[] = [];
+  // If either of the schemas is an allOf, merge them into a single allOf
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === undefined) {
+        // If one of the schemas has no unevaluatedProperties set,
+        // the merged schema should also have no unevaluatedProperties set
+        unevaluatedProperties = undefined;
+      }
+    } else {
+      let nestedSchema: JsonSchema7Type = schema;
+      if ('additionalProperties' in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
+        unevaluatedProperties = undefined;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ?
+      {
+        allOf: mergedAllOf,
+        ...unevaluatedProperties,
+      }
+    : undefined;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/literal.ts

@@ -0,0 +1,37 @@
+import { ZodLiteralDef } from 'zod';
+import { Refs } from '../Refs';
+
+export type JsonSchema7LiteralType =
+  | {
+      type: 'string' | 'number' | 'integer' | 'boolean';
+      const: string | number | boolean;
+    }
+  | {
+      type: 'object' | 'array';
+    };
+
+export function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType {
+  const parsedType = typeof def.value;
+  if (
+    parsedType !== 'bigint' &&
+    parsedType !== 'number' &&
+    parsedType !== 'boolean' &&
+    parsedType !== 'string'
+  ) {
+    return {
+      type: Array.isArray(def.value) ? 'array' : 'object',
+    };
+  }
+
+  if (refs.target === 'openApi3') {
+    return {
+      type: parsedType === 'bigint' ? 'integer' : parsedType,
+      enum: [def.value],
+    } as any;
+  }
+
+  return {
+    type: parsedType === 'bigint' ? 'integer' : parsedType,
+    const: def.value,
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/map.ts

@@ -0,0 +1,42 @@
+import { ZodMapDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7RecordType, parseRecordDef } from './record';
+
+export type JsonSchema7MapType = {
+  type: 'array';
+  maxItems: 125;
+  items: {
+    type: 'array';
+    items: [JsonSchema7Type, JsonSchema7Type];
+    minItems: 2;
+    maxItems: 2;
+  };
+};
+
+export function parseMapDef(def: ZodMapDef, refs: Refs): JsonSchema7MapType | JsonSchema7RecordType {
+  if (refs.mapStrategy === 'record') {
+    return parseRecordDef(def, refs);
+  }
+
+  const keys =
+    parseDef(def.keyType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items', 'items', '0'],
+    }) || {};
+  const values =
+    parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, 'items', 'items', '1'],
+    }) || {};
+  return {
+    type: 'array',
+    maxItems: 125,
+    items: {
+      type: 'array',
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2,
+    },
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/nativeEnum.ts

@@ -0,0 +1,27 @@
+import { ZodNativeEnumDef } from 'zod';
+
+export type JsonSchema7NativeEnumType = {
+  type: 'string' | 'number' | ['string', 'number'];
+  enum: (string | number)[];
+};
+
+export function parseNativeEnumDef(def: ZodNativeEnumDef): JsonSchema7NativeEnumType {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key: string) => {
+    return typeof object[object[key]!] !== 'number';
+  });
+
+  const actualValues = actualKeys.map((key: string) => object[key]!);
+
+  const parsedTypes = Array.from(new Set(actualValues.map((values: string | number) => typeof values)));
+
+  return {
+    type:
+      parsedTypes.length === 1 ?
+        parsedTypes[0] === 'string' ?
+          'string'
+        : 'number'
+      : ['string', 'number'],
+    enum: actualValues,
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/never.ts

@@ -0,0 +1,9 @@
+export type JsonSchema7NeverType = {
+  not: {};
+};
+
+export function parseNeverDef(): JsonSchema7NeverType {
+  return {
+    not: {},
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/null.ts

@@ -0,0 +1,16 @@
+import { Refs } from '../Refs';
+
+export type JsonSchema7NullType = {
+  type: 'null';
+};
+
+export function parseNullDef(refs: Refs): JsonSchema7NullType {
+  return refs.target === 'openApi3' ?
+      ({
+        enum: ['null'],
+        nullable: true,
+      } as any)
+    : {
+        type: 'null',
+      };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/nullable.ts

@@ -0,0 +1,49 @@
+import { ZodNullableDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7NullType } from './null';
+import { primitiveMappings } from './union';
+
+export type JsonSchema7NullableType =
+  | {
+      anyOf: [JsonSchema7Type, JsonSchema7NullType];
+    }
+  | {
+      type: [string, 'null'];
+    };
+
+export function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7NullableType | undefined {
+  if (
+    ['ZodString', 'ZodNumber', 'ZodBigInt', 'ZodBoolean', 'ZodNull'].includes(def.innerType._def.typeName) &&
+    (!def.innerType._def.checks || !def.innerType._def.checks.length)
+  ) {
+    if (refs.target === 'openApi3' || refs.nullableStrategy === 'property') {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName as keyof typeof primitiveMappings],
+        nullable: true,
+      } as any;
+    }
+
+    return {
+      type: [primitiveMappings[def.innerType._def.typeName as keyof typeof primitiveMappings], 'null'],
+    };
+  }
+
+  if (refs.target === 'openApi3') {
+    const base = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath],
+    });
+
+    if (base && '$ref' in base) return { allOf: [base], nullable: true } as any;
+
+    return base && ({ ...base, nullable: true } as any);
+  }
+
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'anyOf', '0'],
+  });
+
+  return base && { anyOf: [base, { type: 'null' }] };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/number.ts

@@ -0,0 +1,62 @@
+import { ZodNumberDef } from 'zod';
+import { addErrorMessage, ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { Refs } from '../Refs';
+
+export type JsonSchema7NumberType = {
+  type: 'number' | 'integer';
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  multipleOf?: number;
+  errorMessage?: ErrorMessages<JsonSchema7NumberType>;
+};
+
+export function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7NumberType {
+  const res: JsonSchema7NumberType = {
+    type: 'number',
+  };
+
+  if (!def.checks) return res;
+
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case 'int':
+        res.type = 'integer';
+        addErrorMessage(res, 'type', check.message, refs);
+        break;
+      case 'min':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMinimum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true as any;
+          }
+          setResponseValueAndErrors(res, 'minimum', check.value, check.message, refs);
+        }
+        break;
+      case 'max':
+        if (refs.target === 'jsonSchema7') {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, 'exclusiveMaximum', check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true as any;
+          }
+          setResponseValueAndErrors(res, 'maximum', check.value, check.message, refs);
+        }
+        break;
+      case 'multipleOf':
+        setResponseValueAndErrors(res, 'multipleOf', check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/object.ts

@@ -0,0 +1,76 @@
+import { ZodObjectDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+function decideAdditionalProperties(def: ZodObjectDef, refs: Refs) {
+  if (refs.removeAdditionalStrategy === 'strict') {
+    return def.catchall._def.typeName === 'ZodNever' ?
+        def.unknownKeys !== 'strict'
+      : parseDef(def.catchall._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, 'additionalProperties'],
+        }) ?? true;
+  } else {
+    return def.catchall._def.typeName === 'ZodNever' ?
+        def.unknownKeys === 'passthrough'
+      : parseDef(def.catchall._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, 'additionalProperties'],
+        }) ?? true;
+  }
+}
+
+export type JsonSchema7ObjectType = {
+  type: 'object';
+  properties: Record<string, JsonSchema7Type>;
+  additionalProperties: boolean | JsonSchema7Type;
+  required?: string[];
+};
+
+export function parseObjectDef(def: ZodObjectDef, refs: Refs) {
+  const result: JsonSchema7ObjectType = {
+    type: 'object',
+    ...Object.entries(def.shape()).reduce(
+      (
+        acc: {
+          properties: Record<string, JsonSchema7Type>;
+          required: string[];
+        },
+        [propName, propDef],
+      ) => {
+        if (propDef === undefined || propDef._def === undefined) return acc;
+        const propertyPath = [...refs.currentPath, 'properties', propName];
+        const parsedDef = parseDef(propDef._def, {
+          ...refs,
+          currentPath: propertyPath,
+          propertyPath,
+        });
+        if (parsedDef === undefined) return acc;
+        if (
+          refs.openaiStrictMode &&
+          propDef.isOptional() &&
+          !propDef.isNullable() &&
+          typeof propDef._def?.defaultValue === 'undefined'
+        ) {
+          throw new Error(
+            `Zod field at \`${propertyPath.join(
+              '/',
+            )}\` uses \`.optional()\` without \`.nullable()\` which is not supported by the API. See: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#all-fields-must-be-required`,
+          );
+        }
+        return {
+          properties: {
+            ...acc.properties,
+            [propName]: parsedDef,
+          },
+          required:
+            propDef.isOptional() && !refs.openaiStrictMode ? acc.required : [...acc.required, propName],
+        };
+      },
+      { properties: {}, required: [] },
+    ),
+    additionalProperties: decideAdditionalProperties(def, refs),
+  };
+  if (!result.required!.length) delete result.required;
+  return result;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/optional.ts

@@ -0,0 +1,28 @@
+import { ZodOptionalDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export const parseOptionalDef = (def: ZodOptionalDef, refs: Refs): JsonSchema7Type | undefined => {
+  if (
+    refs.propertyPath &&
+    refs.currentPath.slice(0, refs.propertyPath.length).toString() === refs.propertyPath.toString()
+  ) {
+    return parseDef(def.innerType._def, { ...refs, currentPath: refs.currentPath });
+  }
+
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'anyOf', '1'],
+  });
+
+  return innerSchema ?
+      {
+        anyOf: [
+          {
+            not: {},
+          },
+          innerSchema,
+        ],
+      }
+    : {};
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/pipeline.ts

@@ -0,0 +1,28 @@
+import { ZodPipelineDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7AllOfType } from './intersection';
+
+export const parsePipelineDef = (
+  def: ZodPipelineDef<any, any>,
+  refs: Refs,
+): JsonSchema7AllOfType | JsonSchema7Type | undefined => {
+  if (refs.pipeStrategy === 'input') {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === 'output') {
+    return parseDef(def.out._def, refs);
+  }
+
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'allOf', '0'],
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'allOf', a ? '1' : '0'],
+  });
+
+  return {
+    allOf: [a, b].filter((x): x is JsonSchema7Type => x !== undefined),
+  };
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/promise.ts

@@ -0,0 +1,7 @@
+import { ZodPromiseDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export function parsePromiseDef(def: ZodPromiseDef, refs: Refs): JsonSchema7Type | undefined {
+  return parseDef(def.type._def, refs);
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/readonly.ts

@@ -0,0 +1,7 @@
+import { ZodReadonlyDef } from 'zod';
+import { parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export const parseReadonlyDef = (def: ZodReadonlyDef<any>, refs: Refs) => {
+  return parseDef(def.innerType._def, refs);
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/record.ts

@@ -0,0 +1,73 @@
+import { ZodFirstPartyTypeKind, ZodMapDef, ZodRecordDef, ZodTypeAny } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+import { JsonSchema7EnumType } from './enum';
+import { JsonSchema7ObjectType } from './object';
+import { JsonSchema7StringType, parseStringDef } from './string';
+
+type JsonSchema7RecordPropertyNamesType =
+  | Omit<JsonSchema7StringType, 'type'>
+  | Omit<JsonSchema7EnumType, 'type'>;
+
+export type JsonSchema7RecordType = {
+  type: 'object';
+  additionalProperties: JsonSchema7Type;
+  propertyNames?: JsonSchema7RecordPropertyNamesType;
+};
+
+export function parseRecordDef(
+  def: ZodRecordDef<ZodTypeAny, ZodTypeAny> | ZodMapDef,
+  refs: Refs,
+): JsonSchema7RecordType {
+  if (refs.target === 'openApi3' && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      type: 'object',
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce(
+        (acc: Record<string, JsonSchema7Type>, key: string) => ({
+          ...acc,
+          [key]:
+            parseDef(def.valueType._def, {
+              ...refs,
+              currentPath: [...refs.currentPath, 'properties', key],
+            }) ?? {},
+        }),
+        {},
+      ),
+      additionalProperties: false,
+    } satisfies JsonSchema7ObjectType as any;
+  }
+
+  const schema: JsonSchema7RecordType = {
+    type: 'object',
+    additionalProperties:
+      parseDef(def.valueType._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'additionalProperties'],
+      }) ?? {},
+  };
+
+  if (refs.target === 'openApi3') {
+    return schema;
+  }
+
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+    const keyType: JsonSchema7RecordPropertyNamesType = Object.entries(
+      parseStringDef(def.keyType._def, refs),
+    ).reduce((acc, [key, value]) => (key === 'type' ? acc : { ...acc, [key]: value }), {});
+
+    return {
+      ...schema,
+      propertyNames: keyType,
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values,
+      },
+    };
+  }
+
+  return schema;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/set.ts

@@ -0,0 +1,36 @@
+import { ZodSetDef } from 'zod';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export type JsonSchema7SetType = {
+  type: 'array';
+  uniqueItems: true;
+  items?: JsonSchema7Type | undefined;
+  minItems?: number;
+  maxItems?: number;
+  errorMessage?: ErrorMessages<JsonSchema7SetType>;
+};
+
+export function parseSetDef(def: ZodSetDef, refs: Refs): JsonSchema7SetType {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, 'items'],
+  });
+
+  const schema: JsonSchema7SetType = {
+    type: 'array',
+    uniqueItems: true,
+    items,
+  };
+
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, 'minItems', def.minSize.value, def.minSize.message, refs);
+  }
+
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, 'maxItems', def.maxSize.value, def.maxSize.message, refs);
+  }
+
+  return schema;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/string.ts

@@ -0,0 +1,400 @@
+// @ts-nocheck
+import { ZodStringDef } from 'zod';
+import { ErrorMessages, setResponseValueAndErrors } from '../errorMessages';
+import { Refs } from '../Refs';
+
+let emojiRegex: RegExp | undefined;
+
+/**
+ * Generated from the regular expressions found here as of 2024-05-22:
+ * https://github.com/colinhacks/zod/blob/master/src/types.ts.
+ *
+ * Expressions with /i flag have been changed accordingly.
+ */
+export const zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === undefined) {
+      emojiRegex = RegExp('^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$', 'u');
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+} as const;
+
+export type JsonSchema7StringType = {
+  type: 'string';
+  minLength?: number;
+  maxLength?: number;
+  format?:
+    | 'email'
+    | 'idn-email'
+    | 'uri'
+    | 'uuid'
+    | 'date-time'
+    | 'ipv4'
+    | 'ipv6'
+    | 'date'
+    | 'time'
+    | 'duration';
+  pattern?: string;
+  allOf?: {
+    pattern: string;
+    errorMessage?: ErrorMessages<{ pattern: string }>;
+  }[];
+  anyOf?: {
+    format: string;
+    errorMessage?: ErrorMessages<{ format: string }>;
+  }[];
+  errorMessage?: ErrorMessages<JsonSchema7StringType>;
+  contentEncoding?: string;
+};
+
+export function parseStringDef(def: ZodStringDef, refs: Refs): JsonSchema7StringType {
+  const res: JsonSchema7StringType = {
+    type: 'string',
+  };
+
+  function processPattern(value: string): string {
+    return refs.patternStrategy === 'escape' ? escapeNonAlphaNumeric(value) : value;
+  }
+
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case 'min':
+          setResponseValueAndErrors(
+            res,
+            'minLength',
+            typeof res.minLength === 'number' ? Math.max(res.minLength, check.value) : check.value,
+            check.message,
+            refs,
+          );
+          break;
+        case 'max':
+          setResponseValueAndErrors(
+            res,
+            'maxLength',
+            typeof res.maxLength === 'number' ? Math.min(res.maxLength, check.value) : check.value,
+            check.message,
+            refs,
+          );
+
+          break;
+        case 'email':
+          switch (refs.emailStrategy) {
+            case 'format:email':
+              addFormat(res, 'email', check.message, refs);
+              break;
+            case 'format:idn-email':
+              addFormat(res, 'idn-email', check.message, refs);
+              break;
+            case 'pattern:zod':
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+
+          break;
+        case 'url':
+          addFormat(res, 'uri', check.message, refs);
+          break;
+        case 'uuid':
+          addFormat(res, 'uuid', check.message, refs);
+          break;
+        case 'regex':
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case 'cuid':
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case 'cuid2':
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case 'startsWith':
+          addPattern(res, RegExp(`^${processPattern(check.value)}`), check.message, refs);
+          break;
+        case 'endsWith':
+          addPattern(res, RegExp(`${processPattern(check.value)}$`), check.message, refs);
+          break;
+
+        case 'datetime':
+          addFormat(res, 'date-time', check.message, refs);
+          break;
+        case 'date':
+          addFormat(res, 'date', check.message, refs);
+          break;
+        case 'time':
+          addFormat(res, 'time', check.message, refs);
+          break;
+        case 'duration':
+          addFormat(res, 'duration', check.message, refs);
+          break;
+        case 'length':
+          setResponseValueAndErrors(
+            res,
+            'minLength',
+            typeof res.minLength === 'number' ? Math.max(res.minLength, check.value) : check.value,
+            check.message,
+            refs,
+          );
+          setResponseValueAndErrors(
+            res,
+            'maxLength',
+            typeof res.maxLength === 'number' ? Math.min(res.maxLength, check.value) : check.value,
+            check.message,
+            refs,
+          );
+          break;
+        case 'includes': {
+          addPattern(res, RegExp(processPattern(check.value)), check.message, refs);
+          break;
+        }
+        case 'ip': {
+          if (check.version !== 'v6') {
+            addFormat(res, 'ipv4', check.message, refs);
+          }
+          if (check.version !== 'v4') {
+            addFormat(res, 'ipv6', check.message, refs);
+          }
+          break;
+        }
+        case 'emoji':
+          addPattern(res, zodPatterns.emoji, check.message, refs);
+          break;
+        case 'ulid': {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case 'base64': {
+          switch (refs.base64Strategy) {
+            case 'format:binary': {
+              addFormat(res, 'binary' as any, check.message, refs);
+              break;
+            }
+
+            case 'contentEncoding:base64': {
+              setResponseValueAndErrors(res, 'contentEncoding', 'base64', check.message, refs);
+              break;
+            }
+
+            case 'pattern:zod': {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case 'nanoid': {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+        case 'toLowerCase':
+        case 'toUpperCase':
+        case 'trim':
+          break;
+        default:
+          ((_: never) => {})(check);
+      }
+    }
+  }
+
+  return res;
+}
+
+const escapeNonAlphaNumeric = (value: string) =>
+  Array.from(value)
+    .map((c) => (/[a-zA-Z0-9]/.test(c) ? c : `\\${c}`))
+    .join('');
+
+const addFormat = (
+  schema: JsonSchema7StringType,
+  value: Required<JsonSchema7StringType>['format'],
+  message: string | undefined,
+  refs: Refs,
+) => {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+
+    if (schema.format) {
+      schema.anyOf!.push({
+        format: schema.format,
+        ...(schema.errorMessage &&
+          refs.errorMessages && {
+            errorMessage: { format: schema.errorMessage.format },
+          }),
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+
+    schema.anyOf!.push({
+      format: value,
+      ...(message && refs.errorMessages && { errorMessage: { format: message } }),
+    });
+  } else {
+    setResponseValueAndErrors(schema, 'format', value, message, refs);
+  }
+};
+
+const addPattern = (
+  schema: JsonSchema7StringType,
+  regex: RegExp | (() => RegExp),
+  message: string | undefined,
+  refs: Refs,
+) => {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+
+    if (schema.pattern) {
+      schema.allOf!.push({
+        pattern: schema.pattern,
+        ...(schema.errorMessage &&
+          refs.errorMessages && {
+            errorMessage: { pattern: schema.errorMessage.pattern },
+          }),
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+
+    schema.allOf!.push({
+      pattern: processRegExp(regex, refs),
+      ...(message && refs.errorMessages && { errorMessage: { pattern: message } }),
+    });
+  } else {
+    setResponseValueAndErrors(schema, 'pattern', processRegExp(regex, refs), message, refs);
+  }
+};
+
+// Mutate z.string.regex() in a best attempt to accommodate for regex flags when applyRegexFlags is true
+const processRegExp = (regexOrFunction: RegExp | (() => RegExp), refs: Refs): string => {
+  const regex = typeof regexOrFunction === 'function' ? regexOrFunction() : regexOrFunction;
+  if (!refs.applyRegexFlags || !regex.flags) return regex.source;
+
+  // Currently handled flags
+  const flags = {
+    i: regex.flags.includes('i'), // Case-insensitive
+    m: regex.flags.includes('m'), // `^` and `$` matches adjacent to newline characters
+    s: regex.flags.includes('s'), // `.` matches newlines
+  };
+
+  // The general principle here is to step through each character, one at a time, applying mutations as flags require. We keep track when the current character is escaped, and when it's inside a group /like [this]/ or (also) a range like /[a-z]/. The following is fairly brittle imperative code; edit at your peril!
+
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = '';
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === '-' && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+
+    if (flags.m) {
+      if (source[i] === '^') {
+        pattern += `(^|(?<=[\r\n]))`;
+        continue;
+      } else if (source[i] === '$') {
+        pattern += `($|(?=[\r\n]))`;
+        continue;
+      }
+    }
+
+    if (flags.s && source[i] === '.') {
+      pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
+      continue;
+    }
+
+    pattern += source[i];
+    if (source[i] === '\\') {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === ']') {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === '[') {
+      inCharGroup = true;
+    }
+  }
+
+  try {
+    const regexTest = new RegExp(pattern);
+  } catch {
+    console.warn(
+      `Could not convert regex pattern at ${refs.currentPath.join(
+        '/',
+      )} to a flag-independent form! Falling back to the flag-ignorant source`,
+    );
+    return regex.source;
+  }
+
+  return pattern;
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/tuple.ts

@@ -0,0 +1,54 @@
+import { ZodTupleDef, ZodTupleItems, ZodTypeAny } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export type JsonSchema7TupleType = {
+  type: 'array';
+  minItems: number;
+  items: JsonSchema7Type[];
+} & (
+  | {
+      maxItems: number;
+    }
+  | {
+      additionalItems?: JsonSchema7Type | undefined;
+    }
+);
+
+export function parseTupleDef(
+  def: ZodTupleDef<ZodTupleItems | [], ZodTypeAny | null>,
+  refs: Refs,
+): JsonSchema7TupleType {
+  if (def.rest) {
+    return {
+      type: 'array',
+      minItems: def.items.length,
+      items: def.items
+        .map((x, i) =>
+          parseDef(x._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, 'items', `${i}`],
+          }),
+        )
+        .reduce((acc: JsonSchema7Type[], x) => (x === undefined ? acc : [...acc, x]), []),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'additionalItems'],
+      }),
+    };
+  } else {
+    return {
+      type: 'array',
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items
+        .map((x, i) =>
+          parseDef(x._def, {
+            ...refs,
+            currentPath: [...refs.currentPath, 'items', `${i}`],
+          }),
+        )
+        .reduce((acc: JsonSchema7Type[], x) => (x === undefined ? acc : [...acc, x]), []),
+    };
+  }
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/undefined.ts

@@ -0,0 +1,9 @@
+export type JsonSchema7UndefinedType = {
+  not: {};
+};
+
+export function parseUndefinedDef(): JsonSchema7UndefinedType {
+  return {
+    not: {},
+  };
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/union.ts

@@ -0,0 +1,119 @@
+import { ZodDiscriminatedUnionDef, ZodLiteralDef, ZodTypeAny, ZodUnionDef } from 'zod';
+import { JsonSchema7Type, parseDef } from '../parseDef';
+import { Refs } from '../Refs';
+
+export const primitiveMappings = {
+  ZodString: 'string',
+  ZodNumber: 'number',
+  ZodBigInt: 'integer',
+  ZodBoolean: 'boolean',
+  ZodNull: 'null',
+} as const;
+type ZodPrimitive = keyof typeof primitiveMappings;
+type JsonSchema7Primitive = (typeof primitiveMappings)[keyof typeof primitiveMappings];
+
+export type JsonSchema7UnionType = JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType;
+
+type JsonSchema7PrimitiveUnionType =
+  | {
+      type: JsonSchema7Primitive | JsonSchema7Primitive[];
+    }
+  | {
+      type: JsonSchema7Primitive | JsonSchema7Primitive[];
+      enum: (string | number | bigint | boolean | null)[];
+    };
+
+type JsonSchema7AnyOfType = {
+  anyOf: JsonSchema7Type[];
+};
+
+export function parseUnionDef(
+  def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,
+  refs: Refs,
+): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined {
+  if (refs.target === 'openApi3') return asAnyOf(def, refs);
+
+  const options: readonly ZodTypeAny[] =
+    def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+
+  // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
+  if (
+    options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))
+  ) {
+    // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
+
+    const types = options.reduce((types: JsonSchema7Primitive[], x) => {
+      const type = primitiveMappings[x._def.typeName as ZodPrimitive]; //Can be safely casted due to row 43
+      return type && !types.includes(type) ? [...types, type] : types;
+    }, []);
+
+    return {
+      type: types.length > 1 ? types : types[0]!,
+    };
+  } else if (options.every((x) => x._def.typeName === 'ZodLiteral' && !x.description)) {
+    // all options literals
+
+    const types = options.reduce((acc: JsonSchema7Primitive[], x: { _def: ZodLiteralDef }) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+          return [...acc, type];
+        case 'bigint':
+          return [...acc, 'integer' as const];
+        case 'object':
+          if (x._def.value === null) return [...acc, 'null' as const];
+        case 'symbol':
+        case 'undefined':
+        case 'function':
+        default:
+          return acc;
+      }
+    }, []);
+
+    if (types.length === options.length) {
+      // all the literals are primitive, as far as null can be considered primitive
+
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0]!,
+        enum: options.reduce(
+          (acc, x) => {
+            return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+          },
+          [] as (string | number | bigint | boolean | null)[],
+        ),
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === 'ZodEnum')) {
+    return {
+      type: 'string',
+      enum: options.reduce(
+        (acc: string[], x) => [...acc, ...x._def.values.filter((x: string) => !acc.includes(x))],
+        [],
+      ),
+    };
+  }
+
+  return asAnyOf(def, refs);
+}
+
+const asAnyOf = (
+  def: ZodUnionDef | ZodDiscriminatedUnionDef<any, any>,
+  refs: Refs,
+): JsonSchema7PrimitiveUnionType | JsonSchema7AnyOfType | undefined => {
+  const anyOf = ((def.options instanceof Map ? Array.from(def.options.values()) : def.options) as any[])
+    .map((x, i) =>
+      parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, 'anyOf', `${i}`],
+      }),
+    )
+    .filter(
+      (x): x is JsonSchema7Type =>
+        !!x && (!refs.strictUnions || (typeof x === 'object' && Object.keys(x).length > 0)),
+    );
+
+  return anyOf.length ? { anyOf } : undefined;
+};

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/parsers/unknown.ts

@@ -0,0 +1,5 @@
+export type JsonSchema7UnknownType = {};
+
+export function parseUnknownDef(): JsonSchema7UnknownType {
+  return {};
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/util.ts

@@ -0,0 +1,11 @@
+import type { ZodSchema, ZodTypeDef } from 'zod';
+
+export const zodDef = (zodSchema: ZodSchema | ZodTypeDef): ZodTypeDef => {
+  return '_def' in zodSchema ? zodSchema._def : zodSchema;
+};
+
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/_vendor/zod-to-json-schema/zodToJsonSchema.ts

@@ -0,0 +1,120 @@
+import { ZodSchema } from 'zod';
+import { Options, Targets } from './Options';
+import { JsonSchema7Type, parseDef } from './parseDef';
+import { getRefs } from './Refs';
+import { zodDef, isEmptyObj } from './util';
+
+const zodToJsonSchema = <Target extends Targets = 'jsonSchema7'>(
+  schema: ZodSchema<any>,
+  options?: Partial<Options<Target>> | string,
+): (Target extends 'jsonSchema7' ? JsonSchema7Type : object) & {
+  $schema?: string;
+  definitions?: {
+    [key: string]: Target extends 'jsonSchema7' ? JsonSchema7Type
+    : Target extends 'jsonSchema2019-09' ? JsonSchema7Type
+    : object;
+  };
+} => {
+  const refs = getRefs(options);
+
+  const name =
+    typeof options === 'string' ? options
+    : options?.nameStrategy === 'title' ? undefined
+    : options?.name;
+
+  const main =
+    parseDef(
+      schema._def,
+      name === undefined ? refs : (
+        {
+          ...refs,
+          currentPath: [...refs.basePath, refs.definitionPath, name],
+        }
+      ),
+      false,
+    ) ?? {};
+
+  const title =
+    typeof options === 'object' && options.name !== undefined && options.nameStrategy === 'title' ?
+      options.name
+    : undefined;
+
+  if (title !== undefined) {
+    main.title = title;
+  }
+
+  const definitions = (() => {
+    if (isEmptyObj(refs.definitions)) {
+      return undefined;
+    }
+
+    const definitions: Record<string, any> = {};
+    const processedDefinitions = new Set();
+
+    // the call to `parseDef()` here might itself add more entries to `.definitions`
+    // so we need to continually evaluate definitions until we've resolved all of them
+    //
+    // we have a generous iteration limit here to avoid blowing up the stack if there
+    // are any bugs that would otherwise result in us iterating indefinitely
+    for (let i = 0; i < 500; i++) {
+      const newDefinitions = Object.entries(refs.definitions).filter(
+        ([key]) => !processedDefinitions.has(key),
+      );
+      if (newDefinitions.length === 0) break;
+
+      for (const [key, schema] of newDefinitions) {
+        definitions[key] =
+          parseDef(
+            zodDef(schema),
+            { ...refs, currentPath: [...refs.basePath, refs.definitionPath, key] },
+            true,
+          ) ?? {};
+        processedDefinitions.add(key);
+      }
+    }
+
+    return definitions;
+  })();
+
+  const combined: ReturnType<typeof zodToJsonSchema<Target>> =
+    name === undefined ?
+      definitions ?
+        {
+          ...main,
+          [refs.definitionPath]: definitions,
+        }
+      : main
+    : refs.nameStrategy === 'duplicate-ref' ?
+      {
+        ...main,
+        ...(definitions || refs.seenRefs.size ?
+          {
+            [refs.definitionPath]: {
+              ...definitions,
+              // only actually duplicate the schema definition if it was ever referenced
+              // otherwise the duplication is completely pointless
+              ...(refs.seenRefs.size ? { [name]: main } : undefined),
+            },
+          }
+        : undefined),
+      }
+    : {
+        $ref: [...(refs.$refStrategy === 'relative' ? [] : refs.basePath), refs.definitionPath, name].join(
+          '/',
+        ),
+        [refs.definitionPath]: {
+          ...definitions,
+          [name]: main,
+        },
+      };
+
+  if (refs.target === 'jsonSchema7') {
+    combined.$schema = 'http://json-schema.org/draft-07/schema#';
+  } else if (refs.target === 'jsonSchema2019-09') {
+    combined.$schema = 'https://json-schema.org/draft/2019-09/schema#';
+  }
+
+  return combined;
+};
+
+export { zodToJsonSchema };

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/beta/realtime/index.ts

@@ -0,0 +1 @@
+export { OpenAIRealtimeError } from './internal-base';

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/beta/realtime/internal-base.ts

@@ -0,0 +1,93 @@
+import { RealtimeClientEvent, RealtimeServerEvent, ErrorEvent } from '../../resources/beta/realtime/realtime';
+import { EventEmitter } from '../../lib/EventEmitter';
+import { OpenAIError } from '../../error';
+import OpenAI, { AzureOpenAI } from '../../index';
+
+export class OpenAIRealtimeError extends OpenAIError {
+  /**
+   * The error data that the API sent back in an `error` event.
+   */
+  error?: ErrorEvent.Error | undefined;
+
+  /**
+   * The unique ID of the server event.
+   */
+  event_id?: string | undefined;
+
+  constructor(message: string, event: ErrorEvent | null) {
+    super(message);
+
+    this.error = event?.error;
+    this.event_id = event?.event_id;
+  }
+}
+
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+type RealtimeEvents = Simplify<
+  {
+    event: (event: RealtimeServerEvent) => void;
+    error: (error: OpenAIRealtimeError) => void;
+  } & {
+    [EventType in Exclude<RealtimeServerEvent['type'], 'error'>]: (
+      event: Extract<RealtimeServerEvent, { type: EventType }>,
+    ) => unknown;
+  }
+>;
+
+export abstract class OpenAIRealtimeEmitter extends EventEmitter<RealtimeEvents> {
+  /**
+   * Send an event to the API.
+   */
+  abstract send(event: RealtimeClientEvent): void;
+
+  /**
+   * Close the websocket connection.
+   */
+  abstract close(props?: { code: number; reason: string }): void;
+
+  protected _onError(event: null, message: string, cause: any): void;
+  protected _onError(event: ErrorEvent, message?: string | undefined): void;
+  protected _onError(event: ErrorEvent | null, message?: string | undefined, cause?: any): void {
+    message =
+      event?.error ?
+        `${event.error.message} code=${event.error.code} param=${event.error.param} type=${event.error.type} event_id=${event.error.event_id}`
+      : message ?? 'unknown error';
+
+    if (!this._hasListener('error')) {
+      const error = new OpenAIRealtimeError(
+        message +
+          `\n\nTo resolve these unhandled rejection errors you should bind an \`error\` callback, e.g. \`rt.on('error', (error) => ...)\` `,
+        event,
+      );
+      // @ts-ignore
+      error.cause = cause;
+      Promise.reject(error);
+      return;
+    }
+
+    const error = new OpenAIRealtimeError(message, event);
+    // @ts-ignore
+    error.cause = cause;
+
+    this._emit('error', error);
+  }
+}
+
+export function isAzure(client: Pick<OpenAI, 'apiKey' | 'baseURL'>): client is AzureOpenAI {
+  return client instanceof AzureOpenAI;
+}
+
+export function buildRealtimeURL(client: Pick<OpenAI, 'apiKey' | 'baseURL'>, model: string): URL {
+  const path = '/realtime';
+  const baseURL = client.baseURL;
+  const url = new URL(baseURL + (baseURL.endsWith('/') ? path.slice(1) : path));
+  url.protocol = 'wss';
+  if (isAzure(client)) {
+    url.searchParams.set('api-version', client.apiVersion);
+    url.searchParams.set('deployment', model);
+  } else {
+    url.searchParams.set('model', model);
+  }
+  return url;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/beta/realtime/websocket.ts

@@ -0,0 +1,143 @@
+import { AzureOpenAI, OpenAI } from '../../index';
+import { OpenAIError } from '../../error';
+import type { RealtimeClientEvent, RealtimeServerEvent } from '../../resources/beta/realtime/realtime';
+import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+import { isRunningInBrowser } from '../../internal/detect-platform';
+
+interface MessageEvent {
+  data: string;
+}
+
+type _WebSocket =
+  typeof globalThis extends (
+    {
+      WebSocket: infer ws extends abstract new (...args: any) => any;
+    }
+  ) ?
+    // @ts-ignore
+    InstanceType<ws>
+  : any;
+
+export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
+  url: URL;
+  socket: _WebSocket;
+
+  constructor(
+    props: {
+      model: string;
+      dangerouslyAllowBrowser?: boolean;
+      /**
+       * Callback to mutate the URL, needed for Azure.
+       * @internal
+       */
+      onURL?: (url: URL) => void;
+    },
+    client?: Pick<OpenAI, 'apiKey' | 'baseURL'>,
+  ) {
+    super();
+
+    const dangerouslyAllowBrowser =
+      props.dangerouslyAllowBrowser ??
+      (client as any)?._options?.dangerouslyAllowBrowser ??
+      (client?.apiKey.startsWith('ek_') ? true : null);
+
+    if (!dangerouslyAllowBrowser && isRunningInBrowser()) {
+      throw new OpenAIError(
+        "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\n\nYou can avoid this error by creating an ephemeral session token:\nhttps://platform.openai.com/docs/api-reference/realtime-sessions\n",
+      );
+    }
+
+    client ??= new OpenAI({ dangerouslyAllowBrowser });
+
+    this.url = buildRealtimeURL(client, props.model);
+    props.onURL?.(this.url);
+
+    // @ts-ignore
+    this.socket = new WebSocket(this.url.toString(), [
+      'realtime',
+      ...(isAzure(client) ? [] : [`openai-insecure-api-key.${client.apiKey}`]),
+      'openai-beta.realtime-v1',
+    ]);
+
+    this.socket.addEventListener('message', (websocketEvent: MessageEvent) => {
+      const event = (() => {
+        try {
+          return JSON.parse(websocketEvent.data.toString()) as RealtimeServerEvent;
+        } catch (err) {
+          this._onError(null, 'could not parse websocket event', err);
+          return null;
+        }
+      })();
+
+      if (event) {
+        this._emit('event', event);
+
+        if (event.type === 'error') {
+          this._onError(event);
+        } else {
+          // @ts-expect-error TS isn't smart enough to get the relationship right here
+          this._emit(event.type, event);
+        }
+      }
+    });
+
+    this.socket.addEventListener('error', (event: any) => {
+      this._onError(null, event.message, null);
+    });
+
+    if (isAzure(client)) {
+      if (this.url.searchParams.get('Authorization') !== null) {
+        this.url.searchParams.set('Authorization', '<REDACTED>');
+      } else {
+        this.url.searchParams.set('api-key', '<REDACTED>');
+      }
+    }
+  }
+
+  static async azure(
+    client: Pick<AzureOpenAI, '_getAzureADToken' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
+    options: { deploymentName?: string; dangerouslyAllowBrowser?: boolean } = {},
+  ): Promise<OpenAIRealtimeWebSocket> {
+    const token = await client._getAzureADToken();
+    function onURL(url: URL) {
+      if (client.apiKey !== '<Missing Key>') {
+        url.searchParams.set('api-key', client.apiKey);
+      } else {
+        if (token) {
+          url.searchParams.set('Authorization', `Bearer ${token}`);
+        } else {
+          throw new Error('AzureOpenAI is not instantiated correctly. No API key or token provided.');
+        }
+      }
+    }
+    const deploymentName = options.deploymentName ?? client.deploymentName;
+    if (!deploymentName) {
+      throw new Error('No deployment name provided');
+    }
+    const { dangerouslyAllowBrowser } = options;
+    return new OpenAIRealtimeWebSocket(
+      {
+        model: deploymentName,
+        onURL,
+        ...(dangerouslyAllowBrowser ? { dangerouslyAllowBrowser } : {}),
+      },
+      client,
+    );
+  }
+
+  send(event: RealtimeClientEvent) {
+    try {
+      this.socket.send(JSON.stringify(event));
+    } catch (err) {
+      this._onError(null, 'could not send data', err);
+    }
+  }
+
+  close(props?: { code: number; reason: string }) {
+    try {
+      this.socket.close(props?.code ?? 1000, props?.reason ?? 'OK');
+    } catch (err) {
+      this._onError(null, 'could not close the connection', err);
+    }
+  }
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/beta/realtime/ws.ts

@@ -0,0 +1,96 @@
+import * as WS from 'ws';
+import { AzureOpenAI, OpenAI } from '../../index';
+import type { RealtimeClientEvent, RealtimeServerEvent } from '../../resources/beta/realtime/realtime';
+import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+
+export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
+  url: URL;
+  socket: WS.WebSocket;
+
+  constructor(
+    props: { model: string; options?: WS.ClientOptions | undefined },
+    client?: Pick<OpenAI, 'apiKey' | 'baseURL'>,
+  ) {
+    super();
+    client ??= new OpenAI();
+
+    this.url = buildRealtimeURL(client, props.model);
+    this.socket = new WS.WebSocket(this.url, {
+      ...props.options,
+      headers: {
+        ...props.options?.headers,
+        ...(isAzure(client) ? {} : { Authorization: `Bearer ${client.apiKey}` }),
+        'OpenAI-Beta': 'realtime=v1',
+      },
+    });
+
+    this.socket.on('message', (wsEvent) => {
+      const event = (() => {
+        try {
+          return JSON.parse(wsEvent.toString()) as RealtimeServerEvent;
+        } catch (err) {
+          this._onError(null, 'could not parse websocket event', err);
+          return null;
+        }
+      })();
+
+      if (event) {
+        this._emit('event', event);
+
+        if (event.type === 'error') {
+          this._onError(event);
+        } else {
+          // @ts-expect-error TS isn't smart enough to get the relationship right here
+          this._emit(event.type, event);
+        }
+      }
+    });
+
+    this.socket.on('error', (err) => {
+      this._onError(null, err.message, err);
+    });
+  }
+
+  static async azure(
+    client: Pick<AzureOpenAI, '_getAzureADToken' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
+    options: { deploymentName?: string; options?: WS.ClientOptions | undefined } = {},
+  ): Promise<OpenAIRealtimeWS> {
+    const deploymentName = options.deploymentName ?? client.deploymentName;
+    if (!deploymentName) {
+      throw new Error('No deployment name provided');
+    }
+    return new OpenAIRealtimeWS(
+      { model: deploymentName, options: { headers: await getAzureHeaders(client) } },
+      client,
+    );
+  }
+
+  send(event: RealtimeClientEvent) {
+    try {
+      this.socket.send(JSON.stringify(event));
+    } catch (err) {
+      this._onError(null, 'could not send data', err);
+    }
+  }
+
+  close(props?: { code: number; reason: string }) {
+    try {
+      this.socket.close(props?.code ?? 1000, props?.reason ?? 'OK');
+    } catch (err) {
+      this._onError(null, 'could not close the connection', err);
+    }
+  }
+}
+
+async function getAzureHeaders(client: Pick<AzureOpenAI, '_getAzureADToken' | 'apiKey'>) {
+  if (client.apiKey !== '<Missing Key>') {
+    return { 'api-key': client.apiKey };
+  } else {
+    const token = await client._getAzureADToken();
+    if (token) {
+      return { Authorization: `Bearer ${token}` };
+    } else {
+      throw new Error('AzureOpenAI is not instantiated correctly. No API key or token provided.');
+    }
+  }
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/internal/decoders/line.ts

@@ -0,0 +1,135 @@
+import { concatBytes, decodeUTF8, encodeUTF8 } from '../utils/bytes';
+
+export type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+export class LineDecoder {
+  // prettier-ignore
+  static NEWLINE_CHARS = new Set(['\n', '\r']);
+  static NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+
+  #buffer: Uint8Array;
+  #carriageReturnIndex: number | null;
+
+  constructor() {
+    this.#buffer = new Uint8Array();
+    this.#carriageReturnIndex = null;
+  }
+
+  decode(chunk: Bytes): string[] {
+    if (chunk == null) {
+      return [];
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    this.#buffer = concatBytes([this.#buffer, binaryChunk]);
+
+    const lines: string[] = [];
+    let patternIndex;
+    while ((patternIndex = findNewlineIndex(this.#buffer, this.#carriageReturnIndex)) != null) {
+      if (patternIndex.carriage && this.#carriageReturnIndex == null) {
+        // skip until we either get a corresponding `\n`, a new `\r` or nothing
+        this.#carriageReturnIndex = patternIndex.index;
+        continue;
+      }
+
+      // we got double \r or \rtext\n
+      if (
+        this.#carriageReturnIndex != null &&
+        (patternIndex.index !== this.#carriageReturnIndex + 1 || patternIndex.carriage)
+      ) {
+        lines.push(decodeUTF8(this.#buffer.subarray(0, this.#carriageReturnIndex - 1)));
+        this.#buffer = this.#buffer.subarray(this.#carriageReturnIndex);
+        this.#carriageReturnIndex = null;
+        continue;
+      }
+
+      const endIndex =
+        this.#carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+
+      const line = decodeUTF8(this.#buffer.subarray(0, endIndex));
+      lines.push(line);
+
+      this.#buffer = this.#buffer.subarray(patternIndex.index);
+      this.#carriageReturnIndex = null;
+    }
+
+    return lines;
+  }
+
+  flush(): string[] {
+    if (!this.#buffer.length) {
+      return [];
+    }
+    return this.decode('\n');
+  }
+}
+
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(
+  buffer: Uint8Array,
+  startIndex: number | null,
+): { preceding: number; index: number; carriage: boolean } | null {
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = startIndex ?? 0; i < buffer.length; i++) {
+    if (buffer[i] === newline) {
+      return { preceding: i, index: i + 1, carriage: false };
+    }
+
+    if (buffer[i] === carriage) {
+      return { preceding: i, index: i + 1, carriage: true };
+    }
+  }
+
+  return null;
+}
+
+export function findDoubleNewlineIndex(buffer: Uint8Array): number {
+  // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+  // and returns the index right after the first occurrence of any pattern,
+  // or -1 if none of the patterns are found.
+  const newline = 0x0a; // \n
+  const carriage = 0x0d; // \r
+
+  for (let i = 0; i < buffer.length - 1; i++) {
+    if (buffer[i] === newline && buffer[i + 1] === newline) {
+      // \n\n
+      return i + 2;
+    }
+    if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+      // \r\r
+      return i + 2;
+    }
+    if (
+      buffer[i] === carriage &&
+      buffer[i + 1] === newline &&
+      i + 3 < buffer.length &&
+      buffer[i + 2] === carriage &&
+      buffer[i + 3] === newline
+    ) {
+      // \r\n\r\n
+      return i + 4;
+    }
+  }
+
+  return -1;
+}

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/internal/qs/LICENSE.md

@@ -0,0 +1,13 @@
+BSD 3-Clause License
+
+Copyright (c) 2014, Nathan LaFreniere and other [contributors](https://github.com/puruvj/neoqs/graphs/contributors) All rights reserved.
+
+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.

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/internal/qs/README.md

@@ -0,0 +1,3 @@
+# qs
+
+This is a vendored version of [neoqs](https://github.com/PuruVJ/neoqs) which is a TypeScript rewrite of [qs](https://github.com/ljharb/qs), a query string library.

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/internal/qs/formats.ts

@@ -0,0 +1,10 @@
+import type { Format } from './types';
+
+export const default_format: Format = 'RFC3986';
+export const default_formatter = (v: PropertyKey) => String(v);
+export const formatters: Record<Format, (str: PropertyKey) => string> = {
+  RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
+  RFC3986: default_formatter,
+};
+export const RFC1738 = 'RFC1738';
+export const RFC3986 = 'RFC3986';

platform/aiml/elizabeth/e-1-first_session/claude-code-router/node_modules/openai/src/internal/qs/index.ts

@@ -0,0 +1,13 @@
+import { default_format, formatters, RFC1738, RFC3986 } from './formats';
+
+const formats = {
+  formatters,
+  RFC1738,
+  RFC3986,
+  default: default_format,
+};
+
+export { stringify } from './stringify';
+export { formats };
+
+export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from './types';