初始化仓库

This commit is contained in:
mmc
2025-09-15 10:04:47 +08:00
commit 87a4a76f1b
2576 changed files with 221250 additions and 0 deletions

146
node_modules/openai/src/helpers/audio.ts generated vendored Normal file
View File

@@ -0,0 +1,146 @@
import { spawn } from 'node:child_process';
import { Readable } from 'node:stream';
import { platform, versions } from 'node:process';
import { checkFileSupport } from '../internal/uploads';
const DEFAULT_SAMPLE_RATE = 24000;
const DEFAULT_CHANNELS = 1;
const isNode = Boolean(versions?.node);
const recordingProviders: Record<NodeJS.Platform, string> = {
win32: 'dshow',
darwin: 'avfoundation',
linux: 'alsa',
aix: 'alsa',
android: 'alsa',
freebsd: 'alsa',
haiku: 'alsa',
sunos: 'alsa',
netbsd: 'alsa',
openbsd: 'alsa',
cygwin: 'dshow',
};
function isResponse(stream: NodeJS.ReadableStream | Response | File): stream is Response {
return typeof (stream as any).body !== 'undefined';
}
function isFile(stream: NodeJS.ReadableStream | Response | File): stream is File {
checkFileSupport();
return stream instanceof File;
}
async function nodejsPlayAudio(stream: NodeJS.ReadableStream | Response | File): Promise<void> {
return new Promise((resolve, reject) => {
try {
const ffplay = spawn('ffplay', ['-autoexit', '-nodisp', '-i', 'pipe:0']);
if (isResponse(stream)) {
(stream.body! as any).pipe(ffplay.stdin);
} else if (isFile(stream)) {
Readable.from(stream.stream()).pipe(ffplay.stdin);
} else {
stream.pipe(ffplay.stdin);
}
ffplay.on('close', (code: number) => {
if (code !== 0) {
reject(new Error(`ffplay process exited with code ${code}`));
}
resolve();
});
} catch (error) {
reject(error);
}
});
}
export async function playAudio(input: NodeJS.ReadableStream | Response | File): Promise<void> {
if (isNode) {
return nodejsPlayAudio(input);
}
throw new Error(
'Play audio is not supported in the browser yet. Check out https://npm.im/wavtools as an alternative.',
);
}
type RecordAudioOptions = {
signal?: AbortSignal;
device?: number;
timeout?: number;
};
function nodejsRecordAudio({ signal, device, timeout }: RecordAudioOptions = {}): Promise<File> {
checkFileSupport();
return new Promise((resolve, reject) => {
const data: any[] = [];
const provider = recordingProviders[platform];
try {
const ffmpeg = spawn(
'ffmpeg',
[
'-f',
provider,
'-i',
`:${device ?? 0}`, // default audio input device; adjust as needed
'-ar',
DEFAULT_SAMPLE_RATE.toString(),
'-ac',
DEFAULT_CHANNELS.toString(),
'-f',
'wav',
'pipe:1',
],
{
stdio: ['ignore', 'pipe', 'pipe'],
},
);
ffmpeg.stdout.on('data', (chunk) => {
data.push(chunk);
});
ffmpeg.on('error', (error) => {
console.error(error);
reject(error);
});
ffmpeg.on('close', (code) => {
returnData();
});
function returnData() {
const audioBuffer = Buffer.concat(data);
const audioFile = new File([audioBuffer], 'audio.wav', { type: 'audio/wav' });
resolve(audioFile);
}
if (typeof timeout === 'number' && timeout > 0) {
const internalSignal = AbortSignal.timeout(timeout);
internalSignal.addEventListener('abort', () => {
ffmpeg.kill('SIGTERM');
});
}
if (signal) {
signal.addEventListener('abort', () => {
ffmpeg.kill('SIGTERM');
});
}
} catch (error) {
reject(error);
}
});
}
export async function recordAudio(options: RecordAudioOptions = {}) {
if (isNode) {
return nodejsRecordAudio(options);
}
throw new Error(
'Record audio is not supported in the browser. Check out https://npm.im/wavtools as an alternative.',
);
}

154
node_modules/openai/src/helpers/zod.ts generated vendored Normal file
View File

@@ -0,0 +1,154 @@
import { ResponseFormatJSONSchema } from '../resources/index';
import type { infer as zodInfer, ZodType } from 'zod';
import {
AutoParseableResponseFormat,
AutoParseableTextFormat,
AutoParseableTool,
makeParseableResponseFormat,
makeParseableTextFormat,
makeParseableTool,
} from '../lib/parser';
import { zodToJsonSchema as _zodToJsonSchema } from '../_vendor/zod-to-json-schema';
import { AutoParseableResponseTool, makeParseableResponseTool } from '../lib/ResponsesParser';
import { type ResponseFormatTextJSONSchemaConfig } from '../resources/responses/responses';
function zodToJsonSchema(schema: ZodType, options: { name: string }): Record<string, unknown> {
return _zodToJsonSchema(schema, {
openaiStrictMode: true,
name: options.name,
nameStrategy: 'duplicate-ref',
$refStrategy: 'extract-to-root',
nullableStrategy: 'property',
});
}
/**
* Creates a chat completion `JSONSchema` response format object from
* the given Zod schema.
*
* If this is passed to the `.parse()`, `.stream()` or `.runTools()`
* chat completion methods then the response message will contain a
* `.parsed` property that is the result of parsing the content with
* the given Zod object.
*
* ```ts
* const completion = await client.chat.completions.parse({
* model: 'gpt-4o-2024-08-06',
* messages: [
* { role: 'system', content: 'You are a helpful math tutor.' },
* { role: 'user', content: 'solve 8x + 31 = 2' },
* ],
* response_format: zodResponseFormat(
* z.object({
* steps: z.array(z.object({
* explanation: z.string(),
* answer: z.string(),
* })),
* final_answer: z.string(),
* }),
* 'math_answer',
* ),
* });
* const message = completion.choices[0]?.message;
* if (message?.parsed) {
* console.log(message.parsed);
* console.log(message.parsed.final_answer);
* }
* ```
*
* This can be passed directly to the `.create()` method but will not
* result in any automatic parsing, you'll have to parse the response yourself.
*/
export function zodResponseFormat<ZodInput extends ZodType>(
zodObject: ZodInput,
name: string,
props?: Omit<ResponseFormatJSONSchema.JSONSchema, 'schema' | 'strict' | 'name'>,
): AutoParseableResponseFormat<zodInfer<ZodInput>> {
return makeParseableResponseFormat(
{
type: 'json_schema',
json_schema: {
...props,
name,
strict: true,
schema: zodToJsonSchema(zodObject, { name }),
},
},
(content) => zodObject.parse(JSON.parse(content)),
);
}
export function zodTextFormat<ZodInput extends ZodType>(
zodObject: ZodInput,
name: string,
props?: Omit<ResponseFormatTextJSONSchemaConfig, 'schema' | 'type' | 'strict' | 'name'>,
): AutoParseableTextFormat<zodInfer<ZodInput>> {
return makeParseableTextFormat(
{
type: 'json_schema',
...props,
name,
strict: true,
schema: zodToJsonSchema(zodObject, { name }),
},
(content) => zodObject.parse(JSON.parse(content)),
);
}
/**
* Creates a chat completion `function` tool that can be invoked
* automatically by the chat completion `.runTools()` method or automatically
* parsed by `.parse()` / `.stream()`.
*/
export function zodFunction<Parameters extends ZodType>(options: {
name: string;
parameters: Parameters;
function?: ((args: zodInfer<Parameters>) => unknown | Promise<unknown>) | undefined;
description?: string | undefined;
}): AutoParseableTool<{
arguments: Parameters;
name: string;
function: (args: zodInfer<Parameters>) => unknown;
}> {
// @ts-expect-error TODO
return makeParseableTool<any>(
{
type: 'function',
function: {
name: options.name,
parameters: zodToJsonSchema(options.parameters, { name: options.name }),
strict: true,
...(options.description ? { description: options.description } : undefined),
},
},
{
callback: options.function,
parser: (args) => options.parameters.parse(JSON.parse(args)),
},
);
}
export function zodResponsesFunction<Parameters extends ZodType>(options: {
name: string;
parameters: Parameters;
function?: ((args: zodInfer<Parameters>) => unknown | Promise<unknown>) | undefined;
description?: string | undefined;
}): AutoParseableResponseTool<{
arguments: Parameters;
name: string;
function: (args: zodInfer<Parameters>) => unknown;
}> {
return makeParseableResponseTool<any>(
{
type: 'function',
name: options.name,
parameters: zodToJsonSchema(options.parameters, { name: options.name }),
strict: true,
...(options.description ? { description: options.description } : undefined),
},
{
callback: options.function,
parser: (args) => options.parameters.parse(JSON.parse(args)),
},
);
}