@aigne/core 0.4.211-beta.2 → 1.0.0

package/lib/esm/index.js

@@ -1,18 +1,18 @@
-export * from './utils';
-export * from './constants';
-export * from './definitions/data-type';
-export * from './definitions/data-type-schema';
-export * from './definitions/open-api';
-export * from './definitions/memory';
-export * from './context';
-export * from './runnable';
-export * from './agent';
-export * from './pipeline-agent';
-export * from './llm-agent';
-export * from './llm-model';
-export * from './function-agent';
-export * from './function-runner';
-export * from './llm-decision-agent';
-export * from './local-function-agent';
-export * from './open-api-agent';
-export * from './memorable';
+export * from "./utils";
+export * from "./constants";
+export * from "./definitions/data-type";
+export * from "./definitions/data-type-schema";
+export * from "./definitions/open-api";
+export * from "./definitions/memory";
+export * from "./context";
+export * from "./runnable";
+export * from "./agent";
+export * from "./pipeline-agent";
+export * from "./llm-agent";
+export * from "./llm-model";
+export * from "./function-agent";
+export * from "./function-runner";
+export * from "./llm-decision-agent";
+export * from "./local-function-agent";
+export * from "./open-api-agent";
+export * from "./memorable";

package/lib/esm/llm-agent.js

@@ -10,17 +10,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { nanoid } from 'nanoid';
-import { inject, injectable } from 'tsyringe';
-import { Agent } from './agent';
-import { StreamTextOutputName, TYPES } from './constants';
-import { schemaToDataType } from './definitions/data-type-schema';
-import { toRunnableMemories } from './definitions/memory';
-import { LLMModel } from './llm-model';
-import { prepareMessages } from './utils/message-utils';
-import { renderMessage } from './utils/mustache-utils';
-import { OrderedRecord } from './utils/ordered-map';
-import { outputsToJsonSchema } from './utils/structured-output-schema';
+import { nanoid } from "nanoid";
+import { inject, injectable } from "tsyringe";
+import { Agent } from "./agent";
+import { StreamTextOutputName, TYPES } from "./constants";
+import { schemaToDataType, } from "./definitions/data-type-schema";
+import { toRunnableMemories, } from "./definitions/memory";
+import { prepareMessages } from "./utils/message-utils";
+import { renderMessage } from "./utils/mustache-utils";
+import { OrderedRecord } from "./utils/ordered-map";
+import { outputsToJsonSchema } from "./utils/structured-output-schema";
 let LLMAgent = class LLMAgent extends Agent {
     definition;
     model;
@@ -34,17 +33,17 @@ let LLMAgent = class LLMAgent extends Agent {
     async *process(input, options) {
         const { definition, model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         const { originalMessages, messagesWithMemory } = prepareMessages(definition, input, options.memories);
         const llmInputs = {
             messages: messagesWithMemory,
             modelOptions: definition.modelOptions,
         };
-        let $text = '';
+        let $text = "";
         const hasTextOutput = OrderedRecord.find(definition.outputs, (i) => i.name === StreamTextOutputName);
         if (hasTextOutput) {
             for await (const chunk of await this.runWithTextOutput(llmInputs)) {
-                $text += chunk.$text || '';
+                $text += chunk.$text || "";
                 yield { $text: chunk.$text };
             }
         }
@@ -53,37 +52,39 @@ let LLMAgent = class LLMAgent extends Agent {
             yield { delta: json };
         await this.updateMemories([
             ...originalMessages,
-            { role: 'assistant', content: renderMessage('{{$text}}\n{{json}}', { $text, json }).trim() },
+            {
+                role: "assistant",
+                content: renderMessage("{{$text}}\n{{json}}", { $text, json }).trim(),
+            },
         ]);
     }
     async runWithStructuredOutput(llmInputs) {
-        const jsonOutputs = OrderedRecord.filter(this.definition.outputs, (i) => i.name !== StreamTextOutputName // ignore `$text` output
-        );
+        const jsonOutputs = OrderedRecord.filter(this.definition.outputs, (i) => i.name !== StreamTextOutputName);
         if (!jsonOutputs.length)
             return null;
         const schema = outputsToJsonSchema(OrderedRecord.fromArray(jsonOutputs));
         const { model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         const response = await model.run({
             ...llmInputs,
             responseFormat: {
-                type: 'json_schema',
+                type: "json_schema",
                 jsonSchema: {
-                    name: 'output',
+                    name: "output",
                     schema,
                     strict: true,
                 },
             },
         });
         if (!response.$text)
-            throw new Error('No text in JSON mode response');
+            throw new Error("No text in JSON mode response");
         return JSON.parse(response.$text);
     }
     async runWithTextOutput(llmInputs) {
         const { model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         return model.run(llmInputs, { stream: true });
     }
 };
@@ -92,7 +93,7 @@ LLMAgent = __decorate([
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
     __param(2, inject(TYPES.llmModel)),
-    __metadata("design:paramtypes", [Object, Object, LLMModel])
+    __metadata("design:paramtypes", [Object, Object, Function])
 ], LLMAgent);
 export { LLMAgent };
 /**
@@ -109,7 +110,7 @@ function create({ context, ...options }) {
         .filter(([, i]) => i.primary)
         .map(([name]) => name);
     if (primaryMemoryNames && primaryMemoryNames.length > 1) {
-        throw new Error('Only one primary memory is allowed');
+        throw new Error("Only one primary memory is allowed");
     }
     const messages = OrderedRecord.fromArray(options.messages?.map((i) => ({
         id: nanoid(),
@@ -119,7 +120,7 @@ function create({ context, ...options }) {
     return new LLMAgent({
         id: agentId,
         name: options.name,
-        type: 'llm_agent',
+        type: "llm_agent",
         inputs,
         outputs,
         primaryMemoryId: primaryMemoryNames?.at(0),

package/lib/esm/llm-decision-agent.js

@@ -10,14 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { nanoid } from 'nanoid';
-import { inject, injectable } from 'tsyringe';
-import { Agent } from './agent';
-import { TYPES } from './constants';
-import { toRunnableMemories } from './definitions/memory';
-import { LLMModel } from './llm-model';
-import { OrderedRecord, extractOutputsFromRunnableOutput, renderMessage } from './utils';
-import { prepareMessages } from './utils/message-utils';
+import { nanoid } from "nanoid";
+import { inject, injectable } from "tsyringe";
+import { Agent } from "./agent";
+import { TYPES } from "./constants";
+import { toRunnableMemories, } from "./definitions/memory";
+import { OrderedRecord, extractOutputsFromRunnableOutput, renderMessage, } from "./utils";
+import { prepareMessages } from "./utils/message-utils";
 let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
     definition;
     model;
@@ -31,18 +30,18 @@ let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
     async process(input, options) {
         const { definition, context, model } = this;
         if (!model)
-            throw new Error('LLM model is required');
+            throw new Error("LLM model is required");
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         const { originalMessages, messagesWithMemory } = prepareMessages(definition, input, options.memories);
         const cases = await Promise.all(OrderedRecord.map(definition.cases, async (t) => {
             if (!t.runnable?.id)
-                throw new Error('Runnable is required');
+                throw new Error("Runnable is required");
             const runnable = await context.resolve(t.runnable.id);
             // TODO: auto generate name by llm model if needed
             const name = t.name || runnable.name;
             if (!name)
-                throw new Error('Case name is required');
+                throw new Error("Case name is required");
             return { name, description: t.description, runnable };
         }));
         const llmInputs = {
@@ -51,7 +50,7 @@ let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
             tools: cases.map((t) => {
                 // TODO: auto generate parameters by llm model if needed
                 return {
-                    type: 'function',
+                    type: "function",
                     function: {
                         name: t.name,
                         description: t.description,
@@ -59,21 +58,24 @@ let LLMDecisionAgent = class LLMDecisionAgent extends Agent {
                     },
                 };
             }),
-            toolChoice: 'required',
+            toolChoice: "required",
         };
         const { toolCalls } = await model.run(llmInputs);
         // TODO: support run multiple calls
         const functionNameToCall = toolCalls?.[0]?.function?.name;
         if (!functionNameToCall)
-            throw new Error('No any runnable called');
+            throw new Error("No any runnable called");
         const caseToCall = cases.find((i) => i.name === functionNameToCall);
         if (!caseToCall)
-            throw new Error('Case not found');
+            throw new Error("Case not found");
         // TODO: check result structure and omit undefined values
         const output = await caseToCall.runnable.run(input, { stream: true });
         return extractOutputsFromRunnableOutput(output, ({ $text, ...json }) => this.updateMemories([
             ...originalMessages,
-            { role: 'assistant', content: renderMessage('{{$text}}\n{{json}}', { $text, json }).trim() },
+            {
+                role: "assistant",
+                content: renderMessage("{{$text}}\n{{json}}", { $text, json }).trim(),
+            },
         ]));
     }
 };
@@ -82,7 +84,7 @@ LLMDecisionAgent = __decorate([
     __param(0, inject(TYPES.definition)),
     __param(1, inject(TYPES.context)),
     __param(2, inject(TYPES.llmModel)),
-    __metadata("design:paramtypes", [Object, Object, LLMModel])
+    __metadata("design:paramtypes", [Object, Object, Function])
 ], LLMDecisionAgent);
 export { LLMDecisionAgent };
 function create({ context, ...options }) {
@@ -100,7 +102,7 @@ function create({ context, ...options }) {
         .filter(([, i]) => i.primary)
         .map(([name]) => name);
     if (primaryMemoryNames && primaryMemoryNames.length > 1) {
-        throw new Error('Only one primary memory is allowed');
+        throw new Error("Only one primary memory is allowed");
     }
     const messages = OrderedRecord.fromArray(options.messages?.map((i) => ({
         id: nanoid(),
@@ -110,7 +112,7 @@ function create({ context, ...options }) {
     return new LLMDecisionAgent({
         id: agentId,
         name: options.name,
-        type: 'llm_decision_agent',
+        type: "llm_decision_agent",
         inputs,
         outputs,
         messages,

package/lib/esm/llm-model.js

@@ -1,22 +1,22 @@
-import { Agent } from './agent';
-import { OrderedRecord } from './utils';
+import { Agent } from "./agent";
+import { OrderedRecord } from "./utils";
 export class LLMModel extends Agent {
     constructor(context) {
         super({
-            id: 'llm_model',
-            type: 'llm_model',
-            name: 'LLM Model',
-            description: 'Run a LLM model',
+            id: "llm_model",
+            type: "llm_model",
+            name: "LLM Model",
+            description: "Run a LLM model",
             inputs: OrderedRecord.fromArray([
-                { id: 'messages', name: 'messages', type: 'array', required: true },
-                { id: 'responseFormat', name: 'responseFormat', type: 'object' },
-                { id: 'tools', name: 'tools', type: 'array' },
-                { id: 'toolChoice', name: 'toolChoice', type: 'object' },
-                { id: 'modelOptions', name: 'modelOptions', type: 'object' },
+                { id: "messages", name: "messages", type: "array", required: true },
+                { id: "responseFormat", name: "responseFormat", type: "object" },
+                { id: "tools", name: "tools", type: "array" },
+                { id: "toolChoice", name: "toolChoice", type: "object" },
+                { id: "modelOptions", name: "modelOptions", type: "object" },
             ]),
             outputs: OrderedRecord.fromArray([
-                { id: '$text', name: '$text', type: 'string' },
-                { id: 'toolCalls', name: 'toolCalls', type: 'object' },
+                { id: "$text", name: "$text", type: "string" },
+                { id: "toolCalls", name: "toolCalls", type: "object" },
             ]),
         }, context);
     }

package/lib/esm/local-function-agent.js

@@ -10,12 +10,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { nanoid } from 'nanoid';
-import { inject, injectable } from 'tsyringe';
-import { Agent } from './agent';
-import { TYPES } from './constants';
-import { schemaToDataType } from './definitions/data-type-schema';
-import { toRunnableMemories } from './definitions/memory';
+import { nanoid } from "nanoid";
+import { inject, injectable } from "tsyringe";
+import { Agent } from "./agent";
+import { TYPES } from "./constants";
+import { schemaToDataType, } from "./definitions/data-type-schema";
+import { toRunnableMemories, } from "./definitions/memory";
 let LocalFunctionAgent = class LocalFunctionAgent extends Agent {
     definition;
     static create = create;
@@ -26,9 +26,9 @@ let LocalFunctionAgent = class LocalFunctionAgent extends Agent {
     async process(input, options) {
         const { definition: { function: func }, context, } = this;
         if (!func)
-            throw new Error('Function is required');
+            throw new Error("Function is required");
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         return await func(input, { context, memories: options.memories });
     }
 };
@@ -47,7 +47,7 @@ function create({ context, ...options }) {
     return new LocalFunctionAgent({
         id: agentId,
         name: options.name,
-        type: 'local_function_agent',
+        type: "local_function_agent",
         inputs,
         outputs,
         memories,

package/lib/esm/memorable.js

@@ -1,12 +1,12 @@
-import { camelCase, startCase } from 'lodash';
-import { Runnable } from './runnable';
-import { OrderedRecord } from './utils';
+import { camelCase, startCase } from "lodash";
+import { Runnable } from "./runnable";
+import { OrderedRecord } from "./utils";
 export class Memorable extends Runnable {
     constructor() {
         super({
-            id: 'memory',
-            type: 'memory',
-            name: 'Memory',
+            id: "memory",
+            type: "memory",
+            name: "Memory",
             inputs: OrderedRecord.fromArray([]),
             outputs: OrderedRecord.fromArray([]),
         });

package/lib/esm/open-api-agent.js

@@ -10,13 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { nanoid } from 'nanoid';
-import { inject, injectable } from 'tsyringe';
-import { Agent } from './agent';
-import { TYPES } from './constants';
-import { schemaToDataType } from './definitions/data-type-schema';
-import { fetchOpenApi } from './utils/fetch-open-api';
-import { formatOpenAPIRequest } from './utils/open-api-parameter';
+import { nanoid } from "nanoid";
+import { inject, injectable } from "tsyringe";
+import { Agent } from "./agent";
+import { TYPES } from "./constants";
+import { schemaToDataType, } from "./definitions/data-type-schema";
+import { fetchOpenApi } from "./utils/fetch-open-api";
+import { formatOpenAPIRequest } from "./utils/open-api-parameter";
 let OpenAPIAgent = class OpenAPIAgent extends Agent {
     definition;
     static create = create;
@@ -25,13 +25,13 @@ let OpenAPIAgent = class OpenAPIAgent extends Agent {
         this.definition = definition;
     }
     async process(input) {
-        const { url, method = 'get', auth, inputs } = this.definition;
+        const { url, method = "get", auth, inputs } = this.definition;
         if (!url)
-            throw new Error('API url is required');
+            throw new Error("API url is required");
         const request = await formatOpenAPIRequest({ url, method, auth }, inputs, input);
         return this.fetch(request);
     }
-    fetch(request) {
+    async fetch(request) {
         return fetchOpenApi(request);
     }
 };
@@ -49,7 +49,7 @@ function create({ context, ...options }) {
     return new OpenAPIAgent({
         id: agentId,
         name: options.name,
-        type: 'open_api_agent',
+        type: "open_api_agent",
         inputs,
         outputs,
         url: options.url,

package/lib/esm/pipeline-agent.js

@@ -10,16 +10,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { get, isNil } from 'lodash';
-import { nanoid } from 'nanoid';
-import { inject, injectable } from 'tsyringe';
-import { Agent } from './agent';
-import { StreamTextOutputName, TYPES } from './constants';
-import { schemaToDataType } from './definitions/data-type-schema';
-import { toRunnableMemories } from './definitions/memory';
-import logger from './logger';
-import { isNonNullable } from './utils/is-non-nullable';
-import { OrderedRecord } from './utils/ordered-map';
+import { get, isNil } from "lodash";
+import { nanoid } from "nanoid";
+import { inject, injectable } from "tsyringe";
+import { Agent } from "./agent";
+import { StreamTextOutputName, TYPES } from "./constants";
+import { schemaToDataType, } from "./definitions/data-type-schema";
+import { toRunnableMemories, } from "./definitions/memory";
+import logger from "./logger";
+import { isNonNullable } from "./utils/is-non-nullable";
+import { OrderedRecord } from "./utils/ordered-map";
 let PipelineAgent = class PipelineAgent extends Agent {
     definition;
     static create = create;
@@ -30,10 +30,10 @@ let PipelineAgent = class PipelineAgent extends Agent {
     async process(input, options) {
         const { definition, context } = this;
         if (!context)
-            throw new Error('Context is required');
+            throw new Error("Context is required");
         const { processes } = definition;
         if (!processes?.$indexes.length) {
-            throw new Error('No processes defined');
+            throw new Error("No processes defined");
         }
         return new ReadableStream({
             async start(controller) {
@@ -53,7 +53,7 @@ let PipelineAgent = class PipelineAgent extends Agent {
                     let result = {};
                     for (const process of OrderedRecord.iterator(processes)) {
                         if (!process.runnable?.id) {
-                            logger.warn('Runnable id is required for process', process);
+                            logger.warn("Runnable id is required for process", process);
                             continue;
                         }
                         const runnable = await context.resolve(process.runnable.id);
@@ -65,18 +65,21 @@ let PipelineAgent = class PipelineAgent extends Agent {
                             if (!targetInput?.name)
                                 return null;
                             let value;
-                            if (input.from === 'variable') {
+                            if (input.from === "variable") {
                                 const v = variables[input.fromVariableId];
-                                value = input.fromVariablePropPath?.length ? get(v, input.fromVariablePropPath) : v;
+                                value = input.fromVariablePropPath?.length
+                                    ? get(v, input.fromVariablePropPath)
+                                    : v;
                             }
                             else {
-                                throw new Error('Unsupported input source');
+                                throw new Error("Unsupported input source");
                             }
                             return [targetInput.name, value];
                         })
                             .filter(isNonNullable));
                         const stream = await runnable.run(inputValues, { stream: true });
-                        const needRespondTextStream = textStreamOutput?.from === 'variable' && textStreamOutput.fromVariableId === process.id;
+                        const needRespondTextStream = textStreamOutput?.from === "variable" &&
+                            textStreamOutput.fromVariableId === process.id;
                         // const needRespondJsonStream = outputs.some(
                         //   (i) => i.name !== StreamTextOutputName && i.from === 'variable' && i.fromVariableId === process.id
                         // );
@@ -84,7 +87,9 @@ let PipelineAgent = class PipelineAgent extends Agent {
                         variables[process.id] = processResult;
                         for await (const chunk of stream) {
                             if (chunk.$text) {
-                                Object.assign(processResult, { $text: (processResult.$text || '') + chunk.$text });
+                                Object.assign(processResult, {
+                                    $text: (processResult.$text || "") + chunk.$text,
+                                });
                                 if (needRespondTextStream) {
                                     controller.enqueue({ $text: chunk.$text });
                                 }
@@ -99,9 +104,11 @@ let PipelineAgent = class PipelineAgent extends Agent {
                                     if (output.name === StreamTextOutputName)
                                         return null;
                                     let value;
-                                    if (output.from === 'variable') {
+                                    if (output.from === "variable") {
                                         const v = variables[output.fromVariableId];
-                                        value = output.fromVariablePropPath?.length ? get(v, output.fromVariablePropPath) : v;
+                                        value = output.fromVariablePropPath?.length
+                                            ? get(v, output.fromVariablePropPath)
+                                            : v;
                                     }
                                     else {
                                         throw new Error(`Unsupported output source ${output.from}`);
@@ -157,7 +164,7 @@ function create({ context, ...options }) {
                 return [
                     inputOfProcess.id,
                     {
-                        from: 'variable',
+                        from: "variable",
                         fromVariableId: inputFromPipeline.id,
                         fromVariablePropPath: i.fromVariablePropPath,
                     },
@@ -171,12 +178,17 @@ function create({ context, ...options }) {
             OrderedRecord.find(processes, (p) => p.name === fromVariable);
         if (!from)
             throw new Error(`Output ${output.name} not found in inputs or processes`);
-        return { ...output, from: 'variable', fromVariableId: from.id, fromVariablePropPath };
+        return {
+            ...output,
+            from: "variable",
+            fromVariableId: from.id,
+            fromVariablePropPath,
+        };
     }));
     return new PipelineAgent({
         id: agentId,
         name: options.name,
-        type: 'pipeline_agent',
+        type: "pipeline_agent",
         inputs,
         memories,
         outputs,

package/lib/esm/runnable.js

@@ -1,4 +1,4 @@
-import { OrderedRecord } from './utils/ordered-map';
+import { OrderedRecord } from "./utils/ordered-map";
 export class Runnable {
     definition;
     context;
@@ -19,8 +19,8 @@ export class Runnable {
     outputs;
 }
 export function isRunnableResponseDelta(chunk) {
-    return '$text' in chunk || 'delta' in chunk;
+    return "$text" in chunk || "delta" in chunk;
 }
 export function isRunnableResponseError(chunk) {
-    return 'error' in chunk;
+    return "error" in chunk;
 }

package/lib/esm/utils/fetch-open-api.js

@@ -1,11 +1,11 @@
-import { withQuery } from 'ufo';
-import { FETCH_TIMEOUT } from './constants';
-import { checkFetchResponse } from './fetch';
-export const fetchOpenApi = async (request) => {
+import { withQuery } from "ufo";
+import { FETCH_TIMEOUT } from "./constants";
+import { checkFetchResponse } from "./fetch";
+export async function fetchOpenApi(request) {
     const cookie = request.cookies
         ? Object.entries(request.cookies)
             .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
-            .join('; ')
+            .join("; ")
             .trim()
         : undefined;
     const controller = new AbortController();
@@ -13,14 +13,16 @@ export const fetchOpenApi = async (request) => {
     const response = await fetch(withQuery(request.url, request.query ?? {}), {
         method: request.method,
         headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
             ...request.headers,
             ...(cookie && { cookie }),
         },
-        body: request.method.toLowerCase() !== 'get' && request.body ? JSON.stringify(request.body) : undefined,
-        credentials: request.cookies ? 'include' : 'same-origin',
+        body: request.method.toLowerCase() !== "get" && request.body
+            ? JSON.stringify(request.body)
+            : undefined,
+        credentials: request.cookies ? "include" : "same-origin",
         signal: controller.signal,
     }).finally(() => clearTimeout(abortTimer));
     await checkFetchResponse(response);
     return response.json();
-};
+}

package/lib/esm/utils/fetch.js

@@ -4,14 +4,15 @@ export async function checkFetchResponse(result) {
         try {
             const json = await result.json();
             const msg = json.error?.message || json.message;
-            if (msg && typeof msg === 'string') {
+            if (msg && typeof msg === "string") {
                 message = msg;
             }
         }
         catch {
             // ignore
         }
-        throw new Error(message || `Failed to fetch url ${result.url} with status ${result.status}`);
+        throw new Error(message ||
+            `Failed to fetch url ${result.url} with status ${result.status}`);
     }
     return result;
 }

package/lib/esm/utils/index.js

@@ -1,10 +1,10 @@
-export * from './fetch';
-export * from './fetch-open-api';
-export * from './is-non-nullable';
-export * from './mustache-utils';
-export * from './nullable';
-export * from './omit';
-export * from './open-api-parameter';
-export * from './ordered-map';
-export * from './stream-utils';
-export * from './union';
+export * from "./fetch";
+export * from "./fetch-open-api";
+export * from "./is-non-nullable";
+export * from "./mustache-utils";
+export * from "./nullable";
+export * from "./omit";
+export * from "./open-api-parameter";
+export * from "./ordered-map";
+export * from "./stream-utils";
+export * from "./union";