@tool-bridge/server 0.16.0 → 0.19.0

package/dist/{amap-LGVGNPML.js → amap-CYQCYW2Z.js}

@@ -1,21 +1,27 @@
+import {
+  createProviderHttpClient
+} from "./chunk-VLOIDU5U.js";
+import {
+  asJsonObject,
+  booleanValue,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
 import {
   createProviderPlugin,
   requireApiKey,
   upstreamError
-} from "./chunk-VK3V2WTY.js";
-import {
-  guardedFetch
-} from "./chunk-2O27H4Y2.js";
-import "./chunk-GKX72JMJ.js";
+} from "./chunk-B4P6YZFS.js";
+import "./chunk-SWBNHIO4.js";
 import {
   TBError,
   external_exports
-} from "./chunk-YB2FLNWI.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-OKRZPQ3R.js";
+import "./chunk-U67V476Y.js";
 
 // ../plugins/src/amap/api.ts
 var SERVICE = "amap";
 var API_BASE = "https://restapi.amap.com";
+var http = createProviderHttpClient({ baseUrl: API_BASE, service: SERVICE });
 var MAX_GET_URL_LENGTH = 2e3;
 var AUTH_INFOS = /* @__PURE__ */ new Set([
   "INVALID_USER_KEY",
@@ -31,23 +37,12 @@ var RATE_LIMIT_INFOS = /* @__PURE__ */ new Set(["DAILY_QUERY_OVER_LIMIT", "ACCES
 var RATE_LIMIT_INFOCODES = /* @__PURE__ */ new Set(["10003", "10004"]);
 var INPUT_ERROR_INFOS = /* @__PURE__ */ new Set(["MISSING_REQUIRED_PARAMS", "INVALID_PARAMS"]);
 var INPUT_ERROR_INFOCODES = /* @__PURE__ */ new Set(["18001", "18002"]);
-function text(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
 function number(value) {
   return typeof value === "number" ? value : void 0;
 }
-function boolean(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
 function recordArray(value) {
   if (!Array.isArray(value)) return [];
-  return value.map((item) => record(item)).filter((item) => item !== void 0);
+  return value.map((item) => asJsonObject(item)).filter((item) => item !== void 0);
 }
 function stringOrStringArray(value) {
   if (typeof value === "string") return value;
@@ -55,7 +50,7 @@ function stringOrStringArray(value) {
   return value.filter((item) => typeof item === "string");
 }
 function requireText(value, field) {
-  const result = text(value);
+  const result = trimmedText(value);
   if (result === void 0) throw new TBError("invalid_argument", `${field} is required.`);
   return result;
 }
@@ -93,30 +88,26 @@ function amapError(status, payload) {
   return upstreamError(status === 0 ? 500 : status, message);
 }
 async function amapGet(ctx, path, query) {
-  const url = buildUrl(path, { ...query, key: requireApiKey(ctx, SERVICE) });
-  let response;
-  try {
-    response = await guardedFetch(url, { method: "GET", headers: { accept: "application/json" } });
-  } catch (error) {
-    if (error instanceof TBError) throw error;
-    throw upstreamError(
+  const { data, status } = await http.request({
+    path,
+    method: "GET",
+    query: Object.entries({ ...query, key: requireApiKey(ctx, SERVICE) }),
+    headers: { accept: "application/json" },
+    invalidJsonMessage: "amap \u8FD4\u56DE\u4E86\u975E JSON \u5BF9\u8C61\u54CD\u5E94",
+    mapError: ({ data: payload2, status: status2 }) => {
+      const body = asJsonObject(payload2);
+      return body === void 0 ? new TBError("unavailable", "amap \u8FD4\u56DE\u4E86\u975E JSON \u5BF9\u8C61\u54CD\u5E94", { retryable: true }) : amapError(status2, body);
+    },
+    mapTransportError: ({ message }) => upstreamError(
       502,
-      error instanceof Error ? `amap request failed: ${error.message}` : "amap request failed"
-    );
-  }
-  const raw = await response.text().catch(() => "");
-  let payload;
-  if (raw.trim() !== "") {
-    try {
-      payload = record(JSON.parse(raw));
-    } catch {
-      payload = void 0;
-    }
-  }
+      message === void 0 ? "amap request failed" : `amap request failed: ${message}`
+    )
+  });
+  const payload = asJsonObject(data);
   if (payload === void 0) {
     throw new TBError("unavailable", "amap \u8FD4\u56DE\u4E86\u975E JSON \u5BF9\u8C61\u54CD\u5E94", { retryable: true });
   }
-  if (!response.ok || payload.status !== "1") throw amapError(response.status, payload);
+  if (payload.status !== "1") throw amapError(status, payload);
   return payload;
 }
 function assertGetUrlLength(ctx, path, query) {
@@ -126,37 +117,37 @@ function assertGetUrlLength(ctx, path, query) {
 }
 function poi(item) {
   return {
-    id: text(item.id),
-    name: text(item.name),
-    type: text(item.type),
-    typecode: text(item.typecode),
-    address: text(item.address),
-    location: text(item.location),
-    pname: text(item.pname),
-    cityname: text(item.cityname),
-    adname: text(item.adname)
+    id: trimmedText(item.id),
+    name: trimmedText(item.name),
+    type: trimmedText(item.type),
+    typecode: trimmedText(item.typecode),
+    address: trimmedText(item.address),
+    location: trimmedText(item.location),
+    pname: trimmedText(item.pname),
+    cityname: trimmedText(item.cityname),
+    adname: trimmedText(item.adname)
   };
 }
 function poiSearchOutput(payload) {
   return {
-    count: text(payload.count),
+    count: trimmedText(payload.count),
     pois: recordArray(payload.pois).map((item) => poi(item))
   };
 }
 async function geocode(input, ctx) {
   const payload = await amapGet(ctx, "/v3/geocode/geo", {
     address: requireText(input.address, "address"),
-    city: text(input.city)
+    city: trimmedText(input.city)
   });
   return {
     geocodes: recordArray(payload.geocodes).map((item) => ({
-      formattedAddress: text(item.formatted_address),
-      country: text(item.country),
-      province: text(item.province),
+      formattedAddress: trimmedText(item.formatted_address),
+      country: trimmedText(item.country),
+      province: trimmedText(item.province),
       city: stringOrStringArray(item.city),
-      district: text(item.district),
-      adcode: text(item.adcode),
-      location: text(item.location)
+      district: trimmedText(item.district),
+      adcode: trimmedText(item.adcode),
+      location: trimmedText(item.location)
     }))
   };
 }
@@ -164,14 +155,14 @@ async function reverseGeocode(input, ctx) {
   const payload = await amapGet(ctx, "/v3/geocode/regeo", {
     location: requireText(input.location, "location"),
     radius: number(input.radius),
-    extensions: text(input.extensions),
+    extensions: trimmedText(input.extensions),
     // 入参是 camelCase 的 roadLevel,高德认的是全小写 roadlevel。
     roadlevel: number(input.roadLevel)
   });
-  const regeocode = record(payload.regeocode);
+  const regeocode = asJsonObject(payload.regeocode);
   return {
-    formattedAddress: text(regeocode?.formatted_address),
-    addressComponent: record(regeocode?.addressComponent),
+    formattedAddress: trimmedText(regeocode?.formatted_address),
+    addressComponent: asJsonObject(regeocode?.addressComponent),
     pois: recordArray(regeocode?.pois),
     roads: recordArray(regeocode?.roads),
     roadinters: recordArray(regeocode?.roadinters),
@@ -181,84 +172,84 @@ async function reverseGeocode(input, ctx) {
 async function searchPlaces(input, ctx) {
   return poiSearchOutput(await amapGet(ctx, "/v5/place/text", {
     keywords: requireText(input.keywords, "keywords"),
-    region: text(input.region),
-    city_limit: boolean(input.cityLimit),
-    types: text(input.types),
+    region: trimmedText(input.region),
+    city_limit: booleanValue(input.cityLimit),
+    types: trimmedText(input.types),
     page_num: number(input.pageNum),
     page_size: number(input.pageSize),
-    show_fields: text(input.showFields)
+    show_fields: trimmedText(input.showFields)
   }));
 }
 async function searchPlacesAround(input, ctx) {
   return poiSearchOutput(await amapGet(ctx, "/v5/place/around", {
     location: requireText(input.location, "location"),
     radius: number(input.radius),
-    keywords: text(input.keywords),
-    types: text(input.types),
-    sortrule: text(input.sortRule),
+    keywords: trimmedText(input.keywords),
+    types: trimmedText(input.types),
+    sortrule: trimmedText(input.sortRule),
     page_num: number(input.pageNum),
     page_size: number(input.pageSize),
-    show_fields: text(input.showFields)
+    show_fields: trimmedText(input.showFields)
   }));
 }
 async function searchPlacesPolygon(input, ctx) {
   return poiSearchOutput(await amapGet(ctx, "/v5/place/polygon", {
     polygon: requireText(input.polygon, "polygon"),
-    keywords: text(input.keywords),
-    types: text(input.types),
+    keywords: trimmedText(input.keywords),
+    types: trimmedText(input.types),
     page_num: number(input.pageNum),
     page_size: number(input.pageSize),
-    show_fields: text(input.showFields)
+    show_fields: trimmedText(input.showFields)
   }));
 }
 async function getPlaceDetail(input, ctx) {
   const payload = await amapGet(ctx, "/v5/place/detail", {
     id: requireText(input.id, "id"),
-    show_fields: text(input.showFields)
+    show_fields: trimmedText(input.showFields)
   });
   return { pois: recordArray(payload.pois).map((item) => poi(item)) };
 }
 async function inputTips(input, ctx) {
   const payload = await amapGet(ctx, "/v3/assistant/inputtips", {
     keywords: requireText(input.keywords, "keywords"),
-    type: text(input.type),
-    location: text(input.location),
-    city: text(input.city),
+    type: trimmedText(input.type),
+    location: trimmedText(input.location),
+    city: trimmedText(input.city),
     // 入参 cityLimit,高德认的是全小写 citylimit;下面 datatype 同理。
-    citylimit: boolean(input.cityLimit),
-    datatype: text(input.dataType)
+    citylimit: booleanValue(input.cityLimit),
+    datatype: trimmedText(input.dataType)
   });
   return { tips: recordArray(payload.tips) };
 }
 async function ipLocate(input, ctx) {
-  const ip = text(input.ip);
+  const ip = trimmedText(input.ip);
   if (ip === void 0) {
     throw new TBError("invalid_argument", "ip is required: \u672C\u5C42\u62FF\u4E0D\u5230\u8C03\u7528\u65B9\u7684\u6765\u6E90 IP,\u5FC5\u987B\u663E\u5F0F\u7ED9\u51FA\u8981\u5B9A\u4F4D\u7684 IP");
   }
   const payload = await amapGet(ctx, "/v3/ip", { ip });
   return {
-    province: text(payload.province),
-    city: text(payload.city),
-    adcode: text(payload.adcode),
-    rectangle: text(payload.rectangle)
+    province: trimmedText(payload.province),
+    city: trimmedText(payload.city),
+    adcode: trimmedText(payload.adcode),
+    rectangle: trimmedText(payload.rectangle)
   };
 }
 async function districtSearch(input, ctx) {
   const payload = await amapGet(ctx, "/v3/config/district", {
     keywords: requireText(input.keywords, "keywords"),
     subdistrict: number(input.subDistrict),
-    extensions: text(input.extensions),
+    extensions: trimmedText(input.extensions),
     page: number(input.page),
     offset: number(input.offset),
-    filter: text(input.filter)
+    filter: trimmedText(input.filter)
   });
   return {
-    count: text(payload.count),
+    count: trimmedText(payload.count),
     districts: recordArray(payload.districts)
   };
 }
 async function weather(input, ctx) {
-  const extensions = text(input.extensions);
+  const extensions = trimmedText(input.extensions);
   const payload = await amapGet(ctx, "/v3/weather/weatherInfo", {
     city: requireText(input.city, "city"),
     extensions
@@ -269,28 +260,28 @@ async function weather(input, ctx) {
 function simpleRoutePaths(value, includeCost) {
   return recordArray(value).map((item) => {
     const path = {
-      distance: text(item.distance),
+      distance: trimmedText(item.distance),
       steps: recordArray(item.steps)
     };
-    const cost = record(item.cost);
+    const cost = asJsonObject(item.cost);
     if (!includeCost || cost === void 0) return path;
-    return { ...path, cost: { duration: text(cost.duration) } };
+    return { ...path, cost: { duration: trimmedText(cost.duration) } };
   });
 }
 async function simpleRoute(ctx, path, input, extra = {}) {
   const query = {
     origin: requireText(input.origin, "origin"),
     destination: requireText(input.destination, "destination"),
-    show_fields: text(input.showFields),
+    show_fields: trimmedText(input.showFields),
     ...extra
   };
   assertGetUrlLength(ctx, path, query);
   const payload = await amapGet(ctx, path, query);
-  const route = record(payload.route);
+  const route = asJsonObject(payload.route);
   return {
     route: {
-      origin: text(route?.origin),
-      destination: text(route?.destination),
+      origin: trimmedText(route?.origin),
+      destination: trimmedText(route?.destination),
       paths: simpleRoutePaths(route?.paths, hasShowField(input.showFields, "cost"))
     }
   };
@@ -300,7 +291,7 @@ async function routeWalking(input, ctx) {
 }
 async function routeBicycling(input, ctx) {
   return simpleRoute(ctx, "/v5/direction/bicycling", input, {
-    alternative_route: text(input.alternativeRoute)
+    alternative_route: trimmedText(input.alternativeRoute)
   });
 }
 async function routeElectrobike(input, ctx) {
@@ -310,32 +301,32 @@ async function routeDriving(input, ctx) {
   const query = {
     origin: requireText(input.origin, "origin"),
     destination: requireText(input.destination, "destination"),
-    waypoints: text(input.waypoints),
-    strategy: text(input.strategy),
-    plate: text(input.plate),
-    cartype: text(input.carType),
-    avoidpolygons: text(input.avoidPolygons),
-    show_fields: text(input.showFields)
+    waypoints: trimmedText(input.waypoints),
+    strategy: trimmedText(input.strategy),
+    plate: trimmedText(input.plate),
+    cartype: trimmedText(input.carType),
+    avoidpolygons: trimmedText(input.avoidPolygons),
+    show_fields: trimmedText(input.showFields)
   };
   assertGetUrlLength(ctx, "/v5/direction/driving", query);
   const payload = await amapGet(ctx, "/v5/direction/driving", query);
-  const route = record(payload.route);
+  const route = asJsonObject(payload.route);
   const includeCost = hasShowField(input.showFields, "cost");
   return {
     route: {
-      origin: text(route?.origin),
-      destination: text(route?.destination),
-      taxi_cost: text(route?.taxi_cost),
+      origin: trimmedText(route?.origin),
+      destination: trimmedText(route?.destination),
+      taxi_cost: trimmedText(route?.taxi_cost),
       // 驾车路径多两个字段:限行信息与过路费。
       paths: recordArray(route?.paths).map((item) => {
         const path = {
-          distance: text(item.distance),
-          restriction: text(item.restriction),
+          distance: trimmedText(item.distance),
+          restriction: trimmedText(item.restriction),
           steps: recordArray(item.steps)
         };
-        const cost = record(item.cost);
+        const cost = asJsonObject(item.cost);
         if (!includeCost || cost === void 0) return path;
-        return { ...path, cost: { duration: text(cost.duration), tolls: text(cost.tolls) } };
+        return { ...path, cost: { duration: trimmedText(cost.duration), tolls: trimmedText(cost.tolls) } };
       })
     }
   };
@@ -347,9 +338,9 @@ function transitSegments(value, includeCost) {
       delete rest.cost;
       return rest;
     }
-    const cost = record(item.cost);
+    const cost = asJsonObject(item.cost);
     if (cost === void 0) return item;
-    return { ...item, cost: { transit_fee: text(cost.transit_fee) } };
+    return { ...item, cost: { transit_fee: trimmedText(cost.transit_fee) } };
   });
 }
 async function routeTransit(input, ctx) {
@@ -359,29 +350,29 @@ async function routeTransit(input, ctx) {
     // 入参是 originCity / destinationCity,高德认的是 city1 / city2。
     city1: requireText(input.originCity, "originCity"),
     city2: requireText(input.destinationCity, "destinationCity"),
-    strategy: text(input.strategy),
-    nightflag: text(input.nightFlag),
-    show_fields: text(input.showFields)
+    strategy: trimmedText(input.strategy),
+    nightflag: trimmedText(input.nightFlag),
+    show_fields: trimmedText(input.showFields)
   };
   assertGetUrlLength(ctx, "/v5/direction/transit/integrated", query);
   const payload = await amapGet(ctx, "/v5/direction/transit/integrated", query);
-  const route = record(payload.route);
+  const route = asJsonObject(payload.route);
   const includeCost = hasShowField(input.showFields, "cost");
-  const taxiCost = record(route?.cost);
+  const taxiCost = asJsonObject(route?.cost);
   return {
     route: {
-      origin: text(route?.origin),
-      destination: text(route?.destination),
-      cost: includeCost && taxiCost !== void 0 ? { taxi_fee: text(taxiCost.taxi_fee) } : void 0,
+      origin: trimmedText(route?.origin),
+      destination: trimmedText(route?.destination),
+      cost: includeCost && taxiCost !== void 0 ? { taxi_fee: trimmedText(taxiCost.taxi_fee) } : void 0,
       transits: recordArray(route?.transits).map((item) => {
         const transit = {
-          distance: text(item.distance),
-          nightflag: text(item.nightflag),
+          distance: trimmedText(item.distance),
+          nightflag: trimmedText(item.nightflag),
           segments: transitSegments(item.segments, includeCost)
         };
-        const cost = record(item.cost);
+        const cost = asJsonObject(item.cost);
         if (!includeCost || cost === void 0) return transit;
-        return { ...transit, cost: { duration: text(cost.duration) } };
+        return { ...transit, cost: { duration: trimmedText(cost.duration) } };
       })
     }
   };

package/dist/{anthropic-27RFZO35.js → anthropic-5P62HDNR.js}

@@ -1,38 +1,33 @@
+import {
+  createProviderHttpClient
+} from "./chunk-VLOIDU5U.js";
+import {
+  asJsonObject,
+  compactDefined,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
 import {
   createProviderPlugin,
   requireApiKey,
   upstreamError
-} from "./chunk-VK3V2WTY.js";
-import {
-  guardedFetch
-} from "./chunk-2O27H4Y2.js";
-import "./chunk-GKX72JMJ.js";
+} from "./chunk-B4P6YZFS.js";
+import "./chunk-SWBNHIO4.js";
 import {
   TBError,
   external_exports
-} from "./chunk-YB2FLNWI.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-OKRZPQ3R.js";
+import "./chunk-U67V476Y.js";
 
 // ../plugins/src/anthropic/api.ts
 var SERVICE = "anthropic";
 var API_BASE = "https://api.anthropic.com";
 var API_VERSION = "2023-06-01";
-function record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
-function text(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
+var http = createProviderHttpClient({ baseUrl: `${API_BASE}/`, service: SERVICE });
 function requireText(value, field) {
-  const result = text(value);
+  const result = trimmedText(value);
   if (result === void 0) throw new TBError("invalid_argument", `${field} \u4E0D\u80FD\u4E3A\u7A7A`);
   return result;
 }
-function compact(input) {
-  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
-}
 function headers(apiKey) {
   return {
     "accept": "application/json",
@@ -41,46 +36,29 @@ function headers(apiKey) {
     "x-api-key": apiKey
   };
 }
-function errorMessage(status, body) {
+function errorMessage(status, payload) {
   const fallback = `anthropic request failed with ${status}`;
-  try {
-    const nested = record(record(JSON.parse(body))?.error);
-    const message = text(nested?.message);
-    if (message !== void 0) return message;
-  } catch {
-  }
-  return text(body) ?? fallback;
-}
-function buildUrl(path, query) {
-  const url = new URL(`${API_BASE}${path}`);
-  for (const [key, value] of Object.entries(query ?? {})) {
-    if (value === void 0 || value === null) continue;
-    url.searchParams.set(key, String(value));
-  }
-  return url.toString();
+  const nested = asJsonObject(asJsonObject(payload)?.error);
+  return trimmedText(nested?.message) ?? trimmedText(payload) ?? fallback;
 }
 async function request(ctx, input) {
   const apiKey = requireApiKey(ctx, SERVICE);
   const method = input.method ?? "GET";
-  let response;
-  try {
-    response = await guardedFetch(buildUrl(input.path, input.query), {
-      method,
-      headers: headers(apiKey),
-      body: input.body === void 0 ? void 0 : JSON.stringify(input.body)
-    });
-  } catch (error) {
-    if (error instanceof TBError) throw error;
-    const message = error instanceof Error ? error.message : "unknown network error";
-    throw upstreamError(502, `anthropic ${method} ${input.path} failed before receiving response: ${message}`);
-  }
-  const raw = await response.text().catch(() => "");
-  if (!response.ok) throw upstreamError(response.status, errorMessage(response.status, raw));
-  try {
-    return JSON.parse(raw);
-  } catch {
-    throw upstreamError(502, "anthropic returned malformed JSON");
-  }
+  const { data } = await http.request({
+    path: input.path,
+    method,
+    query: Object.entries(input.query ?? {}),
+    headers: headers(apiKey),
+    ...input.body === void 0 ? {} : { json: input.body },
+    invalidJsonMessage: "anthropic returned malformed JSON",
+    mapError: ({ data: payload, status }) => upstreamError(status, errorMessage(status, payload)),
+    mapTransportError: ({ message }) => upstreamError(
+      502,
+      `anthropic ${method} ${input.path} failed before receiving response: ${message ?? "unknown network error"}`
+    )
+  });
+  if (data === void 0) throw upstreamError(502, "anthropic returned malformed JSON");
+  return data;
 }
 function assertStreamingDisabled(input) {
   if (input.stream === true) {
@@ -98,10 +76,10 @@ async function getModel(input, ctx) {
 }
 async function createMessage(input, ctx) {
   assertStreamingDisabled(input);
-  return request(ctx, { method: "POST", path: "/v1/messages", body: compact(input) });
+  return request(ctx, { method: "POST", path: "/v1/messages", body: compactDefined(input) });
 }
 async function countMessageTokens(input, ctx) {
-  return request(ctx, { method: "POST", path: "/v1/messages/count_tokens", body: compact(input) });
+  return request(ctx, { method: "POST", path: "/v1/messages/count_tokens", body: compactDefined(input) });
 }
 
 // ../plugins/src/anthropic/schema.ts