@levelcode/sdk 0.0.4 → 0.1.0

package/dist/common/src/types/agent-template.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Backend Agent Template Types
+ *
+ * This file provides backend-compatible agent template types with strict validation.
+ * It imports base types from the user-facing template to eliminate duplication.
+ */
+import { z } from 'zod/v4';
+import type { MCPConfig } from './mcp';
+import type { Model } from '../old-constants';
+import type { ToolResultOutput } from './messages/content-part';
+import type { AgentState, AgentTemplateType } from './session-state';
+import type { ToolCall, AgentState as PublicAgentState } from '../templates/initial-agents-dir/types/agent-definition';
+import type { Logger } from '../templates/initial-agents-dir/types/util-types';
+import type { ToolName } from '../tools/constants';
+export type AgentId = `${string}/${string}@${number}.${number}.${number}`;
+export type OpenRouterReasoningOptions = {
+    /**
+     * https://openrouter.ai/docs/use-cases/reasoning-tokens
+     * One of `max_tokens` or `effort` is required.
+     * If `exclude` is true, reasoning will be removed from the response. Default is false.
+     */
+    enabled?: boolean;
+    exclude?: boolean;
+} & ({
+    max_tokens: number;
+} | {
+    effort: 'high' | 'medium' | 'low' | 'minimal' | 'none';
+});
+export type OpenRouterProviderRoutingOptions = {
+    /**
+     * List of provider slugs to try in order (e.g. ["anthropic", "openai"])
+     */
+    order?: string[];
+    /**
+     * Whether to allow backup providers when primary is unavailable (default: true)
+     */
+    allow_fallbacks?: boolean;
+    /**
+     * Only use providers that support all parameters in your request (default: false)
+     */
+    require_parameters?: boolean;
+    /**
+     * Control whether to use providers that may store data
+     */
+    data_collection?: 'allow' | 'deny';
+    /**
+     * List of provider slugs to allow for this request
+     */
+    only?: string[];
+    /**
+     * List of provider slugs to skip for this request
+     */
+    ignore?: string[];
+    /**
+     * List of quantization levels to filter by (e.g. ["int4", "int8"])
+     */
+    quantizations?: Array<'int4' | 'int8' | 'fp4' | 'fp6' | 'fp8' | 'fp16' | 'bf16' | 'fp32' | 'unknown'>;
+    /**
+     * Sort providers by price, throughput, or latency
+     */
+    sort?: 'price' | 'throughput' | 'latency';
+    /**
+     * Maximum pricing you want to pay for this request
+     */
+    max_price?: {
+        prompt?: number | string;
+        completion?: number | string;
+        image?: number | string;
+        audio?: number | string;
+        request?: number | string;
+    };
+};
+export type OpenRouterProviderOptions = {
+    models?: string[];
+    reasoning?: OpenRouterReasoningOptions;
+    /**
+     * A unique identifier representing your end-user, which can
+     * help OpenRouter to monitor and detect abuse.
+     */
+    user?: string;
+};
+/**
+ * Backend agent template with strict validation and Zod schemas
+ * Extends the user-facing AgentDefinition but with backend-specific requirements
+ */
+export type AgentTemplate<P = string | undefined, T = Record<string, any> | undefined> = {
+    id: AgentTemplateType;
+    displayName: string;
+    model: Model;
+    reasoningOptions?: OpenRouterReasoningOptions;
+    providerOptions?: OpenRouterProviderRoutingOptions;
+    mcpServers: Record<string, MCPConfig>;
+    toolNames: (ToolName | (string & {}))[];
+    spawnableAgents: AgentTemplateType[];
+    spawnerPrompt?: string;
+    systemPrompt: string;
+    instructionsPrompt: string;
+    stepPrompt: string;
+    parentInstructions?: Record<string, string>;
+    inputSchema: {
+        prompt?: z.ZodSchema<P>;
+        params?: z.ZodSchema<T>;
+    };
+    includeMessageHistory: boolean;
+    inheritParentSystemPrompt: boolean;
+    outputMode: 'last_message' | 'all_messages' | 'structured_output';
+    outputSchema?: z.ZodSchema<any>;
+    handleSteps?: StepHandler<P, T> | string;
+};
+export type StepText = {
+    type: 'STEP_TEXT';
+    text: string;
+};
+export type GenerateN = {
+    type: 'GENERATE_N';
+    n: number;
+};
+export declare const StepTextSchema: z.ZodObject<{
+    type: z.ZodLiteral<"STEP_TEXT">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const GenerateNSchema: z.ZodObject<{
+    type: z.ZodLiteral<"GENERATE_N">;
+    n: z.ZodNumber;
+}, z.core.$strip>;
+export declare const HandleStepsToolCallSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodAny>;
+    includeToolCall: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const HandleStepsYieldValueSchema: z.ZodUnion<readonly [z.ZodLiteral<"STEP">, z.ZodLiteral<"STEP_ALL">, z.ZodObject<{
+    type: z.ZodLiteral<"STEP_TEXT">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"GENERATE_N">;
+    n: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    toolName: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodAny>;
+    includeToolCall: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>;
+export type HandleStepsYieldValue = z.infer<typeof HandleStepsYieldValueSchema>;
+export type StepGenerator = Generator<Omit<ToolCall, 'toolCallId'> | 'STEP' | 'STEP_ALL' | StepText | GenerateN, // Generic tool call type
+void, {
+    agentState: PublicAgentState;
+    toolResult: ToolResultOutput[];
+    stepsComplete: boolean;
+    nResponses?: string[];
+}>;
+export type StepHandler<P = string | undefined, T = Record<string, any> | undefined> = (context: {
+    agentState: AgentState;
+    prompt: P;
+    params: T;
+    logger: Logger;
+}) => StepGenerator;
+export { Logger, PublicAgentState };

package/dist/common/src/types/contracts/agent-runtime.d.ts

@@ -0,0 +1,36 @@
+import type { TrackEventFn } from './analytics';
+import type { ConsumeCreditsWithFallbackFn } from './billing';
+import type { HandleStepsLogChunkFn, RequestFilesFn, RequestMcpToolDataFn, RequestOptionalFileFn, RequestToolCallFn, SendActionFn, SendSubagentChunkFn } from './client';
+import type { AddAgentStepFn, DatabaseAgentCache, FetchAgentFromDatabaseFn, FinishAgentRunFn, GetUserInfoFromApiKeyFn, StartAgentRunFn } from './database';
+import type { ClientEnv, CiEnv } from './env';
+import type { PromptAiSdkFn, PromptAiSdkStreamFn, PromptAiSdkStructuredFn } from './llm';
+import type { Logger } from './logger';
+/** Shared dependencies */
+export type AgentRuntimeDeps = {
+    clientEnv: ClientEnv;
+    ciEnv: CiEnv;
+    getUserInfoFromApiKey: GetUserInfoFromApiKeyFn;
+    fetchAgentFromDatabase: FetchAgentFromDatabaseFn;
+    startAgentRun: StartAgentRunFn;
+    finishAgentRun: FinishAgentRunFn;
+    addAgentStep: AddAgentStepFn;
+    consumeCreditsWithFallback: ConsumeCreditsWithFallbackFn;
+    promptAiSdkStream: PromptAiSdkStreamFn;
+    promptAiSdk: PromptAiSdkFn;
+    promptAiSdkStructured: PromptAiSdkStructuredFn;
+    databaseAgentCache: DatabaseAgentCache;
+    trackEvent: TrackEventFn;
+    logger: Logger;
+    fetch: typeof globalThis.fetch;
+};
+/** Per-run dependencies */
+export type AgentRuntimeScopedDeps = {
+    handleStepsLogChunk: HandleStepsLogChunkFn;
+    requestToolCall: RequestToolCallFn;
+    requestMcpToolData: RequestMcpToolDataFn;
+    requestFiles: RequestFilesFn;
+    requestOptionalFile: RequestOptionalFileFn;
+    sendAction: SendActionFn;
+    sendSubagentChunk: SendSubagentChunkFn;
+    apiKey: string;
+};

package/dist/common/src/types/contracts/analytics.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from './logger';
+import type { AnalyticsEvent } from '../../constants/analytics-events';
+export type TrackEventFn = (params: {
+    event: AnalyticsEvent;
+    userId: string;
+    properties?: Record<string, any>;
+    logger: Logger;
+}) => void;

package/dist/common/src/types/contracts/billing.d.ts

@@ -0,0 +1,40 @@
+import type { Logger } from './logger';
+import type { ErrorOr } from '../../util/error';
+export type GetUserUsageDataFn = (params: {
+    userId: string;
+    logger: Logger;
+}) => Promise<{
+    usageThisCycle: number;
+    balance: {
+        totalRemaining: number;
+        totalDebt: number;
+        netBalance: number;
+        breakdown: Record<string, number>;
+    };
+    nextQuotaReset: string;
+    autoTopupTriggered?: boolean;
+    autoTopupEnabled?: boolean;
+}>;
+export type ConsumeCreditsWithFallbackFn = (params: {
+    userId: string;
+    creditsToCharge: number;
+    repoUrl?: string | null;
+    context: string;
+    logger: Logger;
+}) => Promise<ErrorOr<CreditFallbackResult>>;
+export type CreditFallbackResult = {
+    organizationId?: string;
+    organizationName?: string;
+    chargedToOrganization: boolean;
+};
+export type GetOrganizationUsageResponseFn = (params: {
+    organizationId: string;
+    userId: string;
+    logger: Logger;
+}) => Promise<{
+    type: 'usage-response';
+    usage: number;
+    remainingBalance: number;
+    balanceBreakdown: Record<string, never>;
+    next_quota_reset: null;
+}>;

package/dist/common/src/types/contracts/client.d.ts

@@ -0,0 +1,45 @@
+import type { ServerAction } from '../../actions';
+import type { MCPConfig } from '../mcp';
+import type { ToolResultOutput } from '../messages/content-part';
+export type RequestToolCallFn = (params: {
+    userInputId: string;
+    toolName: string;
+    input: Record<string, any> & {
+        timeout_seconds?: number;
+    };
+    mcpConfig?: MCPConfig;
+}) => Promise<{
+    output: ToolResultOutput[];
+}>;
+export type RequestMcpToolDataFn = (params: {
+    mcpConfig: MCPConfig;
+    toolNames: string[] | null;
+}) => Promise<{
+    name: string;
+    description?: string;
+    inputSchema: unknown;
+}[]>;
+export type RequestFilesFn = (params: {
+    filePaths: string[];
+}) => Promise<Record<string, string | null>>;
+export type RequestOptionalFileFn = (params: {
+    filePath: string;
+}) => Promise<string | null>;
+export type SendSubagentChunkFn = (params: {
+    userInputId: string;
+    agentId: string;
+    agentType: string;
+    chunk: string;
+    prompt?: string | undefined;
+    forwardToPrompt?: boolean;
+}) => void;
+export type HandleStepsLogChunkFn = (params: {
+    userInputId: string;
+    runId: string;
+    level: 'debug' | 'info' | 'warn' | 'error';
+    data: unknown;
+    message?: string;
+}) => void;
+export type SendActionFn = (params: {
+    action: ServerAction;
+}) => void;

package/dist/common/src/types/contracts/database.d.ts

@@ -0,0 +1,80 @@
+import type { AgentTemplate } from '@levelcode/common/types/agent-template';
+import type { Logger } from '@levelcode/common/types/contracts/logger';
+type User = {
+    id: string;
+    email: string;
+    discord_id: string | null;
+    referral_code: string | null;
+    stripe_customer_id: string | null;
+    banned: boolean;
+};
+export declare const userColumns: readonly ["id", "email", "discord_id", "referral_code", "stripe_customer_id", "banned"];
+export type UserColumn = keyof User;
+export type GetUserInfoFromApiKeyInput<T extends UserColumn> = {
+    apiKey: string;
+    fields: readonly T[];
+    logger: Logger;
+};
+export type GetUserInfoFromApiKeyOutput<T extends UserColumn> = Promise<{
+    [K in T]: User[K];
+} | null>;
+export type GetUserInfoFromApiKeyFn = <T extends UserColumn>(params: GetUserInfoFromApiKeyInput<T>) => GetUserInfoFromApiKeyOutput<T>;
+type AgentRun = {
+    agent_id: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+};
+export type AgentRunColumn = keyof AgentRun;
+export type GetAgentRunFromIdInput<T extends AgentRunColumn> = {
+    runId: string;
+    userId: string;
+    fields: readonly T[];
+};
+export type GetAgentRunFromIdOutput<T extends AgentRunColumn> = Promise<{
+    [K in T]: AgentRun[K];
+} | null>;
+export type GetAgentRunFromIdFn = <T extends AgentRunColumn>(params: GetAgentRunFromIdInput<T>) => GetAgentRunFromIdOutput<T>;
+/**
+ * Fetch and validate an agent from the database by `publisher/agent-id[@version]` format
+ */
+export type FetchAgentFromDatabaseFn = (params: {
+    apiKey: string;
+    parsedAgentId: {
+        publisherId: string;
+        agentId: string;
+        version?: string;
+    };
+    logger: Logger;
+}) => Promise<AgentTemplate | null>;
+export type StartAgentRunFn = (params: {
+    apiKey: string;
+    userId?: string;
+    agentId: string;
+    ancestorRunIds: string[];
+    logger: Logger;
+}) => Promise<string | null>;
+export type FinishAgentRunFn = (params: {
+    apiKey: string;
+    userId: string | undefined;
+    runId: string;
+    status: 'completed' | 'failed' | 'cancelled';
+    totalSteps: number;
+    directCredits: number;
+    totalCredits: number;
+    errorMessage?: string;
+    logger: Logger;
+}) => Promise<void>;
+export type AddAgentStepFn = (params: {
+    apiKey: string;
+    userId: string | undefined;
+    agentRunId: string;
+    stepNumber: number;
+    credits?: number;
+    childRunIds?: string[];
+    messageId: string | null;
+    status?: 'running' | 'completed' | 'skipped';
+    errorMessage?: string;
+    startTime: Date;
+    logger: Logger;
+}) => Promise<string | null>;
+export type DatabaseAgentCache = Map<string, AgentTemplate | null>;
+export {};

package/dist/common/src/types/contracts/env.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Environment variable contract types for dependency injection.
+ *
+ * ARCHITECTURE:
+ * =============
+ * Base types (defined here in common) that packages extend:
+ *
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │                      BASE TYPES (common)                        │
+ * ├─────────────────────────────────────────────────────────────────┤
+ * │  BaseProcessEnv  - OS/runtime vars (SHELL, HOME, TERM, etc.)   │
+ * │  BaseCiEnv       - CI vars (CI, GITHUB_ACTIONS, etc.)          │
+ * │  ClientEnv       - Public vars (NEXT_PUBLIC_*) from env-schema │
+ * └─────────────────────────────────────────────────────────────────┘
+ *                               │
+ *                     extends   │
+ *                               ▼
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │                    PACKAGE-SPECIFIC ENVS                        │
+ * ├─────────────────────────────────────────────────────────────────┤
+ * │  CLI:    CliProcessEnv = BaseProcessEnv & { CLI-specific }     │
+ * │  SDK:    SdkProcessEnv = BaseProcessEnv & { SDK-specific }     │
+ * │  Server: ServerEnv = ClientEnv & { server secrets }            │
+ * │  Evals:  EvalsCiEnv = BaseCiEnv & { eval-specific }             │
+ * └─────────────────────────────────────────────────────────────────┘
+ *
+ * Each package imports the base types and extends them with package-specific vars.
+ */
+import type { ClientEnv } from '../../env-schema';
+export type { ClientEnv } from '../../env-schema';
+/**
+ * Base CI environment variables.
+ * Used in CI/CD pipelines across all packages.
+ */
+export type BaseCiEnv = {
+    CI?: string;
+    GITHUB_ACTIONS?: string;
+    RENDER?: string;
+    IS_PULL_REQUEST?: string;
+};
+/**
+ * Base runtime environment variables.
+ * These are OS-level env vars common across all packages.
+ */
+export type BaseEnv = {
+    SHELL?: string;
+    COMSPEC?: string;
+    HOME?: string;
+    USERPROFILE?: string;
+    APPDATA?: string;
+    XDG_CONFIG_HOME?: string;
+    TERM?: string;
+    TERM_PROGRAM?: string;
+    TERM_BACKGROUND?: string;
+    TERMINAL_EMULATOR?: string;
+    COLORFGBG?: string;
+    NODE_ENV?: string;
+    NODE_PATH?: string;
+    PATH?: string;
+};
+/**
+ * Extended CI env with LevelCode-specific CI vars.
+ * Used by agent-runtime and server code.
+ */
+export type CiEnv = BaseCiEnv & {
+    LEVELCODE_GITHUB_TOKEN?: string;
+    LEVELCODE_API_KEY?: string;
+    EVAL_RESULTS_EMAIL?: string;
+};
+/**
+ * Extended process env with terminal/IDE detection.
+ * This is the full ProcessEnv used by CLI and SDK.
+ * Packages can import this or create their own extensions of BaseProcessEnv.
+ */
+export type ProcessEnv = BaseEnv & {
+    KITTY_WINDOW_ID?: string;
+    SIXEL_SUPPORT?: string;
+    ZED_NODE_ENV?: string;
+    VSCODE_THEME_KIND?: string;
+    VSCODE_COLOR_THEME_KIND?: string;
+    VSCODE_GIT_IPC_HANDLE?: string;
+    VSCODE_PID?: string;
+    VSCODE_CWD?: string;
+    VSCODE_NLS_CONFIG?: string;
+    CURSOR_PORT?: string;
+    CURSOR?: string;
+    JETBRAINS_REMOTE_RUN?: string;
+    IDEA_INITIAL_DIRECTORY?: string;
+    IDE_CONFIG_DIR?: string;
+    JB_IDE_CONFIG_DIR?: string;
+    VISUAL?: string;
+    EDITOR?: string;
+    LEVELCODE_CLI_EDITOR?: string;
+    LEVELCODE_EDITOR?: string;
+    OPEN_TUI_THEME?: string;
+    OPENTUI_THEME?: string;
+    LEVELCODE_IS_BINARY?: string;
+    LEVELCODE_CLI_VERSION?: string;
+    LEVELCODE_CLI_TARGET?: string;
+    LEVELCODE_RG_PATH?: string;
+    LEVELCODE_WASM_DIR?: string;
+    VERBOSE?: string;
+    OVERRIDE_TARGET?: string;
+    OVERRIDE_PLATFORM?: string;
+    OVERRIDE_ARCH?: string;
+};
+/**
+ * Function type for getting a client env value.
+ */
+export type GetClientEnvFn = () => ClientEnv;
+/**
+ * Function type for getting base env values.
+ */
+export type GetBaseEnvFn = () => BaseEnv;
+/**
+ * Function type for getting full process env values.
+ */
+export type GetProcessEnvFn = () => ProcessEnv;
+/**
+ * Function type for getting base CI env values.
+ */
+export type GetBaseCiEnvFn = () => BaseCiEnv;
+/**
+ * Function type for getting extended CI env values.
+ */
+export type GetCiEnvFn = () => CiEnv;
+/**
+ * Base env deps - minimal set for most functions.
+ */
+export type BaseEnvDeps = {
+    clientEnv: ClientEnv;
+    env: BaseEnv;
+};
+/**
+ * Combined env deps with full process env.
+ * Used in CLI and client-side code.
+ */
+export type EnvDeps = {
+    clientEnv: ClientEnv;
+    processEnv: ProcessEnv;
+};
+/**
+ * Full env deps including CI vars.
+ * Note: ServerEnv is defined in packages/internal and should be imported from there.
+ */
+export type FullEnvDeps = {
+    clientEnv: ClientEnv;
+    processEnv: ProcessEnv;
+    ciEnv: CiEnv;
+};

package/dist/common/src/types/contracts/llm.d.ts

@@ -0,0 +1,102 @@
+import type { TrackEventFn } from './analytics';
+import type { SendActionFn } from './client';
+import type { OpenRouterProviderRoutingOptions, AgentTemplate } from '../agent-template';
+import type { ParamsExcluding } from '../function-params';
+import type { Logger } from './logger';
+import type { Model } from '../../old-constants';
+import type { Message } from '../messages/levelcode-message';
+import type { PromptResult } from '../../util/error';
+import type { generateText, streamText, ToolCallPart } from 'ai';
+import type z from 'zod/v4';
+export type StreamChunk = {
+    type: 'text';
+    text: string;
+    agentId?: string;
+} | {
+    type: 'reasoning';
+    text: string;
+} | Pick<ToolCallPart, 'type' | 'toolCallId' | 'toolName' | 'input' | 'providerOptions'> | {
+    type: 'error';
+    message: string;
+};
+export type PromptAiSdkStreamFn = (params: {
+    apiKey: string;
+    runId: string;
+    messages: Message[];
+    clientSessionId: string;
+    fingerprintId: string;
+    model: Model;
+    userId: string | undefined;
+    chargeUser?: boolean;
+    thinkingBudget?: number;
+    userInputId: string;
+    agentId?: string;
+    maxRetries?: number;
+    onCostCalculated?: (credits: number) => Promise<void>;
+    includeCacheControl?: boolean;
+    agentProviderOptions?: OpenRouterProviderRoutingOptions;
+    /** List of agents that can be spawned - used to transform agent tool calls */
+    spawnableAgents?: string[];
+    /** Map of locally available agent templates - used to transform agent tool calls */
+    localAgentTemplates?: Record<string, AgentTemplate>;
+    /** Cost mode - 'free' mode means 0 credits charged for all agents */
+    costMode?: string;
+    sendAction: SendActionFn;
+    logger: Logger;
+    trackEvent: TrackEventFn;
+    signal: AbortSignal;
+} & ParamsExcluding<typeof streamText, 'model' | 'messages'>) => AsyncGenerator<StreamChunk, PromptResult<string | null>>;
+export type PromptAiSdkFn = (params: {
+    apiKey: string;
+    runId: string;
+    messages: Message[];
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    model: Model;
+    userId: string | undefined;
+    chargeUser?: boolean;
+    agentId?: string;
+    onCostCalculated?: (credits: number) => Promise<void>;
+    includeCacheControl?: boolean;
+    agentProviderOptions?: OpenRouterProviderRoutingOptions;
+    maxRetries?: number;
+    /** Cost mode - 'free' mode means 0 credits charged for all agents */
+    costMode?: string;
+    sendAction: SendActionFn;
+    logger: Logger;
+    trackEvent: TrackEventFn;
+    n?: number;
+    signal: AbortSignal;
+} & ParamsExcluding<typeof generateText, 'model' | 'messages'>) => Promise<PromptResult<string>>;
+export type PromptAiSdkStructuredInput<T> = {
+    apiKey: string;
+    runId: string;
+    messages: Message[];
+    schema: z.ZodType<T>;
+    clientSessionId: string;
+    fingerprintId: string;
+    userInputId: string;
+    model: Model;
+    userId: string | undefined;
+    maxTokens?: number;
+    temperature?: number;
+    timeout?: number;
+    chargeUser?: boolean;
+    agentId?: string;
+    onCostCalculated?: (credits: number) => Promise<void>;
+    includeCacheControl?: boolean;
+    agentProviderOptions?: OpenRouterProviderRoutingOptions;
+    maxRetries?: number;
+    sendAction: SendActionFn;
+    logger: Logger;
+    trackEvent: TrackEventFn;
+    signal: AbortSignal;
+};
+export type PromptAiSdkStructuredOutput<T> = Promise<PromptResult<T>>;
+export type PromptAiSdkStructuredFn = <T>(params: PromptAiSdkStructuredInput<T>) => PromptAiSdkStructuredOutput<T>;
+export type HandleOpenRouterStreamFn = (params: {
+    body: any;
+    userId: string;
+    agentId: string;
+}) => Promise<ReadableStream>;

package/dist/common/src/types/contracts/logger.d.ts

@@ -0,0 +1,8 @@
+export type LoggerFn = (data: unknown, msg?: string, ...args: unknown[]) => unknown;
+export type Logger = {
+    debug: LoggerFn;
+    info: LoggerFn;
+    warn: LoggerFn;
+    error: LoggerFn;
+};
+export type LoggerWithContextFn = (context: Record<string, any>) => Logger;