webctx 0.2.5 → 0.2.7

package/internal/app/research.go

@@ -87,6 +87,10 @@ func readLinkFocused(rawURL, question string, reader func(string) (string, error
 	if err != nil {
 		return "", err
 	}
+	primary = copyableCurlExamples(primary)
+	if answer, ok := directlyAnsweredMetadata(rawURL, question, primary); ok {
+		return answer, nil
+	}
 
 	// Combine on-page links and authoritative Markdown index links instead of
 	// filling the entire budget from whichever links happen to appear first.
@@ -94,7 +98,7 @@ func readLinkFocused(rawURL, question string, reader func(string) (string, error
 	// SQLite, webhook, and API references over incidental alarm/concept pages.
 	links := researchCandidates(rawURL, primary, question, maxRelatedSources)
 	structuredDone := make(chan string, 1)
-	if strings.Contains(primary, "**Markdown source:**") {
+	if strings.Contains(primary, "**Markdown source:**") || !asksForAPIContracts(question) {
 		structuredDone <- ""
 	} else {
 		go func() { structuredDone <- embeddedStructuredContext(rawURL, question) }()
@@ -109,7 +113,11 @@ func readLinkFocused(rawURL, question string, reader func(string) (string, error
 		"**Source:** " + rawURL,
 		"",
 	}
-	primaryExcerpt := focusExcerpt(primary, question, focusedPrimaryBudget)
+	primaryBudget := focusedPrimaryBudget
+	if asksForAPIContracts(question) {
+		primaryBudget = 5300
+	}
+	primaryExcerpt := focusExcerpt(primary, question, primaryBudget)
 	parts = append(parts, primaryExcerpt)
 	successful := 1
 	relatedSuccessful := 0
@@ -124,7 +132,11 @@ func readLinkFocused(rawURL, question string, reader func(string) (string, error
 		relatedSuccessful++
 		seenURLs[source.url] = true
 		allRetrieved += "\n" + source.content
-		excerpt := focusExcerpt(source.content, question, relatedExcerptBudget(source.url))
+		relatedBudget := relatedExcerptBudget(source.url)
+		if asksForAPIContracts(question) && relatedBudget > 3000 {
+			relatedBudget = 3000
+		}
+		excerpt := focusExcerpt(copyableCurlExamples(source.content), question, relatedBudget)
 		outputEvidence += "\n" + excerpt
 		parts = append(parts, "", "## Related source", "**Source:** "+source.url, "", excerpt)
 	}
@@ -172,7 +184,11 @@ func readLinkFocused(rawURL, question string, reader func(string) (string, error
 			successful++
 			relatedSuccessful++
 			allRetrieved += "\n" + source.content
-			excerpt := focusExcerpt(source.content, question, relatedExcerptBudget(source.url))
+			followupBudget := relatedExcerptBudget(source.url)
+			if asksForAPIContracts(question) && followupBudget > 3000 {
+				followupBudget = 3000
+			}
+			excerpt := focusExcerpt(copyableCurlExamples(source.content), question, followupBudget)
 			outputEvidence += "\n" + excerpt
 			parts = append(parts, "", "## Supporting implementation reference", "**Source:** "+source.url, "", excerpt)
 		}
@@ -181,7 +197,10 @@ func readLinkFocused(rawURL, question string, reader func(string) (string, error
 		if contract := <-openAPIDone; contract.Content != "" {
 			successful++
 			outputEvidence += "\n" + contract.Content
-			parts = append(parts, "", "## REST API contract", "**Source:** "+contract.URL, "", contract.Content)
+			// Put exact REST contracts first so coding agents encounter the
+			// implementation-ready operations before lengthy source excerpts.
+			front := []string{"## REST API contract", "**Source:** " + contract.URL, "", contract.Content, ""}
+			parts = append(append(append([]string(nil), parts[:4]...), front...), parts[4:]...)
 		}
 	}
 	if structured := <-structuredDone; structured != "" {

package/internal/app/research_answers.go

@@ -0,0 +1,30 @@
+package app
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var githubLicenseField = regexp.MustCompile(`(?mi)^license:\s*["']?([A-Za-z0-9.+-]+)["']?\s*$`)
+var repositoryLicenseURL = regexp.MustCompile(`https://github\.com/[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+/blob/[A-Za-z0-9_.-]+/(?:LICENSE|COPYING)(?:\.md|\.txt)?`)
+
+func directlyAnsweredMetadata(rawURL, question, markdown string) (string, bool) {
+	q := strings.ToLower(question)
+	if !strings.Contains(q, "license") || !strings.Contains(strings.ToLower(rawURL), "github.com/") {
+		return "", false
+	}
+	match := githubLicenseField.FindStringSubmatch(markdown)
+	if len(match) != 2 {
+		return "", false
+	}
+	value := match[1]
+	evidenceURL := rawURL
+	if source := repositoryLicenseURL.FindString(markdown); source != "" {
+		evidenceURL = source
+	}
+	return fmt.Sprintf(
+		"## Answer\n\nThe repository lists its license as **%s**.\n\n**Source:** %s\n\n**Evidence:** GitHub repository metadata lists `license: %q`.\n",
+		value, evidenceURL, value,
+	), true
+}

package/internal/app/research_copyable.go

@@ -0,0 +1,48 @@
+package app
+
+import (
+	"encoding/json"
+	"regexp"
+	"strings"
+)
+
+var trailingPayloadSlash = regexp.MustCompile("(?m)\\\\[ \\t]*(\\r?\\n)")
+
+// Some source scrapers leave JavaScript-style line-continuation slashes
+// inside shell-quoted JSON. Those slashes make the published cURL request
+// uncopyable. Repair only payloads that are initially invalid JSON and become
+// valid JSON after removing those continuation markers. Label every repair.
+// The original source URL remains in the surrounding cited context.
+func copyableCurlExamples(markdown string) string {
+	parts := strings.Split(markdown, backtickFence)
+	if len(parts) < 3 {
+		return markdown
+	}
+	for i := 1; i < len(parts); i += 2 {
+		code := parts[i]
+		if !strings.Contains(code, "curl ") {
+			continue
+		}
+		start := strings.Index(code, "-d '{")
+		if start < 0 {
+			continue
+		}
+		bodyStart := start + len("-d '")
+		endRel := strings.LastIndex(code[bodyStart:], "}'")
+		if endRel < 0 {
+			continue
+		}
+		bodyEnd := bodyStart + endRel + 1
+		original := code[bodyStart:bodyEnd]
+		if json.Valid([]byte(original)) {
+			continue
+		}
+		fixed := trailingPayloadSlash.ReplaceAllString(original, "$1")
+		if fixed == original || !json.Valid([]byte(fixed)) {
+			continue
+		}
+		parts[i] = code[:bodyStart] + fixed + code[bodyEnd:]
+		parts[i-1] += "\n\n*[Copy-ready correction: removed stray line-continuation backslashes inside the published JSON payload; see the cited URL for the original.]*\n"
+	}
+	return strings.Join(parts, backtickFence)
+}

package/internal/app/research_copyable_test.go

@@ -0,0 +1,57 @@
+package app
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestMalformedAlexandriaJSONBecomesCopyable(t *testing.T) {
+	source := "# REST example\n" + backtickFence + "bash\n" +
+		"curl https://api.firecrawl.dev/v2/search \\\n" +
+		" -H 'Content-Type: application/json' \\\n" +
+		" -d '{\n  \"query\": \"podcast conversations\",\n  \"sources\": [\\\n    \"web\",\\\n    \"alexandria\"\\\n  ],\n  \"limit\": 2\n}'\n" +
+		backtickFence
+	got := copyableCurlExamples(source)
+	if !strings.Contains(got, "Copy-ready correction") {
+		t.Fatalf("lost truthful correction label: %s", got)
+	}
+	start := strings.Index(got, "-d '{")
+	if start < 0 {
+		t.Fatalf("lost source cURL: %s", got)
+	}
+	bodyStart := start + len("-d '")
+	bodyEnd := bodyStart + strings.LastIndex(got[bodyStart:], "}'") + 1
+	if !json.Valid([]byte(got[bodyStart:bodyEnd])) {
+		t.Fatalf("JSON request still uncopyable: %s", got[bodyStart:bodyEnd])
+	}
+	if !strings.Contains(got, " -H 'Content-Type: application/json' \\") {
+		t.Fatalf("source shell continuations should be preserved: %s", got)
+	}
+	if strings.Contains(got, "\"sources\": [\\") {
+		t.Fatalf("malformed JSON continuation not repaired: %s", got)
+	}
+	if copyableCurlExamples(got) != got {
+		t.Fatalf("correction should be idempotent")
+	}
+}
+
+func TestCorrectSourceExamplesAreNeverRewritten(t *testing.T) {
+	source := backtickFence + "bash\ncurl https://api.example.com/v2/search -d '{\"sources\":[\"alexandria\"]}'\n" + backtickFence
+	if got := copyableCurlExamples(source); got != source {
+		t.Fatalf("valid published snippet was modified: %s", got)
+	}
+}
+
+func TestRESTContractsLeadAndExcerptsStayConcise(t *testing.T) {
+	if focusedPrimaryBudget <= 5300 {
+		t.Fatal("REST excerpt budget should be narrower than normal focused context")
+	}
+	source := "# Official API docs\n" + strings.Repeat("Large unrelated introduction about navigation.\n", 700) +
+		"\n## REST API endpoint example\n" +
+		backtickFence + "bash\ncurl https://api.example.com/v2/search -d '{\"sources\":[\"alexandria\"]}'\n" + backtickFence
+	got := focusExcerpt(source, "What are the REST API endpoints and exact request examples?", 5300)
+	if len(got) > 6000 || !strings.Contains(got, "/v2/search") {
+		t.Fatalf("REST excerpt did not prioritize complete example under budget: len=%d", len(got))
+	}
+}

package/internal/app/site_map_page.go

@@ -0,0 +1,256 @@
+package app
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"golang.org/x/sync/singleflight"
+)
+
+// MapSiteInput retrieves an agent-sized page rather than dumping thousands
+// of URLs. An omitted language prefers English; "all" allows all locales.
+type MapSiteInput struct {
+	URL        string `json:"url" jsonschema:"Website URL to map; HTTP(S) only"`
+	Query      string `json:"query,omitempty" jsonschema:"Optional topic to filter and rank discovered pages"`
+	Limit      int    `json:"limit,omitempty" jsonschema:"Number of URLs to return, 1-100; defaults to 30"`
+	Offset     int    `json:"offset,omitempty" jsonschema:"Pagination offset, zero-based"`
+	PathPrefix string `json:"path_prefix,omitempty" jsonschema:"Optional URL path prefix, e.g. /api/"`
+	Language   string `json:"language,omitempty" jsonschema:"Locale code such as en or fr; defaults to English, use all for all languages"`
+}
+
+type siteMapCacheValue struct {
+	links   []any
+	expires time.Time
+}
+
+var siteMapCache = struct {
+	sync.Mutex
+	items map[string]siteMapCacheValue
+}{items: map[string]siteMapCacheValue{}}
+var siteMapFlight singleflight.Group
+
+func rawMappedLinks(ctx context.Context, rawURL string) ([]any, error) {
+	if err := validateSourceURL(rawURL); err != nil {
+		return nil, &DataError{Code: "invalid_url", Message: err.Error()}
+	}
+	credential := strings.TrimSpace(os.Getenv("FIRECRAWL_API_KEY"))
+	if credential == "" {
+		return nil, missingCredentialsError("Error mapping website", []string{"FIRECRAWL_API_KEY"}, "")
+	}
+	digest := sha256.Sum256([]byte(credential + "\x00" + rawURL))
+	cacheKey := hex.EncodeToString(digest[:])
+	useCache := !strings.HasPrefix(credential, "test")
+	if useCache {
+		siteMapCache.Lock()
+		cached, ok := siteMapCache.items[cacheKey]
+		siteMapCache.Unlock()
+		if ok && time.Now().Before(cached.expires) {
+			return cached.links, nil
+		}
+	}
+	fetch := func() (any, error) {
+		request := map[string]any{
+			"url": rawURL, "sitemap": "include",
+			"includeSubdomains": true, "ignoreQueryParameters": true, "limit": 5000,
+		}
+		body, err := doJSONRequest(ctx, http.MethodPost, "https://api.firecrawl.dev/v2/map", map[string]string{
+			"Authorization": "Bearer " + credential, "Content-Type": "application/json",
+		}, request)
+		if err != nil {
+			return nil, fmt.Errorf("Error mapping website: %w", err)
+		}
+		var result map[string]any
+		if err := json.Unmarshal(body, &result); err != nil {
+			return nil, fmt.Errorf("Error decoding map: %w", err)
+		}
+		if result["success"] != true {
+			return nil, dataError("map_failed", fmt.Sprintf("The source could not be mapped: %v", result["error"]))
+		}
+		links := listField(result["links"])
+		if useCache {
+			siteMapCache.Lock()
+			if len(siteMapCache.items) > 50 {
+				siteMapCache.items = map[string]siteMapCacheValue{}
+			}
+			siteMapCache.items[cacheKey] = siteMapCacheValue{links: links, expires: time.Now().Add(3 * time.Minute)}
+			siteMapCache.Unlock()
+		}
+		return links, nil
+	}
+	if !useCache {
+		data, err := fetch()
+		if err != nil {
+			return nil, err
+		}
+		return data.([]any), nil
+	}
+	data, err, _ := siteMapFlight.Do(cacheKey, fetch)
+	if err != nil {
+		return nil, err
+	}
+	return data.([]any), nil
+}
+
+var knownSiteLocales = map[string]bool{
+	"en": true, "fr": true, "es": true, "de": true, "ja": true, "zh": true, "zh-cn": true, "zh-tw": true,
+	"pt": true, "pt-br": true, "it": true, "ko": true, "ru": true, "ar": true, "hi": true, "id": true,
+	"nl": true, "pl": true, "tr": true, "vi": true, "th": true, "sv": true, "da": true,
+	"es-es": true, "en-us": true, "en-gb": true, "fr-fr": true, "fr-ca": true,
+}
+
+func mapPageLocale(raw string) string {
+	u, err := url.Parse(raw)
+	if err != nil {
+		return "en"
+	}
+	parts := strings.Split(strings.Trim(u.Path, "/"), "/")
+	if len(parts) > 0 {
+		first := strings.ToLower(parts[0])
+		if knownSiteLocales[first] {
+			if strings.HasPrefix(first, "en") {
+				return "en"
+			}
+			if strings.HasPrefix(first, "zh") {
+				return "zh"
+			}
+			if strings.HasPrefix(first, "es") {
+				return "es"
+			}
+			if strings.HasPrefix(first, "fr") {
+				return "fr"
+			}
+			if strings.HasPrefix(first, "pt") {
+				return "pt"
+			}
+			return first
+		}
+	}
+	return "en"
+}
+
+func MapSitePage(input MapSiteInput) (map[string]any, error) {
+	if input.Limit == 0 {
+		input.Limit = 30
+	}
+	if input.Limit < 1 || input.Limit > 100 {
+		return nil, dataError("invalid_limit", "map_site limit must be 1-100.")
+	}
+	if input.Offset < 0 || input.Offset > 100000 {
+		return nil, dataError("invalid_offset", "map_site offset must be nonnegative.")
+	}
+	if input.Language == "" {
+		input.Language = "en"
+	}
+	input.Language = strings.ToLower(strings.TrimSpace(input.Language))
+	if input.PathPrefix != "" && !strings.HasPrefix(input.PathPrefix, "/") {
+		input.PathPrefix = "/" + input.PathPrefix
+	}
+	if err := validateSourceURL(input.URL); err != nil {
+		return nil, &DataError{Code: "invalid_url", Message: err.Error()}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	links, err := rawMappedLinks(ctx, input.URL)
+	if err != nil {
+		return nil, err
+	}
+	type located struct {
+		entry map[string]any
+		score int
+		path  string
+	}
+	var matched []located
+	seen := map[string]bool{}
+	terms := queryTerms(input.Query)
+	for _, v := range links {
+		item := map[string]any{}
+		if s, ok := v.(string); ok {
+			item["url"] = s
+		} else {
+			item = mapField(v)
+		}
+		raw := stringField(item["url"])
+		if raw == "" || seen[raw] {
+			continue
+		}
+		seen[raw] = true
+		u, e := url.Parse(raw)
+		if e != nil || u.Host == "" {
+			continue
+		}
+		if input.Language != "all" && mapPageLocale(raw) != input.Language {
+			continue
+		}
+		if input.PathPrefix != "" && !strings.HasPrefix(strings.ToLower(u.Path), strings.ToLower(input.PathPrefix)) {
+			continue
+		}
+		name := stringField(item["title"])
+		desc := stringField(item["description"])
+		score := termScore(u.Path+" "+name, terms)*3 + termScore(desc, terms)
+		if len(terms) > 0 && score == 0 {
+			continue
+		}
+		clean := map[string]any{"url": raw}
+		if name != "" {
+			clean["title"] = boundedSiteText(name, 140)
+		}
+		if desc != "" {
+			clean["description"] = boundedSiteText(desc, 230)
+		}
+		matched = append(matched, located{entry: clean, score: score, path: u.Path})
+	}
+	sort.SliceStable(matched, func(i, j int) bool {
+		if len(terms) > 0 && matched[i].score != matched[j].score {
+			return matched[i].score > matched[j].score
+		}
+		if depthI, depthJ := strings.Count(matched[i].path, "/"), strings.Count(matched[j].path, "/"); depthI != depthJ {
+			return depthI < depthJ
+		}
+		return matched[i].path < matched[j].path
+	})
+	start := input.Offset
+	if start > len(matched) {
+		start = len(matched)
+	}
+	end := start + input.Limit
+	if end > len(matched) {
+		end = len(matched)
+	}
+	page := make([]map[string]any, 0, end-start)
+	for _, entry := range matched[start:end] {
+		page = append(page, entry.entry)
+	}
+	output := map[string]any{
+		"url": input.URL, "total_discovered": len(links),
+		"total_matching": len(matched), "links": page,
+		"count": len(page), "offset": start, "limit": input.Limit,
+		"language": input.Language, "provider_page_ceiling": 5000,
+		"may_be_incomplete": len(links) >= 5000,
+		"guidance":          "Use next to request another bounded page, or set query/path_prefix/language to narrow results. Language=all includes translated pages.",
+	}
+	if end < len(matched) {
+		output["next"] = map[string]any{"tool": "map_site", "arguments": MapSiteInput{
+			URL: input.URL, Query: input.Query, Limit: input.Limit, Offset: end,
+			PathPrefix: input.PathPrefix, Language: input.Language,
+		}}
+	}
+	return output, nil
+}
+
+func boundedSiteText(value string, max int) string {
+	value = strings.Join(strings.Fields(value), " ")
+	if len(value) > max {
+		return value[:max] + "…"
+	}
+	return value
+}

package/internal/app/tools.go

@@ -252,57 +252,27 @@ func scrapeLinkWithFirecrawl(rawURL string) (string, string, error) {
 }
 
 func MapSite(rawURL string) (string, error) {
-	if err := validateSourceURL(rawURL); err != nil {
+	data, err := MapSitePage(MapSiteInput{URL: rawURL})
+	if err != nil {
 		return "", err
 	}
-	apiKey := strings.TrimSpace(os.Getenv("FIRECRAWL_API_KEY"))
-	if apiKey == "" {
-		return "", missingCredentialsError("Error mapping website", []string{"FIRECRAWL_API_KEY"}, "")
+	parts := []string{
+		fmt.Sprintf("total urls found: %v", data["total_discovered"]),
+		fmt.Sprintf("matching pages: %v; displayed: %v (offset %v)", data["total_matching"], data["count"], data["offset"]),
+		"",
 	}
-
-	requestBody := map[string]any{
-		"url":                   rawURL,
-		"sitemap":               "include",
-		"includeSubdomains":     true,
-		"ignoreQueryParameters": true,
-		"limit":                 5000,
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
-	defer cancel()
-	body, err := doJSONRequest(ctx, http.MethodPost, "https://api.firecrawl.dev/v2/map", map[string]string{
-		"Authorization": "Bearer " + apiKey,
-		"Content-Type":  "application/json",
-	}, requestBody)
-	if err != nil {
-		return "", fmt.Errorf("Error mapping website: %v", err)
-	}
-
-	var parsed map[string]any
-	if err := json.Unmarshal(body, &parsed); err != nil {
-		return "", fmt.Errorf("Error mapping website: %v", err)
-	}
-	if success, _ := parsed["success"].(bool); !success {
-		return "", fmt.Errorf("Error mapping website: Mapping failed for %s: %v", rawURL, parsed["error"])
-	}
-
-	linksAny, _ := parsed["links"].([]any)
-	parts := []string{fmt.Sprintf("total urls found: %d", len(linksAny)), ""}
-	for _, item := range linksAny {
-		switch link := item.(type) {
-		case string:
-			parts = append(parts, "- "+link, "")
-		case map[string]any:
-			parts = append(parts, "- "+stringValue(link["url"]))
-			if v := stringValue(link["title"]); v != "" {
-				parts = append(parts, "- "+v)
-			}
-			if v := stringValue(link["description"]); v != "" {
-				parts = append(parts, "- "+v)
-			}
-			parts = append(parts, "")
+	for _, entry := range data["links"].([]map[string]any) {
+		parts = append(parts, "- "+stringField(entry["url"]))
+		if title := stringField(entry["title"]); title != "" {
+			parts = append(parts, "  - "+title)
+		}
+		if desc := stringField(entry["description"]); desc != "" {
+			parts = append(parts, "  - "+desc)
 		}
 	}
+	if data["next"] != nil {
+		parts = append(parts, "", "More pages available; use --offset with webctx map-site for the next page.")
+	}
 	return strings.Join(parts, "\n"), nil
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webctx",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Go CLI for agent-friendly web research, structured-data discovery, and source-native querying",
   "license": "MIT",
   "author": "amxv",

package/pkg/origo/data_test.go

@@ -49,26 +49,52 @@ func TestDataToolErrorsAreActionableStructuredMCPResults(t *testing.T) {
 		{"research", map[string]any{"view": "invalid"}, "invalid_view"},
 		{"inspect", map[string]any{"id": "not-a-valid-operation/"}, "invalid_operation"},
 		{"execute", map[string]any{"calls": []any{}}, "invalid_calls"},
+		{"execute", map[string]any{"calls": []any{map[string]any{"id": "example/data/list"}}, "max_credits": 1}, "invalid_arguments"},
 	} {
 		response := toolResponse(t, tc.name, tc.input, 11)
-		if response["isError"] != true {
-			t.Fatalf("%s should return isError: %#v", tc.name, response)
+		if response["isError"] == true {
+			t.Fatalf("%s should return normal structured response, not an MCP error: %#v", tc.name, response)
 		}
 		output, ok := response["structuredContent"].(map[string]any)
 		if !ok {
 			t.Fatalf("%s did not preserve structuredContent: %#v", tc.name, response)
 		}
 		errorResult, ok := output["error"].(map[string]any)
-		if !ok || errorResult["code"] != tc.code {
+		if !ok || errorResult["code"] != tc.code || output["ok"] != false {
 			t.Fatalf("%s error should be %s: %#v", tc.name, tc.code, response)
 		}
 	}
 }
 
+func TestAuditMCPRejectsZeroLimitAndInvalidSourceURLsWithoutExceptions(t *testing.T) {
+	t.Setenv("ORIGO_API_KEY", "secret")
+	for _, tt := range []struct {
+		name string
+		args map[string]any
+		code string
+	}{
+		{"research", map[string]any{"mode": "catalogue", "view": "sources", "limit": 0}, "invalid_limit"},
+		{"read_link", map[string]any{"url": "file:///etc/passwd", "question": "summarize"}, "invalid_url"},
+		{"map_site", map[string]any{"url": "file:///etc/passwd"}, "invalid_url"},
+	} {
+		reply := toolResponse(t, tt.name, tt.args, 990)
+		if reply["isError"] == true {
+			t.Fatalf("%s surfaced a host error: %+v", tt.name, reply)
+		}
+		data, ok := reply["structuredContent"].(map[string]any)
+		if !ok || data["ok"] != false {
+			t.Fatalf("%s did not return a structured error: %+v", tt.name, reply)
+		}
+		failure := data["error"].(map[string]any)
+		if failure["code"] != tt.code {
+			t.Fatalf("%s expected %s, got %+v", tt.name, tt.code, failure)
+		}
+	}
+}
+
 func TestDataToolResearchInspectExecuteOverHTTP(t *testing.T) {
 	t.Setenv("ORIGO_API_KEY", "secret")
 	t.Setenv("FIRECRAWL_API_KEY", "test")
-	t.Setenv("WEBCTX_ALEXANDRIA_PAID", "true")
 	original := http.DefaultClient
 	t.Cleanup(func() { http.DefaultClient = original })
 	var paidCount int
@@ -126,7 +152,7 @@ func TestDataToolResearchInspectExecuteOverHTTP(t *testing.T) {
 	}
 	result := toolResponse(t, "execute", map[string]any{"calls": []any{
 		map[string]any{"id": "example/data/list", "inputs": map[string]any{"query": "forty two"}},
-	}, "max_credits": 3}, 14)
+	}}, 14)
 	final := result["structuredContent"].(map[string]any)
 	if result["isError"] == true || final["credits_used"] != float64(2) || paidCount != 1 {
 		t.Fatalf("paid query failed: %#v calls=%d", final, paidCount)