@base44-preview/sdk 0.8.32-pr.202.0f8275d → 0.8.32-pr.205.168e407

package/dist/client.js

@@ -7,6 +7,7 @@ import { createConnectorsModule, createUserConnectorsModule, } from "./modules/c
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
+import { createDynamicAgentsModule } from "./modules/dynamic-agents.js";
 import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
@@ -150,6 +151,10 @@ export function createClient(config) {
             serverUrl,
             token,
         }),
+        dynamicAgents: createDynamicAgentsModule({
+            serverUrl,
+            getToken: () => token || getAccessToken() || undefined,
+        }),
         appLogs: createAppLogsModule(axiosClient, appId),
         users: createUsersModule(axiosClient, appId),
         analytics: createAnalyticsModule({
@@ -192,6 +197,10 @@ export function createClient(config) {
             serverUrl,
             token,
         }),
+        dynamicAgents: createDynamicAgentsModule({
+            serverUrl,
+            getToken: () => serviceToken,
+        }),
         appLogs: createAppLogsModule(serviceRoleAxiosClient, appId),
         cleanup: () => {
             if (socket) {

package/dist/client.types.d.ts

@@ -7,6 +7,7 @@ import type { FunctionsModule } from "./modules/functions.types.js";
 import type { AgentsModule } from "./modules/agents.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
+import type { DynamicAgentsModule } from "./modules/dynamic-agents.types.js";
 /**
  * Options for creating a Base44 client.
  */
@@ -85,6 +86,8 @@ export interface Base44Client {
     analytics: AnalyticsModule;
     /** {@link AppLogsModule | App logs module} for tracking app usage. */
     appLogs: AppLogsModule;
+    /** {@link DynamicAgentsModule | Dynamic agents module} for code-defined AI agents and tool loops. */
+    dynamicAgents: DynamicAgentsModule;
     /** {@link AuthModule | Auth module} for user authentication and management. */
     auth: AuthModule;
     /** {@link UserConnectorsModule | Connectors module} for app-user OAuth flows. */
@@ -126,6 +129,8 @@ export interface Base44Client {
         agents: AgentsModule;
         /** {@link AppLogsModule | App logs module} with elevated permissions. */
         appLogs: AppLogsModule;
+        /** {@link DynamicAgentsModule | Dynamic agents module} with elevated permissions. */
+        dynamicAgents: DynamicAgentsModule;
         /** {@link ConnectorsModule | Connectors module} for OAuth token retrieval. */
         connectors: ConnectorsModule;
         /** {@link EntitiesModule | Entities module} with elevated permissions. */

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { createClient, createClientFromRequest, type Base44Client, type CreateClientConfig, type CreateClientOptions } from "./client.js";
 import { Base44Error, type Base44ErrorJSON } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from "./utils/auth-utils.js";
-export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
+import { tool } from "./modules/dynamic-agents.js";
+export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, tool, };
 export type { Base44Client, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
 export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityFilterOperators, EntityFilterQuery, EntityFilterValue, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } from "./modules/entities.types.js";
@@ -13,4 +14,5 @@ export type { AppLogsModule } from "./modules/app-logs.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
 export type { ConnectorsModule, UserConnectorsModule, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
+export type { Tool, JSONSchema, ChatMessage, Step, RunUsage, RunResult, RunInput, RunOptions, ToolChoice, AgentConfig, Agent, DynamicAgentsModule, } from "./modules/dynamic-agents.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 import { createClient, createClientFromRequest, } from "./client.js";
 import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, } from "./utils/auth-utils.js";
-export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
+import { tool } from "./modules/dynamic-agents.js";
+export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, tool, };
 export * from "./types.js";

package/dist/modules/ai-gateway.d.ts

@@ -0,0 +1,20 @@
+import type { DynamicAgentsModuleConfig } from "./dynamic-agents.types.js";
+/**
+ * Resolves the AI Gateway connection from a client config.
+ * @internal
+ */
+export declare function resolveConnection(config: DynamicAgentsModuleConfig): {
+    baseURL: string;
+    apiKey: string;
+};
+/**
+ * Creates the gateway transport. Owns the single HTTP call to the OpenAI-compatible
+ * `/chat/completions` endpoint. Shaped so a streaming `.stream()` method can be added
+ * later without changing callers of `.complete()`.
+ * @internal
+ */
+export declare function createGatewayTransport(config: DynamicAgentsModuleConfig): {
+    complete(body: Record<string, unknown>, opts?: {
+        signal?: AbortSignal;
+    }): Promise<any>;
+};

package/dist/modules/ai-gateway.js

@@ -0,0 +1,42 @@
+import { Base44Error } from "../utils/axios-client.js";
+/**
+ * Resolves the AI Gateway connection from a client config.
+ * @internal
+ */
+export function resolveConnection(config) {
+    var _a;
+    const { serverUrl, getToken } = config;
+    // No appId in the path: the gateway resolves the app by request Host.
+    return {
+        baseURL: `${serverUrl}/api/ai/unified/v1`,
+        apiKey: (_a = getToken()) !== null && _a !== void 0 ? _a : "",
+    };
+}
+/**
+ * Creates the gateway transport. Owns the single HTTP call to the OpenAI-compatible
+ * `/chat/completions` endpoint. Shaped so a streaming `.stream()` method can be added
+ * later without changing callers of `.complete()`.
+ * @internal
+ */
+export function createGatewayTransport(config) {
+    return {
+        async complete(body, opts = {}) {
+            const { baseURL, apiKey } = resolveConnection(config);
+            const res = await fetch(`${baseURL}/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: opts.signal,
+            });
+            const json = await res.json().catch(() => null);
+            if (!res.ok) {
+                const err = (json && json.error) || {};
+                throw new Base44Error(err.message || `AI Gateway request failed with status ${res.status}`, res.status, err.code || err.type || "ai_gateway_error", json, null);
+            }
+            return json;
+        },
+    };
+}

package/dist/modules/dynamic-agents.d.ts

@@ -0,0 +1,32 @@
+import type { AgentConfig, ChatMessage, DynamicAgentsModule, DynamicAgentsModuleConfig, Tool } from "./dynamic-agents.types.js";
+/**
+ * Defines a tool an agent can call.
+ *
+ * @example
+ * ```typescript
+ * const getWeather = tool({
+ *   description: "Get the current weather for a city.",
+ *   parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
+ *   execute: async ({ city }) => ({ city, tempC: 28 }),
+ * });
+ * ```
+ */
+export declare function tool(t: Tool): Tool;
+/**
+ * Maps a `{ name: Tool }` map to the OpenAI `tools[]` array. Returns `undefined`
+ * when empty so the param is omitted from the request body.
+ * @internal
+ */
+export declare function serializeTools(tools?: Record<string, Tool>): any[] | undefined;
+/**
+ * Builds the gateway request body from config + messages using an explicit whitelist.
+ * Rejected params (max_tokens, stop, top_p, penalties, logit_bias, seed, n) can never
+ * appear because only the supported keys are ever written.
+ * @internal
+ */
+export declare function buildRequestBody(config: AgentConfig, messages: ChatMessage[]): Record<string, unknown>;
+/**
+ * Creates the `base44.dynamicAgents` module.
+ * @internal
+ */
+export declare function createDynamicAgentsModule(config: DynamicAgentsModuleConfig): DynamicAgentsModule;

package/dist/modules/dynamic-agents.js

@@ -0,0 +1,176 @@
+import { createGatewayTransport } from "./ai-gateway.js";
+/**
+ * Defines a tool an agent can call.
+ *
+ * @example
+ * ```typescript
+ * const getWeather = tool({
+ *   description: "Get the current weather for a city.",
+ *   parameters: { type: "object", properties: { city: { type: "string" } }, required: ["city"] },
+ *   execute: async ({ city }) => ({ city, tempC: 28 }),
+ * });
+ * ```
+ */
+export function tool(t) {
+    return t;
+}
+/**
+ * Maps a `{ name: Tool }` map to the OpenAI `tools[]` array. Returns `undefined`
+ * when empty so the param is omitted from the request body.
+ * @internal
+ */
+export function serializeTools(tools) {
+    if (!tools)
+        return undefined;
+    const entries = Object.entries(tools);
+    if (entries.length === 0)
+        return undefined;
+    return entries.map(([name, t]) => ({
+        type: "function",
+        function: { name, description: t.description, parameters: t.parameters },
+    }));
+}
+/**
+ * Builds the gateway request body from config + messages using an explicit whitelist.
+ * Rejected params (max_tokens, stop, top_p, penalties, logit_bias, seed, n) can never
+ * appear because only the supported keys are ever written.
+ * @internal
+ */
+export function buildRequestBody(config, messages) {
+    const body = {
+        model: config.model,
+        messages,
+    };
+    if (config.temperature !== undefined)
+        body.temperature = config.temperature;
+    if (config.toolChoice !== undefined)
+        body.tool_choice = config.toolChoice;
+    if (config.responseFormat !== undefined) {
+        body.response_format = {
+            type: "json_schema",
+            json_schema: { name: "response", schema: config.responseFormat, strict: true },
+        };
+    }
+    const tools = serializeTools(config.tools);
+    if (tools)
+        body.tools = tools;
+    return body;
+}
+const DEFAULT_MAX_STEPS = 8;
+function inputToMessages(input) {
+    if ("messages" in input)
+        return input.messages;
+    return [{ role: "user", content: input.prompt }];
+}
+function stringifyResult(out) {
+    return typeof out === "string" ? out : JSON.stringify(out);
+}
+function mapUsage(raw) {
+    const u = (raw && raw.usage) || {};
+    return {
+        promptTokens: u.prompt_tokens,
+        completionTokens: u.completion_tokens,
+        totalTokens: u.total_tokens,
+        credits: u.base44_credits,
+    };
+}
+/**
+ * Creates the `base44.dynamicAgents` module.
+ * @internal
+ */
+export function createDynamicAgentsModule(config) {
+    const transport = createGatewayTransport(config);
+    function create(agentConfig) {
+        var _a;
+        const maxSteps = (_a = agentConfig.maxSteps) !== null && _a !== void 0 ? _a : DEFAULT_MAX_STEPS;
+        const tools = agentConfig.tools;
+        const agent = {
+            async run(input, options = {}) {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                const messages = [];
+                if (agentConfig.system)
+                    messages.push({ role: "system", content: agentConfig.system });
+                messages.push(...inputToMessages(input));
+                const steps = [];
+                let raw = null;
+                for (let i = 0; i < maxSteps; i++) {
+                    const body = buildRequestBody(agentConfig, messages);
+                    raw = await transport.complete(body, { signal: options.abortSignal });
+                    const choice = (_a = raw === null || raw === void 0 ? void 0 : raw.choices) === null || _a === void 0 ? void 0 : _a[0];
+                    const message = (_b = choice === null || choice === void 0 ? void 0 : choice.message) !== null && _b !== void 0 ? _b : { role: "assistant", content: "" };
+                    messages.push(message);
+                    const toolCalls = message.tool_calls;
+                    if (!toolCalls || toolCalls.length === 0) {
+                        return {
+                            text: (_c = message.content) !== null && _c !== void 0 ? _c : "",
+                            steps,
+                            finishReason: (_d = choice === null || choice === void 0 ? void 0 : choice.finish_reason) !== null && _d !== void 0 ? _d : "stop",
+                            usage: mapUsage(raw),
+                            raw,
+                        };
+                    }
+                    const toolResults = [];
+                    for (const call of toolCalls) {
+                        const name = (_e = call.function) === null || _e === void 0 ? void 0 : _e.name;
+                        const t = tools === null || tools === void 0 ? void 0 : tools[name];
+                        let args = {};
+                        try {
+                            args = JSON.parse(((_f = call.function) === null || _f === void 0 ? void 0 : _f.arguments) || "{}");
+                        }
+                        catch (_l) {
+                            args = {};
+                        }
+                        let resultContent;
+                        if (!t) {
+                            resultContent = `Error: tool "${name}" is not available.`;
+                        }
+                        else {
+                            try {
+                                resultContent = stringifyResult(await t.execute(args));
+                            }
+                            catch (e) {
+                                resultContent = `Error: ${(_g = e === null || e === void 0 ? void 0 : e.message) !== null && _g !== void 0 ? _g : String(e)}`;
+                            }
+                        }
+                        messages.push({ role: "tool", tool_call_id: call.id, content: resultContent });
+                        toolResults.push({ toolCallId: call.id, toolName: name, args, result: resultContent });
+                    }
+                    steps.push({ toolResults });
+                }
+                // maxSteps exhausted
+                const lastMessage = (_j = (_h = raw === null || raw === void 0 ? void 0 : raw.choices) === null || _h === void 0 ? void 0 : _h[0]) === null || _j === void 0 ? void 0 : _j.message;
+                return {
+                    text: (_k = lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.content) !== null && _k !== void 0 ? _k : "",
+                    steps,
+                    finishReason: "max_steps",
+                    usage: mapUsage(raw),
+                    raw,
+                };
+            },
+            asTool(toolOpts) {
+                return {
+                    description: toolOpts.description,
+                    parameters: {
+                        type: "object",
+                        properties: { prompt: { type: "string", description: "What to ask the sub-agent." } },
+                        required: ["prompt"],
+                    },
+                    execute: async (args) => {
+                        const result = await agent.run({ prompt: args.prompt });
+                        return result.text;
+                    },
+                };
+            },
+        };
+        return agent;
+    }
+    function run(runConfig, options) {
+        if ("messages" in runConfig) {
+            const { messages, ...agentConfig } = runConfig;
+            return create(agentConfig).run({ messages }, options);
+        }
+        const { prompt, ...agentConfig } = runConfig;
+        return create(agentConfig).run({ prompt }, options);
+    }
+    return { create, run };
+}

package/dist/modules/dynamic-agents.types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * A JSON Schema object describing a tool's input parameters.
+ * Use the standard JSON Schema `object` shape: `{ type: "object", properties: {...}, required: [...] }`.
+ */
+export type JSONSchema = Record<string, unknown>;
+/**
+ * A tool an agent can call. Create one with {@linkcode tool | tool()}, or derive it from a
+ * resource with `.asTool()`.
+ */
+export interface Tool {
+    /** Natural-language description the model uses to decide when to call the tool. */
+    description: string;
+    /** JSON Schema for the tool's arguments. */
+    parameters: JSONSchema;
+    /** Runs the tool. Receives parsed arguments; returns any JSON-serializable value (or a string). */
+    execute: (args: any) => Promise<unknown> | unknown;
+}
+/** An OpenAI-shaped chat message used internally and accepted by {@linkcode Agent.run}. */
+export interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content?: string | null;
+    tool_calls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    tool_call_id?: string;
+}
+/** One iteration of the agent loop: the tool calls the model made and their results. */
+export interface Step {
+    toolResults: Array<{
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+        result: string;
+    }>;
+}
+/** Token/credit usage for a run. `credits` is the Base44 gateway's `base44_credits`. */
+export interface RunUsage {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    credits?: number;
+}
+/** Result of {@linkcode Agent.run} / {@linkcode DynamicAgentsModule.run}. */
+export interface RunResult {
+    /** The model's final text output. */
+    text: string;
+    /** The loop history (one entry per step that made tool calls). */
+    steps: Step[];
+    /** Why the run ended: `"stop"` (model finished), `"tool_calls"`, or `"max_steps"`. */
+    finishReason: string;
+    /** Token and credit usage from the final completion. */
+    usage: RunUsage;
+    /** The raw final completion body, for advanced use. */
+    raw: unknown;
+}
+/** Input to {@linkcode Agent.run}: either a single prompt or a full message list. */
+export type RunInput = {
+    prompt: string;
+} | {
+    messages: ChatMessage[];
+};
+/** Per-run options. */
+export interface RunOptions {
+    /** Abort the run (and the in-flight gateway request). */
+    abortSignal?: AbortSignal;
+}
+/** OpenAI-compatible tool choice. */
+export type ToolChoice = "auto" | "none" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+};
+/** Configuration for a dynamic agent. */
+export interface AgentConfig {
+    /** Model alias (e.g. `"claude_sonnet_4_6"`, `"gpt_5_mini"`) or vendor id. */
+    model: string;
+    /** System prompt. */
+    system?: string;
+    /** Tools the agent may call, keyed by name. */
+    tools?: Record<string, Tool>;
+    /** Max loop iterations before stopping. Default `8`. */
+    maxSteps?: number;
+    /** Sampling temperature. Omitted unless set. Note: GPT-5 models only accept `1`. */
+    temperature?: number;
+    /** A JSON Schema to constrain output to structured JSON (`response_format: json_schema`). */
+    responseFormat?: JSONSchema;
+    /** Controls whether/which tool the model must call. */
+    toolChoice?: ToolChoice;
+}
+/** A reusable dynamic agent. */
+export interface Agent {
+    /** Run the agent's tool-calling loop to completion. */
+    run(input: RunInput, options?: RunOptions): Promise<RunResult>;
+    /**
+     * Turn this agent into a {@linkcode Tool} so another agent can call it as a sub-agent.
+     * (Implemented in Effort 2.)
+     */
+    asTool(opts: {
+        name?: string;
+        description: string;
+    }): Tool;
+}
+/** The `base44.dynamicAgents` module. */
+export interface DynamicAgentsModule {
+    /** Define a reusable agent. */
+    create(config: AgentConfig): Agent;
+    /** One-shot: `create(config).run({ prompt })`. */
+    run(config: AgentConfig & RunInput, options?: RunOptions): Promise<RunResult>;
+}
+/**
+ * Configuration for the dynamic-agents module.
+ *
+ * Note: the gateway resolves the app by request Host, so no `appId` is needed here —
+ * `serverUrl` must be an app-resolving domain.
+ * @internal
+ */
+export interface DynamicAgentsModuleConfig {
+    serverUrl: string;
+    /** Returns the current bearer token at call time (thunk — never a captured string). */
+    getToken: () => string | undefined;
+}

package/dist/modules/dynamic-agents.types.js

@@ -0,0 +1,2 @@
+// src/modules/dynamic-agents.types.ts
+export {};

package/dist/modules/functions.js

@@ -31,38 +31,40 @@ export function createFunctionsModule(axios, appId, config) {
         }
         return headers;
     };
+    // Hoisted so both the returned `invoke` property and `asTool.execute` can reference it
+    // without relying on `this` (which breaks when the object is spread into the client).
+    const invoke = async (functionName, data) => {
+        // Validate input
+        if (typeof data === "string") {
+            throw new Error(`Function ${functionName} must receive an object with named parameters, received: ${data}`);
+        }
+        let formData;
+        let contentType;
+        // Handle file uploads with FormData
+        if (data instanceof FormData ||
+            (data && Object.values(data).some((value) => value instanceof File))) {
+            formData = new FormData();
+            Object.keys(data).forEach((key) => {
+                if (data[key] instanceof File) {
+                    formData.append(key, data[key], data[key].name);
+                }
+                else if (typeof data[key] === "object" && data[key] !== null) {
+                    formData.append(key, JSON.stringify(data[key]));
+                }
+                else {
+                    formData.append(key, data[key]);
+                }
+            });
+            contentType = "multipart/form-data";
+        }
+        else {
+            formData = data;
+            contentType = "application/json";
+        }
+        return axios.post(`/apps/${appId}/functions/${functionName}`, formData || data, { headers: { "Content-Type": contentType } });
+    };
     return {
-        // Invoke a custom backend function by name
-        async invoke(functionName, data) {
-            // Validate input
-            if (typeof data === "string") {
-                throw new Error(`Function ${functionName} must receive an object with named parameters, received: ${data}`);
-            }
-            let formData;
-            let contentType;
-            // Handle file uploads with FormData
-            if (data instanceof FormData ||
-                (data && Object.values(data).some((value) => value instanceof File))) {
-                formData = new FormData();
-                Object.keys(data).forEach((key) => {
-                    if (data[key] instanceof File) {
-                        formData.append(key, data[key], data[key].name);
-                    }
-                    else if (typeof data[key] === "object" && data[key] !== null) {
-                        formData.append(key, JSON.stringify(data[key]));
-                    }
-                    else {
-                        formData.append(key, data[key]);
-                    }
-                });
-                contentType = "multipart/form-data";
-            }
-            else {
-                formData = data;
-                contentType = "application/json";
-            }
-            return axios.post(`/apps/${appId}/functions/${functionName}`, formData || data, { headers: { "Content-Type": contentType } });
-        },
+        invoke,
         // Fetch a backend function endpoint directly.
         async fetch(path, init = {}) {
             const normalizedPath = path.startsWith("/") ? path : `/${path}`;
@@ -75,5 +77,17 @@ export function createFunctionsModule(axios, appId, config) {
             const response = await fetch(joinBaseUrl(config === null || config === void 0 ? void 0 : config.baseURL, primaryPath), requestInit);
             return response;
         },
+        // Turn a backend function into an agent tool.
+        asTool(name, opts) {
+            var _a;
+            return {
+                description: opts.description,
+                parameters: (_a = opts.parameters) !== null && _a !== void 0 ? _a : { type: "object", properties: {}, additionalProperties: true },
+                execute: async (args) => {
+                    const res = await invoke(name, args !== null && args !== void 0 ? args : {});
+                    return res === null || res === void 0 ? void 0 : res.data;
+                },
+            };
+        },
     };
 }

package/dist/modules/functions.types.d.ts

@@ -86,6 +86,19 @@ export interface FunctionsModule {
      * ```
      */
     invoke(functionName: FunctionName, data?: Record<string, any>): Promise<any>;
+    /**
+     * Turns a backend function into a {@linkcode Tool} an agent can call.
+     *
+     * Functions are invoked by name with no server-known input schema, so you supply a
+     * `description` and (optionally) JSON Schema `parameters` for the model.
+     *
+     * @param name - The backend function name.
+     * @param opts - `description` (required) and optional JSON Schema `parameters`.
+     */
+    asTool(name: FunctionName, opts: {
+        description: string;
+        parameters?: Record<string, unknown>;
+    }): import("./dynamic-agents.types.js").Tool;
     /**
      * Performs a direct HTTP request to a backend function path and returns the native `Response`.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.32-pr.202.0f8275d",
+  "version": "0.8.32-pr.205.168e407",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",