@tool-bridge/server 0.1.0 → 0.3.0

package/dist/wolfram_alpha_api-WHHTH4GU.js

@@ -0,0 +1,212 @@
+import {
+  createProviderPlugin,
+  guardedFetch,
+  requireApiKey,
+  upstreamError
+} from "./chunk-CSJEZHQO.js";
+import "./chunk-K7FVSFUX.js";
+import {
+  TBError,
+  external_exports
+} from "./chunk-JLTYA2B3.js";
+import "./chunk-MLKGABMK.js";
+
+// ../plugins/src/wolfram_alpha_api/api.ts
+var SERVICE = "wolfram_alpha_api";
+var API_BASE = "https://api.wolframalpha.com";
+var RECOGNIZER_URL = "https://www.wolframalpha.com/queryrecognizer/query.jsp";
+var REQUEST_TIMEOUT_MS = 3e4;
+function text(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function nullableText(value) {
+  return text(value) ?? null;
+}
+function nullableNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function booleanLike(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value.toLowerCase() === "true";
+  return false;
+}
+function searchTerm(value) {
+  const query = text(value);
+  if (query === void 0) throw new TBError("invalid_argument", "query \u4E0D\u80FD\u662F\u7A7A\u767D");
+  return query;
+}
+function looksLikeCredentialError(body) {
+  const normalized = body.toLowerCase();
+  return normalized.includes("invalid appid") || normalized.includes("appid missing");
+}
+function wolframError(status, body) {
+  const message = body.trim() || `Wolfram|Alpha \u8FD4\u56DE HTTP ${status}`;
+  if (status === 400 || status === 501) return upstreamError(400, message);
+  if (status === 401 || status === 403 || looksLikeCredentialError(message)) return upstreamError(401, message);
+  return upstreamError(status, message);
+}
+async function requestText(url) {
+  let response;
+  try {
+    response = await guardedFetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      throw upstreamError(504, `Wolfram|Alpha ${REQUEST_TIMEOUT_MS / 1e3} \u79D2\u5185\u6CA1\u6709\u8FD4\u56DE`);
+    }
+    throw error;
+  }
+  const body = await response.text();
+  if (!response.ok) throw wolframError(response.status, body);
+  if (looksLikeCredentialError(body)) throw upstreamError(401, body.trim());
+  return body;
+}
+function authorizedUrl(base, ctx, params) {
+  const url = new URL(base);
+  url.searchParams.set("appid", requireApiKey(ctx, SERVICE));
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) url.searchParams.set(key, value);
+  }
+  return url;
+}
+async function textQuery(path, ctx, params) {
+  const answer = await requestText(authorizedUrl(`${API_BASE}${path}`, ctx, params));
+  if (answer === "") {
+    throw new TBError("unavailable", "Wolfram|Alpha \u8FD4\u56DE\u4E86\u7A7A\u54CD\u5E94", { retryable: true });
+  }
+  return answer;
+}
+async function validateQuery(input, ctx) {
+  const query = searchTerm(input.query);
+  const mode = input.mode === "voice" ? "voice" : "default";
+  const url = authorizedUrl(RECOGNIZER_URL, ctx, { input: query, mode, output: "json" });
+  const body = await requestText(url);
+  let payload;
+  try {
+    payload = JSON.parse(body);
+  } catch {
+    throw new TBError("unavailable", "Wolfram|Alpha \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94", { retryable: true });
+  }
+  const result = record(payload);
+  const queries = result?.query;
+  const first = Array.isArray(queries) ? record(queries[0]) : void 0;
+  if (first === void 0) {
+    throw new TBError("unavailable", "Wolfram|Alpha recognizer \u6CA1\u6709\u8FD4\u56DE\u67E5\u8BE2\u7ED3\u679C", { retryable: true });
+  }
+  return {
+    query,
+    mode,
+    accepted: booleanLike(first.accepted),
+    domain: nullableText(first.domain),
+    // timing 在**顶层**,不在 query[0] 里。
+    timingMs: nullableNumber(result?.timing),
+    resultSignificanceScore: nullableNumber(first.resultsignificancescore),
+    spellingCorrection: nullableText(first.spellingCorrection),
+    summaryBoxPath: nullableText(record(first.summarybox)?.path)
+  };
+}
+async function getShortAnswer(input, ctx) {
+  const query = searchTerm(input.query);
+  const answer = await textQuery("/v1/result", ctx, {
+    i: query,
+    units: input.units,
+    timeout: input.timeout === void 0 ? void 0 : String(input.timeout)
+  });
+  return { query, answer };
+}
+async function getSpokenResult(input, ctx) {
+  const query = searchTerm(input.query);
+  const result = await textQuery("/v1/spoken", ctx, {
+    i: query,
+    units: input.units,
+    timeout: input.timeout === void 0 ? void 0 : String(input.timeout)
+  });
+  return { query, result };
+}
+
+// ../plugins/src/wolfram_alpha_api/schema.ts
+var validateQueryInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Natural-language query or mathematical expression sent to Wolfram|Alpha."),
+  mode: external_exports.enum(["default", "voice"]).describe("Recognizer mode. Use default for general queries or voice for spoken phrasing.").optional()
+}).describe("Input parameters for validating whether Wolfram|Alpha can interpret a query.");
+var validateQueryOutput = external_exports.strictObject({
+  query: external_exports.string().describe("Original query sent to the recognizer endpoint."),
+  mode: external_exports.enum(["default", "voice"]).describe("Recognizer mode. Use default for general queries or voice for spoken phrasing."),
+  accepted: external_exports.boolean().describe("Whether Wolfram|Alpha accepted the query."),
+  domain: external_exports.string().describe("Recognized Wolfram|Alpha domain for the query, when available.").nullable(),
+  timingMs: external_exports.number().describe("Recognizer timing value returned by Wolfram|Alpha in milliseconds.").nullable(),
+  resultSignificanceScore: external_exports.number().describe("Recognizer significance score returned by Wolfram|Alpha, when available.").nullable(),
+  spellingCorrection: external_exports.string().describe("Suggested spelling correction returned by Wolfram|Alpha, when available.").nullable(),
+  summaryBoxPath: external_exports.string().describe("Summary box path returned by Wolfram|Alpha, when available.").nullable()
+}).describe("Normalized query validation result returned by Wolfram|Alpha.");
+var getShortAnswerInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Natural-language query or mathematical expression sent to Wolfram|Alpha."),
+  units: external_exports.enum(["metric", "imperial"]).describe("Measurement system requested by Wolfram|Alpha for unit-sensitive answers.").optional(),
+  timeout: external_exports.int().min(1).describe("Maximum processing time in seconds accepted by Wolfram|Alpha.").optional()
+}).describe("Input parameters for retrieving a concise short answer from Wolfram|Alpha.");
+var getShortAnswerOutput = external_exports.strictObject({
+  query: external_exports.string().describe("Original query sent to the short answer endpoint."),
+  answer: external_exports.string().describe("Short textual answer returned by Wolfram|Alpha.")
+}).describe("Normalized short answer payload returned by Wolfram|Alpha.");
+var getSpokenResultInput = external_exports.strictObject({
+  query: external_exports.string().min(1).describe("Natural-language query or mathematical expression sent to Wolfram|Alpha."),
+  units: external_exports.enum(["metric", "imperial"]).describe("Measurement system requested by Wolfram|Alpha for unit-sensitive answers.").optional(),
+  timeout: external_exports.int().min(1).describe("Maximum processing time in seconds accepted by Wolfram|Alpha.").optional()
+}).describe("Input parameters for retrieving a spoken-style result from Wolfram|Alpha.");
+var getSpokenResultOutput = external_exports.strictObject({
+  query: external_exports.string().describe("Original query sent to the spoken result endpoint."),
+  result: external_exports.string().describe("Spoken-style text returned by Wolfram|Alpha.")
+}).describe("Normalized spoken result payload returned by Wolfram|Alpha.");
+var wolframAlphaApiActions = {
+  validate_query: {
+    description: "Validate whether Wolfram|Alpha can interpret a query.",
+    effect: "write",
+    inputSchema: validateQueryInput,
+    outputSchema: external_exports.toJSONSchema(validateQueryOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_short_answer: {
+    description: "Get a concise short answer from Wolfram|Alpha.",
+    effect: "read",
+    inputSchema: getShortAnswerInput,
+    outputSchema: external_exports.toJSONSchema(getShortAnswerOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_spoken_result: {
+    description: "Get a spoken-style single-sentence result from Wolfram|Alpha.",
+    effect: "read",
+    inputSchema: getSpokenResultInput,
+    outputSchema: external_exports.toJSONSchema(getSpokenResultOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/wolfram_alpha_api/index.ts
+function createWolframAlphaApiPlugin() {
+  return createProviderPlugin({
+    description: "Wolfram|Alpha",
+    actions: wolframAlphaApiActions,
+    // 不设 credentialProbe:三个 action 都必填 `query`,平台空参调探针会被 Zod 拦成
+    // invalid_argument —— 那个错误看起来像凭证问题,实际是探针选错了。上游
+    // credentialValidators 打的 queryrecognizer 端点同样要带 input,没有"空转"调用。
+    handlers: {
+      validate_query: validateQuery,
+      get_short_answer: getShortAnswer,
+      get_spoken_result: getSpokenResult
+    }
+  });
+}
+var wolfram_alpha_api_default = createWolframAlphaApiPlugin();
+export {
+  createWolframAlphaApiPlugin,
+  wolfram_alpha_api_default as default
+};