@takoviz/ai-sdk 1.0.1 → 2.0.1

package/README.md

@@ -1,6 +1,6 @@
-# Tako AI SDK
+# @takoviz/ai-sdk
 
-Add powerful knowledge search with data visualizations to your AI applications using Tako's knowledge base.
+Tako tools for the [Vercel AI SDK](https://sdk.vercel.ai/) — give your agents access to Tako's knowledge base: charts and well-sourced data (`takoSearch`), synthesized answers (`takoAnswer`), and the underlying data behind any result (`takoContents`).
 
 ## Installation
 
@@ -10,108 +10,114 @@ npm install @takoviz/ai-sdk ai
 
 ## Setup
 
-Get your API key from the [Tako Dashboard](https://trytako.com) and set it as an environment variable:
+Get an API key from the [Tako developer console](https://developer.tako.com/console/api-keys) and set it as an environment variable:
 
 ```bash
 export TAKO_API_KEY=your_api_key_here
 ```
 
-## Quick Start
+## Tools
+
+| Tool | Endpoint | What it does |
+| --- | --- | --- |
+| `takoSearch()` | `POST /api/v3/search` | Fast retrieval: Tako cards + web results, no synthesis |
+| `takoAnswer()` | `POST /api/v1/answer` | Retrieval **plus** an LLM-synthesized, sourced answer |
+| `takoContents()` | `POST /api/v1/contents` | Download a result's data (card CSV or web page text) |
+
+## Quick start
 
 ```typescript
-import { takoSearch } from '@takoviz/ai-sdk';
-import { generateText } from 'ai';
+import { takoAnswer } from '@takoviz/ai-sdk';
+import { openai } from '@ai-sdk/openai';
+import { generateText, isStepCount } from 'ai';
 
 const { text } = await generateText({
-  model: 'openai/gpt-4o-mini',
-  prompt: 'What is the stock price of Nvidia?',
-  tools: {
-    takoSearch: takoSearch(),
-  },
-  maxSteps: 5,
+  model: openai('gpt-4o-mini'),
+  prompt: 'Did AMD or Nvidia grow headcount faster over the last decade?',
+  tools: { tako_answer: takoAnswer() },
+  stopWhen: isStepCount(5),
 });
 
 console.log(text);
 ```
 
-## Configuration Options
-
-You can customize the search behavior by passing a configuration object:
+Give the agent the full toolset so it can search, answer, and drill into data:
 
 ```typescript
-const { text } = await generateText({
-  model: 'openai/gpt-4o-mini',
-  prompt: 'What is the GDP of major economies?',
-  tools: {
-    takoSearch: takoSearch({
-      apiKey: 'your_api_key', // Optional: override environment variable
-      sourceIndexes: ['tako', 'web'], // Default: ['tako', 'web']
-      searchEffort: 'deep', // Options: 'fast', 'deep', 'auto'. Default: 'fast'
-      countryCode: 'US', // Default: 'US'
-      locale: 'en-US', // Default: 'en-US'
-      outputSettings: {
-        knowledgeCardSettings: {
-          imageDarkMode: true, // Default: false
-        },
-      },
-    }),
-  },
-  maxSteps: 5,
-});
-```
+import { takoSearch, takoAnswer, takoContents } from '@takoviz/ai-sdk';
 
-## API Reference
+const tools = {
+  tako_search: takoSearch(),
+  tako_answer: takoAnswer(),
+  tako_contents: takoContents(),
+};
+```
 
-### `takoSearch(config?: TakoSearchConfig)`
+## Configuration
 
-Creates a Tako knowledge search tool for use with Vercel AI SDK.
+`takoSearch` and `takoAnswer` take the same config:
 
-#### Parameters
+```typescript
+takoSearch({
+  apiKey: 'your_api_key',      // optional; defaults to TAKO_API_KEY
+  baseUrl: 'https://tako.com', // optional; override for staging
+  effort: 'fast',              // 'fast' (default) | 'instant' | 'deep'
+  sources: {                   // a source is searched iff its key is present; omit to search both
+    tako: { count: 5, includeContents: false, deferDataRetrieval: false },
+    web: { count: 5, includeContents: false },
+  },
+  countryCode: 'US',           // default 'US'
+  locale: 'en-US',             // default 'en-US'
+  timezone: 'America/New_York',// optional IANA timezone
+  outputSettings: {
+    imageDarkMode: false,
+    forceRefresh: false,       // instant mode only
+  },
+});
+```
 
-- `config.apiKey` (optional): Tako API key. Defaults to `TAKO_API_KEY` environment variable.
-- `config.sourceIndexes` (optional): Array of index sources to search. Options: `'tako'`, `'web'`, `'connected_data'`. Default: `['tako', 'web']`.
-- `config.searchEffort` (optional): Search depth. Options: `'fast'`, `'deep'`, `'auto'`. Default: `'fast'`.
-- `config.countryCode` (optional): ISO3166-1 alpha-2 country code. Default: `'US'`.
-- `config.locale` (optional): Language/region identifier. Default: `'en-US'`.
-- `config.outputSettings` (optional): Output customization options.
+`takoContents` takes:
 
-#### Returns
+```typescript
+takoContents({
+  apiKey: 'your_api_key',
+  baseUrl: 'https://tako.com',
+  mode: 'url',                 // 'url' (default) → presigned link; 'inline' → content in the response
+});
+```
 
-A Vercel AI SDK tool that accepts a natural language query and returns Tako knowledge cards with visualizations, data, and sources.
+The LLM supplies only the dynamic input: `{ query }` for `takoSearch`/`takoAnswer`, and `{ url }` (a card's `webpage_url` or a web result's `url`) for `takoContents`.
 
-## Response Format
+## Responses
 
-The tool returns a `TakoSearchResponse` object:
+`takoSearch` resolves to:
 
 ```typescript
 {
-  outputs: {
-    knowledge_cards: [
-      {
-        card_id: string;
-        title: string;
-        description: string;
-        webpage_url: string;
-        image_url: string;
-        sources: Array<{ source_name: string; url: string }>;
-        visualization_data: {
-          data: any[];
-          viz_config: Record<string, any>;
-        };
-      }
-    ];
-    answer: string;
-  };
+  cards: TakoCard[];          // Tako knowledge cards (title, description, image_url, webpage_url, sources, ...)
+  web_results: TakoWebResult[];
+  contents_total_cost: number;
   request_id: string;
 }
 ```
 
-## TypeScript
+`takoAnswer` additionally includes `answer: string` (with `cards[0]` as the lead card). `takoContents` resolves to `{ contents: TakoContentItem[]; request_id: string }`, where each item has a `format` (`'csv'` | `'text'`), a `cost`, and either a presigned `url`/`expires_at` (url mode) or inline `data`/`total_rows`/`truncated` (inline mode).
 
-This package includes full TypeScript type definitions. Import types as needed:
+Full type definitions ship with the package.
+
+## TypeScript
 
 ```typescript
-import type { TakoSearchConfig, TakoSearchResponse, TakoKnowledgeCard } from '@takodata/ai-sdk';
+import type {
+  TakoRetrievalConfig,
+  TakoContentsConfig,
+  TakoSearchResult,
+  TakoAnswerResult,
+  TakoContentsResult,
+  TakoCard,
+  TakoWebResult,
+  TakoContentItem,
+} from '@takoviz/ai-sdk';
 ```
 
 ## License
@@ -120,6 +126,6 @@ MIT
 
 ## Links
 
-- [Tako Documentation](https://docs.tako.com)
-- [Vercel AI SDK Documentation](https://sdk.vercel.ai/docs)
-- [GitHub Repository](https://github.com/TakoData/ai-sdk)
+- [Tako documentation](https://docs.tako.com)
+- [Vercel AI SDK](https://sdk.vercel.ai/docs)
+- [GitHub repository](https://github.com/TakoData/ai-sdk)

package/dist/index.d.ts

@@ -1,5 +1,141 @@
-import type { TakoSearchConfig, TakoSearchResponse } from "./types";
-export declare function takoSearch(config?: TakoSearchConfig): import("@ai-sdk/provider-utils").Tool<{
+import { Tool } from 'ai';
+
+type TakoSearchEffort = "fast" | "instant" | "deep";
+type TakoContentsMode = "url" | "inline";
+type TakoContentFormat = "csv" | "text";
+/** CardSourceIndex on the response surface. */
+type TakoCardSourceIndex = "tako" | "web" | "connected_data" | "tako_deep_v2";
+type TakoKnowledgeCardRelevance = "High" | "Medium" | "Low";
+interface TakoBaseConfig {
+    /** Tako API key. Falls back to TAKO_API_KEY / TAKO_API_TOKEN env vars. */
+    apiKey?: string;
+    /** API base URL. Default "https://tako.com". */
+    baseUrl?: string;
+}
+interface TakoSourceOptions {
+    /** Max results for this source, 1–20 (server default 5). */
+    count?: number;
+    /** Inline this source's underlying data in the response. */
+    includeContents?: boolean;
+}
+interface TakoCardSourceOptions extends TakoSourceOptions {
+    /** Defer data retrieval (faster, less detail). Mutually exclusive with includeContents. */
+    deferDataRetrieval?: boolean;
+}
+interface TakoRetrievalConfig extends TakoBaseConfig {
+    /** "fast" (default) | "instant" | "deep". */
+    effort?: TakoSearchEffort;
+    /** Per-source settings. A source is searched iff its key is present. Omit to search tako + web. */
+    sources?: {
+        tako?: TakoCardSourceOptions;
+        web?: TakoSourceOptions;
+    };
+    /** ISO 3166-1 alpha-2 country code. Default "US". */
+    countryCode?: string;
+    /** BCP-47 locale tag. Default "en-US". */
+    locale?: string;
+    /** IANA timezone, e.g. "America/New_York". */
+    timezone?: string;
+    outputSettings?: {
+        imageDarkMode?: boolean;
+        /** Instant mode only. */
+        forceRefresh?: boolean;
+    };
+}
+interface TakoContentsConfig extends TakoBaseConfig {
+    /** "url" (default) returns a presigned link; "inline" returns content in the body. */
+    mode?: TakoContentsMode;
+}
+interface TakoResultContent {
+    format: TakoContentFormat;
+    cost: number;
+    data?: string | null;
+    total_rows?: number | null;
+    truncated?: boolean;
+}
+interface TakoCardSourceIndexSegment {
+    index_type: TakoCardSourceIndex;
+    segment_id: string;
+}
+interface TakoCardSourcePrivateIndex {
+    index_type: TakoCardSourceIndex;
+    private_index_id: string;
+    /** Optional for private indexes. */
+    segment_id?: string | null;
+}
+interface TakoKnowledgeCardSource {
+    source_name: string | null;
+    source_description: string | null;
+    source_index: TakoCardSourceIndex | TakoCardSourceIndexSegment | TakoCardSourcePrivateIndex;
+    url: string | null;
+    source_text?: string | null;
+}
+interface TakoKnowledgeCardMethodology {
+    methodology_name: string | null;
+    methodology_description: string | null;
+}
+interface TakoCard {
+    card_id?: string | null;
+    title?: string | null;
+    description?: string | null;
+    semantic_description?: string | null;
+    webpage_url?: string | null;
+    image_url?: string | null;
+    embed_url?: string | null;
+    sources?: TakoKnowledgeCardSource[] | null;
+    methodologies?: TakoKnowledgeCardMethodology[] | null;
+    source_indexes?: (TakoCardSourceIndex | TakoCardSourceIndexSegment)[] | null;
+    card_type?: string | null;
+    relevance?: TakoKnowledgeCardRelevance | null;
+    content?: TakoResultContent | null;
+}
+interface TakoWebResult {
+    title: string;
+    url: string;
+    snippet?: string | null;
+    source_name?: string | null;
+    publish_date?: string | null;
+    content?: TakoResultContent | null;
+    citation_number?: number | null;
+}
+interface TakoContentItem extends TakoResultContent {
+    source_url: string;
+    url?: string | null;
+    expires_at?: string | null;
+}
+interface TakoSearchResult {
+    cards: TakoCard[];
+    web_results: TakoWebResult[];
+    contents_total_cost: number;
+    request_id: string;
+}
+interface TakoAnswerResult {
+    /** Synthesized text answer. */
+    answer: string;
+    /** Backing cards; cards[0] is the lead card. */
+    cards: TakoCard[];
+    web_results: TakoWebResult[];
+    contents_total_cost: number;
+    request_id: string;
+}
+interface TakoContentsResult {
+    contents: TakoContentItem[];
+    request_id: string;
+}
+
+/** Tako fast-pipeline search: returns Tako cards + web results, no LLM synthesis. */
+declare function takoSearch(config?: TakoRetrievalConfig): Tool<{
     query: string;
-}, TakoSearchResponse>;
-export type { TakoSearchConfig, TakoSearchResponse, TakoKnowledgeCard, TakoSource, TakoVisualizationData, } from "./types";
+}, TakoSearchResult>;
+
+/** Tako answer: fast-pipeline retrieval plus an LLM-synthesized answer grounded in the results. */
+declare function takoAnswer(config?: TakoRetrievalConfig): Tool<{
+    query: string;
+}, TakoAnswerResult>;
+
+/** Download the data behind a result URL: a Tako card's CSV or a web page's text. */
+declare function takoContents(config?: TakoContentsConfig): Tool<{
+    url: string;
+}, TakoContentsResult>;
+
+export { type TakoAnswerResult, type TakoBaseConfig, type TakoCard, type TakoCardSourceIndex, type TakoCardSourceIndexSegment, type TakoCardSourceOptions, type TakoCardSourcePrivateIndex, type TakoContentFormat, type TakoContentItem, type TakoContentsConfig, type TakoContentsMode, type TakoContentsResult, type TakoKnowledgeCardMethodology, type TakoKnowledgeCardRelevance, type TakoKnowledgeCardSource, type TakoResultContent, type TakoRetrievalConfig, type TakoSearchEffort, type TakoSearchResult, type TakoSourceOptions, type TakoWebResult, takoAnswer, takoContents, takoSearch };

package/dist/index.js

@@ -1,58 +1,135 @@
-import { tool } from "@ai-sdk/provider-utils";
+// src/tools/search.ts
+import { tool } from "ai";
 import { z } from "zod";
-export function takoSearch(config = {}) {
-    const { apiKey = process.env.TAKO_API_KEY || process.env.TAKO_API_TOKEN, sourceIndexes = ["tako", "web"], searchEffort = "auto", outputSettings, countryCode = "US", locale = "en-US", } = config;
-    return tool({
-        description: "Search Tako's knowledge base for visualized data, insights, and information. Use this to find knowledge cards with charts, data visualizations, and well-sourced answers to questions.",
-        inputSchema: z.object({
-            query: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe("The search query - use natural language to describe what you're looking for"),
-        }),
-        execute: async ({ query }) => {
-            if (!apiKey) {
-                throw new Error("TAKO_API_KEY is required. Set it in environment variables or pass it in config.");
-            }
-            const requestBody = {
-                inputs: {
-                    text: query,
-                },
-                source_indexes: sourceIndexes,
-                search_effort: searchEffort,
-                country_code: countryCode,
-                locale: locale,
-            };
-            if (outputSettings) {
-                requestBody.output_settings = {
-                    knowledge_card_settings: {
-                        image_dark_mode: outputSettings.knowledgeCardSettings?.imageDarkMode,
-                    },
-                };
-            }
-            try {
-                const response = await fetch("https://trytako.com/api/v1/knowledge_search", {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        "X-API-Key": apiKey,
-                    },
-                    body: JSON.stringify(requestBody),
-                });
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    throw new Error(`Tako API error: ${response.status} - ${errorText}`);
-                }
-                const data = await response.json();
-                return data;
-            }
-            catch (error) {
-                if (error instanceof Error) {
-                    throw new Error(`Failed to search with Tako: ${error.message}`);
-                }
-                throw error;
-            }
-        },
+
+// src/client.ts
+async function callTako(opts) {
+  const { baseUrl, path, apiKey, body, operation } = opts;
+  if (!apiKey) {
+    throw new Error(
+      "TAKO_API_KEY is required. Set it in environment variables or pass it in config."
+    );
+  }
+  try {
+    const response = await fetch(`${baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": apiKey
+      },
+      body: JSON.stringify(body)
     });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Tako API error: ${response.status} - ${errorText}`);
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to ${operation} with Tako: ${error.message}`);
+    }
+    throw error;
+  }
 }
+
+// src/request.ts
+var DEFAULT_BASE_URL = "https://tako.com";
+function resolveApiKey(config) {
+  return config.apiKey ?? process.env.TAKO_API_KEY ?? process.env.TAKO_API_TOKEN;
+}
+function resolveBaseUrl(config) {
+  return (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+function buildSearchRequestBody(config, query) {
+  const body = {
+    query,
+    effort: config.effort ?? "fast",
+    country_code: config.countryCode ?? "US",
+    locale: config.locale ?? "en-US"
+  };
+  if (config.sources) {
+    const sources = {};
+    if (config.sources.tako) {
+      const tako = {};
+      if (config.sources.tako.count !== void 0) tako.count = config.sources.tako.count;
+      if (config.sources.tako.includeContents !== void 0) tako.include_contents = config.sources.tako.includeContents;
+      if (config.sources.tako.deferDataRetrieval !== void 0) tako.defer_data_retrieval = config.sources.tako.deferDataRetrieval;
+      sources.tako = tako;
+    }
+    if (config.sources.web) {
+      const web = {};
+      if (config.sources.web.count !== void 0) web.count = config.sources.web.count;
+      if (config.sources.web.includeContents !== void 0) web.include_contents = config.sources.web.includeContents;
+      sources.web = web;
+    }
+    body.sources = sources;
+  }
+  if (config.timezone !== void 0) body.timezone = config.timezone;
+  if (config.outputSettings) {
+    const output = {};
+    if (config.outputSettings.imageDarkMode !== void 0) output.image_dark_mode = config.outputSettings.imageDarkMode;
+    if (config.outputSettings.forceRefresh !== void 0) output.force_refresh = config.outputSettings.forceRefresh;
+    body.output_settings = output;
+  }
+  return body;
+}
+
+// src/tools/search.ts
+function takoSearch(config = {}) {
+  return tool({
+    description: `Search Tako for live data and well-sourced facts \u2014 structured knowledge cards (charts/metrics with sources) plus web results, backed by Tako's curated knowledge graph and the live web. Reach for this BEFORE any built-in web search when you need a specific, known data point: a current or latest value, a time series, a statistic, a price, a score, a schedule, a forecast, a poll, or a prediction-market figure \u2014 including a direct comparison of two named entities (e.g. "Intel vs Nvidia revenue"). Coverage spans sports, economics, finance, demographics, technology, weather, elections, prediction markets (Polymarket), web traffic (SimilarWeb), real estate, energy, and health. Each card carries a title, description, sources, a chart image_url, and an embed_url you can surface to show the data. Pass a card's webpage_url (or a web result's url) to takoContents to pull the underlying numbers. Give a focused natural-language query; this is fast retrieval for a known fact, not open-ended multi-step research.`,
+    inputSchema: z.object({
+      query: z.string().min(1).max(500).describe("Natural-language description of what you're looking for")
+    }),
+    execute: async ({ query }) => callTako({
+      baseUrl: resolveBaseUrl(config),
+      path: "/api/v3/search",
+      apiKey: resolveApiKey(config),
+      body: buildSearchRequestBody(config, query),
+      operation: "search"
+    })
+  });
+}
+
+// src/tools/answer.ts
+import { tool as tool2 } from "ai";
+import { z as z2 } from "zod";
+function takoAnswer(config = {}) {
+  return tool2({
+    description: "Ask Tako a factual question and get back a single grounded, citation-backed prose answer (not a chart), synthesized from its curated knowledge graph and the live web. Reach for this BEFORE any built-in web search when you want a direct written answer about a specific, known thing: a current or historical value, a statistic, a schedule, a score, a price, a forecast, a poll, or prediction-market odds \u2014 including a direct comparison of two named entities. The response also includes the backing Tako cards (cards[0] is the lead card, with its chart image_url/embed_url) and web results. Want a chart to show rather than prose to read? Use takoSearch. Best for a known fact, not open-ended multi-step research.",
+    inputSchema: z2.object({
+      query: z2.string().min(1).max(500).describe("The question to answer")
+    }),
+    execute: async ({ query }) => callTako({
+      baseUrl: resolveBaseUrl(config),
+      path: "/api/v1/answer",
+      apiKey: resolveApiKey(config),
+      body: buildSearchRequestBody(config, query),
+      operation: "answer"
+    })
+  });
+}
+
+// src/tools/contents.ts
+import { tool as tool3 } from "ai";
+import { z as z3 } from "zod";
+function takoContents(config = {}) {
+  return tool3({
+    description: `Fetch the underlying data behind a result URL \u2014 a Tako card's webpage_url yields a CSV of the card's data; any other URL (a web result's url) yields the page's extracted full text. Pass a single url taken from a prior takoSearch/takoAnswer result. Delivery is set at construction via \`mode\`: the default "url" returns a short-lived presigned download_url (no row cap) for handing over a download/embed link or for large data you won't read yourself; "inline" instead returns the content in the response (CSV capped at 1000 rows, with total_rows/truncated, or web text) so you can read and reason over the numbers directly.`,
+    inputSchema: z3.object({
+      url: z3.string().min(1).describe("A TakoCard.webpage_url or WebResult.url to download contents for")
+    }),
+    execute: async ({ url }) => callTako({
+      baseUrl: resolveBaseUrl(config),
+      path: "/api/v1/contents",
+      apiKey: resolveApiKey(config),
+      body: { url, mode: config.mode ?? "url" },
+      operation: "fetch contents"
+    })
+  });
+}
+export {
+  takoAnswer,
+  takoContents,
+  takoSearch
+};

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@takoviz/ai-sdk",
-  "version": "1.0.1",
-  "description": "Tako knowledge search tool for Vercel AI SDK",
+  "version": "2.0.1",
+  "description": "Tako knowledge search, answer, and contents tools for the Vercel AI SDK",
+  "type": "module",
   "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "test": "tsx test.ts",
-    "prepublishOnly": "npm run build"
-  },
+  "files": [
+    "dist"
+  ],
   "keywords": [
     "tako",
     "knowledge-search",
@@ -36,18 +35,22 @@
     "url": "https://github.com/TakoData/ai-sdk/issues"
   },
   "peerDependencies": {
-    "ai": "^6.0.18"
-  },
-  "dependencies": {
-    "@ai-sdk/anthropic": "^3.0.8",
-    "@ai-sdk/gateway": "^3.0.9",
-    "@ai-sdk/openai": "^3.0.7",
-    "@ai-sdk/provider-utils": "^4.0.4",
-    "zod": "^3.22.0"
+    "ai": "^6.0.18 || ^7.0.0",
+    "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
-    "tsx": "^4.0.0",
-    "typescript": "^5.0.0"
+    "@ai-sdk/openai": "^4.0.0",
+    "@types/node": "^24.10.1",
+    "ai": "^7.0.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "typecheck": "tsc --noEmit -p tsconfig.check.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/PUBLISH.md

@@ -1,45 +0,0 @@
-# Publishing to npm
-
-## Steps to Publish
-
-1. **Login to npm** (if not already logged in):
-   ```bash
-   npm login
-   ```
-
-2. **Build the package**:
-   ```bash
-   npm run build
-   ```
-   This compiles TypeScript to JavaScript in the `dist/` folder.
-
-3. **Publish to npm**:
-   ```bash
-   npm publish --access public
-   ```
-
-   The package will be published as `@takoviz/ai-sdk` version `1.0.0`.
-
-4. **Verify publication**:
-   - Check at: https://www.npmjs.com/package/@takoviz/ai-sdk
-   - Test installation: `npm install @takoviz/ai-sdk`
-
----
-
-## Updating Version
-
-To publish a new version:
-
-1. Update version in `package.json`:
-   ```bash
-   npm version patch  # For bug fixes (1.0.0 -> 1.0.1)
-   npm version minor  # For new features (1.0.0 -> 1.1.0)
-   npm version major  # For breaking changes (1.0.0 -> 2.0.0)
-   ```
-
-2. Build and publish:
-   ```bash
-   npm run build
-   npm publish --access public
-   git push && git push --tags
-   ```

package/VERCEL_REGISTRY.md

@@ -1,104 +0,0 @@
-# Adding Tako to Vercel AI Registry
-
-After publishing to npm, follow these steps to add Tako to the official Vercel AI tools registry.
-
-## Prerequisites
-
-- ✅ Package published to npm at `@takoviz/ai-sdk`
-- ✅ README with clear documentation
-- ✅ Working code example tested
-- ✅ API key instructions in README
-
-## Steps
-
-### 1. Fork and Clone Vercel AI Repository
-
-```bash
-git clone https://github.com/vercel/ai.git
-cd ai
-pnpm install
-```
-
-### 2. Create Feature Branch
-
-```bash
-git checkout -b feat/add-tool-tako-search
-```
-
-### 3. Add Tool Entry
-
-Edit `content/tools-registry/registry.ts` and add this entry to the tools array:
-
-```typescript
-{
-  slug: 'tako-search',
-  name: 'Tako Search',
-  description: 'Search Tako\'s knowledge base for data visualizations, insights, and well-sourced information with charts and analytics.',
-  packageName: '@takoviz/ai-sdk',
-  installCommand: {
-    pnpm: 'pnpm add @takoviz/ai-sdk',
-    npm: 'npm install @takoviz/ai-sdk',
-    yarn: 'yarn add @takoviz/ai-sdk',
-    bun: 'bun add @takoviz/ai-sdk',
-  },
-  codeExample: `import { takoSearch } from '@takoviz/ai-sdk';
-import { generateText } from 'ai';
-
-const { text } = await generateText({
-  model: 'openai/gpt-4o-mini',
-  prompt: 'What is the stock price of Nvidia?',
-  tools: {
-    takoSearch: takoSearch(),
-  },
-  maxSteps: 5,
-});
-
-console.log(text);`,
-  docsUrl: 'https://github.com/TakoData/ai-sdk#readme',
-  npmUrl: 'https://www.npmjs.com/package/@takoviz/ai-sdk',
-  websiteUrl: 'https://tako.com',
-  apiKeyEnvName: 'TAKO_API_KEY',
-  apiKeyUrl: 'https://trytako.com',
-  tags: ['search', 'data', 'visualization', 'analytics'],
-},
-```
-
-### 4. Test Locally
-
-```bash
-pnpm dev
-```
-
-Navigate to the tools registry page and verify your tool appears correctly.
-
-### 5. Create Pull Request
-
-```bash
-git add content/tools-registry/registry.ts
-git commit -m "feat(tools-registry): add tako-search"
-git push origin feat/add-tool-tako-search
-```
-
-Then:
-1. Go to https://github.com/vercel/ai
-2. Click "New Pull Request"
-3. Use title: `feat(tools-registry): add tako-search`
-4. Description:
-   ```
-   Adds Tako Search tool to the registry.
-
-   Tako Search provides access to Tako's knowledge base with data visualizations,
-   charts, and well-sourced analytics for AI applications.
-
-   - Package: @takoviz/ai-sdk
-   - Docs: https://github.com/TakoData/ai-sdk
-   - Website: https://tako.com
-   ```
-
-### 6. Wait for Review
-
-The Vercel team will review and merge your PR. Once merged, Tako will appear in the official AI SDK tools registry at https://sdk.vercel.ai/docs/ai-sdk-ui/tools-registry!
-
-## Reference
-
-Official guide: https://github.com/vercel/ai/blob/main/contributing/add-new-tool-to-registry.md

package/dist/types.d.ts

@@ -1,36 +0,0 @@
-export interface TakoSearchConfig {
-    apiKey?: string;
-    sourceIndexes?: ("tako" | "web" | "connected_data")[];
-    searchEffort?: "fast" | "deep" | "auto";
-    outputSettings?: {
-        knowledgeCardSettings?: {
-            imageDarkMode?: boolean;
-        };
-    };
-    countryCode?: string;
-    locale?: string;
-}
-export interface TakoSource {
-    source_name: string;
-    url: string;
-}
-export interface TakoVisualizationData {
-    data: any[];
-    viz_config: Record<string, any>;
-}
-export interface TakoKnowledgeCard {
-    card_id: string;
-    title: string;
-    description: string;
-    webpage_url: string;
-    image_url: string;
-    sources: TakoSource[];
-    visualization_data: TakoVisualizationData;
-}
-export interface TakoSearchResponse {
-    outputs: {
-        knowledge_cards: TakoKnowledgeCard[];
-        answer: string;
-    };
-    request_id: string;
-}

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/test.ts

@@ -1,22 +0,0 @@
-import { takoSearch } from './src/index.js';
-import { generateText } from 'ai';
-import { openai } from '@ai-sdk/openai';
-
-async function test() {
-  const result = await generateText({
-    model: openai('gpt-4o-mini'),
-    prompt: 'What is the stock price of Nvidia?',
-    tools: {
-      takoSearch: takoSearch(),
-    },
-    maxSteps: 5,
-  });
-
-  console.log('Result text:', result.text);
-  console.log('\nTool calls:', JSON.stringify(result.toolCalls, null, 2));
-  console.log('\nTool results:', JSON.stringify(result.toolResults, null, 2));
-  console.log('\nSteps:', result.steps.length);
-  console.log('\nWarnings:', result.warnings);
-}
-
-test().catch(console.error);