@hsuite/smart-engines-sdk 3.12.0 → 3.13.1

package/dist/index.d.ts

@@ -3885,7 +3885,7 @@ export type AgentExecuteRequest = {
 	params: Record<string, unknown>;
 };
 export type AgentExecuteStepResult = {
-	kind: "onchain" | "offchain";
+	kind: "onchain" | "offchain" | "function";
 	status: string;
 	transactionBytes?: string;
 	ref?: string;
@@ -5405,6 +5405,8 @@ export type InferArgs = {
 	system?: string;
 	messages: ChatMessage[];
 	maxTokens?: number;
+	timeoutMs?: number;
+	signal?: AbortSignal;
 };
 export type InferResult = {
 	ok: boolean;
@@ -5421,8 +5423,9 @@ export declare function createAnthropicProvider(opts: {
 	model: string;
 }): IModelProvider;
 export declare function createOpenAiProvider(opts: {
-	apiKey: string;
+	apiKey?: string;
 	model: string;
+	baseURL?: string;
 }): IModelProvider;
 export declare function createGeminiProvider(opts: {
 	apiKey: string;
@@ -5430,8 +5433,9 @@ export declare function createGeminiProvider(opts: {
 }): IModelProvider;
 export declare function createModelProvider(opts: {
 	provider: ModelProvider;
-	apiKey: string;
+	apiKey?: string;
 	model: string;
+	baseURL?: string;
 }): IModelProvider;
 export type InferJsonResult<T> = {
 	ok: boolean;
@@ -5441,11 +5445,14 @@ export type InferJsonResult<T> = {
 };
 export declare function inferJson<T = unknown>(opts: {
 	provider: ModelProvider;
-	apiKey: string;
+	apiKey?: string;
 	model: string;
+	baseURL?: string;
 	system?: string;
 	input: unknown;
 	maxTokens?: number;
+	timeoutMs?: number;
+	signal?: AbortSignal;
 	parse?: (raw: unknown) => T;
 }): Promise<InferJsonResult<T>>;
 export type StateRootResponse = {

package/dist/index.js

@@ -10385,6 +10385,65 @@ __export(ai_exports, {
   inferJson: () => inferJson
 });
 
+// src/ai/types.ts
+var DEFAULT_INFER_TIMEOUT_MS = 3e4;
+
+// src/ai/http.ts
+var InferTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`request timed out after ${timeoutMs}ms`);
+    this.name = "InferTimeoutError";
+  }
+};
+function isAbortError(err) {
+  if (err instanceof InferTimeoutError) {
+    return true;
+  }
+  return typeof err === "object" && err !== null && err.name === "AbortError";
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function fetchWithTimeout(url, init, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_INFER_TIMEOUT_MS;
+  const callerSignal = opts.signal;
+  const controller = new AbortController();
+  let timedOut = false;
+  let timer;
+  if (timeoutMs > 0) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    if (typeof timer === "object" && typeof timer.unref === "function") {
+      timer.unref();
+    }
+  }
+  const onCallerAbort = () => controller.abort();
+  if (callerSignal) {
+    if (callerSignal.aborted) {
+      controller.abort();
+    } else {
+      callerSignal.addEventListener("abort", onCallerAbort, { once: true });
+    }
+  }
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (timedOut) {
+      throw new InferTimeoutError(timeoutMs);
+    }
+    throw err;
+  } finally {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+    if (callerSignal) {
+      callerSignal.removeEventListener("abort", onCallerAbort);
+    }
+  }
+}
+
 // src/ai/anthropic.ts
 var ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 var ANTHROPIC_VERSION = "2023-06-01";
@@ -10403,15 +10462,27 @@ function createAnthropicProvider(opts) {
       if (args.system) {
         body.system = args.system;
       }
-      const res = await fetch(ANTHROPIC_URL, {
-        method: "POST",
-        headers: {
-          "x-api-key": apiKey,
-          "anthropic-version": ANTHROPIC_VERSION,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify(body)
-      });
+      let res;
+      try {
+        res = await fetchWithTimeout(
+          ANTHROPIC_URL,
+          {
+            method: "POST",
+            headers: {
+              "x-api-key": apiKey,
+              "anthropic-version": ANTHROPIC_VERSION,
+              "content-type": "application/json"
+            },
+            body: JSON.stringify(body)
+          },
+          { timeoutMs: args.timeoutMs, signal: args.signal }
+        );
+      } catch (err) {
+        if (isAbortError(err)) {
+          return { ok: false, error: errMsg(err) };
+        }
+        throw err;
+      }
       if (!res.ok) {
         throw new Error(`Anthropic request failed with status ${res.status}`);
       }
@@ -10426,10 +10497,11 @@ function createAnthropicProvider(opts) {
 }
 
 // src/ai/openai.ts
-var OPENAI_URL = "https://api.openai.com/v1/chat/completions";
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 var DEFAULT_MAX_TOKENS2 = 1024;
 function createOpenAiProvider(opts) {
   const { apiKey, model } = opts;
+  const url = `${(opts.baseURL ?? DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, "")}/chat/completions`;
   return {
     provider: "openai",
     async infer(args) {
@@ -10440,18 +10512,32 @@ function createOpenAiProvider(opts) {
       for (const m of args.messages) {
         messages.push({ role: m.role, content: m.content });
       }
-      const res = await fetch(OPENAI_URL, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "content-type": "application/json"
-        },
-        body: JSON.stringify({
-          model,
-          max_tokens: args.maxTokens ?? DEFAULT_MAX_TOKENS2,
-          messages
-        })
-      });
+      let res;
+      try {
+        res = await fetchWithTimeout(
+          url,
+          {
+            method: "POST",
+            headers: {
+              // Auth only when a key is supplied — a keyless local server (Ollama)
+              // rejects a bogus Bearer header.
+              ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+              "content-type": "application/json"
+            },
+            body: JSON.stringify({
+              model,
+              max_tokens: args.maxTokens ?? DEFAULT_MAX_TOKENS2,
+              messages
+            })
+          },
+          { timeoutMs: args.timeoutMs, signal: args.signal }
+        );
+      } catch (err) {
+        if (isAbortError(err)) {
+          return { ok: false, error: errMsg(err) };
+        }
+        throw err;
+      }
       if (!res.ok) {
         throw new Error(`OpenAI request failed with status ${res.status}`);
       }
@@ -10484,12 +10570,27 @@ function createGeminiProvider(opts) {
       if (args.system) {
         body.systemInstruction = { parts: [{ text: args.system }] };
       }
-      const url = `${GEMINI_BASE}/${model}:generateContent?key=${encodeURIComponent(apiKey)}`;
-      const res = await fetch(url, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(body)
-      });
+      const url = `${GEMINI_BASE}/${model}:generateContent`;
+      let res;
+      try {
+        res = await fetchWithTimeout(
+          url,
+          {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              "x-goog-api-key": apiKey
+            },
+            body: JSON.stringify(body)
+          },
+          { timeoutMs: args.timeoutMs, signal: args.signal }
+        );
+      } catch (err) {
+        if (isAbortError(err)) {
+          return { ok: false, error: errMsg(err) };
+        }
+        throw err;
+      }
       if (!res.ok) {
         throw new Error(`Gemini request failed with status ${res.status}`);
       }
@@ -10505,14 +10606,14 @@ function createGeminiProvider(opts) {
 
 // src/ai/factory.ts
 function createModelProvider(opts) {
-  const { provider, apiKey, model } = opts;
+  const { provider, apiKey, model, baseURL } = opts;
   switch (provider) {
     case "anthropic":
-      return createAnthropicProvider({ apiKey, model });
+      return createAnthropicProvider({ apiKey: apiKey ?? "", model });
     case "openai":
-      return createOpenAiProvider({ apiKey, model });
+      return createOpenAiProvider({ apiKey, model, baseURL });
     case "gemini":
-      return createGeminiProvider({ apiKey, model });
+      return createGeminiProvider({ apiKey: apiKey ?? "", model });
     default: {
       const never = provider;
       throw new Error(`Unsupported model provider: ${String(never)}`);
@@ -10523,19 +10624,64 @@ function createModelProvider(opts) {
 // src/ai/infer-json.ts
 var JSON_ONLY_INSTRUCTION = "Respond with ONLY a single JSON object, no prose.";
 var RETRY_INSTRUCTION = "Return valid JSON only.";
+function nextBalancedObject(raw, from) {
+  const start = raw.indexOf("{", from);
+  if (start === -1) {
+    return null;
+  }
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < raw.length; i++) {
+    const ch = raw[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return [start, i];
+      }
+    }
+  }
+  return null;
+}
 function extractJson(raw) {
-  const start = raw.indexOf("{");
-  const end = raw.lastIndexOf("}");
-  if (start === -1 || end === -1 || end < start) {
-    throw new Error("no JSON object found in reply");
+  let from = 0;
+  let sawCandidate = false;
+  for (; ; ) {
+    const span = nextBalancedObject(raw, from);
+    if (!span) {
+      break;
+    }
+    sawCandidate = true;
+    const slice = raw.slice(span[0], span[1] + 1);
+    try {
+      return JSON.parse(slice);
+    } catch {
+      from = span[0] + 1;
+    }
   }
-  return JSON.parse(raw.slice(start, end + 1));
+  throw new Error(
+    sawCandidate ? "no valid JSON object found in reply" : "no JSON object found in reply"
+  );
 }
 async function inferJson(opts) {
-  const { provider, apiKey, model, system, input, maxTokens, parse } = opts;
+  const { provider, apiKey, model, baseURL, system, input, maxTokens, timeoutMs, signal, parse } = opts;
   let client;
   try {
-    client = createModelProvider({ provider, apiKey, model });
+    client = createModelProvider({ provider, apiKey, model, baseURL });
   } catch (err) {
     return { ok: false, error: errMsg(err) };
   }
@@ -10544,7 +10690,11 @@ async function inferJson(opts) {
 ${JSON_ONLY_INSTRUCTION}` : JSON_ONLY_INSTRUCTION;
   const userContent = typeof input === "string" ? input : JSON.stringify(input);
   const messages = [{ role: "user", content: userContent }];
-  const first = await runOnce(client, { system: systemPrompt, messages, maxTokens }, parse);
+  const first = await runOnce(
+    client,
+    { system: systemPrompt, messages, maxTokens, timeoutMs, signal },
+    parse
+  );
   if (first.ok) {
     return first;
   }
@@ -10555,7 +10705,7 @@ ${JSON_ONLY_INSTRUCTION}` : JSON_ONLY_INSTRUCTION;
   retryMessages.push({ role: "user", content: RETRY_INSTRUCTION });
   const second = await runOnce(
     client,
-    { system: systemPrompt, messages: retryMessages, maxTokens },
+    { system: systemPrompt, messages: retryMessages, maxTokens, timeoutMs, signal },
     parse
   );
   return second;
@@ -10579,9 +10729,6 @@ async function runOnce(client, args, parse) {
     return { ok: false, error: errMsg(err), raw };
   }
 }
-function errMsg(err) {
-  return err instanceof Error ? err.message : String(err);
-}
 
 // src/baas/index.ts
 var baas_exports = {};