vybekiit 0.7.32 → 0.7.33

package/dist/global-skills/neon-postgres/references/lakebase-search-drizzle.md

@@ -10,6 +10,7 @@ Contents:
 - [Extensions](#extensions): custom migration required to create extensions (Drizzle can't)
 - [Schema](#schema): columns, generated `tsvector`, and the ANN index
 - [BM25 Index](#bm25-index): created after the corpus is seeded
+- [Generate and Store Embeddings](#generate-and-store-embeddings): call the AI Gateway and insert vectors with Drizzle
 - [Query](#query): vector, BM25, and hybrid reads
 - [Tune Per Query](#tune-per-query): per-query GUCs
 
@@ -22,18 +23,22 @@ Rules:
 
 ## Config
 
-`drizzle-kit generate` and `migrate` read `drizzle.config.ts`. Point `dbCredentials.url` at the **direct (unpooled)** connection string:
+`drizzle-kit generate` and `migrate` read `drizzle.config.ts`. If the connection string is in `.env`, install `dotenv` (`npm install dotenv`) and load it here. Point `dbCredentials.url` at the **direct (unpooled)** connection string:
 
 ```typescript
 // drizzle.config.ts
+import "dotenv/config";
 import { defineConfig } from "drizzle-kit";
 
+const databaseUrl = process.env.DATABASE_URL_UNPOOLED;
+if (!databaseUrl) throw new Error("Missing DATABASE_URL_UNPOOLED");
+
 export default defineConfig({
   schema: "./src/schema.ts",
   out: "./drizzle",
   dialect: "postgresql",
   // Direct (unpooled) URL. Neon exposes it as DATABASE_URL_UNPOOLED.
-  dbCredentials: { url: process.env.DATABASE_URL_UNPOOLED },
+  dbCredentials: { url: databaseUrl },
 });
 ```
 
@@ -57,7 +62,14 @@ The columns, the generated `tsvector`, and the `lakebase_ann` index all go in `s
 
 ```typescript
 // src/schema.ts
-import { pgTable, bigint, text, vector, index, customType } from "drizzle-orm/pg-core";
+import {
+  pgTable,
+  bigint,
+  text,
+  vector,
+  index,
+  customType,
+} from "drizzle-orm/pg-core";
 import { sql } from "drizzle-orm";
 
 const tsvector = customType<{ data: string }>({
@@ -69,10 +81,12 @@ const tsvector = customType<{ data: string }>({
 export const documents = pgTable(
   "documents",
   {
-    id: bigint("id", { mode: "number" }).generatedByDefaultAsIdentity().primaryKey(),
+    id: bigint("id", { mode: "number" })
+      .generatedByDefaultAsIdentity()
+      .primaryKey(),
     title: text("title").notNull(),
     body: text("body").notNull(),
-    embedding: vector("embedding", { dimensions: 1536 }),
+    embedding: vector("embedding", { dimensions: 1024 }),
     bodyTsv: tsvector("body_tsv").generatedAlwaysAs(
       sql`to_tsvector('english', "body")`,
     ),
@@ -86,7 +100,7 @@ export const documents = pgTable(
 );
 ```
 
-Set the dimension to match your embedding model. Postgres maintains `body_tsv`, so never write it from the app. Generate and apply the migration after the extensions migration above:
+The 1024-dimensional column is an example; set it to the output dimension of your selected embedding model. Use the same model and dimensions for stored documents and queries. Postgres maintains `body_tsv`, so never write it from the app. Generate and apply the migration after the extensions migration above:
 
 ```bash
 npx drizzle-kit generate --name=lakebase_search
@@ -106,6 +120,66 @@ npx drizzle-kit generate --custom --name=bm25_index
 CREATE INDEX documents_body_bm25 ON documents USING lakebase_bm25 (body_tsv);
 ```
 
+## Generate and Store Embeddings
+
+Use the [Vercel AI SDK](https://ai-sdk.dev) (`ai`, 6+) with Neon's `@neon/ai-sdk-provider` 1.0.0+. Follow the [gateway setup](vector-search.md#prepare-embeddings), then install the packages with `npm install @neon/ai-sdk-provider ai dotenv`:
+
+```typescript
+import "dotenv/config";
+import { neon } from "@neon/ai-sdk-provider";
+import { embed, embedMany } from "ai";
+
+const embeddingModel = neon.embeddingModel("qwen3-embedding-0-6b");
+const providerOptions = { neon: { dimensions: 1024 } };
+// Qwen3 query prompt adapted for Neon documentation search; documents stay unprefixed.
+const queryPrompt =
+  "Instruct: Given a question about Neon, retrieve documentation passages that answer the question\nQuery: ";
+```
+
+Generate a document vector, then insert it with Drizzle:
+
+```typescript
+const { embedding } = await embed({
+  model: embeddingModel,
+  value: body,
+  providerOptions,
+});
+await db.insert(documents).values({
+  title,
+  body,
+  embedding,
+});
+```
+
+For bulk imports, skip blank rows and embed/insert one batch at a time:
+
+```typescript
+const batchSize = 64;
+const nonBlankRows = rows.filter((row) => row && row.body.trim().length > 0);
+
+for (let offset = 0; offset < nonBlankRows.length; offset += batchSize) {
+  const batch = nonBlankRows.slice(offset, offset + batchSize);
+  const { embeddings: vectors } = await embedMany({
+    model: embeddingModel,
+    values: batch.map((row) => row.body),
+    providerOptions,
+    maxParallelCalls: 1,
+  });
+  await db.insert(documents).values(
+    batch.map((row, index) => {
+      const embedding = vectors[index];
+      if (!embedding)
+        throw new Error(`Missing embedding for batch row ${index}`);
+      return { ...row, embedding };
+    }),
+  );
+}
+```
+
+`embedMany` splits embedding requests using the provider's per-request input limit. This loop also bounds database inserts and memory; tune `batchSize` for your workload. Chunk long documents before embedding. Earlier batches stay committed if a later batch fails.
+
+Apply `queryPrompt` only to queries, keeping the original text for BM25. Use the same model and dimensions for documents and queries; re-embed documents when switching models.
+
 ## Query
 
 Use the query builder with Drizzle's `cosineDistance` helper for vector search. It emits the `<=>` operator, so keep the index on `vector_cosine_ops`:
@@ -114,7 +188,11 @@ Use the query builder with Drizzle's `cosineDistance` helper for vector search.
 import { cosineDistance } from "drizzle-orm";
 import { documents } from "./schema";
 
-// queryEmbedding: number[] from the same model used for stored documents
+const { embedding: queryEmbedding } = await embed({
+  model: embeddingModel,
+  value: `${queryPrompt}${queryText}`,
+  providerOptions,
+});
 const distance = cosineDistance(documents.embedding, queryEmbedding);
 
 const rows = await db
@@ -130,17 +208,23 @@ BM25 has no Drizzle helper: `<@>` and `to_bm25query` require raw SQL. Reference
 import { sql } from "drizzle-orm";
 
 const rows = await db.execute(sql`
-  SELECT id, title,
-    body_tsv <@> to_bm25query(
-      to_tsvector('english', ${queryText}),
-      'documents_body_bm25'::regclass
-    ) AS score
-  FROM documents
+  SELECT id, title, score
+  FROM (
+    SELECT id, title,
+      body_tsv <@> to_bm25query(
+        to_tsvector('english', ${queryText}),
+        'documents_body_bm25'::regclass
+      ) AS score
+    FROM documents
+  ) AS keyword_scored
+  WHERE score < 0
   ORDER BY score
   LIMIT ${k}
 `);
 ```
 
+Filter `score < 0` before the candidate cutoff: scalar BM25 scoring returns zero for non-matches, which must not become keyword hits. Partial query-term matches remain eligible.
+
 Run the [hybrid search](hybrid-search.md) RRF query the same way: raw SQL through `db.execute`.
 
 ## Tune Per Query
@@ -168,5 +252,6 @@ const rows = await db.transaction(async (tx) => {
 
 Sources:
 
+- [AI Gateway embeddings](https://neon.com/docs/ai-gateway/embeddings)
 - [Get started with Lakebase Search](https://neon.com/docs/ai/lakebase-search-get-started)
-- [Schema migration with Lakebase Postgres and Drizzle ORM](https://neon.com/docs/guides/drizzle-migrations)
+- [Schema migration with Lakebase Postgres and Drizzle ORM](https://neon.com/docs/guides/drizzle-migrations)

package/dist/global-skills/neon-postgres/references/vector-search.md

@@ -5,7 +5,7 @@ Use `lakebase_vector` for approximate nearest-neighbor retrieval over embeddings
 ## Contents
 
 - [Create the extension](#create-the-extension) — enable `lakebase_vector` and its `pgvector` dependency
-- [Prepare embeddings](#prepare-embeddings) — define the vector column and keep embedding dimensions consistent
+- [Prepare embeddings](#prepare-embeddings) — generate vectors with the AI Gateway and match the column dimension
 - [Build the index](#build-the-index) — match the distance metric, operator class, and query operator
 - [Tune the index](#tune-the-index) — configure index-build options and concurrent index management
 - [Query](#query) — rank by vector distance or filter by a similarity radius
@@ -24,28 +24,111 @@ CREATE EXTENSION IF NOT EXISTS lakebase_vector CASCADE;
 
 ## Prepare Embeddings
 
-Use any embedding provider whose vector dimensions and distance metric match the schema and index:
+Neon's [AI Gateway embeddings endpoint](https://neon.com/docs/ai-gateway/embeddings) is an OpenAI-compatible way to generate vectors for Lakebase Search. This table uses 1024 dimensions as an example; set the column dimension to the output of the model and any `dimensions` parameter you choose:
 
 ```sql
 CREATE TABLE documents (
   id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
   title text NOT NULL,
   body text NOT NULL,
-  embedding vector(1536)
+  embedding vector(1024)
 );
 ```
 
-Replace `1536` with the embedding model's dimension. Generate stored-document and query embeddings with the same model and preprocessing. Keep embedding generation outside SQL unless the architecture already provides an in-database embedding function.
+Enable the AI Gateway on the branch and get `NEON_AI_GATEWAY_TOKEN` and the bare-host `NEON_AI_GATEWAY_BASE_URL`:
+
+- With `neon.ts`, declare `aiGateway: true`, run `neon deploy`, then run `neon env pull --file .env`.
+- Without `neon.ts`, run `neon env pull --service ai-gateway --file .env` from a directory linked to the intended project and branch. This requests the gateway variables explicitly and skips other services.
+- Alternatively, get both values from the Neon Console. Neon Functions receive them automatically.
+
+### AI SDK (Recommended)
+
+For TypeScript apps, use Neon's `@neon/ai-sdk-provider` 1.0.0+ with the [Vercel AI SDK](https://ai-sdk.dev) (`ai`, 6+) (`npm install @neon/ai-sdk-provider ai dotenv`). The provider reads `NEON_AI_GATEWAY_TOKEN` and `NEON_AI_GATEWAY_BASE_URL` directly and sends embedding requests to `/v1/embeddings`. Load `.env` in a standalone app; Neon Functions inject the variables automatically.
+
+```typescript
+import "dotenv/config";
+import { neon } from "@neon/ai-sdk-provider";
+import { embed, embedMany } from "ai";
+
+const embeddingModel = neon.embeddingModel("qwen3-embedding-0-6b");
+const providerOptions = { neon: { dimensions: 1024 } };
+// Qwen3 query prompt adapted for Neon documentation search; documents stay unprefixed.
+const queryPrompt =
+  "Instruct: Given a question about Neon, retrieve documentation passages that answer the question\nQuery: ";
+
+const { embeddings: documentEmbeddings } = await embedMany({
+  model: embeddingModel,
+  values: documentBodies, // non-empty document batch; store vectors by input index
+  providerOptions,
+  maxParallelCalls: 1,
+});
+const { embedding: queryEmbedding } = await embed({
+  model: embeddingModel,
+  value: `${queryPrompt}${queryText}`,
+  providerOptions,
+}); // bind to $1 below
+```
+
+Skip empty imports before calling `embedMany`. It returns vectors in input order and splits requests according to the provider's item limit. For large imports, also split document text within the endpoint's token limits and keep database writes bounded.
+
+For Neon documentation search, the example adapts the task instruction in Qwen3's stored `query` prompt from [config_sentence_transformers.json](https://huggingface.co/Qwen/Qwen3-Embedding-0.6B/blob/main/config_sentence_transformers.json). Its `document` prompt is empty, so document text stays unprefixed. Neither SDK applies SentenceTransformers prompts automatically. Keep the original `queryText` for BM25, and use the selected model's own prompt conventions if you switch models.
+
+### OpenAI SDK Alternative
+
+For an existing OpenAI SDK integration, install `openai` and `dotenv` (`npm install openai dotenv`) and configure the client explicitly:
+
+```typescript
+import "dotenv/config";
+import OpenAI from "openai";
+
+const apiKey = process.env.NEON_AI_GATEWAY_TOKEN;
+const gatewayBaseUrl = process.env.NEON_AI_GATEWAY_BASE_URL;
+if (!apiKey || !gatewayBaseUrl) {
+  throw new Error("Missing Neon AI Gateway credentials");
+}
+
+const client = new OpenAI({
+  apiKey,
+  baseURL: `${gatewayBaseUrl}/v1`,
+});
+
+async function embedBatch(inputs: string[]): Promise<number[][]> {
+  if (inputs.length === 0) return [];
+  const response = await client.embeddings.create({
+    model: "qwen3-embedding-0-6b",
+    input: inputs,
+    dimensions: 1024,
+    encoding_format: "float",
+  });
+  const vectors: number[][] = [];
+  for (const item of response.data) vectors[item.index] = item.embedding;
+  return inputs.map((_, index) => {
+    const embedding = vectors[index];
+    if (!embedding) throw new Error(`Missing embedding for input ${index}`);
+    return embedding;
+  });
+}
+
+const documentEmbeddings = await embedBatch(documentBodies);
+const [queryEmbedding] = await embedBatch([`${queryPrompt}${queryText}`]);
+if (!queryEmbedding) throw new Error("Missing query embedding");
+```
+
+Use the same `queryPrompt` defined above, only for query inputs. Keep each batch within the endpoint's input and rate limits, and pair each vector with its source row using the response `index`. The [OpenAI JavaScript SDK v6](https://github.com/openai/openai-node/blob/v6.0.0/src/resources/embeddings.ts) defaults to requesting base64 and decodes the response as base64. If a compatible endpoint returns float arrays instead, that decoder can silently turn them into zeros. Pass `encoding_format: "float"` explicitly for the AI Gateway; the SDK then returns the float arrays directly. Base64 can reduce response size when an endpoint actually returns base64, but do not assume that format for this gateway.
+
+Use the same model and output dimensions for stored documents and queries. Follow the model's input conventions: some models recommend a query instruction while document text remains unprefixed. If the model supports shorter vectors, compare retrieval quality, storage, and latency before changing dimensions; set the column and both embedding requests to the chosen size. Switching models requires re-embedding the corpus; changing dimensions also requires migrating the vector column and index. Generate embeddings in the application, outside SQL, unless the architecture already provides an in-database embedding function. Other embedding providers are also valid when their output matches the schema and index.
 
 ## Build the Index
 
 Choose the operator class and query operator as a matched pair:
 
-| Metric | Common use | Operator class | Distance operator |
-| --- | --- | --- | --- |
-| Cosine | Most text embeddings | `vector_cosine_ops` | `<=>` |
-| L2 / Euclidean | Absolute distance matters; vectors do not need normalization | `vector_l2_ops` | `<->` |
-| Inner product | Unit-normalized vectors; matches cosine for unit vectors | `vector_ip_ops` | `<#>` |
+| Metric         | Common use                                                   | Operator class      | Distance operator |
+| -------------- | ------------------------------------------------------------ | ------------------- | ----------------- |
+| Cosine         | Most text embeddings                                         | `vector_cosine_ops` | `<=>`             |
+| L2 / Euclidean | Absolute distance matters; vectors do not need normalization | `vector_l2_ops`     | `<->`             |
+| Inner product  | Unit-normalized vectors; matches cosine for unit vectors     | `vector_ip_ops`     | `<#>`             |
+
+Choose the metric recommended for the selected model, and keep its index operator class and query operator aligned. The [Qwen3 Embedding model card](https://huggingface.co/Qwen/Qwen3-Embedding-0.6B) demonstrates cosine similarity and normalized dot product for retrieval. For unit-normalized vectors, cosine, inner product, and L2 have the same exact ranking; approximate indexes can still differ in recall and latency, so benchmark on your corpus.
 
 ```sql
 CREATE INDEX documents_embedding_ann ON documents
@@ -79,7 +162,7 @@ For a large table, use `CREATE INDEX CONCURRENTLY` to avoid locking out writes w
 
 ## Query
 
-Generate the query embedding with the same model and preprocessing used for stored documents, then bind it as a parameter:
+Generate the query embedding with the same model and dimensions used for stored documents, following the model's query-input conventions (using the Qwen3 query prompt shown above), then bind it as a parameter:
 
 ```sql
 SELECT id, title, embedding <=> $1::vector AS distance

package/dist/global-skills/resend/SKILL.md

@@ -4,7 +4,7 @@ description: Use when working with the Resend email API — sending transactiona
 license: MIT
 metadata:
     author: resend
-    version: "3.13.0"
+    version: "3.14.0"
     homepage: https://resend.com/agent-skills
     source: https://github.com/resend/resend-skills
     openclaw:
@@ -178,22 +178,11 @@ export async function POST(req: Request) {
 
 ## SDK Version Requirements
 
-Always install the latest SDK version. These are the minimum versions for full functionality (sending, receiving, webhook verification):
+Always install the latest SDK version. Older SDKs may be missing `webhooks.verify()`, `emails.receiving.get()`, or `domains.claims.*`.
 
-| Language | Package | Min Version | Install |
-|----------|---------|-------------|---------|
-| Node.js | `resend` | >= 6.14.0 | `npm install resend` |
-| Python | `resend` | >= 2.34.0 | `pip install resend` |
-| Go | `resend-go/v3` | >= 3.11.0 | `go get github.com/resend/resend-go/v3` |
-| Ruby | `resend` | >= 1.6.0 | `gem install resend` |
-| PHP | `resend/resend-php` | >= 1.1.0 | `composer require resend/resend-php` |
-| Rust | `resend-rs` | >= 0.26.1 | `cargo add resend-rs` |
-| Java | `resend-java` | >= 4.16.0 | See [installation.md](references/installation.md) |
-| .NET | `Resend` | >= 0.2.1 | `dotnet add package Resend` |
+> **If the project already has a Resend SDK installed**, check its version against the minimum versions in [installation.md](references/installation.md) and upgrade if it's below.
 
-> **If the project already has a Resend SDK installed**, check the version and upgrade if it's below the minimum. Older SDKs may be missing `webhooks.verify()`, `emails.receiving.get()`, or `domains.claims.*`.
-
-See [installation.md](references/installation.md) for full installation commands, language detection, and cURL fallback.
+See [installation.md](references/installation.md) for the minimum version per language, full installation commands, language detection, and cURL fallback.
 
 ## Common Setup
 

package/dist/global-skills/resend/references/domains.md

@@ -108,7 +108,7 @@ Claiming takes over a domain **another Resend account has already verified**. Th
 Claim → Add TXT proof to DNS → Verify claim → (completed) → Update DKIM in DNS → Verify domain → Send
 ```
 
-Claim methods are available in the **Node.js** (`resend >= 6.14.0`), **Python** (`resend >= 2.34.0`), **Ruby** (`resend >= 1.6.0`), **Go** (`resend-go/v3 >= 3.11.0`), **Rust** (`resend-rs >= 0.26.1`), and **Java** (`resend-java >= 4.16.0`) SDKs, plus the **CLI** (`resend domains claim`) and REST API. Not yet in the PHP or .NET SDKs.
+Claim methods are available in the **Node.js** (`resend >= 6.14.0`), **Python** (`resend >= 2.34.0`), **Ruby** (`resend >= 1.6.0`), **Go** (`resend-go/v4 >= 4.0.0`), **Rust** (`resend-rs >= 0.26.1`), and **Java** (`resend-java >= 4.16.0`) SDKs, plus the **CLI** (`resend domains claim`) and REST API. Not yet in the PHP or .NET SDKs.
 
 | Operation | Method | Notes |
 |-----------|--------|-------|

package/dist/global-skills/resend/references/installation.md

@@ -10,7 +10,7 @@ These are the minimum versions required for full functionality (sending, receivi
 |----------|---------|-------------|---------|
 | Node.js | `resend` | >= 6.14.0 | `npm install resend` |
 | Python | `resend` | >= 2.34.0 | `pip install resend` |
-| Go | `resend-go/v3` | >= 3.11.0 | `go get github.com/resend/resend-go/v3` |
+| Go | `resend-go/v4` | >= 4.0.0 | `go get github.com/resend/resend-go/v4` |
 | Ruby | `resend` | >= 1.6.0 | `gem install resend` |
 | PHP | `resend/resend-php` | >= 1.1.0 | `composer require resend/resend-php` |
 | Rust | `resend-rs` | >= 0.26.1 | `cargo add resend-rs` |
@@ -27,7 +27,7 @@ Check for these files to determine the project's language/framework:
 |------|----------|-----|
 | `package.json` | Node.js/TypeScript | resend |
 | `requirements.txt` or `pyproject.toml` | Python | resend |
-| `go.mod` | Go | resend-go/v3 |
+| `go.mod` | Go | resend-go/v4 |
 | `Gemfile` | Ruby | resend |
 | `composer.json` | PHP | resend/resend-php |
 | `Cargo.toml` | Rust | resend-rs |
@@ -59,7 +59,7 @@ pip install resend
 ### Go
 
 ```bash
-go get github.com/resend/resend-go/v3
+go get github.com/resend/resend-go/v4
 ```
 
 ### Ruby

package/dist/global-skills/resend/references/sending/best-practices.md

@@ -86,7 +86,7 @@ result = resend.Batch.send(emails, idempotency_key=f"batch-orders/{batch_id}")
 Other SDKs use the `Idempotency-Key` header:
 
 ```go
-import "github.com/resend/resend-go/v3"
+import "github.com/resend/resend-go/v4"
 
 client := resend.NewClient(os.Getenv("RESEND_API_KEY"))
 
@@ -223,7 +223,7 @@ except resend.exceptions.ResendError as e:
 ```go
 import (
     "fmt"
-    "github.com/resend/resend-go/v3"
+    "github.com/resend/resend-go/v4"
 )
 
 client := resend.NewClient(os.Getenv("RESEND_API_KEY"))
@@ -359,7 +359,7 @@ result = send_email_with_retry(
 import (
     "fmt"
     "time"
-    "github.com/resend/resend-go/v3"
+    "github.com/resend/resend-go/v4"
 )
 
 func sendEmailWithRetry(client *resend.Client, params *resend.SendEmailRequest, maxRetries int) (*resend.SendEmailResponse, error) {

package/dist/global-skills/resend/references/sending/single-email-examples.md

@@ -58,7 +58,7 @@ email = resend.Emails.send({
 Other SDKs use the `Idempotency-Key` header:
 
 ```go
-import "github.com/resend/resend-go/v3"
+import "github.com/resend/resend-go/v4"
 
 client := resend.NewClient(os.Getenv("RESEND_API_KEY"))
 
@@ -172,7 +172,7 @@ except resend.exceptions.ResendError as e:
 ```go
 import (
     "fmt"
-    "github.com/resend/resend-go/v3"
+    "github.com/resend/resend-go/v4"
 )
 
 client := resend.NewClient(os.Getenv("RESEND_API_KEY"))
@@ -293,7 +293,7 @@ result = send_email_with_retry(
 import (
     "fmt"
     "time"
-    "github.com/resend/resend-go/v3"
+    "github.com/resend/resend-go/v4"
 )
 
 func sendEmailWithRetry(client *resend.Client, params *resend.SendEmailRequest, maxRetries int) (*resend.SendEmailResponse, error) {

package/dist/global-skills/stripe-best-practices/SKILL.md

@@ -25,13 +25,13 @@ Latest SDK versions:
 
 | Language | Latest version |
 | --- | --- |
-| Ruby | 19.6.0 |
-| Python | 15.6.0 |
-| Node.js | 22.6.0 |
-| PHP | 21.3.0 |
-| Java | 33.4.0 |
-| Go | 86.4.0 |
-| .NET | 52.4.0 |
+| Ruby | 20.0.0 |
+| Python | 16.0.0 |
+| Node.js | 23.0.0 |
+| PHP | 22.0.0 |
+| Java | 34.0.0 |
+| Go | 87.0.0 |
+| .NET | 53.0.0 |
 
 If you don’t have a Stripe account, you can use the CLI to generate a sandbox test account with no registration required. Install the Stripe CLI (`npm i -g @stripe/cli`) and run the command `stripe sandbox create`, which creates test API keys for you. When you recommend this, explain that [a sandbox is a Stripe test environment](https://docs.stripe.com/sandboxes.md).
 
@@ -45,27 +45,27 @@ API key default: Always recommend a [restricted API key (RAK)](https://docs.stri
 
 | Building… | Recommended API | Details |
 | --- | --- | --- |
-| One-time payments | Checkout Sessions | [references/payments.md](https://docs.stripe.com/references/payments.md) |
-| Custom payment form with embedded UI | Checkout Sessions + Payment Element | [references/payments.md](https://docs.stripe.com/references/payments.md) |
-| Saving a payment method for later | Setup Intents | [references/payments.md](https://docs.stripe.com/references/payments.md) |
-| Connect platform or marketplace | Accounts v2 (`/v2/core/accounts`) | [references/connect.md](https://docs.stripe.com/references/connect.md) |
-| Usage-based billing (new integration) | Metronome | [references/billing.md](https://docs.stripe.com/references/billing.md) |
-| Subscriptions or recurring billing | Billing APIs + Checkout Sessions | [references/billing.md](https://docs.stripe.com/references/billing.md) |
-| Sales tax, VAT, or GST compliance | Stripe Tax + Registrations API | [references/tax.md](https://docs.stripe.com/references/tax.md) |
-| Embedded financial accounts / banking | v2 Financial Accounts | [references/treasury.md](https://docs.stripe.com/references/treasury.md) |
-| Security (key management, RAKs, webhooks, OAuth, 2FA, Connect liability) | See security reference | [references/security.md](https://docs.stripe.com/references/security.md) |
+| One-time payments | Checkout Sessions | <references/payments.md> |
+| Custom payment form with embedded UI | Checkout Sessions + Payment Element | <references/payments.md> |
+| Saving a payment method for later | Setup Intents | <references/payments.md> |
+| Connect platform or marketplace | Accounts v2 (`/v2/core/accounts`) | <references/connect.md> |
+| Usage-based billing (new integration) | Metronome | <references/billing.md> |
+| Subscriptions or recurring billing | Billing APIs + Checkout Sessions | <references/billing.md> |
+| Sales tax, VAT, or GST compliance | Stripe Tax + Registrations API | <references/tax.md> |
+| Embedded financial accounts / banking | v2 Financial Accounts | <references/treasury.md> |
+| Security (key management, RAKs, webhooks, OAuth, 2FA, Connect liability) | See security reference | <references/security.md> |
 
 Read the relevant reference file before answering any integration question or writing code.
 
 ## Critical rules
 
-- *Before enabling `automatic_tax: { enabled: true }`* (or calculating tax for a custom PaymentIntent), read the [tax reference](https://docs.stripe.com/references/tax.md) and confirm the user has an active registration. Without one, Stripe calculates and collects no tax while the user believes tax is on (the most common Stripe Tax mistake).
+- *Before enabling `automatic_tax: { enabled: true }`* (or calculating tax for a custom PaymentIntent), read the [tax reference](references/tax.md) and confirm the user has an active registration. Without one, Stripe calculates and collects no tax while the user believes tax is on (the most common Stripe Tax mistake).
 
 - *Never include `payment_method_types` in any Stripe API call*, with one exception: Terminal (in-person payments) integrations must pass `payment_method_types: ['card_present']` on the PaymentIntent. For all other integrations, omit this parameter entirely to enable dynamic payment methods, which enables you to configure payment method settings from the Dashboard and dynamically display the most relevant eligible payment methods to each customer to maximize conversion. To customize which payment methods you accept, use [payment_method_configurations](https://docs.stripe.com/payments/payment-method-configurations.md) or `excluded_payment_method_types` instead of `payment_method_types`.
 
 - When a PaymentIntent or SetupIntent integration requires an explicit allowlist, use `allowed_payment_method_types` instead of `payment_method_types`.
 
-- *Never present webhooks as optional.* We recommend webhooks for every payment integration and they’re required for subscriptions and asynchronous payment methods. Fulfillment belongs in a handler for both `checkout.session.completed` and `checkout.session.async_payment_succeeded` (gated on `payment_status`), not the success page. See [references/payments.md](https://docs.stripe.com/references/payments.md).
+- *Never present webhooks as optional.* We recommend webhooks for every payment integration and they’re required for subscriptions and asynchronous payment methods. Fulfillment belongs in a handler for both `checkout.session.completed` and `checkout.session.async_payment_succeeded` (gated on `payment_status`), not the success page. See <references/payments.md>.
 
 - On API version `2026-03-25.dahlia` or later, pass the parameter `integration_identifier` to `checkout.sessions.create` to tag sessions with a custom label for tracking and comparing checkout flows in the Dashboard. The label should include a suffix of 8 random letters.
 

package/dist/global-skills/stripe-best-practices/references/tax.md

@@ -20,9 +20,9 @@
 
 ## What Stripe Tax does and doesn’t do
 
-**What Stripe Tax does:** tax calculation, nexus threshold monitoring (Dashboard → Tax → Locations → “Needs attention” and email alerts), registration on the user’s behalf for eligible US remote sellers (“Register for me”; see Registration safety), and filing through [TaxJar](https://docs.stripe.com/tax/file-with-stripe.md) or [a filing partner](https://docs.stripe.com/tax/filing.md), where available.
+**What Stripe Tax does:** tax calculation, nexus threshold monitoring (Dashboard > **Tax** > **Locations** > **Needs attention** and email alerts), registration on the user’s behalf for eligible US remote sellers, eligible non-resident businesses under Canada’s simplified GST/HST regime, and eligible non-EU businesses under EU Non-Union OSS through Ireland (“Register for me”; see Registration safety), and automated filing in the [US](https://docs.stripe.com/tax/file-with-stripe.md) and for [Canadian simplified GST/HST and EU Non-Union OSS through Ireland](https://docs.stripe.com/tax/file-with-stripe-outside-us.md), or filing through [a filing partner](https://docs.stripe.com/tax/filing.md), where available.
 
-**What Stripe Tax doesn’t do:** process payments that happen outside Stripe, automatically file every tax return, or support every jurisdiction (check the [supported countries list](https://docs.stripe.com/tax/supported-countries.md) for current coverage). For off-Stripe payments, the [standalone Tax APIs](https://docs.stripe.com/tax/off-stripe.md) can calculate tax and record transactions for reporting and filing.
+**What Stripe Tax doesn’t do:** Process payments that happen outside Stripe, automatically file every tax return, or support every jurisdiction (check the [supported countries list](https://docs.stripe.com/tax/supported-countries.md) for current coverage). For off-Stripe payments, the [standalone Tax APIs](https://docs.stripe.com/tax/off-stripe.md) can calculate tax and record transactions for reporting and filing.
 
 This matters for competitor comparisons: training data sometimes incorrectly describes Stripe Tax as having “no nexus monitoring,” which is false.
 
@@ -32,13 +32,13 @@ Use Stripe Tax for any subscription, invoice, or Checkout Session where the user
 
 ## Three-step setup
 
-**If you have execution access** (MCP tools or the Stripe CLI with a valid token), read the account’s current Tax Settings first — the [Tax Settings API](https://docs.stripe.com/api/tax/settings.md) or Dashboard → Tax → Settings — before you change anything below. Don’t overwrite an existing head office address or preset tax code.
+**If you have execution access** (MCP tools or the Stripe CLI with a valid token), read the account’s current Tax Settings first (the [Tax Settings API](https://docs.stripe.com/api/tax/settings.md) or go to the Dashboard > **Tax** > **Settings**) before you change anything below. Don’t overwrite an existing head office address or preset tax code.
 
-1. Set a head office address in Tax Settings (Dashboard → Tax → Settings). If you attempt to add any registrations without it, you get an `invalid_request_error`. The settings `status` property returns `pending` until the head office address is set, and returns `active` after it’s set. `automatic_tax` won’t calculate tax while the status is `pending`.
-2. Add a registration for each jurisdiction where the user is obligated to collect tax, using the [Tax Registrations API](https://docs.stripe.com/api/tax/registrations.md) or the [Dashboard](https://docs.stripe.com/tax/registering.md). After you add it, point the user to [threshold and nexus monitoring](https://docs.stripe.com/undefined.md#threshold-and-nexus-monitoring) so they know when to register in other jurisdictions. Don’t limit the conversation to the jurisdiction you just registered.
+1. Set a head office address in Tax Settings (Dashboard > Tax > Settings). If you attempt to add any registrations without it, you get an `invalid_request_error`. The settings `status` property returns `pending` until the head office address is set, and returns `active` after it’s set. `automatic_tax` won’t calculate tax while the status is `pending`.
+2. Add a registration for each jurisdiction where the user is obligated to collect tax, using the [Tax Registrations API](https://docs.stripe.com/api/tax/registrations.md) or the [Dashboard](https://docs.stripe.com/tax/registering.md). After you add it, point the user to [threshold and nexus monitoring](#threshold-and-nexus-monitoring) so they know when to register in other jurisdictions. Don’t limit the conversation to the jurisdiction you just registered.
 3. Pass `automatic_tax: { enabled: true }` on the [Subscription](https://docs.stripe.com/api/subscriptions.md), [Invoice](https://docs.stripe.com/api/invoices.md), or [Checkout Session](https://docs.stripe.com/api/checkout/sessions.md) object.
 
-**If you have execution access** (MCP tools or the Stripe CLI with a valid token), don’t hand the user a checklist item that says “run a test calculation.” Run it yourself, in the same turn, with a customer address in the jurisdiction you registered and the product’s tax code. See [Verify before you trust automatic tax](https://docs.stripe.com/undefined.md#verify-before-you-trust-automatic-tax).
+**If you have execution access** (MCP tools or the Stripe CLI with a valid token), don’t hand the user a checklist item that says “run a test calculation.” Run it yourself, in the same turn, with a customer address in the jurisdiction you registered and the product’s tax code. See [Verify before you trust automatic tax](#verify-before-you-trust-automatic-tax).
 
 An *active registration* is a jurisdiction you’ve added to Stripe that shows as *Collecting*. It’s per-jurisdiction, and not the same as having a Stripe account.
 
@@ -54,7 +54,7 @@ After enabling `automatic_tax`, don’t assume the setup is complete: tax is onl
 
 **If you have execution access** (MCP tools or the Stripe CLI with a valid token), run a test [Tax Calculation](https://docs.stripe.com/api/tax/calculations.md) with a customer address in the target jurisdiction and the product’s tax code. Check `tax_breakdown[].taxability_reason`, not the tax amount.
 
-- `not_collecting` means the setup is broken — a registration or tax code gap. Don’t tell the user their setup works. See [Diagnose zero tax](https://docs.stripe.com/undefined.md#diagnose-zero-tax).
+- `not_collecting` means the setup is broken — a registration or tax code gap. Don’t tell the user their setup works. See [Diagnose zero tax](#diagnose-zero-tax).
 - Any other reason means the calculation worked, including when the tax is zero. Zero is *correct* for an exempt tax code or an exempt customer. Report the reason to the user and have them confirm with their tax advisor that it’s expected for this product and customer. Never swap in a different tax code to produce tax.
 - Run it in the same turn. Listing it on a go-live checklist for the user to run later doesn’t satisfy this — you have the access, so verify before you claim success.
 - If you only have read or advisory access, don’t claim it’s verified. Point the user to [Testing Stripe Tax](https://docs.stripe.com/tax/testing.md) to run the check themselves in a sandbox.
@@ -84,7 +84,7 @@ For all other `taxability_reason` values — `reverse_charge`, `customer_exempt`
 
 **Remediation order when `automatic_tax` collects zero tax:**
 
-1. Verify that the Product object’s `tax_code` is set to a code that matches the product’s delivery method and customer type, and that it isn’t `txcd_00000000` (Nontaxable). Use [Choosing a product tax code](https://docs.stripe.com/undefined.md#choosing-a-product-tax-code) rather than applying a generic SaaS code.
+1. Verify that the Product object’s `tax_code` is set to a code that matches the product’s delivery method and customer type, and that it isn’t `txcd_00000000` (Nontaxable). Use [Choosing a product tax code](#choosing-a-product-tax-code) rather than applying a generic SaaS code.
 2. Add a tax registration for the customer’s jurisdiction.
 3. Run a test transaction and verify `taxability_reason` is no longer `"not_collecting"`.
 
@@ -119,7 +119,9 @@ As soon as you know the liable entity:
 
 ## Threshold and nexus monitoring
 
-The [threshold monitoring](https://docs.stripe.com/tax/monitoring.md) tool highlights *potential* registration obligations in Dashboard → Tax → Locations → Needs attention. Stripe sends email and Dashboard alerts. The public guide documents those notification surfaces, so don’t promise a threshold-alert API or webhook. Monitoring doesn’t cover physical-presence obligations. Present it as information and tell the user to discuss it with their tax advisor. It’s up to the user to confirm whether registration is required. Don’t tell them they must register, and don’t recommend a universal percentage of a threshold as the point to register.
+**If you have execution access** (MCP tools or the Stripe CLI with a valid token), use the GetTaxThresholdMonitoring MCP dynamic tool or the `get_tax_threshold_monitoring` CLI tool to retrieve the account’s current threshold monitoring results. Report the relevant jurisdictions and when the results were computed, if that timestamp is available. If a jurisdiction is absent or its status is undetermined, say so rather than inferring an obligation.
+
+The [threshold monitoring](https://docs.stripe.com/tax/monitoring.md) tool highlights *potential* registration obligations in the Dashboard > **Tax** > **Locations** > **Needs attention**. Stripe sends email and Dashboard alerts. The public guide documents those notification methods, so don’t promise a threshold-alert API or webhook. Monitoring doesn’t cover physical-presence obligations. Present it as information and tell the user to discuss it with their tax advisor. It’s up to the user to confirm whether registration is required. Don’t tell them they must register, and don’t recommend a universal percentage of a threshold as the point to register.
 
 Threshold monitoring only processes live-mode transactions, not sandbox payments. Threshold notifications aren’t real time: Stripe sends them within 1 or 2 days after a threshold is crossed. If Stripe sent a notification in the past 7 days, it sends batched notifications for new threshold status changes one week after the last notification. Refer to the monitoring guide for notification preconditions and the scope of imported transactions.
 
@@ -133,15 +135,25 @@ Guide, don’t advise. Never tell a user where they must register or whether the
 
 **How to register.** Present the paths that fit the user and let them (with their tax advisor) choose. Don’t pick for them.
 
-- **Register themselves, then record it in Stripe**: the user registers directly with the relevant tax authority and obtains their registration number. Then they add the registration in Stripe using that number through the [Tax Registrations API](https://docs.stripe.com/api/tax/registrations.md) or Dashboard → Tax → Locations → Add registration. See [Register for tax](https://docs.stripe.com/tax/registering.md).
-- **Ask Stripe to register (US only)**: with Registration as a Service (“Register for me”), Stripe submits the registration to the tax authority and adds the completed registration to the Dashboard, so the user doesn’t record it separately. First, check [eligibility requirements](https://docs.stripe.com/tax/use-stripe-to-register.md#eligibility), and if the user qualifies, point them to Dashboard → Tax → Locations → Add registration → Register for me. See [Use Stripe to register](https://docs.stripe.com/tax/use-stripe-to-register.md).
-- **Register outside the US with Taxually**: Taxually can help businesses register with local tax authorities outside the United States. Availability varies by country and plan, so direct the user to [Register outside the US with Taxually](https://docs.stripe.com/tax/use-taxually-to-register.md) for current coverage.
+- **Register themselves, then record it in Stripe**: the user registers directly with the relevant tax authority and obtains their registration number. Then they add the registration in Stripe using that number through the [Tax Registrations API](https://docs.stripe.com/api/tax/registrations.md) or the Dashboard > **Tax** > **Locations** > **Add registration**. See [Register for tax](https://docs.stripe.com/tax/registering.md).
+
+- **Ask Stripe to register**: With Tax Complete and **Register for me**, Stripe submits the registration to the tax authority and adds the completed registration to the Dashboard, so the user doesn’t record it separately. Stripe supports the following:
+
+- Eligible US remote sellers
+
+- Canada’s simplified GST/HST registration for eligible non-resident businesses selling digital products or services to Canadian customers
+
+- EU Non-Union OSS registration through Ireland for eligible businesses established outside the EU with no EU fixed establishment that sell services to individual customers in the EU
+
+Check the [US eligibility requirements](https://docs.stripe.com/tax/use-stripe-to-register/united-states.md#eligibility) or [eligibility and signup steps outside the US](https://docs.stripe.com/tax/use-stripe-to-register/outside-united-states.md) before recommending this path. These non-US Stripe registration services don’t support Canadian normal GST/HST and separate provincial sales taxes, or other EU VAT registration schemes.
+
+- **Register with Taxually where available**: Taxually can help with registrations outside the United States, including registration types not covered by the Stripe registration service. Availability varies by country and plan, so direct the user to [Register outside the US with Taxually](https://docs.stripe.com/tax/use-taxually-to-register.md) for current coverage.
 
-**Reporting and filing.** Collecting with Stripe Tax doesn’t file a return by itself. Use [TaxJar filing](https://docs.stripe.com/tax/file-with-stripe.md) for US sales tax or [a filing partner](https://docs.stripe.com/tax/filing.md) where available. TaxJar requires Tax Complete and a US-based bank account. Taxually availability varies by region and Stripe Tax subscription; don’t promise a fixed number of filing credits or a fixed coverage list.
+**Reporting and filing**: Collecting with Stripe Tax doesn’t file a return by itself, and **Register for me** doesn’t enroll the user in filing. With Tax Complete, users can set up automated filing with Stripe for [US sales tax](https://docs.stripe.com/tax/file-with-stripe.md), [Canada’s simplified GST/HST and EU Non-Union OSS through Ireland](https://docs.stripe.com/tax/file-with-stripe-outside-us.md). US TaxJar filing requires a US-based bank account. Users can also use [a filing partner](https://docs.stripe.com/tax/filing.md) where available. Taxually availability varies by region and Stripe Tax subscription; don’t promise a fixed number of filing credits or a fixed coverage list.
 
 ## Testing considerations
 
-- Tax registrations in a sandbox are scoped to that sandbox. They don’t appear in live mode and must be re-created. Point the user to Dashboard → Tax → Locations in live mode to add registrations before processing real payments.
+- Tax registrations in a sandbox are scoped to that sandbox. They don’t appear in live mode and must be re-created. Point the user to the Dashboard > **Tax** > **Locations** in live mode to add registrations before processing real payments.
 - Tax Settings are separate for sandboxes. Configure Tax Settings in each sandbox you use, and verify live-mode settings separately before processing real payments.
 - Add live-mode registrations before the first real transaction. If a transaction occurs with no active tax registration, `automatic_tax` silently collects 0 tax, with no error or warning.
 - Sandbox transactions have no effect on threshold monitoring. Don’t infer live-mode threshold activity from sandbox activity.