nuabase 2.3.4 → 2.3.7

package/dist/types/nua-llm-core/modules/engine/http/provider-call.d.ts

@@ -0,0 +1,33 @@
+import { Logger } from "../../../lib/logger";
+import { LlmProviderId, NormalizedUsage, ProviderRequestBase } from "./provider-config";
+/** A provider's model, and the API key to call it with. */
+export type ProviderTarget = {
+    provider: LlmProviderId;
+    model: string;
+    apiKey: string;
+};
+/** One HTTP request to an LLM provider, and how to read its reply. */
+export type ProviderCall<T> = {
+    target: ProviderTarget;
+    /** The kind of request, for the log (e.g. "chat/completions", "agentic"). */
+    apiOperation: string;
+    maxTokens: number;
+    request: ProviderRequestBase;
+    /** Throws when the reply is an error or cannot be read. */
+    parseResponse: (response: Response) => Promise<T>;
+    /** Characters of reply text, for the log. */
+    responseLength: (reply: T) => number;
+    usage: (reply: T) => NormalizedUsage | undefined;
+};
+export type ProviderCallResult<T> = {
+    kind: "ok";
+    reply: T;
+}
+/** `status` is undefined when no HTTP response arrived. */
+ | {
+    kind: "failed";
+    status: number | undefined;
+    message: string;
+};
+/** Sends the request and reads the reply, logging the start and the end of the call. Never throws. */
+export declare function callProvider<T>(call: ProviderCall<T>, logger: Logger): Promise<ProviderCallResult<T>>;

package/dist/types/nua-llm-core/modules/engine/http/provider-config.d.ts

@@ -0,0 +1,65 @@
+export type ProviderRequestBase = {
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    /** Request details with secrets removed for logging */
+    loggableUrl?: string;
+    loggableHeaders?: Record<string, string>;
+    loggableBody?: unknown;
+};
+export declare const LLM_PROVIDER_IDS: readonly ["groq", "cerebras", "gemini", "openrouter"];
+export type LlmProviderId = (typeof LLM_PROVIDER_IDS)[number];
+export interface ProviderRequestOptions {
+    prompt: string;
+    model: string;
+    maxTokens: number;
+    assistantPrefillPrompt?: string;
+}
+export type NormalizedUsage = {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+};
+export declare const normalizedUsageZero: NormalizedUsage;
+export type ProviderParsedResponse = {
+    text: string;
+    usage: NormalizedUsage;
+};
+export interface ProviderConfig {
+    providerId: LlmProviderId;
+    apiOperation: string;
+    errorLabel: string;
+    buildRequest(options: ProviderRequestOptions, apiKey: string): ProviderRequestBase;
+    parseResponse(response: Response): Promise<ProviderParsedResponse>;
+}
+type OpenAiThinkingDetail = {
+    type?: string;
+    summary?: string;
+    format?: string;
+    index?: number;
+};
+type OpenAiThinkingMessage = {
+    content?: string | null;
+    reasoning?: string | null;
+    reasoning_details?: Array<OpenAiThinkingDetail | Record<string, unknown>>;
+};
+export type OpenAiUsage = {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    prompt_tokens_details?: Record<string, unknown> | null;
+    completion_tokens_details?: Record<string, unknown> | null;
+    [key: string]: unknown;
+} | null;
+export type GeminiUsageMetadata = {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+    [key: string]: unknown;
+};
+export declare const normalizeOpenAiUsage: (usage: OpenAiUsage | undefined) => NormalizedUsage;
+export declare const normalizeGeminiUsage: (usage: GeminiUsageMetadata | undefined) => NormalizedUsage;
+export declare const extractOpenAiMessageText: (message: OpenAiThinkingMessage | undefined) => string | undefined;
+export declare const providerConfigs: Record<LlmProviderId, ProviderConfig>;
+export {};

package/dist/types/nua-llm-core/modules/engine/http/provider-engines.d.ts

@@ -0,0 +1,35 @@
+import { Logger } from "../../../lib/logger";
+import { ModelInput } from "../../model-info";
+import { EngineRouter, Route } from "../engine-router";
+import { ProviderTarget } from "./provider-call";
+import { LlmProviderId } from "./provider-config";
+export type ProviderEnginesConfig = {
+    /** API keys by provider. Providers without a key are never used. */
+    providers: {
+        [key in LlmProviderId]?: {
+            apiKey: string;
+        };
+    };
+    /** Used when a call names no model. Defaults to the "fast" alias. */
+    model?: ModelInput;
+    /** Defaults to the console. */
+    logger?: Logger;
+};
+type Unroutable = Extract<Route, {
+    kind: "unroutable";
+}>;
+/** Runs calls on LLM providers' HTTP APIs, with API keys. Also runs tool-calling agents (see runAgent). */
+export declare function providerEngines(config: ProviderEnginesConfig): ProviderEngines;
+export declare class ProviderEngines implements EngineRouter {
+    readonly logger: Logger;
+    private readonly apiKeys;
+    private readonly defaultModel;
+    constructor(config: ProviderEnginesConfig);
+    route(model: ModelInput | undefined): Route;
+    /** The provider model, with its API key, that a model choice runs on. */
+    resolve(model: ModelInput | undefined): {
+        kind: "resolved";
+        target: ProviderTarget;
+    } | Unroutable;
+}
+export {};

package/dist/types/nua-llm-core/modules/engine/llm-engine.d.ts

@@ -0,0 +1,73 @@
+import { JsonSchema } from "../../lib/schema-utils";
+import { LlmProviderId, NormalizedUsage } from "./http/provider-config";
+import type { LocalAgentId } from "./local-agent/agent-id";
+/**
+ * How one attempt makes the model produce the output shape.
+ * - in-prompt: the prompt describes the schema; the reply is free text that should contain the JSON.
+ * - native: the engine enforces `schema` itself. It is the output schema wrapped in an
+ *   envelope (see cast/envelope), already converted to the engine's own dialect.
+ */
+export type SchemaEnforcement = {
+    kind: "in-prompt";
+} | {
+    kind: "native";
+    schema: JsonSchema;
+};
+export type SchemaEnforcementKind = SchemaEnforcement["kind"];
+/** One prompt for an engine to answer once, on the model the engine was created for. */
+export type AttemptRequest = {
+    prompt: string;
+    maxTokens: number;
+    enforcement: SchemaEnforcement;
+};
+export type Answer = 
+/** A free-text reply that should contain the JSON result. */
+{
+    kind: "text";
+    text: string;
+}
+/** The envelope object the engine enforced natively. */
+ | {
+    kind: "structured";
+    envelope: unknown;
+};
+/** Which engine produced an answer. */
+export type AnswerOrigin = {
+    engine: "http";
+    provider: LlmProviderId;
+    model: string;
+} | {
+    engine: "local-agent";
+    agent: LocalAgentId;
+    /** The model the agent reports using, else the one requested; undefined when neither is known. */
+    model: string | undefined;
+    /** The agent's own estimate. On a subscription this is not what the user pays. */
+    costUsdEstimate: number | undefined;
+};
+export type AttemptFailure = {
+    /**
+     * - transient: another attempt may succeed.
+     * - fatal: every attempt will fail the same way (bad API key, not logged in, out of quota, timed out).
+     * - schema-rejected: the engine refused the native schema; the in-prompt prompt may still work.
+     */
+    kind: "transient" | "fatal" | "schema-rejected";
+    message: string;
+};
+export type AttemptOutcome = {
+    kind: "answered";
+    answer: Answer;
+    usage: NormalizedUsage;
+    origin: AnswerOrigin;
+} | {
+    kind: "failed";
+    failure: AttemptFailure;
+};
+/**
+ * Answers prompts on one model: an LLM provider's HTTP API, or a coding-agent
+ * CLI on this machine. Expected failures come back as outcomes, not exceptions.
+ */
+export interface LlmEngine {
+    /** The envelope schema in the form this engine enforces natively, or null if it cannot. */
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    attempt(request: AttemptRequest): Promise<AttemptOutcome>;
+}

package/dist/types/nua-llm-core/modules/engine/local-agent/adapters/claude-code.d.ts

@@ -0,0 +1,2 @@
+import { AgentAdapter } from "./types";
+export declare const claudeCodeAdapter: AgentAdapter;

package/dist/types/nua-llm-core/modules/engine/local-agent/adapters/codex.d.ts

@@ -0,0 +1,2 @@
+import { AgentAdapter } from "./types";
+export declare const codexAdapter: AgentAdapter;

package/dist/types/nua-llm-core/modules/engine/local-agent/adapters/failure-classification.d.ts

@@ -0,0 +1,4 @@
+import { AttemptFailure } from "../../llm-engine";
+import { AgentProcessResult } from "./types";
+export declare function classifyAgentFailure(agent: string, message: string): AttemptFailure;
+export declare function stderrTail(result: AgentProcessResult, maxChars?: number): string;

package/dist/types/nua-llm-core/modules/engine/local-agent/adapters/index.d.ts

@@ -0,0 +1,3 @@
+import { LocalAgentId } from "../agent-id";
+import { AgentAdapter } from "./types";
+export declare const AGENT_ADAPTERS: Record<LocalAgentId, AgentAdapter>;

package/dist/types/nua-llm-core/modules/engine/local-agent/adapters/pi.d.ts

@@ -0,0 +1,2 @@
+import { AgentAdapter } from "./types";
+export declare const piAdapter: AgentAdapter;

package/dist/types/nua-llm-core/modules/engine/local-agent/adapters/types.d.ts

@@ -0,0 +1,61 @@
+import { JsonSchema } from "../../../../lib/schema-utils";
+import { ModelAliasName } from "../../../model-info";
+import { NormalizedUsage } from "../../http/provider-config";
+import { Answer, AttemptFailure, AttemptRequest } from "../../llm-engine";
+import { LocalAgentId } from "../agent-id";
+/** A process to run inside a fresh, empty working directory. */
+export type AgentInvocation = {
+    args: string[];
+    stdin: string;
+    /** Files written into the working directory before the process starts. */
+    files?: {
+        name: string;
+        content: string;
+    }[];
+    /** Files read back from the working directory after the process exits. */
+    outputFiles?: string[];
+};
+export type AgentProcessResult = {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    /** Contents of the requested output files; undefined when a file was not written. */
+    outputFiles: Record<string, string | undefined>;
+};
+/** What an agent's output says about one attempt. */
+export type AgentReply = {
+    kind: "answered";
+    answer: Answer;
+    usage: NormalizedUsage;
+    /** The model the agent reports having used, when it says. */
+    model: string | undefined;
+    costUsdEstimate: number | undefined;
+} | {
+    kind: "failed";
+    failure: AttemptFailure;
+};
+export type AgentLoginStatus = {
+    loggedIn: boolean;
+    detail?: string;
+};
+/**
+ * Knows one coding-agent CLI: which models it offers, how to invoke it headless,
+ * and how to read its output. Adapters do no I/O; the process runner does the spawning.
+ */
+export interface AgentAdapter {
+    id: LocalAgentId;
+    /** Executable name looked up on PATH. */
+    binaryName: string;
+    /** Env vars that would make the CLI bill an API key instead of the user's subscription. */
+    apiKeyEnvVars: string[];
+    /** The CLI's own model name for each model alias it has an equivalent for. */
+    modelAliases: Partial<Record<ModelAliasName, string>>;
+    /** The envelope schema in the form this CLI accepts, or null if it can't enforce it. */
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    /** `model` is the CLI's own model name; undefined uses the CLI's default. */
+    buildInvocation(request: AttemptRequest, model: string | undefined): AgentInvocation;
+    readResult(result: AgentProcessResult, request: AttemptRequest): AgentReply;
+    loginStatusArgs: string[];
+    readLoginStatus(result: AgentProcessResult): AgentLoginStatus;
+}

package/dist/types/nua-llm-core/modules/engine/local-agent/agent-id.d.ts

@@ -0,0 +1,4 @@
+/** Supported coding-agent CLIs, in the order findLocalAgent() tries them. */
+export declare const LOCAL_AGENT_IDS: readonly ["claude-code", "codex", "pi"];
+export type LocalAgentId = (typeof LOCAL_AGENT_IDS)[number];
+export declare function isLocalAgentId(value: unknown): value is LocalAgentId;

package/dist/types/nua-llm-core/modules/engine/local-agent/create-local-agent.d.ts

@@ -0,0 +1,36 @@
+import { Logger } from "../../../lib/logger";
+import { LocalAgentId } from "./agent-id";
+import { LocalAgent } from "./local-agent";
+/**
+ * - subscription: removes API-key env vars (ANTHROPIC_API_KEY, OPENAI_API_KEY, ...) from the
+ *   agent's environment, so the CLI uses its own login and plan.
+ * - inherit: passes the environment through unchanged.
+ */
+export type LocalAgentAuthMode = "subscription" | "inherit";
+export type LocalAgentOptions = {
+    /** The agent's own model name (e.g. "haiku" for Claude Code) for calls that name no model. Defaults to the agent's default. */
+    model?: string;
+    /** Per-call limit in milliseconds. Defaults to 180000. */
+    timeoutMs?: number;
+    /** Maximum agent processes running at once. Defaults to 2. */
+    concurrency?: number;
+    /** Defaults to "subscription". */
+    auth?: LocalAgentAuthMode;
+    /** Where calls and cast retries are logged. Defaults to the console. */
+    logger?: Logger;
+};
+export type LocalAgentConfig = LocalAgentOptions & {
+    agent: LocalAgentId;
+    /** Path to the agent executable. Defaults to looking it up on PATH. */
+    binaryPath?: string;
+};
+/**
+ * Sets up the named coding-agent CLI on this machine. Throws right away when the
+ * CLI cannot be found; a missing login shows up as the first call's error. Node.js only.
+ */
+export declare function localAgent(config: LocalAgentConfig): LocalAgent;
+/**
+ * Sets up the first supported coding-agent CLI that is installed and logged in,
+ * trying Claude Code first. Rejects when none is. Node.js only.
+ */
+export declare function findLocalAgent(options?: LocalAgentOptions): Promise<LocalAgent>;

package/dist/types/nua-llm-core/modules/engine/local-agent/detect.d.ts

@@ -0,0 +1,20 @@
+import { LocalAgentId } from "./agent-id";
+export type LocalAgentStatus = {
+    agent: LocalAgentId;
+    installed: false;
+    loggedIn: false;
+    detail?: string;
+} | {
+    agent: LocalAgentId;
+    installed: true;
+    loggedIn: boolean;
+    binaryPath: string;
+    version?: string;
+    detail?: string;
+};
+/**
+ * Reports which supported coding agents are installed and logged in, in
+ * preference order. Runs each CLI's version and login-status commands, which
+ * make no model calls.
+ */
+export declare function detectLocalAgents(binaryPaths?: Partial<Record<LocalAgentId, string>>): Promise<LocalAgentStatus[]>;

package/dist/types/nua-llm-core/modules/engine/local-agent/local-agent-engine.d.ts

@@ -0,0 +1,32 @@
+import { Logger } from "../../../lib/logger";
+import { JsonSchema } from "../../../lib/schema-utils";
+import { AttemptOutcome, AttemptRequest, LlmEngine } from "../llm-engine";
+import { AgentAdapter } from "./adapters/types";
+import { Semaphore } from "./semaphore";
+/** How to run one installed agent's processes. Set up once and shared by all its engines. */
+export type AgentRunner = {
+    adapter: AgentAdapter;
+    binaryPath: string;
+    /** Per-attempt limit. */
+    timeoutMs: number;
+    /** Env vars removed from the agent's environment. */
+    unsetEnv: string[];
+    /** Bounds how many agent processes run at once, across all models. */
+    limiter: Semaphore;
+    logger: Logger;
+};
+/**
+ * Answers prompts on one model of a coding-agent CLI installed on this machine.
+ * Each attempt is one agent process. maxTokens has no CLI equivalent and is ignored.
+ */
+export declare class LocalAgentEngine implements LlmEngine {
+    private readonly runner;
+    /** The CLI's own model name; undefined uses the CLI's default. */
+    private readonly model;
+    constructor(runner: AgentRunner, 
+    /** The CLI's own model name; undefined uses the CLI's default. */
+    model: string | undefined);
+    nativeSchema(envelopeSchema: JsonSchema): JsonSchema | null;
+    attempt(request: AttemptRequest): Promise<AttemptOutcome>;
+    private runAgent;
+}

package/dist/types/nua-llm-core/modules/engine/local-agent/local-agent.d.ts

@@ -0,0 +1,25 @@
+import { Logger } from "../../../lib/logger";
+import { ModelInput } from "../../model-info";
+import { EngineRouter, Route } from "../engine-router";
+import { LocalAgentId } from "./agent-id";
+import { AgentRunner } from "./local-agent-engine";
+/**
+ * A coding-agent CLI on this machine, set up once and ready to run casts.
+ * Created by localAgent() or findLocalAgent().
+ */
+export declare class LocalAgent implements EngineRouter {
+    private readonly runner;
+    /** The CLI's own model name for calls that name no model; undefined uses the CLI's default. */
+    private readonly defaultModel;
+    readonly agent: LocalAgentId;
+    readonly logger: Logger;
+    constructor(runner: AgentRunner, 
+    /** The CLI's own model name for calls that name no model; undefined uses the CLI's default. */
+    defaultModel: string | undefined);
+    /**
+     * No model choice runs the default model. An alias runs the CLI's equivalent
+     * model, if it has one. Provider models cannot run on a local agent.
+     */
+    route(model: ModelInput | undefined): Route;
+    private routeTo;
+}

package/dist/types/nua-llm-core/modules/engine/local-agent/process-runner.d.ts

@@ -0,0 +1,16 @@
+import { AgentInvocation, AgentProcessResult } from "./adapters/types";
+export type RunInvocationOptions = {
+    binaryPath: string;
+    invocation: AgentInvocation;
+    timeoutMs: number;
+    /** Env var names removed from the child's environment. */
+    unsetEnv?: string[];
+};
+/**
+ * Runs one CLI invocation in a fresh temporary directory, so the agent sees no
+ * project files, hooks, MCP config, or instructions, and removes the directory
+ * afterwards. Rejects only when the process cannot be started.
+ */
+export declare function runInvocation(options: RunInvocationOptions): Promise<AgentProcessResult>;
+/** Finds an executable on PATH, honouring PATHEXT on Windows. */
+export declare function findOnPath(binaryName: string): string | null;

package/dist/types/nua-llm-core/modules/engine/local-agent/semaphore.d.ts

@@ -0,0 +1,8 @@
+/** Runs at most `limit` tasks at once; the rest wait in order. */
+export declare class Semaphore {
+    private readonly limit;
+    private active;
+    private readonly waiting;
+    constructor(limit: number);
+    run<T>(task: () => Promise<T>): Promise<T>;
+}

package/dist/types/nua-llm-core/modules/execution/llm-response-extraction.d.ts

@@ -0,0 +1,5 @@
+export declare function extractThinkingFromResponse(input: string): {
+    thinking: string;
+    cleanedResponse: string;
+};
+export declare function parseJsonFromLlmResponse(input: string): object;

package/dist/types/nua-llm-core/modules/json-schema-validation/ajv-instances.d.ts

@@ -0,0 +1,12 @@
+import Ajv from "ajv";
+import Ajv2019 from "ajv/dist/2019.js";
+import Ajv2020 from "ajv/dist/2020.js";
+declare class AjvInstances {
+    readonly draft07: Ajv;
+    readonly draft2019: Ajv2019;
+    readonly draft2020: Ajv2020;
+    constructor();
+    getInstanceForSchema(schema: object): Ajv | Ajv2019 | Ajv2020;
+}
+export declare const ajvInstances: AjvInstances;
+export {};

package/dist/types/nua-llm-core/modules/json-schema-validation/nua-json-schema-value-validation.d.ts

@@ -0,0 +1,10 @@
+export type ValidationResult = {
+    success: boolean;
+    data?: object;
+    error?: string;
+};
+/**
+ * Creates a validation function for checking JSON data against a schema using AJV.
+ * Returns a closure that validates unknown data and returns a typed ValidationResult.
+ */
+export declare function buildNuaJsonSchemaValueValidation(llmRequestId: string, parsedSchema: object): (json: object) => ValidationResult;

package/dist/types/nua-llm-core/modules/json-schema-validation/validate-json-schema.d.ts

@@ -0,0 +1,2 @@
+import { NuaValidationError } from "../../lib/nua-errors";
+export declare const validateJsonSchema: (schema: Object) => true | NuaValidationError;

package/dist/types/nua-llm-core/modules/model-info/index.d.ts

@@ -0,0 +1,15 @@
+import { NuaValidationError } from "../../lib/nua-errors";
+import { LlmProviderId } from "../engine/http/provider-config";
+export type ProviderModel = {
+    provider: LlmProviderId;
+    model: string;
+};
+export type ModelAliasName = "fast" | "gemini" | "qwen" | "sonnet" | "opus" | "haiku" | "kimi" | "gpt";
+export type ModelInput = ProviderModel | {
+    alias: ModelAliasName;
+};
+export declare const MODEL_ALIASES: Record<ModelAliasName, ProviderModel[]>;
+export declare const MODEL_ALIAS_NAMES: ModelAliasName[];
+export declare function isLlmProviderId(value: unknown): value is LlmProviderId;
+export declare function isModelAliasName(value: unknown): value is ModelAliasName;
+export declare function resolveModelInput(input: ModelInput | null | undefined, configuredProviders: ReadonlySet<LlmProviderId>): ProviderModel | NuaValidationError;

package/dist/types/nua-llm-core/modules/streaming/sse-parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generic SSE (Server-Sent Events) stream parser.
+ * Reads a ReadableStream<Uint8Array> and yields each `data:` payload as a string.
+ * Handles OpenAI's `[DONE]` sentinel and Gemini's stream-close-means-done.
+ * Uses only web-standard APIs (no node: imports).
+ */
+export declare function parseSSEStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<string>;

package/dist/types/nua-llm-core/nua-llm-client.d.ts

@@ -0,0 +1,37 @@
+import { ListSchema } from "./modules/cast/list-schema";
+import { CastResult } from "./modules/cast/run-cast";
+import { EngineRouter } from "./modules/engine/engine-router";
+import { ModelInput } from "./modules/model-info";
+export type CastValueParams = {
+    model?: ModelInput;
+    maxTokens?: number;
+    input: {
+        prompt: string;
+        data?: unknown;
+    };
+    output: {
+        name: string;
+        schema: object;
+    };
+};
+export type CastArrayParams = {
+    model?: ModelInput;
+    maxTokens?: number;
+    input: {
+        prompt: string;
+        data: unknown[];
+    };
+    /** Built with listSchema(); it names each row's primary key and output field. */
+    output: ListSchema;
+};
+/**
+ * Turns a prompt, data and a JSON schema into a validated value. Where the calls
+ * run is up to the engine router it is given: providerEngines() for LLM
+ * providers' APIs, or localAgent() from "nua-llm-core/local-agent".
+ */
+export declare class NuaLlmClient {
+    private readonly engines;
+    constructor(engines: EngineRouter);
+    castValue<T = unknown>(params: CastValueParams): Promise<CastResult<T>>;
+    castArray<T = unknown>(params: CastArrayParams): Promise<CastResult<T[]>>;
+}

package/dist/types/nua.d.ts

@@ -1,7 +1,7 @@
 import { DirectConfig } from './backend/direct';
 import { GatewayConfig } from './backend/gateway';
 import { CastResult, QueueResult } from './backend/types';
-import type { ModelInput } from 'nua-llm-core';
+import type { ModelInput } from './nua-llm-core/index';
 import { z } from 'zod';
 export type OutputDef<TSchema extends z.ZodTypeAny> = {
     name: string;
@@ -27,6 +27,11 @@ export declare class Nua {
     private readonly backend;
     private constructor();
     static gateway(config: GatewayConfig): Nua;
+    /**
+     * Runs casts in this process: on LLM providers' APIs with your API keys (`providers`), or
+     * on a coding-agent CLI installed on this machine (`localAgent`, set up with `localAgent()` or
+     * `findLocalAgent()` from "nuabase/local-agent").
+     */
     static direct(config: DirectConfig): Nua;
     get(prompt: string): Promise<CastResult<string>>;
     get<TSchema extends z.ZodTypeAny>(prompt: string, options: GetOptions<TSchema>): Promise<CastResult<z.infer<TSchema>>>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuabase",
   "description": "Nuabase TypeScript client to create typed functions from LLM prompts",
-  "version": "2.3.4",
+  "version": "2.3.7",
   "type": "module",
   "author": "Jasim A Basheer <jasim@nuabase.com>",
   "engines": {
@@ -36,6 +36,23 @@
         "types": "./dist/types/index.d.cts",
         "default": "./dist/cjs/index.cjs"
       }
+    },
+    "./local-agent": {
+      "import": {
+        "types": "./dist/types/local-agent.d.mts",
+        "default": "./dist/esm/local-agent.mjs"
+      },
+      "require": {
+        "types": "./dist/types/local-agent.d.cts",
+        "default": "./dist/cjs/local-agent.cjs"
+      }
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "local-agent": [
+        "./dist/types/local-agent.d.cts"
+      ]
     }
   },
   "peerDependencies": {
@@ -83,7 +100,7 @@
   "scripts": {
     "clean": "rimraf dist",
     "generate-dts": "tsx scripts/generate-dts",
-    "build": "rollup -c rollup.config.js && pnpm run generate-dts",
+    "build": "pnpm run clean && rollup -c rollup.config.js && pnpm run generate-dts",
     "pack:test": "tsx scripts/pack-test",
     "prettier:check": "prettier --check \"**/*.{ts,tsx}\"",
     "prettier:write": "prettier --write \"**/*.{ts,tsx}\"",