@aigne/core 1.0.16 → 1.1.0-beta.1

package/lib/esm/runtime.d.ts

@@ -1,64 +0,0 @@
-import { type DependencyContainer } from "tsyringe";
-import type { constructor as Constructor } from "tsyringe/dist/typings/types";
-import type { Context, ContextState } from "./context";
-import type { LLMModel, LLMModelConfiguration } from "./llm-model";
-import type { Memorable } from "./memorable";
-import { Runnable, type RunnableDefinition } from "./runnable";
-import type { SandboxFunctionRunner } from "./sandbox-function-runner";
-import { OrderedRecord } from "./utils/ordered-map";
-import type { DeepPartial } from "./utils/partial";
-export interface RuntimeConfiguration {
-    llmModel?: LLMModelConfiguration;
-}
-export interface RuntimeOptions<Agents extends {
-    [name: string]: Runnable;
-}, State extends ContextState> {
-    id?: string;
-    name?: string;
-    config?: RuntimeConfiguration;
-    state?: State;
-    agents?: Agents;
-    historyManager?: Memorable<{
-        input: object;
-        output: object;
-    }>;
-    llmModel?: LLMModel | Constructor<LLMModel>;
-    sandboxFunctionRunner?: SandboxFunctionRunner | Constructor<SandboxFunctionRunner>;
-}
-export declare class Runtime<Agents extends {
-    [name: string]: Runnable;
-} = {}, State extends ContextState = ContextState> implements Context<State> {
-    constructor(options?: RuntimeOptions<Agents, State>);
-    protected inner: RuntimeInner<Agents, State>;
-    get options(): RuntimeOptions<Agents, State>;
-    get id(): string;
-    get name(): string | undefined;
-    get historyManager(): Memorable<{
-        input: object;
-        output: object;
-    }, Record<string, any>> | undefined;
-    config: RuntimeConfiguration;
-    state: State;
-    agents: Agents;
-    private container;
-    setup(config: DeepPartial<RuntimeConfiguration>): void;
-    register<R extends Array<RunnableDefinition | Runnable> = []>(...runnables: R): void;
-    private resolveSync;
-    resolve<T extends Runnable>(id: string | RunnableDefinition | T): Promise<T>;
-    resolveDependency<T>(token: string | symbol): T;
-    copy<State extends ContextState = ContextState>(options: Pick<RuntimeOptions<Agents, State>, "state" | "config">): Runtime<Agents, State>;
-}
-declare class RuntimeInner<Agents extends {
-    [name: string]: Runnable;
-} = {}, State extends ContextState = ContextState> {
-    options: RuntimeOptions<Agents, State>;
-    constructor(options: RuntimeOptions<Agents, State>);
-    readonly id: string;
-    readonly name?: string;
-    config: RuntimeConfiguration;
-    state: State;
-    container: DependencyContainer;
-    runnableDefinitions: OrderedRecord<RunnableDefinition>;
-    registerDependency<T>(token: string | symbol, dependency: Constructor<T> | T): void;
-}
-export {};

package/lib/esm/runtime.js

@@ -1,146 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var Runtime_1;
-import { produce } from "immer";
-import { merge } from "lodash";
-import { nanoid } from "nanoid";
-import { container, injectable } from "tsyringe";
-import { TYPES } from "./constants";
-import { FunctionAgent } from "./function-agent";
-import { LLMAgent } from "./llm-agent";
-import { LLMDecisionAgent } from "./llm-decision-agent";
-import { OpenAPIAgent } from "./open-api-agent";
-import { PipelineAgent } from "./pipeline-agent";
-import { Runnable } from "./runnable";
-import { SandboxFunctionAgent } from "./sandbox-function-agent";
-import { OrderedRecord } from "./utils/ordered-map";
-let Runtime = Runtime_1 = class Runtime {
-    constructor(options = {}) {
-        // support copy inner from a existing runtime, but not expose to public
-        const inner = options.inner;
-        if (inner instanceof RuntimeInner)
-            this.inner = inner;
-        else
-            this.inner = new RuntimeInner(options);
-        this.container = this.inner.container.createChildContainer();
-        this.container.register(TYPES.context, { useValue: this });
-        this.config = options.config || { ...this.inner.config };
-        this.state = options.state || { ...this.inner.state };
-    }
-    inner;
-    get options() {
-        return this.inner.options;
-    }
-    get id() {
-        return this.inner.id;
-    }
-    get name() {
-        return this.inner.name;
-    }
-    get historyManager() {
-        return this.inner.options.historyManager;
-    }
-    config;
-    state;
-    agents = new Proxy({}, { get: (_, prop) => this.resolveSync(prop.toString()) });
-    container;
-    setup(config) {
-        this.config = produce(this.config, (draft) => {
-            merge(draft, config);
-        });
-    }
-    register(...runnables) {
-        for (const runnable of runnables) {
-            OrderedRecord.pushOrUpdate(this.inner.runnableDefinitions, runnable instanceof Runnable ? runnable.definition : runnable);
-        }
-    }
-    resolveSync(idOrRunnable) {
-        const runnableId = typeof idOrRunnable === "string" ? idOrRunnable : idOrRunnable.id;
-        // Find runnable definition by id or name
-        let definition = this.inner.runnableDefinitions[runnableId] ??
-            OrderedRecord.find(this.inner.runnableDefinitions, (def) => def.name === runnableId);
-        if (!definition) {
-            // extract definition from runnable
-            if (idOrRunnable instanceof Runnable)
-                definition = idOrRunnable.definition;
-            // directly use runnable as definition
-            else if (typeof idOrRunnable === "object")
-                definition = idOrRunnable;
-        }
-        if (definition) {
-            const childContainer = this.container
-                .createChildContainer()
-                .register(TYPES.definition, { useValue: definition });
-            const result = childContainer.resolve(definition.type);
-            childContainer.dispose();
-            return result;
-        }
-        throw new Error(`Runnable not found: ${idOrRunnable}`);
-    }
-    async resolve(id) {
-        return this.resolveSync(id);
-    }
-    resolveDependency(token) {
-        return this.container.resolve(token);
-    }
-    copy(options) {
-        const clone = new Runtime_1({
-            ...options,
-            // Copy inner runtime
-            ...{ inner: this.inner },
-        });
-        return clone;
-    }
-};
-Runtime = Runtime_1 = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [Object])
-], Runtime);
-export { Runtime };
-class RuntimeInner {
-    options;
-    constructor(options) {
-        this.options = options;
-        this.name = options.name;
-        this.id = options.id || this.name || nanoid();
-        this.config = options.config || {};
-        this.state = options.state || {};
-        this.container.register("pipeline_agent", { useClass: PipelineAgent });
-        this.container.register("llm_agent", { useClass: LLMAgent });
-        this.container.register("sandbox_function_agent", {
-            useClass: SandboxFunctionAgent,
-        });
-        this.container.register("llm_decision_agent", {
-            useClass: LLMDecisionAgent,
-        });
-        this.container.register("function_agent", {
-            useClass: FunctionAgent,
-        });
-        this.container.register("open_api_agent", { useClass: OpenAPIAgent });
-        if (options.sandboxFunctionRunner)
-            this.registerDependency(TYPES.sandboxFunctionRunner, options.sandboxFunctionRunner);
-        if (options.llmModel)
-            this.registerDependency(TYPES.llmModel, options.llmModel);
-    }
-    id;
-    name;
-    config;
-    state;
-    container = container.createChildContainer();
-    runnableDefinitions = OrderedRecord.fromArray([]);
-    registerDependency(token, dependency) {
-        if (typeof dependency === "function")
-            this.container.register(token, {
-                useClass: dependency,
-            });
-        else
-            this.container.register(token, { useValue: dependency });
-    }
-}

package/lib/esm/sandbox-function-agent.d.ts

@@ -1,21 +0,0 @@
-import { Agent, type AgentDefinition, type AgentMemories, type AgentPreloads, type AgentProcessInput, type AgentProcessOptions, type CreateAgentInputSchema, type CreateAgentMemoriesSchema, type CreateAgentMemoriesType, type CreateAgentOptions, type CreateAgentOutputSchema, type CreateAgentPreloadsSchema, type CreateAgentPreloadsType } from "./agent";
-import type { Context, ContextState } from "./context";
-import { type SchemaToType } from "./definitions/data-schema";
-import type { RunnableInput, RunnableOutput } from "./runnable";
-import type { SandboxFunctionRunner } from "./sandbox-function-runner";
-export declare class SandboxFunctionAgent<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<I, O, State, Preloads, Memories> {
-    definition: SandboxFunctionAgentDefinition;
-    runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined;
-    static create: typeof create;
-    constructor(definition: SandboxFunctionAgentDefinition, context?: Context<State>, runner?: SandboxFunctionRunner<I, O, State, Preloads, Memories> | undefined);
-    process(input: AgentProcessInput<I, Preloads, Memories>, options: AgentProcessOptions<Preloads, Memories>): Promise<import("./runnable").RunnableResponseStream<O>>;
-}
-export declare function create<I extends CreateAgentInputSchema, O extends CreateAgentOutputSchema, State extends ContextState, Preloads extends CreateAgentPreloadsSchema<I>, Memories extends CreateAgentMemoriesSchema<I>>(options: CreateAgentOptions<I, O, State, Preloads, Memories> & {
-    language?: string;
-    code: string;
-}): SandboxFunctionAgent<SchemaToType<I>, SchemaToType<O>, State, CreateAgentPreloadsType<I, Preloads>, CreateAgentMemoriesType<I, Memories>>;
-export interface SandboxFunctionAgentDefinition extends AgentDefinition {
-    type: "sandbox_function_agent";
-    language?: string;
-    code?: string;
-}

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

@@ -1,74 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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-schema";
-import { toRunnableMemories } from "./definitions/memory";
-import { preloadCreatorsToPreloads } from "./definitions/preload";
-let SandboxFunctionAgent = class SandboxFunctionAgent extends Agent {
-    definition;
-    runner;
-    static create = create;
-    constructor(definition, context, runner) {
-        super(definition, context);
-        this.definition = definition;
-        this.runner = runner;
-        this.runner ??= context?.resolveDependency(TYPES.sandboxFunctionRunner);
-    }
-    async process(input, options) {
-        const { definition: { language, code, ...definition }, runner, context, } = this;
-        if (!runner)
-            throw new Error("Sandbox function runner is required");
-        if (!code)
-            throw new Error("Code is required");
-        if (!context)
-            throw new Error("Context is required");
-        return await runner.run({
-            name: definition.name || definition.id,
-            language,
-            code,
-            input,
-            preloads: options.preloads,
-            memories: options.memories,
-            context: { state: context.state },
-        }, { stream: true });
-    }
-};
-SandboxFunctionAgent = __decorate([
-    injectable(),
-    __param(0, inject(TYPES.definition)),
-    __param(1, inject(TYPES.context)),
-    __param(2, inject(TYPES.sandboxFunctionRunner)),
-    __metadata("design:paramtypes", [Object, Object, Function])
-], SandboxFunctionAgent);
-export { SandboxFunctionAgent };
-export function create(options) {
-    const agentId = options.name || nanoid();
-    const inputs = schemaToDataType(options.inputs);
-    const outputs = schemaToDataType(options.outputs);
-    const preloads = preloadCreatorsToPreloads(inputs, options.preloads);
-    const memories = toRunnableMemories(agentId, inputs, options.memories ?? {});
-    return new SandboxFunctionAgent({
-        id: agentId,
-        name: options.name,
-        type: "sandbox_function_agent",
-        inputs,
-        outputs,
-        preloads,
-        memories,
-        language: options.language,
-        code: options.code,
-    }, options.context);
-}

package/lib/esm/sandbox-function-runner.d.ts

@@ -1,16 +0,0 @@
-import { Agent, type AgentMemories, type AgentPreloads } from "./agent";
-import type { Context, ContextState } from "./context";
-import type { RunnableInput, RunnableOutput } from "./runnable";
-export type SandboxFunctionRunnerInput<Input extends RunnableInput = RunnableInput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> = {
-    name: string;
-    language?: string;
-    code: string;
-    input: Input;
-    preloads: Preloads;
-    memories: Memories;
-    context: Pick<Context<State>, "state">;
-};
-export type SandboxFunctionRunnerOutput<Output extends RunnableOutput> = Output;
-export declare abstract class SandboxFunctionRunner<I extends RunnableInput = RunnableInput, O extends RunnableOutput = RunnableOutput, State extends ContextState = ContextState, Preloads extends AgentPreloads = AgentPreloads, Memories extends AgentMemories = AgentMemories> extends Agent<SandboxFunctionRunnerInput<I, State, Preloads, Memories>, SandboxFunctionRunnerOutput<O>> {
-    constructor(context?: Context);
-}

package/lib/esm/sandbox-function-runner.js

@@ -1,28 +0,0 @@
-import { Agent, } from "./agent";
-import { OrderedRecord } from "./utils";
-export class SandboxFunctionRunner extends Agent {
-    constructor(context) {
-        super({
-            id: "sandbox_function_runner",
-            type: "sandbox_function_runner",
-            name: "Sandbox Function Runner",
-            description: "Run a function",
-            inputs: OrderedRecord.fromArray([
-                { id: "name", name: "name", type: "string", required: true },
-                { id: "language", name: "language", type: "string" },
-                { id: "code", name: "code", type: "string", required: true },
-                { id: "input", name: "input", type: "object", required: true },
-                { id: "preloads", name: "preloads", type: "object", required: true },
-                { id: "memories", name: "memories", type: "object", required: true },
-                { id: "context", name: "context", type: "object", required: true },
-            ]),
-            outputs: OrderedRecord.fromArray([
-                {
-                    id: "result",
-                    name: "result",
-                    type: "object",
-                },
-            ]),
-        }, context);
-    }
-}

package/lib/esm/utils/constants.d.ts

@@ -1 +0,0 @@
-export declare const FETCH_TIMEOUT: number;

package/lib/esm/utils/constants.js

@@ -1 +0,0 @@
-export const FETCH_TIMEOUT = Number(process.env.FETCH_TIMEOUT) || 30000;

package/lib/esm/utils/fetch-open-api.d.ts

@@ -1,2 +0,0 @@
-import type { FetchRequest } from "../definitions/open-api";
-export declare function fetchOpenApi<T>(request: FetchRequest): Promise<T>;

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

@@ -1,28 +0,0 @@
-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("; ")
-            .trim()
-        : undefined;
-    const controller = new AbortController();
-    const abortTimer = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
-    const response = await fetch(withQuery(request.url, request.query ?? {}), {
-        method: request.method,
-        headers: {
-            "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",
-        signal: controller.signal,
-    }).finally(() => clearTimeout(abortTimer));
-    await checkFetchResponse(response);
-    return response.json();
-}

package/lib/esm/utils/fetch.d.ts

@@ -1 +0,0 @@
-export declare function checkFetchResponse(result: Response): Promise<Response>;

package/lib/esm/utils/fetch.js

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

package/lib/esm/utils/index.d.ts

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

package/lib/esm/utils/index.js

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

package/lib/esm/utils/is-non-nullable.d.ts

@@ -1,2 +0,0 @@
-export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
-export declare function isPropsNonNullable<T, K extends keyof T>(...props: (K | K[])[]): (value: T) => value is T & Required<Pick<T, K>>;

package/lib/esm/utils/is-non-nullable.js

@@ -1,13 +0,0 @@
-import isNil from "lodash/isNil";
-export function isNonNullable(value) {
-    return !isNil(value);
-}
-export function isPropsNonNullable(...props) {
-    return (value) => {
-        for (const prop of props.flat()) {
-            if (isNil(value?.[prop]))
-                return false;
-        }
-        return true;
-    };
-}

package/lib/esm/utils/message-utils.d.ts

@@ -1,20 +0,0 @@
-import type { LLMAgentDefinition } from "../llm-agent";
-import type { LLMModelInputMessage } from "../llm-model";
-import type { MemoryItemWithScore } from "../memorable";
-export declare function mergeHistoryMessages(messages: LLMModelInputMessage[], history: LLMModelInputMessage[]): LLMModelInputMessage[];
-export declare function memoriesToMessages(memories: {
-    [name: string]: MemoryItemWithScore[];
-}, { primaryMemoryName }?: {
-    primaryMemoryName?: string;
-}): {
-    primaryMemory: LLMModelInputMessage[];
-    memory: string;
-};
-export declare function prepareMessages(definition: Pick<LLMAgentDefinition, "messages" | "memories" | "primaryMemoryId">, input: {
-    [name: string]: unknown;
-}, memories: {
-    [name: string]: MemoryItemWithScore[];
-}): {
-    originalMessages: LLMModelInputMessage[];
-    messagesWithMemory: LLMModelInputMessage[];
-};

package/lib/esm/utils/message-utils.js

@@ -1,71 +0,0 @@
-import omit from "lodash/omit";
-import { isNonNullable } from "./is-non-nullable";
-import { renderMessage } from "./mustache-utils";
-import { OrderedRecord } from "./ordered-map";
-export function mergeHistoryMessages(messages, history) {
-    const firstUserMessageIndex = messages.findIndex((m) => m.role === "user");
-    if (firstUserMessageIndex >= 0) {
-        return [
-            ...messages.slice(0, firstUserMessageIndex),
-            ...history,
-            ...messages.slice(firstUserMessageIndex),
-        ];
-    }
-    return [...history, ...messages];
-}
-export function memoriesToMessages(memories, { primaryMemoryName } = {}) {
-    const primary = (primaryMemoryName && memories[primaryMemoryName]) || [];
-    const otherMemories = primaryMemoryName
-        ? omit(memories, primaryMemoryName)
-        : memories;
-    const primaryMemory = primary
-        .map((i) => {
-        const content = renderMessage("{{memory}}", { memory: i.memory }).trim();
-        const role = ["user", "assistant"].includes(i.metadata.role)
-            ? i.metadata.role
-            : undefined;
-        if (!role || !content)
-            return null;
-        return { role, content };
-    })
-        .filter(isNonNullable);
-    const memory = Object.values(otherMemories)
-        .map((i) => i
-        .map((j) => renderMessage("{{memory}}\n{{metadata}}", j).trim() || null)
-        .filter(isNonNullable)
-        .join("\n"))
-        .join("\n");
-    return {
-        primaryMemory,
-        memory,
-    };
-}
-export function prepareMessages(definition, input, memories) {
-    const originalMessages = OrderedRecord.toArray(definition.messages).map(({ role, content }) => ({
-        role,
-        content: typeof content === "string" ? renderMessage(content, input) : content,
-    }));
-    if (!originalMessages.length)
-        throw new Error("Messages are required");
-    const { primaryMemory, memory } = memoriesToMessages(memories, {
-        primaryMemoryName: OrderedRecord.find(definition.memories, (i) => i.id === definition.primaryMemoryId)?.name,
-    });
-    let messagesWithMemory = [...originalMessages];
-    // Add memory to a system message
-    if (memory) {
-        const message = {
-            role: "system",
-            content: `\
-        Here are the memories about the user:
-        ${memory}
-        `,
-        };
-        const lastSystemMessageIndex = messagesWithMemory.findLastIndex((i) => i.role === "assistant");
-        messagesWithMemory.splice(lastSystemMessageIndex + 1, 0, message);
-    }
-    // Add primary memory to messages
-    if (primaryMemory.length)
-        messagesWithMemory = mergeHistoryMessages(messagesWithMemory, primaryMemory);
-    // TODO: support comment/image for messages
-    return { originalMessages, messagesWithMemory };
-}

package/lib/esm/utils/mustache-utils.d.ts

@@ -1,3 +0,0 @@
-export declare function renderMessage(template: string, variables?: {
-    [key: string]: any;
-}): string;

package/lib/esm/utils/mustache-utils.js

@@ -1,8 +0,0 @@
-import Mustache from "mustache";
-export function renderMessage(template, variables) {
-    return Mustache.render(template, variables, undefined, {
-        escape: (v) => {
-            return typeof v === "object" ? JSON.stringify(v) : v;
-        },
-    });
-}

package/lib/esm/utils/nullable.d.ts

@@ -1,7 +0,0 @@
-export type MakeNullablePropertyOptional<T extends {
-    [key: string]: any;
-}> = {
-    [K in keyof T as Extract<T[K], null | undefined> extends never ? K : never]: T[K];
-} & {
-    [K in keyof T as Extract<T[K], null | undefined> extends never ? never : K]?: T[K];
-};

package/lib/esm/utils/nullable.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/omit.d.ts

@@ -1 +0,0 @@
-export type OmitPropsFromUnion<T, K extends string | number | symbol> = T extends any ? Omit<T, K> : never;

package/lib/esm/utils/omit.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/open-api-parameter.d.ts

@@ -1,7 +0,0 @@
-import type { AuthConfig, FetchRequest, HTTPMethod } from "../definitions/open-api";
-import type { OpenAPIAgentDefinition } from "../open-api-agent";
-export declare function formatOpenAPIRequest(api: {
-    url: string;
-    method: HTTPMethod;
-    auth?: AuthConfig;
-}, inputs: OpenAPIAgentDefinition["inputs"], input: Record<string, any>): Promise<FetchRequest>;