@zackbart/connecta 0.9.0 → 0.9.1

package/src/catalog.ts

@@ -13,8 +13,19 @@ export function summarizeDescription(
   return `${compact.slice(0, DEFAULT_DESCRIPTION_LENGTH - 1).trimEnd()}…`;
 }
 
+function lexicalTokens(text: string): string[] {
+  return text
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, " ")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
 function normalized(text: string): string {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  return lexicalTokens(text).join(" ");
 }
 
 /**
@@ -75,7 +86,14 @@ export function lexicalSearchQuery(query: string): string {
 interface SearchDocument {
   tool: ToolDef;
   name: string;
-  description: string;
+  nameTokens: string[];
+  descriptionTokens: string[];
+}
+
+interface SearchIndex {
+  documents: SearchDocument[];
+  nameTokenDocuments: ReadonlyMap<string, readonly ToolDef[]>;
+  descriptionTokenDocuments: ReadonlyMap<string, readonly ToolDef[]>;
 }
 
 export type LexicalMatchMode = "all" | "partial";
@@ -86,19 +104,174 @@ export interface RankedTool {
   order: number;
 }
 
-const searchDocuments = new WeakMap<ToolDef[], SearchDocument[]>();
+const searchIndexes = new WeakMap<ToolDef[], SearchIndex>();
+
+function indexFor(tools: ToolDef[]): SearchIndex {
+  let index = searchIndexes.get(tools);
+  if (!index) {
+    const nameTokenDocuments = new Map<string, ToolDef[]>();
+    const descriptionTokenDocuments = new Map<string, ToolDef[]>();
+    const addTokens = (
+      target: Map<string, ToolDef[]>,
+      tokens: string[],
+      tool: ToolDef,
+    ) => {
+      for (const token of new Set(tokens)) {
+        const documents = target.get(token) ?? [];
+        documents.push(tool);
+        target.set(token, documents);
+      }
+    };
+    const documents = tools.map((tool) => {
+      const nameTokens = lexicalTokens(tool.name);
+      const descriptionTokens = lexicalTokens(tool.description ?? "");
+      addTokens(nameTokenDocuments, nameTokens, tool);
+      addTokens(descriptionTokenDocuments, descriptionTokens, tool);
+      return {
+        tool,
+        name: nameTokens.join(" "),
+        nameTokens,
+        descriptionTokens,
+      };
+    });
+    index = {
+      documents,
+      nameTokenDocuments,
+      descriptionTokenDocuments,
+    };
+    searchIndexes.set(tools, index);
+  }
+  return index;
+}
 
 function documentsFor(tools: ToolDef[]): SearchDocument[] {
-  let docs = searchDocuments.get(tools);
-  if (!docs) {
-    docs = tools.map((tool) => ({
-      tool,
-      name: normalized(tool.name),
-      description: normalized(tool.description ?? ""),
-    }));
-    searchDocuments.set(tools, docs);
+  return indexFor(tools).documents;
+}
+
+/**
+ * Whole-token equality is the ordinary lexical match. A deliberately narrow
+ * inflection check retains useful singular/plural and past-tense recall
+ * without bringing back arbitrary substring matches (`list` must not match
+ * `enlist`, and `record` must not match the noun `recording`).
+ */
+function inflectionVariants(base: string): string[] {
+  return [
+    `${base}s`,
+    `${base}es`,
+    `${base}ed`,
+    ...(base.endsWith("e") ? [`${base}d`] : []),
+    ...(base.endsWith("y")
+      ? [
+          `${base.slice(0, -1)}ies`,
+          `${base.slice(0, -1)}ied`,
+        ]
+      : []),
+  ];
+}
+
+function matchingTokenCandidates(term: string): Set<string> {
+  const candidates = new Set([term, ...inflectionVariants(term)]);
+  const possibleBases = [
+    ...(term.endsWith("s") ? [term.slice(0, -1)] : []),
+    ...(term.endsWith("es") ? [term.slice(0, -2)] : []),
+    ...(term.endsWith("ed") ? [term.slice(0, -2)] : []),
+    ...(term.endsWith("d") ? [term.slice(0, -1)] : []),
+    ...(term.endsWith("ies")
+      ? [`${term.slice(0, -3)}y`]
+      : []),
+    ...(term.endsWith("ied")
+      ? [`${term.slice(0, -3)}y`]
+      : []),
+  ];
+  for (const base of possibleBases) {
+    if (base && inflectionVariants(base).includes(term)) {
+      candidates.add(base);
+    }
   }
-  return docs;
+  return candidates;
+}
+
+export interface LexicalCorpusStatistics {
+  documentCount: number;
+  documentFrequency: ReadonlyMap<string, number>;
+  nameMatches: ReadonlyMap<string, ReadonlySet<ToolDef>>;
+  descriptionMatches: ReadonlyMap<string, ReadonlySet<ToolDef>>;
+}
+
+/**
+ * Compute query-specific document frequencies across every available catalog.
+ * The caller does this once per search and shares the result with each
+ * connector rank, so ubiquitous words contribute less than discriminative
+ * ones without making any action word a stopword.
+ */
+export function lexicalCorpusStatistics(
+  toolSets: ToolDef[][],
+  query: string,
+): LexicalCorpusStatistics {
+  const terms = [...new Set(lexicalTokens(query))];
+  if (terms.length === 0) {
+    return {
+      documentCount: toolSets.reduce(
+        (total, tools) => total + tools.length,
+        0,
+      ),
+      documentFrequency: new Map(),
+      nameMatches: new Map(),
+      descriptionMatches: new Map(),
+    };
+  }
+  const nameMatches = new Map<string, Set<ToolDef>>();
+  const descriptionMatches = new Map<string, Set<ToolDef>>();
+  for (const term of terms) {
+    const termNameMatches = new Set<ToolDef>();
+    const termDescriptionMatches = new Set<ToolDef>();
+    for (const tools of toolSets) {
+      const index = indexFor(tools);
+      for (const candidate of matchingTokenCandidates(term)) {
+        for (const tool of index.nameTokenDocuments.get(candidate) ?? []) {
+          termNameMatches.add(tool);
+        }
+        for (
+          const tool of
+          index.descriptionTokenDocuments.get(candidate) ?? []
+        ) {
+          termDescriptionMatches.add(tool);
+        }
+      }
+    }
+    nameMatches.set(term, termNameMatches);
+    descriptionMatches.set(term, termDescriptionMatches);
+  }
+  const documentFrequency = new Map(
+    terms.map((term) => [
+      term,
+      new Set([
+        ...(nameMatches.get(term) ?? []),
+        ...(descriptionMatches.get(term) ?? []),
+      ]).size,
+    ]),
+  );
+  return {
+    documentCount: toolSets.reduce(
+      (total, tools) => total + tools.length,
+      0,
+    ),
+    documentFrequency,
+    nameMatches,
+    descriptionMatches,
+  };
+}
+
+function inverseDocumentFrequency(
+  term: string,
+  statistics: LexicalCorpusStatistics,
+): number {
+  const frequency = statistics.documentFrequency.get(term) ?? 0;
+  return Math.log(
+    1 +
+      (statistics.documentCount - frequency + 0.5) /
+        (frequency + 0.5),
+  );
 }
 
 function scoreDocument(
@@ -106,30 +279,45 @@ function scoreDocument(
   phrase: string,
   terms: string[],
   mode: LexicalMatchMode,
+  statistics: LexicalCorpusStatistics,
 ): number | null {
   if (!phrase) return 0;
-  const haystack = `${doc.name} ${doc.description}`;
-  const matchedTerms = terms.filter((term) => haystack.includes(term));
+  const matchedTerms = terms.filter((term) =>
+    statistics.nameMatches.get(term)?.has(doc.tool) ||
+    statistics.descriptionMatches.get(term)?.has(doc.tool),
+  );
   if (mode === "all" && matchedTerms.length !== terms.length) return null;
-  if (mode === "partial") {
-    if (matchedTerms.length === 0) return null;
-    const nameMatches = matchedTerms.filter((term) =>
-      doc.name.includes(term),
-    ).length;
-    // Coverage wins first, then the number of those terms found in the tool
-    // name. Catalog order breaks the remaining ties at the caller.
-    return matchedTerms.length * 1_000 + nameMatches;
+  if (matchedTerms.length === 0) return null;
+
+  // Coverage remains meaningful in partial mode, but is IDF-weighted rather
+  // than a raw term count: one rare domain term can beat several ubiquitous
+  // catalog verbs.
+  let score = matchedTerms.reduce(
+    (total, term) =>
+      total + 4 * inverseDocumentFrequency(term, statistics),
+    0,
+  );
+  const phraseWeight = terms.reduce(
+    (total, term) =>
+      total + inverseDocumentFrequency(term, statistics),
+    0,
+  );
+  if (doc.name === phrase) score += 40 * phraseWeight;
+  else if (doc.name.startsWith(`${phrase} `)) score += 24 * phraseWeight;
+  else if (` ${doc.name} `.includes(` ${phrase} `)) {
+    score += 16 * phraseWeight;
   }
 
-  let score = 0;
-  if (doc.name === phrase) score += 1_000;
-  else if (doc.name.startsWith(phrase)) score += 800;
-  else if (doc.name.includes(phrase)) score += 600;
-  for (const term of terms) {
-    if (doc.name === term) score += 200;
-    else if (doc.name.startsWith(term)) score += 120;
-    else if (doc.name.includes(term)) score += 80;
-    if (doc.description.includes(term)) score += 10;
+  for (const term of matchedTerms) {
+    const weight = inverseDocumentFrequency(term, statistics);
+    if (doc.nameTokens.includes(term)) score += 12 * weight;
+    else if (statistics.nameMatches.get(term)?.has(doc.tool)) {
+      score += 8 * weight;
+    }
+    if (doc.descriptionTokens.includes(term)) score += 3 * weight;
+    else if (statistics.descriptionMatches.get(term)?.has(doc.tool)) {
+      score += 1.5 * weight;
+    }
   }
   return score;
 }
@@ -139,12 +327,16 @@ export function rankTools(
   tools: ToolDef[],
   query: string,
   mode: LexicalMatchMode = "all",
+  statistics: LexicalCorpusStatistics = lexicalCorpusStatistics(
+    [tools],
+    query,
+  ),
 ): RankedTool[] {
   const phrase = normalized(query);
-  const terms = phrase.split(/\s+/).filter(Boolean);
+  const terms = [...new Set(phrase.split(/\s+/).filter(Boolean))];
   const ranked: RankedTool[] = [];
   documentsFor(tools).forEach((doc, order) => {
-    const score = scoreDocument(doc, phrase, terms, mode);
+    const score = scoreDocument(doc, phrase, terms, mode, statistics);
     if (score !== null) ranked.push({ tool: doc.tool, score, order });
   });
   return ranked;
@@ -300,3 +492,105 @@ export function compactSchema(schema: JsonSchema): string {
   compactSchemas.set(schema, rendered);
   return rendered;
 }
+
+/** The property and required names a schema resolves to, or undefined. */
+export interface SchemaObjectKeys {
+  properties: string[];
+  required: string[];
+}
+
+/**
+ * Walk a schema the way renderSchema does — composing `allOf` and resolving
+ * `$ref` against the root's `$defs`/`definitions` — and collect the top-level
+ * property names it would render. A shallow `Object.keys(schema.properties)`
+ * disagrees with the rendered compact schema for exactly the shapes real
+ * connectors emit (a top-level `$ref` to a `$defs` entry, or the OpenAPI
+ * "extend this base" `allOf`), which is worse than no metadata at all: it
+ * reports an empty field list for a tool that plainly has fields.
+ *
+ * Returns undefined when the schema is not an object shape at all — a union,
+ * array, enum, or unresolvable `$ref`. Absent metadata tells a caller to read
+ * the rendered schema instead; an empty array would claim the tool takes no
+ * fields.
+ */
+export function schemaObjectKeys(
+  schema: JsonSchema | undefined,
+): SchemaObjectKeys | undefined {
+  if (!schema) return undefined;
+  const defs = {
+    ...(schema.$defs as Record<string, unknown>),
+    ...(schema.definitions as Record<string, unknown>),
+  };
+  try {
+    return objectKeys(schema, defs, new Set(), 0);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Merge in declaration order, first occurrence winning, as renderSchema renders. */
+function mergedKeys(
+  parts: readonly SchemaObjectKeys[],
+): SchemaObjectKeys | undefined {
+  if (parts.length === 0) return undefined;
+  return {
+    properties: [...new Set(parts.flatMap((part) => part.properties))],
+    required: [...new Set(parts.flatMap((part) => part.required))],
+  };
+}
+
+/** The key-collecting twin of renderSchema; the branch order must match it. */
+function objectKeys(
+  schema: unknown,
+  defs: Record<string, unknown>,
+  seen: Set<string>,
+  depth: number,
+): SchemaObjectKeys | undefined {
+  if (depth > 4) return undefined;
+  if (schema === null || typeof schema !== "object") return undefined;
+  const s = schema as Record<string, unknown>;
+
+  if (Array.isArray(s.allOf)) {
+    const { allOf: _members, ...own } = s;
+    const parts = declaresShape(own)
+      ? [objectKeys(own, defs, seen, depth)]
+      : [];
+    for (const member of s.allOf) {
+      parts.push(objectKeys(member, defs, seen, depth + 1));
+    }
+    // An allOf whose members are not all object shapes renders as an
+    // intersection with a non-object half; no single key list describes it.
+    return parts.every((part) => part !== undefined)
+      ? mergedKeys(parts as SchemaObjectKeys[])
+      : undefined;
+  }
+
+  if (typeof s.$ref === "string") {
+    const name = refName(s.$ref);
+    if (seen.has(name)) return undefined;
+    const target = defs[name];
+    if (target === undefined) return undefined;
+    seen.add(name);
+    const resolved = objectKeys(target, defs, seen, depth);
+    seen.delete(name);
+    return resolved;
+  }
+
+  if (Array.isArray(s.oneOf ?? s.anyOf)) return undefined;
+  if (Array.isArray(s.enum)) return undefined;
+  if (s.const !== undefined) return undefined;
+  if (s.type === "array" || s.items) return undefined;
+  if (s.type === "object" || s.properties) {
+    const props = s.properties;
+    if (props === null || Array.isArray(props) || typeof props !== "object") {
+      return { properties: [], required: [] };
+    }
+    return {
+      properties: Object.keys(props as Record<string, unknown>),
+      required: Array.isArray(s.required)
+        ? s.required.filter((key): key is string => typeof key === "string")
+        : [],
+    };
+  }
+  return undefined;
+}

package/src/execute.ts

@@ -279,11 +279,20 @@ export async function buildSandboxProviders(
             offset?: number;
             fullDescriptions?: boolean;
             includeSchemas?: "compact" | "json";
+            includeSchemaKeys?: boolean;
           };
-          const result = flatSearchResult(await catalog.search(args));
+          const result = flatSearchResult(
+            await catalog.search({
+              ...args,
+              // Key metadata rides along with schemas by default, since that is
+              // the whole point of it in code mode. It stays opt-out because it
+              // counts against the same hard discovery-byte ceiling.
+              includeSchemaKeys: args.includeSchemaKeys !== false,
+            }),
+          );
           boundedDiscoveryText(
             result,
-            "Request a smaller limit, omit fullDescriptions, or use compact schemas.",
+            "Request a smaller limit, omit fullDescriptions, use compact schemas, or pass includeSchemaKeys: false.",
           );
           return result;
         },
@@ -442,18 +451,18 @@ export function createExecuteTool(
   };
 }
 
-const EXECUTE_DESC = `Use for dependent multi-step calls, loops, joins, branching, or reducing large results in a sandbox. Only tools explicitly annotated readOnlyHint: true are available. For one straightforward call use call_tool; for 2–10 independent calls use batch_call. Each run is limited to ${EXECUTE_MAX_HOST_CALLS} host calls; connecta.batch accepts at most ${EXECUTE_MAX_BATCH_CALLS}; each host call has a ${EXECUTE_HOST_CALL_TIMEOUT_MS / 1_000}-second deadline.
+const EXECUTE_DESC = `Use for dependent multi-step calls, loops, joins, branching, or reducing large results in a sandbox. Never use execute_code for search-only discovery or one downstream call: use search_tools, then call_tool when needed. For 2–10 independent calls use batch_call. Only tools explicitly annotated readOnlyHint: true are available. Each run is limited to ${EXECUTE_MAX_HOST_CALLS} host calls; connecta.batch accepts at most ${EXECUTE_MAX_BATCH_CALLS}; each host call has a ${EXECUTE_HOST_CALL_TIMEOUT_MS / 1_000}-second deadline.
 
 Write an async arrow function. It runs with NO network, filesystem, timers, or imports — the only capabilities are:
 - One global per connector: every address <connectorId>.<toolName> from search_tools is callable as <connectorId>.<toolName>(args) with a single args object matching the schema from describe_tools. Names are sanitized to JS identifiers: characters outside [A-Za-z0-9_$] become "_" (e.g. my-service.get.thing → my_service.get_thing), leading digits get "_" prefixed, reserved words get "_" appended.
 - connecta.call(address, args) and connecta.batch(calls) — call raw addresses.
-- connecta.search(args) and connecta.describe(args) — load and inspect request-local catalogs on demand.
+- connecta.search(args) and connecta.describe(args) — load and inspect request-local catalogs on demand. Matches carrying schemas also list inputKeys, requiredInputKeys, and outputKeys — the same names the schema shows, ready to check against before building args. They are absent when a schema is not a plain object shape, so read the schema itself rather than assuming a missing list means no fields.
 - console.log(...) — captured and returned alongside the result.
 
 Tool calls return plain values (MCP text content is JSON-parsed when possible) and throw on downstream errors — use try/catch to handle them. Return a JSON-serializable value; large results are truncated, so reduce data in code instead of returning raw payloads.
 
-Workflow: search_tools → describe_tools (schemas) → execute_code. Plain JavaScript only — no TypeScript syntax.
-Example: async () => { const r = await crm.search({ query: "roadmap" }); return r.results.map((item) => item.title); }`;
+Plain JavaScript only — no TypeScript syntax. For unknown-address dependent work, use one execute_code call: search inside it, read the compact schemas, and continue to the dependent calls; do not return search results for a second execute_code call. Compact schemas are TypeScript-like strings, not JSON Schema objects: write the property names they display, never a positional guess or an invented alias.
+Dependent example (only when the second call requires a value returned by the first): async () => { const { tools } = await connecta.search({ query: "pipeline run job logs", includeSchemas: "compact" }); const pick = (suffix) => { const match = tools.find((tool) => tool.address.endsWith(suffix)); if (!match) throw new Error("no tool matching " + suffix); return match.address; }; const run = await connecta.call(pick(".get_run"), { runId: 42 }); const logs = await connecta.call(pick(".get_job_logs"), { jobId: run.failedJobId }); return [run, logs]; }`;
 
 /** Register the execute_code meta-tool. Only called when an executor is configured. */
 export function registerExecuteTool(

package/src/meta-tools.ts

@@ -1118,8 +1118,8 @@ export function createMetaTools(
 
 const LIST_DESC =
   "List connectors with status, cached tool count, and recent real-call health. Use probe=false for a fast inventory; use probe=true (default) only to diagnose live health or authorization.";
-const SEARCH_DESC = `Start here when a tool address is unknown. Exact/name matches rank above description matches; an empty query browses all. The default page has ${DEFAULT_SEARCH_LIMIT} tools; explicit limit can request up to ${MAX_SEARCH_LIMIT}. includeSchemas="compact" usually removes the describe_tools round trip.`;
-const DESCRIBE_DESC = `Inspect up to ${MAX_DESCRIBE_ADDRESSES} known tool addresses when search_tools did not include a sufficient schema. Returns descriptions, input/output schemas, and behavior annotations; format "compact" is the default.`;
+const SEARCH_DESC = `Unknown address: use 2–4 distinctive action/object terms, not the full request; omit limit initially (default ${DEFAULT_SEARCH_LIMIT}) and page only if needed, up to ${MAX_SEARCH_LIMIT}. includeSchemas="compact" adds the input and any declared output shape; matches also carry declared annotations. Call directly when sufficient. Empty query browses all.`;
+const DESCRIBE_DESC = `Only when search_tools omitted schemas, a compact shape is ambiguous, or exact JSON constraints are needed. Inspects up to ${MAX_DESCRIBE_ADDRESSES} addresses with schemas and annotations; "compact" is default, while "json" preserves exact constraints.`;
 const CALL_DESC =
   'Use for one tool explicitly annotated readOnlyHint: true. For 2–10 independent read-only calls use batch_call; for dependent steps or data reduction use execute_code when available. Unannotated, write-capable, and destructive tools are refused and require call_destructive_tool. fields selects JSON dot-paths, resultMode "value" unwraps results, timeoutMs sets a deadline, safe maxRetries are annotation-gated, diagnostics adds timing, and large results page through get_result.';
 const CALL_DESTRUCTIVE_DESC =

package/src/skills.ts

@@ -1,16 +1,16 @@
 import type { Connector } from "./types.js";
 
 export const CONNECTA_INSTRUCTIONS =
-  'Connecta exposes many integrations behind meta-tools. When an address is unknown, start with search_tools and includeSchemas="compact"; use describe_tools only when that schema is insufficient. Use call_tool for one explicitly read-only call, batch_call for 2–10 independent explicitly read-only calls, and execute_code (when available) only for dependent read-only steps, loops, joins, or reducing large results. Unannotated, write-capable, and destructive tools must use call_destructive_tool individually. Use authorize_connector only after auth_required and get_result only for truncated results. Fetch skills({ name: "usage" }) when this routing workflow is unfamiliar.';
+  'Connecta exposes integrations behind meta-tools. Unknown address: use search_tools with 2–4 distinctive action/object terms, no initial limit, and includeSchemas="compact"; describe_tools only if that shape is ambiguous or exact JSON constraints are needed. Use call_tool for one explicitly read-only call, batch_call for 2–10 independent read-only calls, and execute_code (when available) only for dependencies, loops, joins, or substantial reduction — searching inside that one run rather than searching first. Use call_destructive_tool individually for unannotated, write-capable, or destructive tools. authorize_connector follows auth_required; get_result follows truncation. If this routing is unfamiliar, fetch skills({ name: "usage" }).';
 
 export const USAGE_SKILL = `# Connecta usage
 
 ## Choose the smallest execution tool
 
-Use exact addresses returned by discovery; never invent one.
+Use exact addresses returned by discovery; never invent one. Search with 2–4 distinctive action/object terms rather than the full request, and omit \`limit\` initially so the default page stays small.
 
-- Unknown address: \`search_tools({ query, includeSchemas: "compact" })\`.
-- Schema still unclear: \`describe_tools({ addresses: [...] })\`.
+- Unknown address: \`search_tools({ query, includeSchemas: "compact" })\`; every match then includes its input shape plus any declared output shape and annotations.
+- Compact shape still ambiguous: \`describe_tools({ addresses: [...] })\`; use \`format: "json"\` only for exact constraints.
 - One explicitly read-only call: \`call_tool\`.
 - Two to ten independent explicitly read-only calls: \`batch_call\`.
 - Dependent read-only calls, loops, joins, branching, or large-result reduction: \`execute_code\` when available.
@@ -18,15 +18,15 @@ Use exact addresses returned by discovery; never invent one.
 - Truncated result: retry with \`fields\` when possible; otherwise page it with \`get_result\`.
 - \`auth_required\`: use \`authorize_connector\`, give its recovery handoff to the operator, then retry the original call.
 
-Use \`list_connectors({ probe: false })\` for a fast inventory based on recent call observations and local credential-shape drift. Use \`probe: true\` only when diagnosing live health or authorization.
+Use \`list_connectors({ probe: false })\` for a fast observed-health inventory; use \`probe: true\` only to diagnose live health or authorization.
 
 ## Code mode
 
-Use code mode when calls depend on earlier results, when joining connectors, or when sandbox filtering or aggregation will substantially shrink the response. Use \`Promise.all\` or \`connecta.batch\` for independent calls inside one execution.
+Unknown addresses plus dependent calls: search inside the run, not in an outer \`search_tools\`. Parallelize independent calls with \`Promise.all\` or \`connecta.batch\`.
 
 Connector namespace calls and \`connecta.call\` use the same read-only gate and throw on downstream errors. Catch only failures the workflow can handle; let authorization failures return to the agent for recovery.
 
-Do not use code mode for one call, independent calls already handled by \`batch_call\`, or any tool lacking \`readOnlyHint: true\`. Host calls and time are bounded. Return only the reduced value the agent needs.
+Skip code mode for one call, calls suited to \`batch_call\`, or tools lacking \`readOnlyHint: true\`. Return only the needed reduction.
 `;
 
 /**

package/src/version.ts

@@ -4,4 +4,4 @@
  * a bump that forgets this file fails the build rather than shipping a stale
  * version to `/health` and to downstream MCP handshakes.
  */
-export const CONNECTA_VERSION = "0.9.0";
+export const CONNECTA_VERSION = "0.9.1";