@absolutejs/ai 0.0.54-beta.0 → 0.0.55

package/README.md

@@ -5,6 +5,31 @@ Standalone AI runtime and provider package extracted from AbsoluteJS.
 This package currently focuses on generic AI/chat/provider functionality.
 RAG remains a separate package.
 
+## Anthropic hosted web search
+
+The Anthropic provider can request native hosted web search without a custom
+client tool. Search blocks are replayable provider data, citations are emitted
+as portable `citation` chunks, usage includes `serverToolUse`, and
+`streamAIWithTools` continues `pause_turn` responses automatically.
+
+```ts
+const result = await generateAI({
+  provider: anthropic({ apiKey: process.env.ANTHROPIC_API_KEY }),
+  model: "claude-sonnet-4-6",
+  messages: [{ role: "user", content: "What changed today?" }],
+  providerOptions: {
+    anthropic: {
+      serverTools: [
+        {
+          type: "anthropic:web_search",
+          parameters: { maxUses: 3 },
+        },
+      ],
+    },
+  },
+});
+```
+
 Provider traffic can cross a trusted control plane without reimplementing a
 vendor protocol. `remoteProvider()` carries normalized provider parameters and
 chunks over SSE, while `createProviderProxyResponse()` hosts any

package/dist/ai/index.js

@@ -1870,6 +1870,61 @@ var mapToolDefinition2 = (tool) => ({
   input_schema: tool.input_schema,
   name: tool.name
 });
+var requestOptionsFor = (params) => {
+  const raw = params.providerOptions?.anthropic;
+  if (raw === undefined)
+    return {};
+  if (!isRecord4(raw)) {
+    throw new Error("providerOptions.anthropic must be an object");
+  }
+  if (raw.serverTools !== undefined && !Array.isArray(raw.serverTools)) {
+    throw new Error("Anthropic serverTools must be an array");
+  }
+  return raw;
+};
+var assertDomains = (domains) => {
+  for (const domain of domains ?? []) {
+    if (!domain || domain.includes("://")) {
+      throw new Error("Anthropic web-search domains must be non-empty bare domains without a scheme");
+    }
+  }
+};
+var mapServerTool = (tool) => {
+  const parameters = tool.parameters ?? {};
+  if (parameters.allowedDomains && parameters.blockedDomains) {
+    throw new Error("Anthropic web search accepts allowedDomains or blockedDomains, not both");
+  }
+  assertDomains(parameters.allowedDomains);
+  assertDomains(parameters.blockedDomains);
+  if (parameters.maxUses !== undefined && (!Number.isInteger(parameters.maxUses) || parameters.maxUses < 1)) {
+    throw new Error("Anthropic web-search maxUses must be a positive integer");
+  }
+  if (parameters.responseInclusion !== undefined && parameters.version !== "web_search_20260318") {
+    throw new Error("Anthropic web-search responseInclusion requires web_search_20260318");
+  }
+  const location = parameters.userLocation;
+  if (location && !location.city && !location.country && !location.region && !location.timezone) {
+    throw new Error("Anthropic web-search userLocation requires a city, region, country, or timezone");
+  }
+  return {
+    ...parameters.allowedCallers ? { allowed_callers: [...parameters.allowedCallers] } : {},
+    ...parameters.allowedDomains ? { allowed_domains: [...parameters.allowedDomains] } : {},
+    ...parameters.blockedDomains ? { blocked_domains: [...parameters.blockedDomains] } : {},
+    ...parameters.maxUses === undefined ? {} : { max_uses: parameters.maxUses },
+    name: "web_search",
+    ...parameters.responseInclusion ? { response_inclusion: parameters.responseInclusion } : {},
+    type: parameters.version ?? "web_search_20250305",
+    ...location ? {
+      user_location: {
+        ...location.city ? { city: location.city } : {},
+        ...location.country ? { country: location.country } : {},
+        ...location.region ? { region: location.region } : {},
+        ...location.timezone ? { timezone: location.timezone } : {},
+        type: "approximate"
+      }
+    } : {}
+  };
+};
 var cacheLastContentBlock = (msg) => {
   const cacheControl = { type: "ephemeral" };
   if (typeof msg.content === "string") {
@@ -1892,6 +1947,7 @@ var cacheLastContentBlock = (msg) => {
 var buildRequestBody4 = (params, configuredMax, configCaching) => {
   const caching = params.promptCaching ?? configCaching;
   const cacheSystem = params.cacheSystemPrompt ?? caching;
+  const options = requestOptionsFor(params);
   const messages = params.messages.filter((msg) => msg.role !== "system").map(mapMessage);
   if (caching && messages.length > 1) {
     const last = messages[messages.length - 1];
@@ -1915,14 +1971,18 @@ var buildRequestBody4 = (params, configuredMax, configCaching) => {
       }
     ] : params.systemPrompt;
   }
-  if (params.tools && params.tools.length > 0) {
-    const tools = params.tools.map(mapToolDefinition2);
+  const clientTools = params.tools?.map(mapToolDefinition2) ?? [];
+  if (clientTools.length > 0) {
     if (caching) {
-      tools[tools.length - 1] = {
-        ...tools[tools.length - 1],
+      clientTools[clientTools.length - 1] = {
+        ...clientTools[clientTools.length - 1],
         cache_control: { type: "ephemeral" }
       };
     }
+  }
+  const serverTools = (options.serverTools ?? []).map(mapServerTool);
+  const tools = [...clientTools, ...serverTools];
+  if (tools.length > 0) {
     body.tools = tools;
     if (params.toolChoice === "auto" || params.toolChoice === "none") {
       body.tool_choice = { type: params.toolChoice };
@@ -2060,6 +2120,17 @@ var handleContentBlockDelta = (parsed, state) => {
       type: "text"
     };
   }
+  if (delta.type === "citations_delta") {
+    const citation = getRecord(delta, "citation");
+    if (citation?.type === "web_search_result_location" && getString(citation, "url")) {
+      return {
+        content: getString(citation, "cited_text") || undefined,
+        title: getString(citation, "title") || undefined,
+        type: "citation",
+        url: getString(citation, "url")
+      };
+    }
+  }
   if (delta.type === "input_json_delta") {
     if (state.currentProviderBlock) {
       state.providerBlockInputJson += getString(delta, "partial_json");
@@ -3163,7 +3234,7 @@ var mapRouting = (routing, allowedProviders) => {
     wire.zdr = routing.zdr;
   return wire;
 };
-var requestOptionsFor = (params, defaults) => {
+var requestOptionsFor2 = (params, defaults) => {
   const supplied = params.providerOptions?.openrouter;
   if (supplied !== undefined && (typeof supplied !== "object" || !supplied)) {
     throw new Error("providerOptions.openrouter must be an object");
@@ -3183,7 +3254,7 @@ var resolveAttributionHeaders = async (config2, params) => {
   if (config2.appCategories?.length) {
     headers.set("X-OpenRouter-Categories", config2.appCategories.join(","));
   }
-  const options = requestOptionsFor(params, config2.requestOptions);
+  const options = requestOptionsFor2(params, config2.requestOptions);
   if (options.routerMetadata ?? true)
     headers.set("X-OpenRouter-Metadata", "enabled");
   if (options.sessionId)
@@ -3348,7 +3419,7 @@ var snapshotPolicy = (config2) => ({
   allowedPresets: config2.allowedPresets ? [...config2.allowedPresets] : undefined
 });
 var transformOpenRouterRequest = (config2, allowedModels, allowedPresets, body, params, skin = "openai") => {
-  const options = requestOptionsFor(params, config2.requestOptions);
+  const options = requestOptionsFor2(params, config2.requestOptions);
   assertRequestOptions(options, allowedModels, allowedPresets, config2.allowedProviders);
   const transformed = { ...body, ...options.extraBody };
   if (options.audioOutput) {
@@ -5169,6 +5240,7 @@ var streamAIWithTools = async function* (options) {
     const blocks = [];
     const pending = [];
     let thinking = null;
+    let stopReason;
     let turnUsage;
     for await (const chunk of stream) {
       if (base.signal?.aborted)
@@ -5212,11 +5284,12 @@ var streamAIWithTools = async function* (options) {
         });
       } else if (chunk.type === "done") {
         thinking = flushThinking3(blocks, thinking);
+        stopReason = chunk.stopReason;
         turnUsage = chunk.usage;
       }
     }
     thinking = flushThinking3(blocks, thinking);
-    return { blocks, pending, usage: turnUsage };
+    return { blocks, pending, stopReason, usage: turnUsage };
   };
   while (turn < maxTurns) {
     turn += 1;
@@ -5225,6 +5298,10 @@ var streamAIWithTools = async function* (options) {
     yield { type: "turn", usage: outcome.usage };
     const { blocks, pending } = outcome;
     allToolCalls.push(...pending);
+    if (outcome.stopReason === "pause_turn" && turn < maxTurns && base.signal?.aborted !== true) {
+      messages.push({ content: blocks, role: "assistant" });
+      continue;
+    }
     const allRepeats = pending.length > 0 && pending.every((call) => executedKeys.has(toolCallKey(call)));
     const finished = pending.length === 0 || turn >= maxTurns || allRepeats || base.signal?.aborted === true;
     if (finished)
@@ -7669,5 +7746,5 @@ export {
   BUILTIN_UI_CARDS
 };
 
-//# debugId=1D47D14F189FCCCF64756E2164756E21
+//# debugId=F018C48519101C9264756E2164756E21
 //# sourceMappingURL=index.js.map