@aliou/pi-linkup 0.0.1 → 0.2.0

package/.changeset/README.md

@@ -0,0 +1,11 @@
+# Changesets
+
+This folder is used by [Changesets](https://github.com/changesets/changesets) to manage versioning and changelogs.
+
+## Adding a changeset
+
+Run `pnpm changeset` to create a new changeset when you make changes that should be released.
+
+## Releasing
+
+When changesets are merged to main, a PR will be created to version and release the package.

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.1.2/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "public",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "pnpm"
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Lint
+        run: pnpm lint
+
+      - name: Typecheck
+        run: pnpm typecheck

package/.github/workflows/publish.yml

@@ -0,0 +1,151 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      skip-checks:
+        description: "Skip lint and typecheck"
+        type: boolean
+        default: false
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    if: ${{ !(github.event_name == 'workflow_dispatch' && inputs.skip-checks) }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          cache: "pnpm"
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Lint
+        run: pnpm lint
+
+      - name: Typecheck
+        run: pnpm typecheck
+
+  publish:
+    name: Publish
+    needs: check
+    if: ${{ always() && (needs.check.result == 'success' || needs.check.result == 'skipped') }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      packages: write
+      pull-requests: write
+      id-token: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+          registry-url: "https://registry.npmjs.org"
+          scope: "@aliou"
+          cache: "pnpm"
+
+      - name: Upgrade npm for OIDC support
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Get release info
+        id: release-info
+        run: |
+          pnpm changeset status --output=release.json 2>/dev/null || echo '{"releases":[]}' > release.json
+          node <<NODE
+          const fs = require('fs');
+          const release = JSON.parse(fs.readFileSync('release.json', 'utf8'));
+          const releases = release.releases?.filter(r => r.type !== 'none') || [];
+
+          let title = 'Version Packages';
+          let commit = 'Version Packages';
+          if (releases.length === 1) {
+            const { name, newVersion } = releases[0];
+            title = 'Updating ' + name + ' to version ' + newVersion;
+            commit = name + '@' + newVersion;
+          } else if (releases.length > 1) {
+            const summary = releases.map(r => r.name + '@' + r.newVersion).join(', ');
+            title = 'Updating ' + summary;
+            commit = summary;
+          }
+
+          fs.appendFileSync(process.env.GITHUB_OUTPUT, 'title=' + title + '\n');
+          fs.appendFileSync(process.env.GITHUB_OUTPUT, 'commit=' + commit + '\n');
+          NODE
+          rm -f release.json
+        continue-on-error: true
+
+      - name: Create Release PR or Publish
+        id: changesets
+        uses: changesets/action@v1
+        with:
+          version: pnpm changeset version
+          publish: pnpm changeset publish
+          title: ${{ steps.release-info.outputs.title || 'Version Packages' }}
+          commit: ${{ steps.release-info.outputs.commit || 'Version Packages' }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+
+      - name: Create GitHub releases
+        if: steps.changesets.outputs.published == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PUBLISHED_PACKAGES: ${{ steps.changesets.outputs.publishedPackages }}
+        run: |
+          node <<'NODE'
+          const { execSync } = require("node:child_process");
+
+          const published = JSON.parse(process.env.PUBLISHED_PACKAGES || "[]");
+
+          for (const pkg of published) {
+            const shortName = pkg.name.replace(/^@[^/]+\//, "");
+            const tag = `${shortName}@${pkg.version}`;
+
+            const existing = execSync(`git tag --list ${tag}`, { encoding: "utf8" }).trim();
+            if (!existing) {
+              execSync(`git tag ${tag}`);
+              execSync(`git push origin ${tag}`);
+            }
+
+            let hasRelease = false;
+            try {
+              const output = execSync(`gh release view ${tag} --json tagName --jq .tagName`, {
+                stdio: ["ignore", "pipe", "ignore"],
+              }).toString().trim();
+              hasRelease = output.length > 0;
+            } catch {
+              hasRelease = false;
+            }
+
+            if (!hasRelease) {
+              execSync(`gh release create ${tag} --title ${tag} --notes "Release ${tag}"`, {
+                stdio: "inherit",
+              });
+            }
+          }
+          NODE

package/.husky/pre-commit

@@ -0,0 +1,3 @@
+pnpm run typecheck
+pnpm run lint
+pnpm run format

package/AGENTS.md

@@ -0,0 +1,48 @@
+# pi-linkup
+
+Public Pi extension providing web search, answer, and fetch tools via the Linkup API. People could be using this, so consider backwards compatibility when making changes.
+
+Pi is pre-1.0.0, so breaking changes can happen between Pi versions. This extension must stay up to date with Pi or things will break.
+
+## Stack
+
+- TypeScript (strict mode)
+- pnpm 10.26.1
+- Biome for linting/formatting
+- Changesets for versioning
+
+## Scripts
+
+```bash
+pnpm typecheck    # Type check
+pnpm lint         # Lint (runs on pre-commit)
+pnpm format       # Format
+pnpm changeset    # Create changeset for versioning
+```
+
+## Structure
+
+```
+src/
+  index.ts        # Extension entry, registers tools and commands
+  client.ts       # Linkup API client
+  types.ts        # Shared types
+  tools/          # Tool implementations
+  commands/       # Command implementations
+skills/
+  linkup/SKILL.md # Skill docs for agents using this extension
+```
+
+## Conventions
+
+- New tools: follow patterns in `src/tools/`
+- API keys come from environment (`LINKUP_API_KEY`)
+- Update `skills/linkup/SKILL.md` when tool behavior changes
+
+## Versioning
+
+Uses changesets. Run `pnpm changeset` before committing user-facing changes.
+
+- `patch`: bug fixes
+- `minor`: new features/tools
+- `major`: breaking changes

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @aliou/pi-linkup
+
+## 0.2.0
+
+### Minor Changes
+
+- 2307674: Update pi packages to 0.51.0. Adapt tool execute signatures to new parameter order.

package/README.md

@@ -0,0 +1,203 @@
+# pi-linkup
+
+Web search and content fetching extension for [Pi](https://buildwithpi.ai/) using the [Linkup API](https://linkup.so).
+
+## Features
+
+- `linkup_web_search` - Search the web, get relevant sources with content
+- `linkup_web_answer` - Get synthesized answers with citations
+- `linkup_web_fetch` - Extract clean markdown from URLs
+- `/linkup:balance` - Check API credit balance
+
+## Installation
+
+### Get API Key
+
+Sign up at [app.linkup.so](https://app.linkup.so) to get an API key.
+
+### Set Environment Variable
+
+```bash
+export LINKUP_API_KEY="your-api-key-here"
+```
+
+Add to shell profile for persistence:
+
+```bash
+echo 'export LINKUP_API_KEY="your-api-key-here"' >> ~/.zshrc
+```
+
+### Install Extension
+
+```bash
+# From npm
+pi install npm:@aliou/pi-linkup
+
+# From git
+pi install git:github.com/aliou/pi-linkup
+
+# Local development
+pi -e ./src/index.ts
+```
+
+## Usage
+
+### linkup_web_search
+
+Search the web and get a list of sources with content snippets.
+
+**Parameters:**
+- `query` (string, required) - The search query
+- `deep` (boolean, optional) - Use deep search mode for comprehensive results. Default: false
+
+**Example prompts:**
+```
+Search for "TypeScript 5.0 new features"
+```
+
+```
+Use linkup_web_search with deep mode to research WebAssembly WASI
+```
+
+The agent will use `linkup_web_search` to find relevant sources. Results are shown in compact view by default. Press `Ctrl+O` to expand and see all sources with full content.
+
+### linkup_web_answer
+
+Get a synthesized answer with sources.
+
+**Parameters:**
+- `query` (string, required) - The question to answer
+- `deep` (boolean, optional) - Use deep search mode. Default: false
+
+**Example prompts:**
+```
+What is the latest stable Node.js version?
+```
+
+```
+Use linkup_web_answer to find Microsoft's 2024 revenue
+```
+
+The agent will use `linkup_web_answer` for concise answers. Press `Ctrl+O` to expand and see the full answer with all sources.
+
+### linkup_web_fetch
+
+Fetch content from a specific URL as markdown.
+
+**Parameters:**
+- `url` (string, required) - The URL to fetch
+- `renderJs` (boolean, optional) - Render JavaScript. Default: true
+
+**Example prompts:**
+```
+Fetch the content from https://docs.linkup.so
+```
+
+```
+Use linkup_web_fetch without JavaScript rendering for https://example.com/docs
+```
+
+The agent will use `linkup_web_fetch` to extract clean markdown. Press `Ctrl+O` to expand and see more content.
+
+### Check Balance
+
+```
+/linkup:balance
+```
+
+Shows remaining API credits.
+
+## Skill
+
+Includes agentskills.io compliant skill with detailed usage guide:
+
+```
+/skill:linkup
+```
+
+Provides:
+- Tool selection guidance
+- Query formulation tips
+- When to use deep vs standard search
+- Prompting best practices
+- Example workflows
+
+## Tool Selection Guide
+
+**Use linkup_web_search when:**
+- Finding information across multiple sources
+- Research and discovery
+- Need to see different perspectives
+
+**Use linkup_web_answer when:**
+- Need a direct answer to a specific question
+- Want a quick summary from multiple sources
+- Time-sensitive queries
+
+**Use linkup_web_fetch when:**
+- Reading documentation from a known URL
+- Following up on search results
+- Extracting content from specific articles
+
+## Best Practices
+
+1. Be specific with queries: "Microsoft 2024 Q4 revenue" beats "Microsoft revenue"
+2. Use deep mode strategically: Deep searches are thorough but slower
+3. Choose the right tool: search for discovery, answer for facts, fetch for known URLs
+4. Monitor usage: Check `/linkup:balance` to track credit consumption
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/aliou/pi-linkup.git
+cd pi-linkup
+
+# Install dependencies (sets up pre-commit hooks)
+pnpm install
+```
+
+Pre-commit hooks run on every commit:
+- TypeScript type checking
+- Biome linting
+- Biome formatting with auto-fix
+
+### Commands
+
+```bash
+# Type check
+pnpm run typecheck
+
+# Lint
+pnpm run lint
+
+# Format
+pnpm run format
+```
+
+### Test Locally
+
+```bash
+pi -e ./src/index.ts
+
+# Then in Pi
+/skill:linkup
+```
+
+## Requirements
+
+- Pi coding agent v0.50.0+
+- LINKUP_API_KEY environment variable
+
+## Links
+
+- [Linkup Documentation](https://docs.linkup.so)
+- [Linkup API Reference](https://docs.linkup.so/pages/documentation/api-reference)
+- [Get API Key](https://app.linkup.so)
+- [Pi Documentation](https://buildwithpi.ai/)
+- [Agent Skills Spec](https://agentskills.io/specification)
+
+## License
+
+MIT

package/biome.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.3.13/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "includes": ["**/*.ts", "**/*.json"],
+    "ignoreUnknown": true
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2
+  }
+}

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@aliou/pi-linkup",
-  "version": "0.0.1",
-  "private": false,
+  "version": "0.2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aliou/pi-linkup"
+  },
   "keywords": [
     "pi-package"
   ],
@@ -12,5 +15,23 @@
     "skills": [
       "./skills"
     ]
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@changesets/cli": "^2.27.11",
+    "@mariozechner/pi-coding-agent": "0.51.0",
+    "@mariozechner/pi-tui": "0.51.0",
+    "@sinclair/typebox": "^0.34.48",
+    "@types/node": "^25.0.10",
+    "husky": "^9.1.7",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check",
+    "format": "biome check --write",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "pnpm changeset publish"
   }
-}
+}

package/shell.nix

@@ -0,0 +1,10 @@
+{
+  pkgs ? import <nixpkgs> { },
+}:
+
+pkgs.mkShell {
+  buildInputs = with pkgs; [
+    nodejs
+    pnpm_10
+  ];
+}

package/skills/linkup/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: linkup
+description: "Web search and content fetching using Linkup extension. Use when needing to search the web, get answers to questions with sources, or fetch content from specific URLs. Provides three tools: linkup_web_search (discovery), linkup_web_answer (direct answers), linkup_web_fetch (URL content extraction)."
+---
+
+# Linkup Extension
+
+Web search and content fetching tools powered by Linkup API.
+
+## Tools
+
+### linkup_web_search
+
+Search the web and get sources with content snippets.
+
+```
+linkup_web_search(query: string, deep?: boolean)
+```
+
+- `query`: Be specific and detailed. Include context like dates, locations, company names.
+- `deep`: Use for complex research requiring multiple searches. Default: false (faster).
+
+**Use when:** Discovering information across multiple sources, researching topics, comparing perspectives.
+
+### linkup_web_answer
+
+Get a synthesized answer with source citations.
+
+```
+linkup_web_answer(query: string, deep?: boolean)
+```
+
+**Use when:** Need a direct answer to a specific question, quick facts with citations.
+
+### linkup_web_fetch
+
+Fetch content from a URL as clean markdown.
+
+```
+linkup_web_fetch(url: string, renderJs?: boolean)
+```
+
+- `url`: The URL to fetch.
+- `renderJs`: Set false for static pages (faster). Default: true.
+
+**Use when:** Reading documentation, following up on search results, extracting content from known URLs.
+
+## Tool Selection
+
+| Need | Tool |
+|------|------|
+| Find information across sources | `linkup_web_search` |
+| Get a direct answer with sources | `linkup_web_answer` |
+| Read content from a known URL | `linkup_web_fetch` |
+
+## Query Formulation
+
+**Good queries are specific:**
+
+| Bad | Good |
+|-----|------|
+| "Microsoft revenue" | "Microsoft fiscal year 2024 total revenue" |
+| "React hooks" | "React useEffect cleanup function best practices" |
+| "AI news" | "OpenAI announcements January 2026" |
+
+**Add context:**
+- Time: "2025", "last quarter", "since version 5.0"
+- Location: "French company Total", "US market"
+- Specifics: company names, version numbers, exact terms
+
+## When to Use Deep Mode
+
+**Standard (default):** Simple questions, quick lookups, known topics.
+
+**Deep:** Complex research, multi-step queries, comprehensive coverage needed.
+
+```
+// Standard - one search is enough
+linkup_web_search("Node.js 22 release date")
+
+// Deep - needs multiple searches
+linkup_web_search("comparison of Rust web frameworks performance benchmarks 2025", deep: true)
+```
+
+## Common Patterns
+
+### Research workflow
+1. `linkup_web_search` to discover sources
+2. `linkup_web_fetch` on promising URLs for full content
+
+### Quick facts
+1. `linkup_web_answer` for direct answer with citations
+
+### Documentation reading
+1. `linkup_web_fetch` on known documentation URL
+
+## Commands
+
+- `/linkup:balance` - Check remaining API credits

package/src/client.ts

@@ -0,0 +1,83 @@
+import type {
+  LinkupBalanceResponse,
+  LinkupErrorResponse,
+  LinkupFetchResponse,
+  LinkupSearchResponse,
+  LinkupSourcedAnswerResponse,
+} from "./types";
+
+const BASE_URL = "https://api.linkup.so/v1";
+
+export class LinkupClient {
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {},
+  ): Promise<T> {
+    const response = await fetch(`${BASE_URL}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const error = (await response.json()) as LinkupErrorResponse;
+      throw new Error(
+        error.error?.message ||
+          `HTTP ${response.status}: ${response.statusText}`,
+      );
+    }
+
+    return response.json();
+  }
+
+  async search(params: {
+    query: string;
+    depth: "standard" | "deep";
+    outputType: "searchResults" | "sourcedAnswer";
+  }): Promise<LinkupSearchResponse | LinkupSourcedAnswerResponse> {
+    return this.request("/search", {
+      method: "POST",
+      body: JSON.stringify({
+        q: params.query,
+        depth: params.depth,
+        outputType: params.outputType,
+      }),
+    });
+  }
+
+  async fetch(params: {
+    url: string;
+    renderJs?: boolean;
+  }): Promise<LinkupFetchResponse> {
+    return this.request("/fetch", {
+      method: "POST",
+      body: JSON.stringify({
+        url: params.url,
+        renderJs: params.renderJs ?? true,
+      }),
+    });
+  }
+
+  async getBalance(): Promise<LinkupBalanceResponse> {
+    return this.request("/credits/balance", {
+      method: "GET",
+    });
+  }
+}
+
+export function getClient(): LinkupClient {
+  const apiKey = process.env.LINKUP_API_KEY;
+  if (!apiKey) {
+    throw new Error("LINKUP_API_KEY environment variable is not set");
+  }
+  return new LinkupClient(apiKey);
+}

package/src/commands/balance.ts

@@ -0,0 +1,23 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getClient } from "../client";
+
+export function registerBalanceCommand(pi: ExtensionAPI) {
+  pi.registerCommand("linkup:balance", {
+    description: "Display remaining Linkup API credits",
+    async handler(_args, ctx) {
+      const client = getClient();
+
+      try {
+        const response = await client.getBalance();
+        ctx.ui.notify(
+          `Linkup Balance: ${response.balance.toFixed(2)} credits`,
+          "info",
+        );
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : "Unknown error";
+        ctx.ui.notify(`Error: ${message}`, "error");
+      }
+    },
+  });
+}

package/src/index.ts

@@ -0,0 +1,33 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { registerBalanceCommand } from "./commands/balance";
+import { registerWebAnswerTool } from "./tools/web-answer";
+import { registerWebFetchTool } from "./tools/web-fetch";
+import { registerWebSearchTool } from "./tools/web-search";
+
+export default function (pi: ExtensionAPI) {
+  const hasApiKey = !!process.env.LINKUP_API_KEY;
+
+  if (!hasApiKey) {
+    console.warn(
+      "[linkup] Warning: LINKUP_API_KEY not set. Linkup extension will not load.",
+    );
+
+    pi.on("session_start", (_event, ctx) => {
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          "LINKUP_API_KEY not set. Linkup extension disabled.",
+          "warning",
+        );
+      }
+    });
+    return;
+  }
+
+  // Register tools
+  registerWebSearchTool(pi);
+  registerWebAnswerTool(pi);
+  registerWebFetchTool(pi);
+
+  // Register commands
+  registerBalanceCommand(pi);
+}

package/src/tools/web-answer.ts

@@ -0,0 +1,143 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { getClient } from "../client";
+import type { LinkupSource, LinkupSourcedAnswerResponse } from "../types";
+
+interface WebAnswerDetails {
+  answer?: string;
+  sources?: LinkupSource[];
+  query?: string;
+  error?: string;
+  isError?: boolean;
+}
+
+export function registerWebAnswerTool(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "linkup_web_answer",
+    label: "Linkup Web Answer",
+    description:
+      "Get a synthesized answer to a question using Linkup API. Returns a direct answer with sources. Use when you need a concise answer to a specific question.",
+    parameters: Type.Object({
+      query: Type.String({
+        description:
+          "The question to answer. Be specific and detailed for best results.",
+      }),
+      deep: Type.Optional(
+        Type.Boolean({
+          description:
+            "Use deep search for more comprehensive answer (slower). Default: false (standard search).",
+        }),
+      ),
+    }),
+
+    async execute(_toolCallId, params, _signal, onUpdate, _ctx) {
+      const client = getClient();
+
+      try {
+        onUpdate?.({
+          content: [
+            {
+              type: "text",
+              text: `Searching for answer${params.deep ? " (deep mode)" : ""}...`,
+            },
+          ],
+          details: {},
+        });
+
+        const response = (await client.search({
+          query: params.query,
+          depth: params.deep ? "deep" : "standard",
+          outputType: "sourcedAnswer",
+        })) as LinkupSourcedAnswerResponse;
+
+        let content = `${response.answer}\n\n`;
+        content += `Sources:\n`;
+        for (const source of response.sources) {
+          content += `- ${source.name}: ${source.url}\n`;
+          if (source.snippet) {
+            content += `  ${source.snippet}\n`;
+          }
+        }
+
+        return {
+          content: [{ type: "text", text: content }],
+          details: {
+            answer: response.answer,
+            sources: response.sources,
+            query: params.query,
+          },
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          details: { error: message, isError: true },
+        };
+      }
+    },
+
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("Linkup: WebAnswer "));
+      text += theme.fg("accent", `"${args.query}"`);
+      if (args.deep) {
+        text += theme.fg("dim", " (deep)");
+      }
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) {
+        const text =
+          result.content?.[0]?.type === "text"
+            ? result.content[0].text
+            : "Searching...";
+        return new Text(theme.fg("dim", text), 0, 0);
+      }
+
+      const details = result.details as WebAnswerDetails;
+
+      if (details?.isError) {
+        const errorMsg =
+          result.content?.[0]?.type === "text"
+            ? result.content[0].text
+            : "Error occurred";
+        return new Text(theme.fg("error", errorMsg), 0, 0);
+      }
+
+      const answer = details?.answer || "";
+      const sources = details?.sources || [];
+
+      let text = theme.fg("success", "✓ Answer received");
+
+      if (!expanded) {
+        const preview = answer.slice(0, 100);
+        text += `\n  ${theme.fg("muted", preview)}`;
+        if (answer.length > 100) {
+          text += theme.fg("dim", "...");
+        }
+        text += `\n  ${theme.fg("dim", `${sources.length} source(s)`)}`;
+        text += theme.fg("muted", ` [Ctrl+O to expand]`);
+      }
+
+      if (expanded) {
+        text += `\n\n${theme.fg("accent", "Answer:")}`;
+        text += `\n${answer}`;
+
+        if (sources.length > 0) {
+          text += `\n\n${theme.fg("accent", "Sources:")}`;
+          for (const source of sources) {
+            text += `\n• ${theme.bold(source.name)}`;
+            text += `\n  ${theme.fg("dim", source.url)}`;
+            if (source.snippet) {
+              text += `\n  ${theme.fg("muted", source.snippet)}`;
+            }
+          }
+        }
+      }
+
+      return new Text(text, 0, 0);
+    },
+  });
+}

package/src/tools/web-fetch.ts

@@ -0,0 +1,119 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { getClient } from "../client";
+
+interface WebFetchDetails {
+  url?: string;
+  markdown?: string;
+  error?: string;
+  isError?: boolean;
+}
+
+export function registerWebFetchTool(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "linkup_web_fetch",
+    label: "Linkup Web Fetch",
+    description:
+      "Fetch and extract content from a specific URL using Linkup API. Returns clean markdown content. Use for reading documentation, articles, or any specific webpage.",
+    parameters: Type.Object({
+      url: Type.String({
+        description: "The URL to fetch content from.",
+      }),
+      renderJs: Type.Optional(
+        Type.Boolean({
+          description:
+            "Whether to render JavaScript on the page. Default: true. Set to false for faster fetching of static pages.",
+        }),
+      ),
+    }),
+
+    async execute(_toolCallId, params, _signal, onUpdate, _ctx) {
+      const client = getClient();
+
+      try {
+        onUpdate?.({
+          content: [
+            {
+              type: "text",
+              text: `Fetching ${params.url}...`,
+            },
+          ],
+          details: {},
+        });
+
+        const response = await client.fetch({
+          url: params.url,
+          renderJs: params.renderJs,
+        });
+
+        return {
+          content: [{ type: "text", text: response.markdown }],
+          details: { url: params.url, markdown: response.markdown },
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          details: { error: message, url: params.url, isError: true },
+        };
+      }
+    },
+
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("Linkup: WebFetch "));
+      text += theme.fg("accent", args.url);
+      if (args.renderJs === false) {
+        text += theme.fg("dim", " (no JS)");
+      }
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) {
+        const text =
+          result.content?.[0]?.type === "text"
+            ? result.content[0].text
+            : "Fetching...";
+        return new Text(theme.fg("dim", text), 0, 0);
+      }
+
+      const details = result.details as WebFetchDetails;
+
+      if (details?.isError) {
+        const errorMsg =
+          result.content?.[0]?.type === "text"
+            ? result.content[0].text
+            : "Error occurred";
+        return new Text(theme.fg("error", errorMsg), 0, 0);
+      }
+
+      const markdown = details?.markdown || "";
+      const url = details?.url || "";
+
+      let text = theme.fg("success", "✓ Fetched");
+      text += ` ${theme.fg("dim", url)}`;
+
+      if (!expanded) {
+        const preview = markdown.slice(0, 100).replace(/\n/g, " ");
+        text += `\n  ${theme.fg("muted", preview)}`;
+        if (markdown.length > 100) {
+          text += theme.fg("dim", "...");
+        }
+        text += theme.fg("muted", ` [Ctrl+O to expand]`);
+      }
+
+      if (expanded) {
+        const lines = markdown.split("\n");
+        const previewLines = lines.slice(0, 50);
+        text += `\n\n${previewLines.join("\n")}`;
+        if (lines.length > 50) {
+          text += `\n${theme.fg("dim", `\n[${lines.length - 50} more lines...]`)}`;
+        }
+      }
+
+      return new Text(text, 0, 0);
+    },
+  });
+}

package/src/tools/web-search.ts

@@ -0,0 +1,134 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { getClient } from "../client";
+import type { LinkupSearchResponse, LinkupSearchResult } from "../types";
+
+interface WebSearchDetails {
+  results?: LinkupSearchResult[];
+  query?: string;
+  error?: string;
+  isError?: boolean;
+}
+
+export function registerWebSearchTool(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "linkup_web_search",
+    label: "Linkup Web Search",
+    description:
+      "Search the web using Linkup API. Returns a list of relevant sources with content snippets. Use for finding information, documentation, articles, or any web content.",
+    parameters: Type.Object({
+      query: Type.String({
+        description:
+          "The search query. Be specific and detailed for best results.",
+      }),
+      deep: Type.Optional(
+        Type.Boolean({
+          description:
+            "Use deep search for comprehensive results (slower). Default: false (standard search).",
+        }),
+      ),
+    }),
+
+    async execute(_toolCallId, params, _signal, onUpdate, _ctx) {
+      const client = getClient();
+
+      try {
+        onUpdate?.({
+          content: [
+            {
+              type: "text",
+              text: `Searching${params.deep ? " (deep mode)" : ""}...`,
+            },
+          ],
+          details: {},
+        });
+
+        const response = (await client.search({
+          query: params.query,
+          depth: params.deep ? "deep" : "standard",
+          outputType: "searchResults",
+        })) as LinkupSearchResponse;
+
+        let content = `Found ${response.results.length} result(s):\n\n`;
+        for (const result of response.results) {
+          content += `## ${result.name}\n`;
+          content += `URL: ${result.url}\n`;
+          if (result.content) {
+            content += `\n${result.content}\n`;
+          }
+          content += "\n---\n\n";
+        }
+
+        return {
+          content: [{ type: "text", text: content }],
+          details: { results: response.results, query: params.query },
+        };
+      } catch (error) {
+        const message =
+          error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          details: { error: message, isError: true },
+        };
+      }
+    },
+
+    renderCall(args, theme) {
+      let text = theme.fg("toolTitle", theme.bold("Linkup: WebSearch "));
+      text += theme.fg("accent", `"${args.query}"`);
+      if (args.deep) {
+        text += theme.fg("dim", " (deep)");
+      }
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(result, { expanded, isPartial }, theme) {
+      if (isPartial) {
+        const text =
+          result.content?.[0]?.type === "text"
+            ? result.content[0].text
+            : "Searching...";
+        return new Text(theme.fg("dim", text), 0, 0);
+      }
+
+      const details = result.details as WebSearchDetails;
+
+      if (details?.isError) {
+        const errorMsg =
+          result.content?.[0]?.type === "text"
+            ? result.content[0].text
+            : "Error occurred";
+        return new Text(theme.fg("error", errorMsg), 0, 0);
+      }
+
+      const results = details?.results || [];
+      let text = theme.fg("success", `✓ Found ${results.length} result(s)`);
+
+      if (!expanded && results.length > 0) {
+        const first = results[0];
+        text += `\n  ${theme.fg("dim", `${first.name}`)}`;
+        if (results.length > 1) {
+          text += theme.fg("dim", ` (${results.length - 1} more)`);
+        }
+        text += theme.fg("muted", ` [Ctrl+O to expand]`);
+      }
+
+      if (expanded) {
+        for (const r of results) {
+          text += `\n\n${theme.fg("accent", theme.bold(r.name))}`;
+          text += `\n${theme.fg("dim", r.url)}`;
+          if (r.content) {
+            const preview = r.content.slice(0, 200);
+            text += `\n${theme.fg("muted", preview)}`;
+            if (r.content.length > 200) {
+              text += theme.fg("dim", "...");
+            }
+          }
+        }
+      }
+
+      return new Text(text, 0, 0);
+    },
+  });
+}

package/src/types.ts

@@ -0,0 +1,34 @@
+export interface LinkupSearchResult {
+  name: string;
+  url: string;
+  content?: string;
+}
+
+export interface LinkupSearchResponse {
+  results: LinkupSearchResult[];
+}
+
+export interface LinkupSource {
+  name: string;
+  url: string;
+  snippet?: string;
+}
+
+export interface LinkupSourcedAnswerResponse {
+  answer: string;
+  sources: LinkupSource[];
+}
+
+export interface LinkupFetchResponse {
+  markdown: string;
+}
+
+export interface LinkupBalanceResponse {
+  balance: number;
+}
+
+export interface LinkupErrorResponse {
+  error?: {
+    message?: string;
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}