大语言模型下的JSON数据格式交互

你是一个翻译大师，我给你一段中文，你翻译为英文、日文、韩文。返回JSON格式，包含三个属性，分别为：english、japanese、korean。现在开始翻译，中文内容是：阿里巴巴是一家伟大的公司。

```json{"english": "Alibaba is a great company.","japanese": "アリババは素晴らしい会社です。","korean": "알리바바는 위대한 회사입니다."}```

const match = /```(json)?(.*)```/s.exec(s);if (!match) {return JSON.parse(s);} else {return JSON.parse(match[2]);}

Here is the translation in JSON format:
{"english": "Alibaba is a great company.","japanese": "アルイババは偉大な企業です。","korean": "알리바바는 위대한 기업입니다."}
Let me know if you need anything else! ?

import OpenAI from "openai";
const openai = new OpenAI();
async function main() {const completion = await openai.chat.completions.create({messages: [{role: "system",content: "You are a helpful assistant designed to output JSON.",},{ role: "user", content: "Who won the world series in 2020?" },],model: "gpt-3.5-turbo-0125",response_format: { type: "json_object" },});console.log(completion.choices[0].message.content);}
main();

"content": "{\"winner\": \"Los Angeles Dodgers\"}"`

const messages = [{ role: 'system', content: 'You are a helpful assistant.' },{role: 'user',content: '给发一封邮件，主题是祝福他生日快乐，内容是祝福语',},];const response = await openai.chat.completions.create({messages: messages,model: 'gpt-4-1106-preview',tools: [{type: 'function',function: {name: 'send_email',description: 'Send an email',parameters: {type: 'object',properties: {to: {type: 'string',description: 'Email address of the recipient',},subject: {type: 'string',description: 'Subject of the email',},body: {type: 'string',description: 'Body of the email',},},required: ['to', 'body'],}}}],});const responseMessage = response.choices[0].message;console.log(JSON.stringify(responseMessage));

{"content": null,"role": "assistant","tool_calls": [{"function": {"arguments": "{\"to\":\"\",\"subject\":\"祝你生日快乐\",\"body\":\"亲爱的无弃，祝你生日快乐！愿你新的一年里，幸福安康、梦想成真。\"}","name": "send_email"},"id": "call_JqC8t3jlmg25uDJg7mwHvvOG","type": "function"}]}

import { z } from "zod";
const User = z.object({username: z.string(),});
User.parseAsync({ username: "无弃" });// => { username: "无弃" }User.parseAsync({ name: "无弃" }); // => throws ZodError

import { z } from "zod";import { StructuredOutputParser } from "langchain/output_parsers";
const parser = StructuredOutputParser.fromZodSchema(z.object({answer: z.string().describe("answer to the user's question"),sources: z.array(z.string()).describe("sources used to answer the question, should be websites."),}));console.log(parser.getFormatInstructions());/*Answer the users question as best as possible.You must format your output as a JSON value that adheres to a given "JSON Schema" instance.
"JSON Schema" is a declarative language that allows you to annotate and validate JSON documents.
For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}}would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings.Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.
Your output will be parsed and type-checked according to the provided schema instance, so make sure all fields in your output match the schema exactly and there are no trailing commas!
Here is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:```{"type":"object","properties":{"answer":{"type":"string","description":"answer to the user's question"},"sources":{"type":"array","items":{"type":"string"},"description":"sources used to answer the question, should be websites."}},"required":["answer","sources"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}```
What is the capital of France?*/

import { z } from "zod";import { OpenAI } from "@langchain/openai";import { RunnableSequence } from "@langchain/core/runnables";import { StructuredOutputParser } from "langchain/output_parsers";import { PromptTemplate } from "@langchain/core/prompts";
const chain = RunnableSequence.from([PromptTemplate.fromTemplate("Answer the users question as best as possible.\n{format_instructions}\n{question}"),new OpenAI({ temperature: 0 }),parser,]);
const response = await chain.invoke({question: "What is the capital of France?",format_instructions: parser.getFormatInstructions(),});
console.log(response);/*{ answer: 'Paris', sources: [ 'https://en.wikipedia.org/wiki/Paris' ] }*/

你是翻译专家，负责把输入内容从中文翻译成英文，需要翻译的内容为:你好。You must format your output as a JSON value that adheres to a given "JSON Schema" instance."JSON Schema" is a declarative language that allows you to annotate and validate JSON documents.For example, the example "JSON Schema" instance {{"properties": {{"foo": {{"description": "a list of test words", "type": "array", "items": {{"type": "string"}}}}}}, "required": ["foo"]}}}}would match an object with one required property, "foo". The "type" property specifies "foo" must be an "array", and the "description" property semantically describes it as "a list of test words". The items within "foo" must be strings.Thus, the object {{"foo": ["bar", "baz"]}} is a well-formatted instance of this example "JSON Schema". The object {{"properties": {{"foo": ["bar", "baz"]}}}} is not well-formatted.Your output will be parsed and type-checked according to the provided schema instance, so make sure all fields in your output match the schema exactly and there are no trailing commas!Here is the JSON Schema instance your output must adhere to. Include the enclosing markdown codeblock:{"type":"object","properties":{"output":{"type":"string","description":"翻译后的结果"}},"required":["output"],"additionalProperties":false,"$schema":"http://json-schema.org/draft-07/schema#"}

```json{"type": "object","properties": {"output": {"type": "string","description": "翻译后的结果"}},"required": ["output"],"additionalProperties": false,"$schema": "http://json-schema.org/draft-07/schema#"}``````json{"output": "Hello."}```

你是一个翻译大师，我给你一段中文，你翻译为英文、日文、韩文。返回JSON格式，符合typescript的interface：interface Response {english: string;japanese:string;korean: string;}现在开始翻译，中文内容是：阿里巴巴是一家伟大的公司。

import { TypeChat } from 'typechat';
interface CoffeeOrder {type: string;size: string;extras: string[];}
const typeChat = new TypeChat<CoffeeOrder>();
// 用户输入const userInput = "I would like a large cappuccino with extra foam and a shot of vanilla.";
// 使用 TypeChat 获取一个结构化的数据const order = typeChat.process(userInput);console.log(order);
// 输出: { type: 'cappuccino', size: 'large', extras: ['extra foam', 'shot of vanilla'] }

你是一个数据mock专家，我给你一段数据描述，你生成一份mock数据。现在数据结构如下：```[{"path":"param_0","text":"应用名","isArray":false},{"path":"param_1","text":"应用图标","isArray":false},{"path":"param_2","text":"应用描述","isArray":false}]```请生成mock数据。

{"param_0":"oa审批","param_1":"https://via.placeholder.com/300x200","param_2":"oa审批是一个表单流程低码搭建平台，可以快速搭建一个审批流"}

// zodz.object({mockData: z.string().describe("mock数据"),})// typechatinterface IResponse {mockData: string; // mock数据}

// 正确：{"mockData": "{\"param_0\":\"oa审批\",\"param_1\":\"https://via.placeholder.com/300x200\",\"param_2\":\"oa审批是一个表单流程低码搭建平台，可以快速搭建一个审批流\"}"}// 错误,会导致校验不通过，因为mockdata的值不是一个string{"mockData": {"param_0":"oa审批","param_1":"https://via.placeholder.com/300x200","param_2":"oa审批是一个表单流程低码搭建平台，可以快速搭建一个审批流"}}

你是一个数据mock助手，我给你一个生成数据的变量描述，请帮我按照需求生成mock数据。我给你举几个例子：举例一：------输入：<interface>[{"path":"paramArray_0","text":"返回内容","isArray":true,"children":[{"path":"param_0","text":"商品标题","isArray":false},{"path":"param_1","text":"商品图片","isArray":false},{"path":"param_2","text":"商品价格","isArray":false},{"path":"param_3","text":"商品链接","isArray":false}]},{"path":"param_4","text":"今天（流程触发时间）","isArray":false}]<interface>推理过程：paramArray_0代表返回内容，isArray为true，是一个数组，子级中，param_0代表商品标题，param_1代表商品图片，是一个http连接，param_2代表商品价格，应该是一个数字字符串，param_3代表商品链接，是一个http链接，param_4代表今日时间，是一个格式化的时间。输出mock数据：```json{"paramArray_0":[{"param_0":"苹果iPhone 14 Pro Max 5G智能手机 256GB 深空黑","param_1":"https://via.placeholder.com/300x200","param_2":"8999.99","param_3":"https://item.taobao.com/item.htm?id=37221120302"},{"param_0":"三星Galaxy S23 Ultra 5G旗舰手机 12GB+256GB 幻影黑","param_1":"https://via.placeholder.com/300x200","param_2":"8999.99","param_3":"https://item.taobao.com/item.htm?id=525519066299"}],"param_4":"2024-04-16 21:07:45"}```------举例二：------输入：<interface>[{"path":"param_0","text":"应用名","isArray":false},{"path":"param_1","text":"应用图标","isArray":false},{"path":"param_2","text":"应用描述","isArray":false}]<interface>推理过程：param_0代表应用名；param_1代表应用图标，应该是一个图片http链接；param_2代表应用描述。输出mock数据：```json{"param_0":"oa审批","param_1":"https://via.placeholder.com/300x200","param_2":"oa审批是一个表单流程低码搭建平台，可以快速搭建一个审批流"}```------现在正式开始：输入：<interface>[{"path":"paramArray_0","originkey":"$.node_service.payload","text":"返回内容","pathText":"搜索商品.返回内容","isArray":true,"children":[{"path":"param_0","text":"商品标题","isArray":false},{"path":"param_1","text":"商品价格","isArray":false},{"path":"param_2","text":"商品图片","isArray":false},{"path":"param_3","text":"商品链接","isArray":false}]}]<interface>请生成mock数据，生成的数据必须符合变量描述，只返回mock数据，不要返回其他内容。

```json{"paramArray_0": [{"param_0": "Apple iPhone 14 Pro","param_1": "5999.99","param_2": "https://via.placeholder.com/300x200","param_3": "https://item.taobao.com/item.htm?id=1111"},{"param_0": "Samsung Galaxy S23","param_1": "6999.99","param_2": "https://via.placeholder.com/300x200","param_3": "https://item.taobao.com/item.htm?id=2222"}]}```

[{% for item in paramArray_0 %}{\"type\": \"mediaContent\",\"value\": {\"link\": \"{{ item.param_3 }}\",\"title\": \"{{ item.param_0 }}\",\"cover\": \"{{ item.param_1 }}\",\"tagList\": [\"￥{{ item.param_2 }}\"]}},{% endfor %}]

import nunjucks from 'nunjucks';
const data = nunjucks.renderString(`[{% for item in paramArray_0 %}{\"type\": \"mediaContent\",\"value\": {\"link\": \"{{ item.param_3 }}\",\"title\": \"{{ item.param_0 }}\",\"cover\": \"{{ item.param_1 }}\",\"tagList\": [\"￥{{ item.param_2 }}\"]}},{% endfor %}]`,{"paramArray_0": [{"param_0": "Apple iPhone 14 Pro","param_1": "5999.99","param_2": "https://via.placeholder.com/300x200","param_3": "https://item.taobao.com/item.htm?id=1111"},{"param_0": "Samsung Galaxy S23","param_1": "6999.99","param_2": "https://via.placeholder.com/300x200","param_3": "https://item.taobao.com/item.htm?id=2222"}]} );

{"propertyName": "propertyValue"}

{"mockData": "{\"param_0\":\"oa审批\",\"param_1\":\"https://via.placeholder.com/300x200\",\"param_2\":\"oa审批是一个表单流程低码搭建平台，可以快速搭建一个审批流\"}"}

import JSON5 from 'json5'；
const obj = JSON5.parse('{unquoted:"key",trailing:"comma",}');

type LiteralValue = boolean | null;type PrimitiveValue = number | LiteralValue | string;type JSONArray = (PrimitiveValue | JSONArray | JSONObject)[];type JSONObject = { [key: string]: PrimitiveValue | JSONArray | JSONObject };type JSONValue = PrimitiveValue | JSONArray | JSONObject;
type ParseResult<T extends JSONValue> = {success: boolean;
// 如果转换成功，它的值表示值的最后一位在整个JSON字符串的位置// 如果失败，它表示失败的那个位置position: number;value?: T;};
enum MaybeJSONValue {LITERAL,NUMBER,STRING,ARRAY,OBJECT,UNKNOWN,}
const ESCAPE_CHAR_MAP: {[key: string]: string;} = {'\\\\': '\\','\\"': '"','\\b': '\b','\\f': '\f','\\n': '\n','\\r': '\r',};
export class JSONParserService {private input: string;
private parseLiteral(cur = 0): ParseResult<LiteralValue> {cur = this.skipWhitespace(cur);if (this.input[cur] === 't') {if (this.input.substring(cur, cur + 4) === 'true') {return {success: true,position: cur + 3,value: true,};}} else if (this.input[cur] === 'f') {if (this.input.substring(cur, cur + 5) === 'false') {return {success: true,position: cur + 4,value: false,};}} else if (this.input[cur] === 'n') {if (this.input.substring(cur, cur + 4) === 'null') {return {success: true,position: cur + 3,value: null,};}}return {success: false,position: cur,};}
private parseNumber(cur = 0): ParseResult<number> {cur = this.skipWhitespace(cur);const parseDigit = (cur: number, allowLeadingZero: boolean) => {let dights = '';if (!allowLeadingZero && this.input[cur] === '0') {return ['', cur] as const;}
let allowZero = allowLeadingZero;while ((allowZero ? '0' : '1') <= this.input[cur] &&this.input[cur] <= '9') {dights += this.input[cur];cur++;allowZero = true;}return [dights, cur - 1] as const;};
let value = '';let isFloat = false;
// 负号if (this.input[cur] === '-') {value += '-';cur++;}
// 小数点前的数字if (this.input[cur] === '0') {value += '0';} else {const [dights, endCur] = parseDigit(cur, false);
// 非法情形1，以非数字开头或以多个0开头if (dights.length === 0) {return {success: false,position: cur,};}
value += dights;cur = endCur;}
// 小数点if (this.input[cur + 1] === '.') {isFloat = true;value += '.';cur++;// 此时input[cur]是小数点
// 移动到小数点之后的位置const [dights, endCur] = parseDigit(cur + 1, true);// 非法情形2，小数点后没有数字了if (dights.length === 0) {return {success: false,position: cur,};}value += dights;cur = endCur;}
// 科学计数法的指数if (this.input[cur + 1] === 'e' || this.input[cur + 1] === 'E') {isFloat = true;value += 'e';cur++;// 此时this.input[cur]是e或Eif (this.input[cur + 1] === '+' || this.input[cur + 1] === '-') {cur++;value += this.input[cur];// 此时this.input[cur]是符号}
const [dights, endCur] = parseDigit(cur + 1, false);// 非法情形3，E后面没有指数if (dights.length === 0) {return {success: false,position: cur,};}value += dights;cur = endCur;}
return {success: true,value: isFloat ? parseFloat(value) : parseInt(value, 10),position: cur,};}
private parseString(cur = 0): ParseResult<string> {cur = this.skipWhitespace(cur);if (this.input[cur] !== '"') {return {success: true,position: cur,};}
let value = '';cur++;while (this.input[cur] !== undefined && this.input[cur] !== '"') {if (this.input[cur] === '\\') {const maybeEscapeChar = this.input.slice(cur, cur + 2);const ch = ESCAPE_CHAR_MAP[maybeEscapeChar];if (ch) {value += ch;cur += 2;continue;} else {return {success: false,position: cur,};}}
value += this.input[cur];cur++;}
return {success: true,position: cur,value,};}
private skipWhitespace(cur = 0): number {const isWhitespace = (cur: string) => {return (cur === '\n' ||cur === '\r' ||cur === '\t' ||cur === '\u0009' ||cur === '\u000A' ||cur === '\u000D' ||cur === '\u0020');};
while (isWhitespace(this.input[cur])) {cur++;}
return cur;}
private parseArray(cur = 0): ParseResult<JSONArray> {cur = this.skipWhitespace(cur);if (this.input[cur] !== '[') {return {success: false,position: cur,};}const result: JSONArray = [];cur++;
let isFirstItem = true;while (this.input[cur] !== undefined && this.input[cur] !== ']') {cur = this.skipWhitespace(cur);
if (!isFirstItem) {if (this.input[cur] !== ',') {return {success: true,position: cur,value: result,};// return {// success: false,// position: cur,// };}cur++;}const itemResult = this.parseJSON(cur);if (!itemResult.success) {// completereturn {success: true,position: cur,value: result,};// return itemResult as ParseResult<JSONArray>;}cur = itemResult.position + 1;result.push(itemResult.value!);isFirstItem = false;}
return {success: true,position: cur,value: result,};}
private parseObject(cur = 0): ParseResult<JSONObject> {cur = this.skipWhitespace(cur);if (this.input[cur] !== '{') {return {success: false,position: cur,};}
const result: JSONObject = {};let isFirstItem = true;cur++;cur = this.skipWhitespace(cur);
while (this.input[cur] !== undefined && this.input[cur] !== '}') {if (!isFirstItem) {if (this.input[cur] !== ',') {return {success: true,value: result,position: cur,};}cur++;}
const keyResult = this.parseString(cur);
cur = keyResult.position;cur = this.skipWhitespace(cur);cur++;if (this.input[cur] !== ':') {return {success: true,value: result,position: cur,};}
const valueResult = this.parseJSON(cur + 1);
if (valueResult.value !== undefined) {result[keyResult.value!] = valueResult.value;}isFirstItem = false;cur = valueResult.position + 1;cur = this.skipWhitespace(cur);}
return {success: true,value: result,position: cur,};}
private guessNextValueType(cur = 0): MaybeJSONValue {const leadingChar = this.input[cur];if (/[-0-9]/.test(leadingChar)) {return MaybeJSONValue.NUMBER;}
switch (leadingChar) {case '[':return MaybeJSONValue.ARRAY;case '{':return MaybeJSONValue.OBJECT;case '"':return MaybeJSONValue.STRING;case 'n':return MaybeJSONValue.LITERAL;case 't':return MaybeJSONValue.LITERAL;case 'f':return MaybeJSONValue.LITERAL;default:return MaybeJSONValue.UNKNOWN;}}
private parseJSON(cur = 0): ParseResult<JSONValue> {cur = this.skipWhitespace(cur);const valueType = this.guessNextValueType(cur);switch (valueType) {case MaybeJSONValue.NUMBER:return this.parseNumber(cur);case MaybeJSONValue.ARRAY:return this.parseArray(cur);case MaybeJSONValue.OBJECT:return this.parseObject(cur);case MaybeJSONValue.STRING:return this.parseString(cur);case MaybeJSONValue.LITERAL:return this.parseLiteral(cur);case MaybeJSONValue.UNKNOWN:return {success: false,position: cur,};}}
public parse(input: string) {this.input = input;const result = this.parseJSON();if (result.success) {return result.value!;} else {return undefined;}}}

const jsonParseService = new JSONParserService();const jsonData = jsonParseService.parse(`[1, 2, {"a": "apple`);console.log(jsonData) // [1, 2, { a: 'apple' }]

import { jsonrepair } from 'jsonrepair'
try {// The following is invalid JSON: is consists of JSON contents copied from // a JavaScript code base, where the keys are missing double quotes, // and strings are using single quotes:const json = "{name: 'John'}"const repaired = jsonrepair(json)console.log(repaired) // '{"name": "John"}'} catch (err) {console.error(err)}

import { parse } from 'best-effort-json-parser'
let data = parse(`[1, 2, {"a": "apple`)console.log(data) // [1, 2, { a: 'apple' }]

this.ctx.status = 200;let str = '';this.ctx.set('Transfer-Encoding', 'chunked');for await (const chunk of streamResponse) {str += chunk;// 注意：str还是会有```json这样的包裹,需要提前处理一下const jsonStr = str.replace(/```json/, '').replace(/```/, '');const json = this.JSONParserService.parse(str);if (typeof json === 'object') {this.ctx.res.write(JSON.stringify(json));}this.ctx.res.write(chunk);}this.ctx.res.end();