fortrip 2.0.0 → 3.0.0

package/dist/{mcp-bridge-LPQBHWLD.js → mcp-bridge-3WLWV2KY.js}

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import {
-  API,
   CONTRACT_VERSION,
   CliError,
   EXIT,
   TOOLS,
+  isEnvelope,
   loadSession,
+  localRequestId,
   refreshSession,
+  renderError,
   renderGuide,
   requireToken
-} from "./chunk-53656LB2.js";
+} from "./chunk-26IHFJYT.js";
 
 // src/mcp-bridge.ts
 import {
@@ -52,14 +54,14 @@ async function signedIn(run) {
     throw error;
   }
 }
-function authorizedFetch(apiUrl) {
+function authorizedFetch(mcpUrl, apiUrl) {
   const attempt = async (url, init) => {
     try {
       return await fetch(url, init);
     } catch (error) {
       if (error?.name === "AbortError") throw error;
       const cause = error?.cause ?? error;
-      throw new Error(`Could not reach ${apiUrl}: ${cause?.message ?? String(error)}`);
+      throw new Error(`Could not reach ${mcpUrl}: ${cause?.message ?? String(error)}`);
     }
   };
   let turn = Promise.resolve();
@@ -95,22 +97,41 @@ function authorizedFetch(apiUrl) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isRpcError(value) {
+  return isRecord(value) && !(value instanceof Error) && typeof value.code === "number" && typeof value.message === "string";
+}
+function bodyOf(error) {
+  try {
+    return JSON.parse(typeof error.data.text === "string" ? error.data.text : "");
+  } catch {
+    return void 0;
+  }
+}
 function rpcErrorOf(error) {
+  if (isRpcError(error)) return error;
   if (error instanceof SignInRequired) {
     return { code: SIGN_IN_REQUIRED, message: error.message, data: error.data };
   }
   if (error instanceof SdkHttpError) {
     const { status } = error;
     const text = typeof error.data.text === "string" ? error.data.text : "";
-    let body;
-    try {
-      body = JSON.parse(text);
-    } catch {
-    }
+    const body = bodyOf(error);
     if (isRecord(body) && isRecord(body.error)) {
       const { code, message } = body.error;
       if (typeof code === "number" && typeof message === "string") return body.error;
     }
+    if (isEnvelope(body)) {
+      const { message, requestId, retryable, retryAfterSeconds } = body.error;
+      return {
+        code: INTERNAL_ERROR,
+        message: `Fortrip answered HTTP ${status}${typeof message === "string" ? `: ${message}` : ""}${typeof requestId === "string" ? ` (request id ${requestId})` : ""}`,
+        data: {
+          status,
+          ...retryable === true ? { retryable } : {},
+          ...typeof retryAfterSeconds === "number" ? { retryAfterSeconds } : {}
+        }
+      };
+    }
     const said = isRecord(body) ? body.error ?? body.message : text.slice(0, 200);
     return {
       code: INTERNAL_ERROR,
@@ -124,6 +145,36 @@ function rpcErrorOf(error) {
     ...error instanceof CliError && error.details.retryable ? { data: { retryable: true } } : {}
   };
 }
+function toolErrorOf(error) {
+  let envelope;
+  if (error instanceof SignInRequired) {
+    envelope = {
+      error: {
+        code: "unauthenticated",
+        message: error.message,
+        retryable: false,
+        requestId: localRequestId()
+      }
+    };
+  } else if (error instanceof SdkHttpError) {
+    envelope = bodyOf(error);
+  } else if (error instanceof CliError) {
+    envelope = error.envelope;
+  }
+  if (!isEnvelope(envelope)) return void 0;
+  return {
+    isError: true,
+    content: [
+      { type: "text", text: renderError(envelope) },
+      { type: "text", text: JSON.stringify(envelope) }
+    ],
+    _meta: { "ai.fortrip/error": envelope }
+  };
+}
+function failureAnswer(id, method, error) {
+  const result = method === "tools/call" ? toolErrorOf(error) : void 0;
+  return result ? { jsonrpc: "2.0", id, result } : { jsonrpc: "2.0", id, error: rpcErrorOf(error) };
+}
 var CONNECTION_LOST = {
   code: INTERNAL_ERROR,
   message: "The connection to Fortrip ended before it answered.",
@@ -134,6 +185,16 @@ async function hasSignIn(apiUrl) {
   if (process.env.FORTRIP_TOKEN?.trim()) return true;
   return await loadSession(apiUrl).catch(() => null) !== null;
 }
+function passThrough(schema) {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "fortrip",
+      validate: (value) => ({ value }),
+      jsonSchema: schema["~standard"].jsonSchema
+    }
+  };
+}
 function localServer() {
   const server = new McpServer(
     { name: "fortrip", version: CONTRACT_VERSION },
@@ -147,28 +208,28 @@ function localServer() {
       title: spec.title,
       description: spec.description,
       annotations: spec.annotations,
-      outputSchema: spec.output ?? void 0
+      ...spec.output ? { outputSchema: passThrough(spec.output) } : {}
     };
     if (spec.input === null) {
       server.registerTool(spec.name, config, handler);
     } else {
       server.registerTool(
         spec.name,
-        { ...config, inputSchema: spec.input },
+        { ...config, inputSchema: passThrough(spec.input) },
         handler
       );
     }
   }
   return server;
 }
-async function runMcpBridge(apiUrl, io = {
+async function runMcpBridge(mcpUrl, apiUrl, io = {
   stdin: process.stdin,
   stdout: process.stdout
 }, { switchTimeoutMs = SWITCH_TIMEOUT_MS } = {}) {
   const stderr = io.stderr ?? process.stderr;
   const stdio = new StdioServerTransport(io.stdin, io.stdout);
-  const http = new StreamableHTTPClientTransport(new URL(API.mcp, apiUrl), {
-    fetch: authorizedFetch(apiUrl)
+  const http = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+    fetch: authorizedFetch(mcpUrl, apiUrl)
   });
   const server = localServer();
   const [local, localServerEnd] = InMemoryTransport.createLinkedPair();
@@ -179,7 +240,7 @@ async function runMcpBridge(apiUrl, io = {
   let listChanged = false;
   let received = 0;
   let abandonedThrough = 0;
-  const pending = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
   let initializeId;
   const asked = /* @__PURE__ */ new Map();
   const log = (message) => {
@@ -190,8 +251,10 @@ async function runMcpBridge(apiUrl, io = {
     stdio.send(message).catch((cause) => log(cause.message));
   };
   const fail = (id, error) => {
-    if (closed || !pending.delete(id)) return;
-    toClient({ jsonrpc: "2.0", id, error });
+    const method = pending.get(id);
+    if (closed || method === void 0) return;
+    pending.delete(id);
+    toClient(failureAnswer(id, method, error));
   };
   const adopt = ({ result }) => {
     if (typeof result.protocolVersion === "string") http.setProtocolVersion(result.protocolVersion);
@@ -202,12 +265,12 @@ async function runMcpBridge(apiUrl, io = {
       });
       return;
     }
-    pending.add(message.id);
+    pending.set(message.id, message.method);
     if (message.method === "initialize") initializeId = message.id;
     try {
       await http.send(message, { onRequestStreamEnd: () => fail(message.id, CONNECTION_LOST) });
     } catch (error) {
-      fail(message.id, rpcErrorOf(error));
+      fail(message.id, error);
     }
   };
   const ask = (request, signal) => {
@@ -252,9 +315,9 @@ async function runMcpBridge(apiUrl, io = {
       try {
         answer = await Promise.race([ask(initialize2, deadline.signal), late]);
       } catch (error) {
-        return rpcErrorOf(error);
+        return { error };
       }
-      if (answer && !isJSONRPCResultResponse(answer)) return answer.error;
+      if (answer && !isJSONRPCResultResponse(answer)) return { error: answer.error };
       if (answer) {
         adopt(answer);
         await http.send(
@@ -265,15 +328,15 @@ async function runMcpBridge(apiUrl, io = {
       }
       if (!deadline.signal.aborted) return void 0;
       abandonedThrough = received;
-      return CONNECTION_LOST;
+      return { error: CONNECTION_LOST };
     } finally {
       clearTimeout(timer);
     }
   };
   const callTool = async (call) => {
     if (clientInitialize) {
-      const error = await handshake(clientInitialize);
-      if (error) return toClient({ jsonrpc: "2.0", id: call.id, error });
+      const failed = await handshake(clientInitialize);
+      if (failed) return toClient(failureAnswer(call.id, call.method, failed.error));
     }
     remote = true;
     void forward(call);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fortrip",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "license": "Apache-2.0",
   "description": "Search, price and book Fortrip hotels from the terminal or an AI agent.",
   "mcpName": "io.github.FortripEngineering/fortrip",
@@ -32,7 +32,7 @@
     "tsx": "^4.20.0",
     "typescript": "^5.9.0",
     "zod": "4.4.3",
-    "@fortrip/agent-contract": "2.0.0"
+    "@fortrip/agent-contract": "3.0.0"
   },
   "scripts": {
     "build": "tsup",