@yugenlab/vaayu 0.1.3 → 0.1.4

package/chunks/agentic-tool-loop-2FZK72JO.js

@@ -0,0 +1,147 @@
+import "./chunk-IGKYKEKT.js";
+
+// apps/gateway/dist/agent/agentic-tool-loop.js
+async function runAgenticToolLoop(params) {
+  const { initialContent, initialModel, contextMessages, tools, getToolRegistration, isToolAllowed, reChat, maxIterations, signal, logger, sessionId } = params;
+  let currentToolCalls = params.toolCalls;
+  let allToolResults = [];
+  const accumulatedMessages = [...contextMessages];
+  let finalContent = initialContent;
+  let finalModel = initialModel;
+  let iteration = 0;
+  while (currentToolCalls.length > 0 && iteration < maxIterations) {
+    iteration++;
+    if (signal?.aborted) {
+      logger.info("agentic_loop_aborted", { sessionId, iteration });
+      break;
+    }
+    accumulatedMessages.push({
+      role: "assistant",
+      content: finalContent,
+      toolCalls: currentToolCalls
+    });
+    const iterationResults = [];
+    for (const call of currentToolCalls) {
+      const callId = call.id ?? `call_${call.name}_${iteration}`;
+      if (!isToolAllowed(call.name)) {
+        const errorMsg = `Tool "${call.name}" is not allowed by current policy.`;
+        logger.warn("agentic_tool_blocked", { sessionId, tool: call.name, iteration });
+        iterationResults.push({
+          name: call.name,
+          input: call.input,
+          output: { error: errorMsg },
+          ok: false,
+          callId
+        });
+        accumulatedMessages.push({
+          role: "tool",
+          content: JSON.stringify({ error: errorMsg }),
+          name: call.name,
+          toolCallId: callId
+        });
+        continue;
+      }
+      const registration = getToolRegistration(call.name);
+      if (!registration) {
+        const errorMsg = `Tool "${call.name}" not found in registry.`;
+        logger.warn("agentic_tool_not_found", { sessionId, tool: call.name, iteration });
+        iterationResults.push({
+          name: call.name,
+          input: call.input,
+          output: { error: errorMsg },
+          ok: false,
+          callId
+        });
+        accumulatedMessages.push({
+          role: "tool",
+          content: JSON.stringify({ error: errorMsg }),
+          name: call.name,
+          toolCallId: callId
+        });
+        continue;
+      }
+      try {
+        const ctx = {
+          sessionId,
+          signal
+        };
+        const result = await registration.handler(call.input, ctx);
+        const output = result.ok ? result.output : result.error;
+        iterationResults.push({
+          name: call.name,
+          input: call.input,
+          output,
+          ok: result.ok,
+          callId
+        });
+        accumulatedMessages.push({
+          role: "tool",
+          content: JSON.stringify(result.ok ? result.output : { error: result.error }),
+          name: call.name,
+          toolCallId: callId
+        });
+        logger.info("agentic_tool_executed", {
+          sessionId,
+          tool: call.name,
+          ok: result.ok,
+          iteration
+        });
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        logger.warn("agentic_tool_error", {
+          sessionId,
+          tool: call.name,
+          error: errorMsg,
+          iteration
+        });
+        iterationResults.push({
+          name: call.name,
+          input: call.input,
+          output: { error: errorMsg },
+          ok: false,
+          callId
+        });
+        accumulatedMessages.push({
+          role: "tool",
+          content: JSON.stringify({ error: errorMsg }),
+          name: call.name,
+          toolCallId: callId
+        });
+      }
+    }
+    allToolResults = [...allToolResults, ...iterationResults];
+    try {
+      const response = await reChat(accumulatedMessages, tools);
+      finalContent = response.content;
+      finalModel = response.model;
+      currentToolCalls = response.toolCalls ?? [];
+    } catch (error) {
+      logger.warn("agentic_rechat_failed", {
+        sessionId,
+        iteration,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      if (!finalContent && allToolResults.length > 0) {
+        finalContent = allToolResults.map((r) => `${r.name}: ${r.ok ? JSON.stringify(r.output) : `Error: ${JSON.stringify(r.output)}`}`).join("\n");
+      }
+      break;
+    }
+  }
+  if (iteration >= maxIterations && currentToolCalls.length > 0) {
+    logger.warn("agentic_loop_max_iterations", {
+      sessionId,
+      maxIterations,
+      remainingToolCalls: currentToolCalls.length
+    });
+  }
+  return {
+    finalContent,
+    toolResults: allToolResults,
+    iterations: iteration,
+    finalModel
+  };
+}
+export {
+  runAgenticToolLoop
+};
+//# sourceMappingURL=agentic-tool-loop-2FZK72JO.js.map

package/gateway.js

@@ -14387,10 +14387,33 @@ var OpenAICompatibleProvider = class {
     }
     const payload = {
       model: request.model,
-      messages: request.messages.map((message) => ({
-        role: message.role,
-        content: message.content
-      })),
+      messages: request.messages.map((message) => {
+        if (message.role === "assistant" && message.toolCalls?.length) {
+          return {
+            role: "assistant",
+            content: message.content || null,
+            tool_calls: message.toolCalls.map((call) => ({
+              id: call.id ?? `call_${call.name}`,
+              type: "function",
+              function: {
+                name: call.name,
+                arguments: JSON.stringify(call.input)
+              }
+            }))
+          };
+        }
+        if (message.role === "tool") {
+          return {
+            role: "tool",
+            tool_call_id: message.toolCallId ?? message.name ?? "unknown",
+            content: message.content
+          };
+        }
+        return {
+          role: message.role,
+          content: message.content
+        };
+      }),
       temperature: request.temperature,
       top_p: request.topP,
       max_tokens: request.maxTokens,
@@ -14508,10 +14531,49 @@ function splitSystem(messages) {
   };
 }
 function toAnthropicMessages(messages) {
-  return messages.filter((message) => message.role !== "tool").map((message) => ({
-    role: message.role === "assistant" ? "assistant" : "user",
-    content: [{ type: "text", text: message.content }]
-  }));
+  const result = [];
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role === "system") continue;
+    if (message.role === "tool") {
+      const toolResults = [];
+      let j = i;
+      while (j < messages.length) {
+        const tm = messages[j];
+        if (tm.role !== "tool") break;
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: tm.toolCallId ?? tm.name ?? "unknown",
+          content: tm.content
+        });
+        j++;
+      }
+      result.push({ role: "user", content: toolResults });
+      i = j - 1;
+      continue;
+    }
+    if (message.role === "assistant" && message.toolCalls?.length) {
+      const content = [];
+      if (message.content) {
+        content.push({ type: "text", text: message.content });
+      }
+      for (const call of message.toolCalls) {
+        content.push({
+          type: "tool_use",
+          id: call.id ?? `call_${call.name}`,
+          name: call.name,
+          input: call.input
+        });
+      }
+      result.push({ role: "assistant", content });
+      continue;
+    }
+    result.push({
+      role: message.role === "assistant" ? "assistant" : "user",
+      content: [{ type: "text", text: message.content }]
+    });
+  }
+  return result;
 }
 function buildUrl2(config) {
   if (config.path) {
@@ -29723,7 +29785,7 @@ function buildForcedIntentPlan(params) {
   return null;
 }
 async function handleToolPlanning(params) {
-  const { session, message, runId, signal, profile, locale, contextMessages, combinedSystem, resolvedProviderId, resolvedModel, budgetFallbackTarget, routingDecision, routingResult, isPureGreeting: isPureGreeting2, isPureAck: isPureAck2, maybeAppendSmritiMemory, config, logger, storage, toolRegistry, toolPolicy, isToolAllowed: isToolAllowed2, interpretRules: interpretRules2, interpretNlu, planToolInvocation: planToolInvocation2, looksLikeWeatherAsk: looksLikeWeatherAsk2, cleanLocationInput: cleanLocationInput2, isTemporalLocation: isTemporalLocation2, getToolApprovalRequirement: getToolApprovalRequirement2, createToolApprovalRequest, skillSynthEngine, skillSynthEnabled, getProvider, chitraguptaBridge } = params;
+  const { session, message, runId, signal, plannerMode = "default", profile, locale, contextMessages, combinedSystem, resolvedProviderId, resolvedModel, budgetFallbackTarget, routingDecision, routingResult, isPureGreeting: isPureGreeting2, isPureAck: isPureAck2, maybeAppendSmritiMemory, config, logger, storage, toolRegistry, toolPolicy, isToolAllowed: isToolAllowed2, interpretRules: interpretRules2, interpretNlu, planToolInvocation: planToolInvocation2, looksLikeWeatherAsk: looksLikeWeatherAsk2, cleanLocationInput: cleanLocationInput2, isTemporalLocation: isTemporalLocation2, getToolApprovalRequirement: getToolApprovalRequirement2, createToolApprovalRequest, skillSynthEngine, skillSynthEnabled, getProvider, chitraguptaBridge } = params;
   if (!message.text)
     return null;
   const normalized = normalizeIncomingText(message.text);
@@ -29937,6 +29999,10 @@ async function handleToolPlanning(params) {
   let plannerProvider = null;
   let plannerResult = null;
   if (!plan) {
+    if (plannerMode === "deterministic_only") {
+      await maybeRecordActiveToolDiscovery();
+      return null;
+    }
     const plannerRole = config.routing.roles?.planner;
     plannerProviderId = plannerRole?.providerId ?? resolvedProviderId;
     plannerModel = plannerRole?.model ?? resolvedModel;
@@ -30982,6 +31048,8 @@ async function runChatWithFallback(params) {
           messages: prunedMessages ?? baseMessages,
           maxTokens: config.routing.budgets?.maxTokensPerRequest,
           metadata: requestMeta,
+          tools: params.tools,
+          toolChoice: params.toolChoice,
           signal: attemptSignal
         });
         response = await chatWithPolicy({
@@ -31057,7 +31125,8 @@ async function runChatWithFallback(params) {
           reason: "no_healthy_provider",
           retryable: true,
           responseModel: "provider.failure"
-        }
+        },
+        friendlyMessage: "I'm switching routes right now and can still handle quick tasks like weather, reminders, and notes. Please retry this request in a moment."
       };
     }
     return {
@@ -31068,7 +31137,8 @@ async function runChatWithFallback(params) {
         reason: "attempts_exhausted",
         retryable: true,
         responseModel: "provider.failure"
-      }
+      },
+      friendlyMessage: "I couldn't complete that with the current model route. I'm rebalancing providers automatically - please retry this request now."
     };
   }
   return {
@@ -33238,7 +33308,8 @@ async function executeAgentRun(params) {
       taskType: margaDecision.taskType,
       complexity: margaDecision.complexity
     });
-    const skipContent = "Hey! What can I help you with?";
+    const skipKind = margaDecision.taskType === "heartbeat" ? "ack" : "greeting";
+    const skipContent = deps.buildSmalltalkReply(runtime.profile, skipKind, payload.message.channel, locale);
     const skipModel = `marga:${margaDecision.taskType}`;
     await appendAssistantEvent(storage, session.id, skipContent, {
       providerId: "marga",
@@ -33302,6 +33373,11 @@ async function executeAgentRun(params) {
     routingResult.fallbackUsed = false;
     return buildEarlyResult(session, cacheModel, cached2.responseContent, routingDecision, routingResult);
   }
+  const agenticTools = runtime.toolRegistry.list().filter((t2) => deps.isToolAllowed(toolPolicy, t2.name)).filter((t2) => !t2.name.startsWith("memory.")).map((t2) => ({
+    name: t2.name,
+    description: t2.description,
+    inputSchema: t2.inputSchema
+  }));
   const chatResult = await runChatWithFallback({
     sessionId: session.id,
     messageText: payload.message.text,
@@ -33338,10 +33414,63 @@ async function executeAgentRun(params) {
     providerHealth: runtime.providerHealth,
     lastAnthropicCallAt,
     logger,
-    signal: runSignal
+    signal: runSignal,
+    tools: agenticTools.length > 0 ? agenticTools : void 0
   });
   if (!chatResult.ok) {
     const escalation = chatResult.escalation;
+    if (escalation.reason !== "request_aborted" && actionability.kind !== "smalltalk") {
+      const degradedToolResult = await handleToolPlanning({
+        session,
+        message,
+        runId,
+        signal: runSignal,
+        plannerMode: "deterministic_only",
+        profile,
+        locale: locale ?? "en",
+        contextMessages: context.messages,
+        combinedSystem,
+        resolvedProviderId,
+        resolvedModel,
+        budgetFallbackTarget,
+        routingDecision,
+        routingResult,
+        isPureGreeting: deps.isPureGreeting,
+        isPureAck: deps.isPureAck,
+        maybeAppendSmritiMemory: maybeAppendSmritiMemorySafe,
+        config,
+        storage,
+        logger,
+        providerHealth: runtime.providerHealth,
+        getProfile: () => runtime.profile,
+        toolRegistry: runtime.toolRegistry,
+        toolPolicy,
+        isToolAllowed: deps.isToolAllowed,
+        interpretRules: deps.interpretRules,
+        interpretNlu: deps.interpretNlu,
+        planToolInvocation: deps.planToolInvocation,
+        looksLikeWeatherAsk: deps.looksLikeWeatherAsk,
+        cleanLocationInput: deps.cleanLocationInput,
+        isTemporalLocation: deps.isTemporalLocation,
+        getToolApprovalRequirement: deps.getToolApprovalRequirement,
+        createToolApprovalRequest: deps.createToolApprovalRequest,
+        guardToolExecution: deps.guardToolExecution,
+        updateWeatherDefaults: deps.updateWeatherDefaults,
+        formatWeatherResponse: deps.formatWeatherResponse,
+        formatWeatherForecastResponse: deps.formatWeatherForecastResponse,
+        renderToolOutput: deps.renderToolOutput,
+        renderToolFailure: deps.renderToolFailure,
+        stripModelThinking: deps.stripModelThinking,
+        getProvider,
+        skillSynthEngine: deps.skillSynthEngine,
+        skillSynthEnabled: deps.skillSynthEnabled,
+        chitraguptaBridge: runtime.chitraguptaBridge
+      });
+      if (degradedToolResult) {
+        routingResult.escalation = escalation;
+        return degradedToolResult;
+      }
+    }
     const smalltalkFallback = resolveSmalltalkProviderFallback({
       actionability,
       escalation,
@@ -33370,7 +33499,7 @@ async function executeAgentRun(params) {
       routingResult.fallbackUsed = false;
       return buildEarlyResult(session, smalltalkFallback.model, smalltalkFallback.content, routingDecision, routingResult);
     }
-    const content = escalation.policy === "degraded_tools_only" && chatResult.friendlyMessage ? chatResult.friendlyMessage : formatProviderError2(chatResult.error ?? new Error("Provider failed"));
+    const content = chatResult.friendlyMessage ? chatResult.friendlyMessage : formatProviderError2(chatResult.error ?? new Error("Provider failed"));
     const errorModel = escalation.responseModel;
     routingResult.escalation = escalation;
     await appendAssistantEvent(storage, session.id, content, {
@@ -33392,6 +33521,43 @@ async function executeAgentRun(params) {
     return buildEarlyResult(session, errorModel, content, routingDecision, routingResult);
   }
   const { response, provider, model, fallbackUsed } = chatResult;
+  let finalResponse = response;
+  if (response.toolCalls?.length && agenticTools.length > 0) {
+    const { runAgenticToolLoop } = await import("./chunks/agentic-tool-loop-2FZK72JO.js");
+    const agenticResult = await runAgenticToolLoop({
+      toolCalls: response.toolCalls,
+      initialContent: response.content,
+      initialModel: model,
+      contextMessages: [...context.messages, { role: "user", content: payload.message.text }],
+      tools: agenticTools,
+      getToolRegistration: (name) => runtime.toolRegistry.get(name),
+      isToolAllowed: (name) => deps.isToolAllowed(toolPolicy, name),
+      reChat: async (msgs, tools) => {
+        return provider.chat({
+          model,
+          messages: msgs,
+          tools,
+          maxTokens: config.routing.budgets?.maxTokensPerRequest,
+          signal: runSignal
+        });
+      },
+      maxIterations: config.routing.agenticMaxIterations ?? 5,
+      signal: runSignal,
+      logger,
+      sessionId: session.id
+    });
+    finalResponse = {
+      ...response,
+      content: agenticResult.finalContent,
+      model: agenticResult.finalModel,
+      toolCalls: void 0
+    };
+    logger.info("agentic_loop_complete", {
+      sessionId: session.id,
+      iterations: agenticResult.iterations,
+      toolsExecuted: agenticResult.toolResults.length
+    });
+  }
   if (runSignal.aborted) {
     throw new Error("Request aborted");
   }
@@ -33399,7 +33565,7 @@ async function executeAgentRun(params) {
     sessionId: session.id,
     category: semanticCacheCategory,
     query: routingText,
-    responseContent: response.content,
+    responseContent: finalResponse.content,
     selected: { providerId: provider.id, model },
     ttlMs: semanticCacheRule.ttlMs
   });
@@ -33424,7 +33590,7 @@ async function executeAgentRun(params) {
     config,
     provider,
     model,
-    response,
+    response: finalResponse,
     fallbackUsed,
     routingDecision,
     routingResult,
@@ -38453,6 +38619,7 @@ var routingSchema = external_exports.object({
   chatTimeoutMs: external_exports.number().int().min(1e3).max(12e4).default(15e3),
   maxAttempts: external_exports.number().int().min(1).max(10).default(2),
   plannerMaxAttempts: external_exports.number().int().min(1).max(10).default(1),
+  agenticMaxIterations: external_exports.number().int().min(1).max(20).default(5),
   strategy: external_exports.enum(["first", "hash"]).default("hash"),
   minChars: external_exports.number().int().min(10).max(5e3).default(280),
   minWords: external_exports.number().int().min(5).max(500).default(60),
@@ -41004,6 +41171,9 @@ function formatProviderError(error) {
     return "I hit an error while handling that.";
   const raw = error instanceof Error ? error.message : String(error);
   const sanitized = sanitizeProviderError(raw);
+  if (/^(i['’]m|please try)/i.test(sanitized)) {
+    return sanitized;
+  }
   return `I hit an error while handling that: ${sanitized}`;
 }
 function stripAnsi(input) {
@@ -41047,10 +41217,12 @@ function sanitizeProviderError(message) {
   if (/\b(timeout|timed out|etimedout|econnrefused|econnreset|fetch failed|network)\b/i.test(cleaned)) {
     return `${providerLabel} is temporarily unreachable.`;
   }
+  if (/\b(no healthy provider|all providers on cooldown|all candidates on cooldown)\b/i.test(cleaned) || /\bprovider\s+[a-z0-9._-]+\s+unavailable\b/i.test(cleaned)) {
+    return "I'm switching routes automatically right now. Please retry your request in a moment.";
+  }
   const cooling = cleaned.match(/\bcooling down\s*\(([^)]+)\)/i);
   if (cooling) {
-    const reason = cooling[1]?.trim() || "temporary_error";
-    return `${providerLabel} is cooling down (${reason}). You can run /provider reset all or wait briefly.`;
+    return "I'm switching routes automatically right now. Please retry your request in a moment.";
   }
   if (providerId) {
     return `${providerLabel} failed.`;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@yugenlab/vaayu",
-	"version": "0.1.3",
+	"version": "0.1.4",
 	"description": "AI gateway — multi-provider, multi-channel personal AI assistant with memory",
 	"type": "module",
 	"author": "Srinivas Pendela",