@semanticist14/clco 0.1.0 → 0.2.0

package/README.md

@@ -61,7 +61,7 @@ clco
 
 1. **GitHub login**, once — a device-flow code to paste in your browser. The
    token is stored at `~/.config/clco/auth.json` (mode 600).
-2. **Three questions**, once. Re-run them any time with `clco setup`:
+2. **Four questions**, once. Re-run them any time with `clco setup`:
 
    | Question | Default | What it does |
    |---|---|---|
@@ -71,7 +71,7 @@ clco
 
 3. **Pick a model**, then claude starts. Switch mid-session with `/model`.
 
-   Answering yes to the first two together is worth understanding: claude runs
+   Answering yes to the permission and browser questions together is worth understanding: claude runs
    without permission prompts, and each session resolves the current
    `@playwright/mcp` release from npm (`bunx -y @playwright/mcp@latest`) and runs
    it with access to the browser tab you share. The version is re-resolved every
@@ -82,6 +82,14 @@ clco
    `CLCO_MCP_PACKAGE` pins or redirects the package — see
    [Browser control](#browser-control).
 
+## Web access
+
+Claude's built-in Fetch works as-is: it fetches pages locally and only the
+summarizing model call rides the adapter. Claude's built-in WebSearch cannot
+work here - Anthropic executes it server-side, and Copilot's endpoint rejects
+a native web_search tool - so the adapter drops it instead of sending a
+broken request. No web MCP server is registered.
+
 ## Usage
 
 ```sh

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,13 @@
+# Third-party notices
+
+## pi-web-access
+
+The `web_fetch` implementation in `src/webfetch.ts` is an independent adaptation of the core public-URL fetching and readable-content extraction approach from [pi-web-access](https://github.com/nicobailon/pi-web-access), used under the MIT License.
+
+Copyright (c) 2025 nicobailon and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files, to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

package/bun.lock

@@ -1,11 +1,15 @@
 {
-  "lockfileVersion": 2,
+  "lockfileVersion": 1,
   "configVersion": 1,
   "workspaces": {
     "": {
-      "name": "clcopilot",
+      "name": "@semanticist14/clco",
       "dependencies": {
         "@clack/prompts": "^1.8.0",
+        "@mozilla/readability": "^0.6.0",
+        "linkedom": "^0.18.12",
+        "turndown": "^7.0.3",
+        "unpdf": "^1.6.2",
       },
       "devDependencies": {
         "@types/bun": "latest",
@@ -18,22 +22,74 @@
 
     "@clack/prompts": ["@clack/prompts@1.8.0", "", { "dependencies": { "@clack/core": "1.5.0", "fast-string-width": "^3.0.2", "fast-wrap-ansi": "^0.2.0", "sisteransi": "^1.0.5" } }, "sha512-PXzLZ8N34rxmuo4dJg3xtOXhcBse94qGjDqsteoEYrFrrZ5FSjIGwMAuOcv64ln8rHVBBD06XeVGr+/JX+plcA=="],
 
+    "@mixmark-io/domino": ["@mixmark-io/domino@2.2.0", "", {}, "sha512-Y28PR25bHXUg88kCV7nivXrP2Nj2RueZ3/l/jdx6J9f8J4nsEGcgX0Qe6lt7Pa+J79+kPiJU3LguR6O/6zrLOw=="],
+
+    "@mozilla/readability": ["@mozilla/readability@0.6.0", "", {}, "sha512-juG5VWh4qAivzTAeMzvY9xs9HY5rAcr2E4I7tiSSCokRFi7XIZCAu92ZkSTsIj1OPceCifL3cpfteP3pDT9/QQ=="],
+
     "@types/bun": ["@types/bun@1.4.2", "", { "dependencies": { "bun-types": "1.4.2" } }, "sha512-GimotNn7+ZV0uVArItBbriZsR1oNf0+WTzPkdcFrzShI7k2norL0uzEaJT8T33dWr7O/c9ZDuAFQrctKCi72oQ=="],
 
-    "@types/node": ["@types/node@22.20.2", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-xlvWf4Vs9n1PEVYwP1n4vvG07M6y8WgvJ2t0vbrWTmijsIHp1cS+uJ2kMIRdY3nHZK0nCYKrPeD171+SzF4/zw=="],
+    "@types/node": ["@types/node@26.5.1", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-CzNm2FezW4VR/LjG6yUdiEgLE/rAQ9Slj5gCu/C2VrdcW7I0ahNZ8DRbHT7zOZ6r3ONgd/bsQIeSaoDGrd1C6g=="],
+
+    "boolbase": ["boolbase@2.0.0", "", {}, "sha512-DkVaaQHymRhpYEYo9x1oo7Q7B0Y6KJUsjm3c9eTyFDby4MHLBTwZ6ZDWBel5zrYxj1WsZgC5oLpiz+93MluXeA=="],
 
     "bun-types": ["bun-types@1.4.2", "", { "dependencies": { "@types/node": "*" } }, "sha512-bxV1FgK7yBIzjRe5zBozIM4Bem11ZJcCXSrjWRG3YWLt8yFDePu4cLjpebO8OvPeIE9trbyPF4fuj3Cia4Fj3w=="],
 
+    "css-select": ["css-select@7.0.0", "", { "dependencies": { "boolbase": "^2.0.0", "css-what": "^8.0.0", "domhandler": "^6.0.1", "domutils": "^4.0.2", "nth-check": "^3.0.1" } }, "sha512-snmjEVXy+1LnwXdxhYvTMj1d9tOh4HxkA1YmoayVBeeyR2C14Pum7fcxJIm4SswYspVy866eYNwlH6xC3/VH5g=="],
+
+    "css-what": ["css-what@8.0.0", "", {}, "sha512-DH0Bqq3DNp5tdOReuNyAA+Ev4Y2GS5FMbZpeTLP6C4CDi0h5nL0BmUPChXw3o/qbHLDWHl49sbNqQVY7bMSDdw=="],
+
+    "cssom": ["cssom@0.5.0", "", {}, "sha512-iKuQcq+NdHqlAcwUY0o/HL69XQrUaQdMjmStJ8JFmUaiiQErlhrmuigkg/CU4E2J0IyUKUrMAgl36TvN67MqTw=="],
+
+    "dom-serializer": ["dom-serializer@3.1.1", "", { "dependencies": { "domelementtype": "^3.0.0", "domhandler": "^6.0.0", "entities": "^8.0.0" } }, "sha512-4MEa38/QexBob6gFNwu+EGdWvhJ1OKuNwdYY3Y3NyeWDQfnGeDYQUDfIRzWu5B5gsv03so2Uxd28YC6zrsx3Lw=="],
+
+    "domelementtype": ["domelementtype@2.3.0", "", {}, "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw=="],
+
+    "domhandler": ["domhandler@6.0.1", "", { "dependencies": { "domelementtype": "^3.0.0" } }, "sha512-gYzvtM72ZtxQO0T048kd6HWSbbGCNOUwcnfQ01cqIJ4X2IYKFFHZ5mKvrQETcFXxsRObZulDaKmy//R7TPtsBg=="],
+
+    "domutils": ["domutils@4.0.2", "", { "dependencies": { "dom-serializer": "^3.0.0", "domelementtype": "^3.0.0", "domhandler": "^6.0.0" } }, "sha512-qI4JLRKnSzqFqr7hAlS5xQDusBCjKSEG4t4+7aNrIQMHBcsC2TGEhuyABJdYkgSewL57PNLYEiibY2iPKhKpaA=="],
+
+    "entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
+
     "fast-string-truncated-width": ["fast-string-truncated-width@3.0.3", "", {}, "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g=="],
 
     "fast-string-width": ["fast-string-width@3.0.2", "", { "dependencies": { "fast-string-truncated-width": "^3.0.2" } }, "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg=="],
 
     "fast-wrap-ansi": ["fast-wrap-ansi@0.2.2", "", { "dependencies": { "fast-string-width": "^3.0.2" } }, "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q=="],
 
+    "html-escaper": ["html-escaper@3.0.3", "", {}, "sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ=="],
+
+    "htmlparser2": ["htmlparser2@10.1.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.2.2", "entities": "^7.0.1" } }, "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ=="],
+
+    "linkedom": ["linkedom@0.18.13", "", { "dependencies": { "css-select": "^7.0.0", "cssom": "^0.5.0", "html-escaper": "^3.0.3", "htmlparser2": "^10.1.0", "uhyphen": "^0.2.0" }, "peerDependencies": { "canvas": ">= 2" }, "optionalPeers": ["canvas"] }, "sha512-ES/o9qotMpzpN2MHs+Iq/JcVoOj8Fa5wiQYrTdFpvAnwXL0g66XHHUc9WUMk6nAlBtGsFQ24ne+SYnvnaQ2FSw=="],
+
+    "nth-check": ["nth-check@3.0.1", "", { "dependencies": { "boolbase": "^2.0.0" } }, "sha512-GX0gsdbGVCgnRgbeGaubfjpBXyYRWOOCVeYh08bSQvDZqxz5ndXs1OTfAt/h36G1xvI94YIspsI0sVFqAV9+RQ=="],
+
     "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="],
 
+    "turndown": ["turndown@7.2.4", "", { "dependencies": { "@mixmark-io/domino": "^2.2.0" } }, "sha512-I8yFsfRzmzK0WV1pNNOA4A7y4RDfFxPRxb3t+e3ui14qSGOxGtiSP6GjeX+Y6CHb7HYaFj7ECUD7VE5kQMZWGQ=="],
+
     "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
 
-    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+    "uhyphen": ["uhyphen@0.2.0", "", {}, "sha512-qz3o9CHXmJJPGBdqzab7qAYuW8kQGKNEuoHFYrBwV6hWIMcpAmxDLXojcHfFr9US1Pe6zUswEIJIbLI610fuqA=="],
+
+    "undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="],
+
+    "unpdf": ["unpdf@1.8.1", "", { "peerDependencies": { "@napi-rs/canvas": "^0.1.69 || ^1.0.0" }, "optionalPeers": ["@napi-rs/canvas"] }, "sha512-xkURhy2SoGpOIH0a1gLHNkASPIQYonadDJs2AQwPEfUakafeD9EA1WTWWsaR++gfTCXJpV27W7tU1nXuk82UKQ=="],
+
+    "dom-serializer/domelementtype": ["domelementtype@3.0.0", "", {}, "sha512-umCQid3jKbDmVjx8jGaW7uUykm4DEUeyV21hPxNMo2nV955DhUThwqyOIDtreepP31hl84X7G5U9ZfsWvIB3Pg=="],
+
+    "dom-serializer/entities": ["entities@8.1.0", "", {}, "sha512-kxL7msIffSuh9aaFAMD7rxAIuTRMAHMeBtgHW2yUdWw732ZNh4MehkF2gdjvtdmikkaIP9bFDDJOPlsvm7avrA=="],
+
+    "domhandler/domelementtype": ["domelementtype@3.0.0", "", {}, "sha512-umCQid3jKbDmVjx8jGaW7uUykm4DEUeyV21hPxNMo2nV955DhUThwqyOIDtreepP31hl84X7G5U9ZfsWvIB3Pg=="],
+
+    "domutils/domelementtype": ["domelementtype@3.0.0", "", {}, "sha512-umCQid3jKbDmVjx8jGaW7uUykm4DEUeyV21hPxNMo2nV955DhUThwqyOIDtreepP31hl84X7G5U9ZfsWvIB3Pg=="],
+
+    "htmlparser2/domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="],
+
+    "htmlparser2/domutils": ["domutils@3.2.2", "", { "dependencies": { "dom-serializer": "^2.0.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3" } }, "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw=="],
+
+    "htmlparser2/domutils/dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="],
+
+    "htmlparser2/domutils/dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semanticist14/clco",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "description": "Run Claude Code on a GitHub Copilot subscription",
@@ -18,6 +18,7 @@
     "uninstall.sh",
     "README.md",
     "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
     "bun.lock"
   ],
   "scripts": {
@@ -30,6 +31,10 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@clack/prompts": "^1.8.0"
+    "@clack/prompts": "^1.8.0",
+    "@mozilla/readability": "^0.6.0",
+    "unpdf": "^1.6.2",
+    "linkedom": "^0.18.12",
+    "turndown": "^7.0.3"
   }
 }

package/src/browsermcp.ts

@@ -192,6 +192,28 @@ export function browserMcpConfig(
   })
 }
 
+/** Compose the session-only MCP config without replacing a user's config file. */
+export function combinedMcpConfig(
+  browserInstalled: boolean,
+  webEnabled = false,
+  searchModel?: string,
+): string | null {
+  const browser = browserMcpConfig(browserInstalled)
+  const mcpServers: Record<string, unknown> = browser
+    ? ((JSON.parse(browser) as { mcpServers: Record<string, unknown> }).mcpServers)
+    : {}
+  if (webEnabled) {
+    const env: Record<string, string> = {}
+    if (searchModel) env.CLCO_SEARCH_AGENT = searchModel
+    mcpServers.clco_web = {
+      command: process.execPath,
+      args: [join(import.meta.dir, "webmcp.ts")],
+      ...(Object.keys(env).length > 0 ? { env } : {}),
+    }
+  }
+  return Object.keys(mcpServers).length > 0 ? JSON.stringify({ mcpServers }) : null
+}
+
 // The extension mints a base64url value; nothing else should be accepted.
 // A paste can easily pick up a shell prompt or a stray line, and storing that
 // silently produces a token that never works and no clue why.

package/src/claudehome.ts

@@ -46,6 +46,35 @@ const PRIVATE_ENTRIES = new Set([
  * user's file every launch discarded whatever claude had persisted in the
  * private one.
  */
+/**
+ * clco owns routing and auth: ANTHROPIC_BASE_URL and the bearer travel in
+ * the --settings tier. A provider env block in the user's own settings.json
+ * (e.g. z.ai's ANTHROPIC_AUTH_TOKEN) must not survive the copy: claude
+ * applies settings-file env over the child environment, so a surviving
+ * token would override clco's and every request would 401 against the
+ * adapter. ANTHROPIC_MODEL is stripped too: clco pins the session model
+ * itself, and a surviving pin makes every /model switch cosmetic.
+ */
+const ROUTING_ENV = /^ANTHROPIC_(AUTH_TOKEN|API_KEY|BASE_URL|MODEL)$/
+function stripRoutingEnv(parsed: Record<string, unknown>): void {
+  const env = parsed.env as Record<string, unknown> | undefined
+  if (env && typeof env === "object" && !Array.isArray(env)) {
+    for (const key of Object.keys(env)) if (ROUTING_ENV.test(key)) delete env[key]
+  }
+}
+
+// Claude's built-in WebSearch executes server-side on Anthropic's API and can
+// never work through the adapter. Denying it in the private copy keeps the
+// model from calling a tool that always no-ops and steering it toward the
+// clco_web search tool instead. The user's own file is never touched.
+function denyServerWebSearch(parsed: Record<string, unknown>): void {
+  const permissions = (parsed.permissions ?? {}) as Record<string, unknown>
+  const deny = Array.isArray(permissions.deny) ? [...permissions.deny] : []
+  if (!deny.includes("WebSearch")) deny.push("WebSearch")
+  permissions.deny = deny
+  parsed.permissions = permissions
+}
+
 async function writeSettings(real: string, home: string): Promise<void> {
   const target = join(home, "settings.json")
   const source = await readFile(join(real, "settings.json"), "utf8").catch(
@@ -57,6 +86,8 @@ async function writeSettings(real: string, home: string): Promise<void> {
   try {
     const parsed = JSON.parse(raw) as Record<string, unknown>
     delete parsed.model
+    stripRoutingEnv(parsed)
+    denyServerWebSearch(parsed)
     await atomicWrite(target, JSON.stringify(parsed, null, 2) + "\n")
   } catch {
     // claude tolerates comments where JSON.parse does not. A line-based regex
@@ -68,6 +99,8 @@ async function writeSettings(real: string, home: string): Promise<void> {
     try {
       const parsed = JSON.parse(stripJsonComments(raw)) as Record<string, unknown>
       delete parsed.model
+    stripRoutingEnv(parsed)
+    denyServerWebSearch(parsed)
       await atomicWrite(target, JSON.stringify(parsed, null, 2) + "\n")
     } catch (err) {
       // Neither form parses: keep the previous private file rather than

package/src/cli.ts

@@ -103,6 +103,13 @@ const pad = (rows: ReadonlyArray<[string, string]>, width: number) =>
 
 export const COMMAND_LIST = `Commands:\n${pad(COMMANDS, 20)}`
 
+function searchAgentModel(models: ReadonlyArray<{ id: string }>): string | undefined {
+  // Copilot's own search-agent models: a plans web queries, b/c plan code
+  // search. Prefer the web one; anything is better than no planner.
+  return models.find((model) => model.id === "copilot-search-a")?.id ??
+    models.find((model) => model.id.startsWith("copilot-search"))?.id
+}
+
 const HELP = `clco v${VERSION} — run Claude Code on your GitHub Copilot subscription
 
 Usage:
@@ -160,7 +167,8 @@ export function parseArgs(rawArgv: string[]): Args {
     if (
       arg === "--no-bypass" ||
       arg === "--no-select" ||
-      arg === "--no-browser"
+      arg === "--no-browser" ||
+      arg === "--no-web"
     ) {
       overrides[arg.slice(5) as keyof SetupOverrides] = false
       i++
@@ -836,15 +844,13 @@ async function main(): Promise<void> {
   const browserEnabled =
     setup?.browser === true && args.overrides.browser !== false
   const browserExtension = browserEnabled ? await extensionInstalled() : false
+  // Web is on unless the user turned it off; absent prefs mean on.
+  const webEnabled = setup?.web !== false && args.overrides.web !== false
+  const searchAgent = searchAgentModel(list)
   // Computed from the arguments actually produced: clco stands aside when the
   // user passes their own --mcp-config, and claiming success there would be
   // the same trap as registering a server with no extension.
-  const injected = setupClaudeArgs(
-    setup,
-    args.overrides,
-    args.claudeArgs,
-    browserExtension,
-  )
+  const injected = setupClaudeArgs(setup, args.overrides, args.claudeArgs, browserExtension, searchAgent)
   const registered = injected.includes("--mcp-config")
   const browserLine = startupLine(
     browserEnabled,
@@ -860,6 +866,15 @@ async function main(): Promise<void> {
     browserEnabled && browserExtension ? registered : undefined,
   )
   if (browserLine) console.error(browserLine)
+  console.error(
+    webEnabled && !searchAgent
+      ? "+ web: unavailable (Copilot exposed no search-agent model)"
+      : webEnabled && injected.includes("--mcp-config")
+      ? `+ web: search via ${searchAgent} planner + live local execution`
+      : webEnabled
+        ? "+ web: enabled in setup, but not registered because --mcp-config was supplied"
+        : "+ web: disabled (run `clco setup` to enable)",
+  )
 
   if (args.command === "serve") {
     console.error("Adapter running... (Ctrl+C to stop)")

package/src/config.ts

@@ -106,6 +106,8 @@ export interface SetupPrefs {
    * secret — the GitHub token lives in auth.json.
    */
   browserToken?: string
+  /** Register Copilot native web search and the local URL fetcher. */
+  web?: boolean
 }
 
 export interface Prefs {

package/src/responses.ts

@@ -141,6 +141,16 @@ export function toResponsesRequest(
 
   const effort = effortFor(payload, allowedEfforts)
 
+  // Claude's built-in server-side tools (WebSearch, WebFetch) arrive without
+  // input_schema and cannot be executed by an upstream that only knows
+  // function tools - drop them rather than sending a broken schema. If
+  // tool_choice pinned one of the dropped tools, degrade to "auto", or the
+  // upstream rejects the request with "tool choice not found in tools".
+  const servable = (payload.tools ?? []).filter((t) => t.input_schema)
+  const choice = payload.tool_choice
+  const pinnedMissing =
+    choice?.type === "tool" && !servable.some((t) => t.name === choice.name)
+
   return {
     model: normalizeModel(payload.model),
     ...(instructions && { instructions }),
@@ -150,21 +160,22 @@ export function toResponsesRequest(
     max_output_tokens: payload.max_tokens,
     temperature: payload.temperature,
     top_p: payload.top_p,
-    tools: payload.tools?.map((t) => ({
+    tools: servable.map((t) => ({
       type: "function" as const,
       name: t.name,
       description: t.description,
       parameters: t.input_schema,
     })),
-    tool_choice:
-      payload.tool_choice?.type === "auto"
-        ? "auto"
-        : payload.tool_choice?.type === "none"
-          ? "none"
-          : payload.tool_choice?.type === "any"
-            ? "required"
-            : payload.tool_choice?.name
-              ? { type: "function", name: payload.tool_choice.name }
+    tool_choice: pinnedMissing
+      ? ("auto" as const)
+      : choice?.type === "auto"
+        ? ("auto" as const)
+        : choice?.type === "none"
+          ? ("none" as const)
+          : choice?.type === "any"
+            ? ("required" as const)
+            : choice?.name
+              ? { type: "function" as const, name: choice.name }
               : undefined,
   }
 }

package/src/search.ts

@@ -0,0 +1,131 @@
+// Semi-native web search: Copilot's dedicated search-agent model plans the
+// queries (copilot-search-a; GitHub's own web-search planner, callable with
+// the same OAuth token), execution is ours - DuckDuckGo HTML for results and
+// the local fetcher for pages - and the planner synthesizes the final answer.
+// Verified live 2026-09-13: the planner emits real read_article URLs only
+// after live results are fed back, so information genuinely flows web ->
+// model. Rounds are capped; any failure surfaces as WebFetchError.
+import { getCopilotToken } from "./token"
+import { copilotBaseUrl, copilotFetch, copilotRequestHeaders } from "./api"
+import { fetchContent, WebFetchError } from "./webfetch"
+
+export const SEARCH_AGENT = process.env.CLCO_SEARCH_AGENT ?? "copilot-search-a"
+const MAX_ROUNDS = 4
+const MAX_CALLS_PER_ROUND = 3
+const UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)"
+
+type ToolCall = { id: string; function: { name: string; arguments: string } }
+type Msg = Record<string, unknown>
+
+async function chat(token: string, messages: Msg[], withTools = true): Promise<{ content: string; calls: ToolCall[] }> {
+  const res = await copilotFetch(`${copilotBaseUrl()}/chat/completions`, {
+    method: "POST",
+    headers: copilotRequestHeaders(token, { accept: "application/json" }),
+    body: JSON.stringify({
+      model: SEARCH_AGENT,
+      messages,
+      ...(withTools
+        ? {
+            tools: [
+              { type: "web_search" },
+              { type: "function", function: { name: "read_article", description: "Read a web page by URL.", parameters: { type: "object", properties: { url: { type: "string" } }, required: ["url"] } } },
+            ],
+          }
+        : {}),
+      stream: false,
+    }),
+    signal: AbortSignal.timeout(60_000),
+  })
+  if (!res.ok) throw new WebFetchError(`search agent failed: HTTP ${res.status} ${(await res.text()).slice(0, 200)}`)
+  const json = (await res.json()) as { choices?: Array<{ message?: { content?: string; tool_calls?: ToolCall[] } }> }
+  const message = json.choices?.[0]?.message ?? {}
+  return { content: message.content ?? "", calls: message.tool_calls ?? [] }
+}
+
+async function ddg(query: string): Promise<string> {
+  const res = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
+    headers: { "User-Agent": UA },
+    signal: AbortSignal.timeout(20_000),
+  })
+  const html = await res.text()
+  const results = [...html.matchAll(/class="result__a"[^>]*>([^<]+)<\/a>[\s\S]*?class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g)]
+    .slice(0, 5)
+    .map((m, i) => `${i + 1}. ${strip(m[1]!)}: ${strip(m[2]!).slice(0, 250)}`)
+  return results.join("\n") || "(no results)"
+}
+
+function strip(html: string): string {
+  return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&#x27;/g, "'").replace(/&quot;/g, '"').trim()
+}
+
+async function readUrl(url: string): Promise<string> {
+  const { text } = await fetchContent(url, 4_000)
+  return text
+}
+
+type LoopDeps = {
+  /** One planner turn: returns its text plus any tool calls it wants. */
+  ask: (messages: Msg[]) => Promise<{ content: string; calls: ToolCall[] }>
+  /** Execute a search query. */
+  search: (query: string) => Promise<string>
+  /** Read a page by URL. */
+  read: (url: string) => Promise<string>
+  /** Final answer from gathered material; must not plan more tool calls. */
+  synthesize: (messages: Msg[]) => Promise<string>
+}
+
+/** The planner/executor loop, injectable for tests. */
+export async function searchLoop(query: string, deps: LoopDeps): Promise<string> {
+  const messages: Msg[] = [
+    {
+      role: "system",
+      content:
+        "You are a web research assistant. Always call web_search FIRST to find live results; never guess or construct URLs yourself - only read_article URLs that appeared in web_search results. Finish with a concise answer and list the sources you used.",
+    },
+    { role: "user", content: query },
+  ]
+  const done = new Map<string, string>()
+  let material = ""
+  for (let round = 0; round < MAX_ROUNDS; round++) {
+    const { content, calls } = await deps.ask(messages)
+    if (!calls.length) return content.trim() || material || "(no results)"
+    messages.push({ role: "assistant", content: content || null, tool_calls: calls })
+    for (const call of calls.slice(0, MAX_CALLS_PER_ROUND)) {
+      let args: { query?: string; url?: string } = {}
+      try { args = JSON.parse(call.function.arguments || "{}") } catch { /* empty args stay empty */ }
+      // Re-running a failed or finished call only burns rounds; replay it.
+      const key = `${call.function.name}:${args.query ?? args.url ?? ""}`
+      let output = done.get(key)
+      if (output === undefined) {
+        if (call.function.name === "read_article" && args.url) {
+          output = await deps.read(args.url).catch((error) => `(fetch failed: ${(error as Error).message}. Use web_search to find a working source.)`)
+          material += `\n(source) ${args.url}\n${output.slice(0, 300)}`
+        } else {
+          output = await deps.search(args.query ?? query)
+          material += `\n${output}`
+        }
+        done.set(key, output)
+      }
+      messages.push({ role: "tool", tool_call_id: call.id, content: output })
+    }
+  }
+  // The planner always wants one more round, so conclude without tools:
+  // answer the original question from the gathered material only.
+  return (
+    await deps.synthesize([
+      ...messages,
+      { role: "user", content: "Stop searching. Answer the original question using only the results gathered above. Be concise and list the sources you used." },
+    ])
+  ).trim() || material.trim()
+}
+
+/** One search: plan with the agent, execute, feed back, return the answer. */
+export async function runSearch(query: string): Promise<string> {
+  const token = await getCopilotToken()
+  return searchLoop(query, {
+    ask: (messages) => chat(token, messages),
+    search: ddg,
+    read: readUrl,
+    synthesize: async (messages) => (await chat(token, messages, false)).content,
+  })
+}

package/src/server.ts

@@ -540,9 +540,14 @@ async function handleMessages(
 // origin we actually bound instead.
 function authorize(req: Request, selfHost: string): Response | null {
   if (req.headers.get("host") !== selfHost) {
+    logLine(`[${timestamp()}]   -> 403 ${new URL(req.url).pathname} host=${req.headers.get("host")}`)
     return anthropicError(403, "host header mismatch")
   }
-  if (req.headers.get("authorization") !== `Bearer ${LOCAL_TOKEN}`) {
+  const auth = req.headers.get("authorization")
+  if (auth !== `Bearer ${LOCAL_TOKEN}`) {
+    // Never log the full value: enough to tell which credential source sent it.
+    const got = auth === null ? "(none)" : auth.startsWith("Bearer ") ? `Bearer ${auth.slice(7, 15)}…(${auth.length - 7} chars)` : `other(${auth.slice(0, 8)}…)`
+    logLine(`[${timestamp()}]   -> 401 ${new URL(req.url).pathname} auth=${got} expected=Bearer ${LOCAL_TOKEN.slice(0, 8)}…`)
     return anthropicError(401, "missing or invalid adapter token")
   }
   return null
@@ -624,6 +629,9 @@ export async function startServer(
   const server = Bun.serve({
     hostname: "127.0.0.1",
     port: opts.port ?? 0,
+    // Search-planner and provider calls can hold the client socket silent
+    // for the whole upstream generation; Bun's 10s default killed those.
+    idleTimeout: 255,
     fetch: (req) =>
       handle(req, upstreamBase, mockToken, selfHost).catch((err) =>
         anthropicError(500, String(err)),

package/src/setup.ts

@@ -5,7 +5,7 @@
 import * as p from "@clack/prompts"
 import {
   TOKEN_ENV,
-  browserMcpConfig,
+  combinedMcpConfig,
   extensionInstalled,
   parseToken,
   setupNote,
@@ -13,12 +13,13 @@ import {
 import { loadPrefs, savePrefs, type SetupPrefs } from "./config"
 
 /** Bump when an option is added, so existing users get told once. */
-export const SETUP_VERSION = 2
+export const SETUP_VERSION = 3
 
 export interface SetupOverrides {
   bypass?: boolean
   select?: boolean
   browser?: boolean
+  web?: boolean
 }
 
 // What the first-run prompts come pre-filled with: these are the options
@@ -30,6 +31,7 @@ export const SETUP_DEFAULTS: Omit<SetupPrefs, "version"> = {
   bypass: true,
   select: true,
   browser: true,
+  web: true,
 }
 
 export async function runSetup(): Promise<SetupPrefs> {
@@ -62,6 +64,11 @@ export async function runSetup(): Promise<SetupPrefs> {
     current.bypass,
   )
 
+  setup.web = await ask(
+    "Search the web via Copilot's search planner (queries by copilot-search-a, live execution locally)?",
+    current.web ?? true,
+  )
+
   // Claude's own Chrome integration cannot work here, so there is nothing to
   // ask about it - only an alternative to offer.
   setup.browser = await ask(
@@ -98,7 +105,7 @@ export async function runSetup(): Promise<SetupPrefs> {
   await savePrefs({ ...prefs, setup })
   p.outro(
     "Saved. Re-run `clco setup` to change it, or turn one off for a single\n" +
-      "run with --no-bypass / --no-select / --no-browser.",
+      "run with --no-bypass / --no-select / --no-browser / --no-web.",
   )
   return setup
 }
@@ -135,6 +142,8 @@ export function setupClaudeArgs(
   claudeArgs: string[],
   /** Whether the Playwright MCP Bridge extension is installed. */
   browserExtension = false,
+  /** The Copilot search-agent model the web tool plans with. */
+  searchAgent?: string,
 ): string[] {
   if (!setup) return []
   // Match the `--flag=value` form too: an exact comparison let a user's own
@@ -153,12 +162,10 @@ export function setupClaudeArgs(
   }
   // Registered per session rather than written into the user's MCP config, so
   // clco never edits configuration that outlives it.
-  if (
-    setup.browser &&
-    overrides.browser !== false &&
-    !has("--mcp-config")
-  ) {
-    const config = browserMcpConfig(browserExtension)
+  const browserRequested = setup.browser && overrides.browser !== false && browserExtension
+  const webRequested = setup.web === true && overrides.web !== false
+  if ((browserRequested || webRequested) && !has("--mcp-config")) {
+    const config = combinedMcpConfig(browserExtension, webRequested, searchAgent)
     if (config) out.push("--mcp-config", config)
   }
   return out

package/src/tokens.ts

@@ -48,7 +48,7 @@ export function estimateTokens(payload: AnthropicRequest): number {
   count(payload.system)
   for (const tool of payload.tools ?? []) {
     chars += tool.name.length + (tool.description?.length ?? 0)
-    chars += JSON.stringify(tool.input_schema).length
+    chars += JSON.stringify(tool.input_schema ?? {}).length
   }
   return Math.ceil(chars / CHARS_PER_TOKEN) + images * IMAGE_TOKENS +
     (payload.messages?.length ?? 0) * MESSAGE_TOKENS

package/src/translate.ts

@@ -249,6 +249,7 @@ function translateTools(
 
 function translateToolChoice(
   choice: AnthropicRequest["tool_choice"],
+  servableNames: Set<string>,
 ): OpenAIRequest["tool_choice"] {
   if (!choice) return undefined
   switch (choice.type) {
@@ -259,9 +260,12 @@ function translateToolChoice(
     case "none":
       return "none"
     case "tool":
-      return choice.name
+      // A pinned tool that was dropped (Claude's built-in server-side ones
+      // carry no input_schema) must degrade to "auto", or the upstream
+      // rejects with "tool choice not found in tools".
+      return choice.name && servableNames.has(choice.name)
         ? { type: "function", function: { name: choice.name } }
-        : undefined
+        : "auto"
     default:
       return undefined
   }
@@ -298,7 +302,14 @@ export function translateRequest(
     top_p: payload.top_p,
     user: payload.metadata?.user_id ?? null,
     tools: translateTools(payload.tools),
-    tool_choice: translateToolChoice(payload.tool_choice),
+    tool_choice: translateToolChoice(
+      payload.tool_choice,
+      new Set(
+        (payload.tools ?? [])
+          .filter((tool) => tool.input_schema)
+          .map((tool) => tool.name),
+      ),
+    ),
   }
 }
 

package/src/webfetch.ts

@@ -0,0 +1,60 @@
+import { lookup } from "node:dns/promises"
+import { Readability } from "@mozilla/readability"
+import { parseHTML } from "linkedom"
+import TurndownService from "turndown"
+
+const MAX_BYTES = 5 * 1024 * 1024
+const MAX_REDIRECTS = 5
+const FETCH_TIMEOUT_MS = 20_000
+export class WebFetchError extends Error {}
+
+export function privateAddress(address: string): boolean {
+  const value = address.toLowerCase()
+  if (value.startsWith("::ffff:")) return privateAddress(value.slice(7))
+  if (value === "::" || value === "::1" || value.startsWith("fc") || value.startsWith("fd") || value.startsWith("fe8") || value.startsWith("fe9") || value.startsWith("fea") || value.startsWith("feb") || value.startsWith("ff") || value.startsWith("2001:db8:")) return true
+  const octets = value.split(".").map(Number)
+  if (octets.length !== 4 || octets.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false
+  const [a, b, c] = octets
+  return a === 0 || a === 10 || a === 127 || a >= 224 || (a === 100 && b >= 64 && b <= 127) || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 192 && b === 0 && (c === 0 || c === 2)) || (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100))) || (a === 203 && b === 0 && c === 113)
+}
+async function publicAddress(url: URL): Promise<string> {
+  const addresses = await Promise.race([lookup(url.hostname, { all: true, verbatim: true }), new Promise<never>((_, reject) => setTimeout(() => reject(new WebFetchError("web_fetch DNS lookup timed out")), 5_000))])
+  if (!addresses.length || addresses.some(({ address }) => privateAddress(address))) throw new WebFetchError("web_fetch blocked a private or local destination")
+  return addresses[0]!.address
+}
+async function validateUrl(raw: string): Promise<URL> {
+  let url: URL
+  try { url = new URL(raw) } catch { throw new WebFetchError("web_fetch requires a valid URL") }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new WebFetchError("web_fetch only permits credential-free HTTP(S) URLs")
+  await publicAddress(url)
+  return url
+}
+async function pinnedFetch(url: URL, init: RequestInit): Promise<Response> {
+  const address = await publicAddress(url); const target = new URL(url); const originalHost = target.host; target.hostname = address; const headers = new Headers(init.headers); headers.set("host", originalHost); const options = { ...init, headers } as RequestInit & { tls?: { serverName: string } }; if (url.protocol === "https:") options.tls = { serverName: url.hostname }; return fetch(target, options as RequestInit)
+}
+async function readLimited(response: Response): Promise<Uint8Array> {
+  if (!response.body) throw new WebFetchError("web_fetch received an empty response")
+  const reader = response.body.getReader(); const chunks: Uint8Array[] = []; let total = 0
+  try { while (true) { const { done, value } = await reader.read(); if (done) break; total += value.byteLength; if (total > MAX_BYTES) throw new WebFetchError("web_fetch refused a response larger than 5 MB"); chunks.push(value) } } finally { await reader.cancel().catch(() => {}) }
+  const result = new Uint8Array(total); let offset = 0
+  for (const chunk of chunks) { result.set(chunk, offset); offset += chunk.byteLength }
+  return result
+}
+async function pdfText(bytes: Uint8Array): Promise<string> {
+  try { const module = await import("unpdf") as { extractText?: (data: Uint8Array) => Promise<unknown> }; if (!module.extractText) throw new Error(); const result = await module.extractText(bytes); if (typeof result === "string") return result; const text = (result as { text?: string | string[] } | null)?.text; return Array.isArray(text) ? text.join("\n") : text ?? "" } catch { throw new WebFetchError("web_fetch could not extract text from this PDF") }
+}
+export async function fetchContent(rawUrl: string, maxChars = 30_000): Promise<{ url: string; contentType: string; text: string; title?: string }> {
+  let url = await validateUrl(rawUrl); let response: Response | undefined
+  for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects++) { response = await pinnedFetch(url, { redirect: "manual", signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) }); if (![301, 302, 303, 307, 308].includes(response.status)) break; const location = response.headers.get("location"); if (!location || redirects === MAX_REDIRECTS) throw new WebFetchError("web_fetch followed too many redirects"); url = await validateUrl(new URL(location, url).toString()) }
+  if (!response) throw new WebFetchError("web_fetch did not receive a response"); if (!response.ok) throw new WebFetchError(`web_fetch failed: HTTP ${response.status}`)
+  const bytes = await readLimited(response); const contentType = (response.headers.get("content-type") ?? "application/octet-stream").split(";", 1)[0].trim().toLowerCase()
+  if (contentType === "application/pdf" || url.pathname.toLowerCase().endsWith(".pdf")) return { url: url.toString(), contentType, text: (await pdfText(bytes)).trim().slice(0, maxChars) }
+  const source = new TextDecoder().decode(bytes)
+  if (["application/json", "text/plain", "text/csv", "application/xml"].includes(contentType)) return { url: url.toString(), contentType, text: source.slice(0, maxChars) }
+  if (!contentType.includes("html")) throw new WebFetchError(`web_fetch does not support ${contentType || "this content type"}`)
+  const { document } = parseHTML(source); const article = new Readability(document as unknown as Document).parse()
+  if (!article?.content) throw new WebFetchError("web_fetch found no readable static content; use browser control for JavaScript-only pages")
+  const markdown = new TurndownService({ codeBlockStyle: "fenced" }).turndown(article.content).trim()
+  if (!markdown) throw new WebFetchError("web_fetch found no readable static content; use browser control for JavaScript-only pages")
+  return { url: url.toString(), contentType, title: article.title || undefined, text: markdown.slice(0, maxChars) }
+}

package/src/webmcp.ts

@@ -0,0 +1,45 @@
+// Session-scoped MCP server exposing one tool: web_search. The heavy lifting
+// lives in search.ts (planner + execution loop); this file is the stdio
+// JSON-RPC wrapper Claude Code talks to.
+import { runSearch, SEARCH_AGENT } from "./search"
+import { WebFetchError } from "./webfetch"
+import { loadAuth } from "./config"
+
+type Rpc = { jsonrpc: "2.0"; id?: string | number; method: string; params?: Record<string, unknown> }
+function reply(id: Rpc["id"], result: unknown): void { if (id !== undefined) process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n") }
+function failure(message: string): { content: [{ type: "text"; text: string }]; isError: true } { return { content: [{ type: "text", text: message }], isError: true } }
+
+const tools = [
+  { name: "web_search", description: "Search the live web. Use this whenever the user asks to search, look up, or find current information - results are fresh, not from training data.", inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"], additionalProperties: false } },
+]
+
+async function call(name: string, args: Record<string, unknown>): Promise<unknown> {
+  try {
+    if (name === "web_search") {
+      if (!(await loadAuth())?.github_token && !process.env.CLCO_UPSTREAM) return failure("GitHub authentication is required; run `clco login` before using web search")
+      return { content: [{ type: "text", text: await runSearch(String(args.query ?? "")) }] }
+    }
+    return failure(`unknown web tool: ${name}`)
+  } catch (error) {
+    return failure(error instanceof Error ? error.message : String(error))
+  }
+}
+
+process.stdin.setEncoding("utf8")
+let input = ""
+let queue = Promise.resolve()
+process.stdin.on("data", (chunk: string) => {
+  input += chunk
+  for (const line of input.split("\n").slice(0, -1)) queue = queue.then(() => handle(line))
+  input = input.split("\n").pop() ?? ""
+})
+async function handle(line: string): Promise<void> {
+  if (!line.trim()) return
+  let message: Rpc
+  try { message = JSON.parse(line) as Rpc } catch { return }
+  if (message.method === "initialize") return reply(message.id, { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "clco-web", version: "0.1.0" }, instructions: "This server provides live web search. Whenever the user asks to search the web, look something up online, or needs current information (news, releases, prices, docs), call its web_search tool instead of answering from memory." })
+  if (message.method === "ping") return reply(message.id, {})
+  if (message.method === "tools/list") return reply(message.id, { tools })
+  if (message.method === "tools/call") { const params = message.params ?? {}; return reply(message.id, await call(String(params.name), (params.arguments ?? {}) as Record<string, unknown>)) }
+  if (message.id !== undefined) reply(message.id, { error: { code: -32601, message: `Method not found: ${message.method}` } })
+}