convex-vapi 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,437 @@
+# convex-vapi
+
+Sync Vapi voice AI calls into your Convex database reactively, and place
+outbound calls directly from Convex functions.
+
+[![npm version](https://img.shields.io/npm/v/convex-vapi)](https://www.npmjs.com/package/convex-vapi)
+[![Convex Component](https://www.convex.dev/components/badge/sholajegede/convex-vapi)](https://www.convex.dev/components/sholajegede/convex-vapi)
+[![npm downloads](https://img.shields.io/npm/dw/convex-vapi)](https://www.npmjs.com/package/convex-vapi)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue)](./LICENSE)
+
+```ts
+const vapi = new Vapi(components.convexVapi, {
+  apiKey: process.env.VAPI_API_KEY!,
+  webhookSecret: process.env.VAPI_WEBHOOK_SECRET!,
+});
+
+// Place a call and get the result back immediately — no waiting on the webhook
+const { callId } = await vapi.createCall(ctx, {
+  assistantId,
+  phoneNumberId,
+  customerNumber,
+});
+
+// Stays live from here — status, transcript, summary, and cost all update
+// reactively as Vapi's webhooks arrive, including from a call ended outside
+// your app, like one you hung up from Vapi's own dashboard
+const call = useQuery(api.example.getCall, { callId });
+```
+
+<!-- START: Include on https://convex.dev/components -->
+
+## What this does
+
+`convex-vapi` gives your Convex app a live, queryable record of Vapi voice AI
+calls, kept up to date by Vapi's server-URL webhooks, plus a small set of
+actions for placing and inspecting calls:
+
+- **Reactive call tracking** — every `status-update` and `end-of-call-report`
+  webhook event updates a Convex row, so `useQuery` in your React app re-renders
+  as a call rings, connects, and ends, complete with transcript, summary, and
+  recording once available.
+- **Place outbound calls** — call `createCall` from a Convex action to start a
+  phone call through a Vapi assistant.
+- **Non-destructive merges** — a sparser event (e.g. a mid-call status update)
+  never overwrites richer data an earlier event already recorded (e.g. a
+  transcript from the final report).
+- **Secret-verified webhooks** — every inbound webhook is checked against Vapi's
+  `X-Vapi-Secret` header with a constant-time comparison before anything is
+  written.
+
+This is a [Convex component](https://convex.dev/components): its `calls` and
+`webhookEvents` tables live in an isolated schema, not your app's schema, and
+are only reachable through the functions this component exposes.
+
+## Table of Contents
+
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [Setup](#setup)
+- [Usage](#usage)
+- [API Reference](#api-reference)
+- [Type Reference](#type-reference)
+- [Webhook Events](#webhook-events)
+- [Database Schema](#database-schema)
+- [Authentication](#authentication)
+- [Example App](#example-app)
+- [Testing](#testing)
+- [Limitations](#limitations)
+- [Troubleshooting](#troubleshooting)
+- [Contributing](#contributing)
+- [Changelog](#changelog)
+
+## Install
+
+```sh
+npm install convex-vapi
+```
+
+## Quick Start
+
+### 1. Add the component
+
+```ts
+// convex/convex.config.ts
+import { defineApp } from "convex/server";
+import convexVapi from "convex-vapi/convex.config";
+
+const app = defineApp();
+app.use(convexVapi);
+
+export default app;
+```
+
+### 2. Set environment variables
+
+```sh
+npx convex env set VAPI_API_KEY your-private-api-key
+npx convex env set VAPI_WEBHOOK_SECRET whsec_...
+```
+
+`VAPI_API_KEY` is your private key from the Vapi dashboard (Settings → API
+Keys). `VAPI_WEBHOOK_SECRET` is a secret string you choose yourself — you'll
+configure the same value on the assistant in step 4.
+
+### 3. Mount the webhook handler
+
+```ts
+// convex/http.ts
+import { httpRouter } from "convex/server";
+import { components } from "./_generated/api";
+import { Vapi } from "convex-vapi";
+
+const vapi = new Vapi(components.convexVapi, {
+  apiKey: process.env.VAPI_API_KEY!,
+  webhookSecret: process.env.VAPI_WEBHOOK_SECRET!,
+});
+
+const http = httpRouter();
+
+http.route({
+  path: "/webhooks/vapi",
+  method: "POST",
+  handler: vapi.webhookHandler,
+});
+
+export default http;
+```
+
+### 4. Configure the webhook on your assistant
+
+Set the assistant's `serverUrl` to
+`https://<your-deployment>.convex.site/webhooks/vapi` and its `server.secret` to
+the same value as `VAPI_WEBHOOK_SECRET`, either in the Vapi dashboard or via the
+API:
+
+```sh
+curl -X PATCH https://api.vapi.ai/assistant/<assistant-id> \
+  -H "Authorization: Bearer $VAPI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"serverUrl": "https://<your-deployment>.convex.site/webhooks/vapi", "server": {"secret": "whsec_..."}}'
+```
+
+### 5. Initialize the client
+
+```ts
+// convex/example.ts
+import { action, query } from "./_generated/server";
+import { components } from "./_generated/api";
+import { Vapi } from "convex-vapi";
+import { v } from "convex/values";
+
+const vapi = new Vapi(components.convexVapi, {
+  apiKey: process.env.VAPI_API_KEY!,
+  webhookSecret: process.env.VAPI_WEBHOOK_SECRET!,
+});
+
+export const listCallsByAssistant = query({
+  args: { assistantId: v.string() },
+  handler: async (ctx, args) => {
+    return await vapi.listCallsByAssistant(ctx, args);
+  },
+});
+```
+
+## Setup
+
+The component needs no schema changes in your app — its tables (`calls`,
+`webhookEvents`) live entirely inside the component's own isolated schema. All
+you need is the webhook mounted (step 3) and secret configured (step 4), plus a
+`Vapi` client instance wherever you call its methods.
+
+Assistants and phone numbers are managed entirely in the Vapi dashboard or API —
+this component tracks calls, not the assistants that make them.
+
+## Usage
+
+### Place an outbound call
+
+```ts
+export const dial = action({
+  args: {
+    assistantId: v.string(),
+    phoneNumberId: v.string(),
+    customerNumber: v.string(),
+  },
+  handler: async (ctx, args) => {
+    return await vapi.createCall(ctx, args);
+  },
+});
+```
+
+Returns `{ callId, status }` and immediately records the call in Convex — you
+don't have to wait for the first webhook to see it in a query.
+
+### Refresh a call on demand
+
+```ts
+export const sync = action({
+  args: { callId: v.string() },
+  handler: async (ctx, args) => {
+    await vapi.refreshCall(ctx, args);
+    return null;
+  },
+});
+```
+
+Fetches the call directly from the Vapi API and re-records it — useful as a
+fallback if a webhook delivery was missed, or to pull in the
+transcript/recording immediately after a call ends without waiting on the
+webhook queue.
+
+### Read calls reactively
+
+```tsx
+const calls = useQuery(api.example.listCallsByAssistant, {
+  assistantId: "assistant_...",
+});
+```
+
+Every `status-update` and `end-of-call-report` webhook event patches a row, so
+this query re-renders live as a call progresses from `queued` through `ringing`,
+`in-progress`, and `ended` — no polling.
+
+## API Reference
+
+### Actions (need `ctx` from an action)
+
+| Method                                                            | Description                                                                                                                         |
+| ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `createCall(ctx, { assistantId, phoneNumberId, customerNumber })` | Places an outbound call via the REST API and records it. Returns `{ callId, status }`.                                              |
+| `refreshCall(ctx, { callId })`                                    | Re-fetches a call from the Vapi API and re-records its current state, including transcript/summary/recording if the call has ended. |
+
+### Queries (work from actions, queries, or mutations)
+
+| Method                                               | Description                                                                                                                                   |
+| ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
+| `getCall(ctx, { callId })`                           | Fetch one call by its Vapi call id.                                                                                                           |
+| `listCallsByAssistant(ctx, { assistantId, limit? })` | Most recently updated calls for an assistant, newest first.                                                                                   |
+| `getStats(ctx)`                                      | Aggregate counts across every call and webhook event this deployment has recorded: `{ callCount, endedCount, liveCount, webhookEventCount }`. |
+| `listRecentCalls(ctx, { limit? })`                   | Most recently updated calls across every assistant, newest first.                                                                             |
+| `listRecentWebhookEvents(ctx, { limit? })`           | Most recent webhook deliveries across every call, newest first.                                                                               |
+
+### Webhook
+
+| Property         | Description                                                                                                                                    |
+| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| `webhookHandler` | An `httpAction` that verifies, deduplicates, and processes `status-update` and `end-of-call-report` webhook deliveries. Mount it at any route. |
+
+## Type Reference
+
+```ts
+type VapiOptions = {
+  apiKey: string; // private API key from the Vapi dashboard
+  webhookSecret: string; // matches the assistant's server.secret
+};
+
+type CreateCallArgs = {
+  assistantId: string;
+  phoneNumberId: string;
+  customerNumber: string; // E.164 format, e.g. "+11231231234"
+};
+
+type Call = {
+  callId: string;
+  assistantId?: string;
+  phoneNumberId?: string;
+  customerNumber?: string;
+  status: string; // "queued" | "ringing" | "in-progress" | "forwarding" | "ended" | ...
+  endedReason?: string;
+  transcript?: string;
+  summary?: string;
+  recordingUrl?: string;
+  cost?: number;
+  startedAt?: number;
+  endedAt?: number;
+  createdAt: number;
+  updatedAt: number;
+};
+```
+
+## Webhook Events
+
+The webhook handler processes two of Vapi's server message types (all others are
+recorded for idempotency but otherwise ignored — see Limitations):
+
+- **`status-update`** — updates the call's `status` field (`queued`, `ringing`,
+  `in-progress`, `forwarding`, `ended`, ...) as the call progresses.
+- **`end-of-call-report`** — the final summary sent once a call ends; records
+  `endedReason`, `transcript`, `summary`, `recordingUrl`, and `cost`.
+
+Every request is checked against the `X-Vapi-Secret` header with a constant-time
+comparison against your configured `webhookSecret` before anything is written.
+Vapi does not include a per-delivery id in its webhook headers, so duplicate
+detection here hashes the raw request body with SHA-256 — an identical payload
+delivered twice is treated as a duplicate and skipped.
+
+Calls are recorded with a merge, not a blind overwrite: fields missing from the
+current event (e.g. `transcript` on a mid-call `status-update`) fall back to
+whatever was already stored, so a later, sparser event can never blank out data
+an earlier, richer one recorded.
+
+## Database Schema
+
+```ts
+calls: {
+  callId: string;           // indexed: by_callId
+  assistantId?: string;     // indexed: by_assistantId
+  phoneNumberId?: string;
+  customerNumber?: string;
+  status: string;
+  endedReason?: string;
+  transcript?: string;
+  summary?: string;
+  recordingUrl?: string;
+  cost?: number;
+  startedAt?: number;
+  endedAt?: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+webhookEvents: {
+  eventId: string;   // indexed: by_eventId — SHA-256 hex of the raw payload
+  eventType: string; // message.type
+  callId?: string;
+  payload: string;   // raw JSON body, for auditing/replay
+  receivedAt: number;
+}
+```
+
+This schema lives entirely inside the component's isolated namespace — it will
+never collide with tables in your app's own `convex/schema.ts`.
+
+## Authentication
+
+Vapi supports several ways to authenticate outgoing webhook requests. This
+component implements the original and simplest one: a shared secret you set on
+the assistant's `server.secret` field, which Vapi echoes back verbatim in the
+`X-Vapi-Secret` header on every request — verified here with a constant-time
+string comparison. Vapi's newer configurable-HMAC system (a separate Custom
+Credential resource with a selectable algorithm and signature header) is not
+implemented, since it requires provisioning that Credential outside of the
+assistant's own configuration; if you need it, verify the signature yourself
+before the request reaches this component's `webhookHandler`.
+
+## Example App
+
+The `example/` app is a full interactive demo, not just a form:
+
+- **Calls** — place a call (with a live-updating list for that assistant,
+  reactively reflected the instant the action call returns — no waiting on the
+  webhook), and a stats bar showing total/live/ended calls plus webhook
+  deliveries, visible from every tab.
+- **Webhooks** — a live, expandable feed of every raw delivery to
+  `/webhooks/vapi`, so you can watch signature verification and deduplication
+  happen in real time.
+- **History** — every call this component has ever recorded, newest first,
+  across every assistant, with status, cost, duration, and an expandable
+  transcript.
+- A sidebar **Activity** console logging every action call this demo makes, with
+  its result or error.
+
+Run it from the repo root (not `example/`):
+
+```sh
+npm install --legacy-peer-deps
+npx convex env set VAPI_API_KEY your-private-api-key
+npx convex env set VAPI_WEBHOOK_SECRET whsec_...
+npm run dev
+```
+
+Then point a test assistant's `serverUrl` at
+`https://<your-dev-deployment>.convex.site/webhooks/vapi` (see
+[Quick Start](#quick-start)) to see live deliveries land in the Webhooks tab.
+
+## Testing
+
+```sh
+npm run test
+npm run typecheck
+```
+
+Tests use [`convex-test`](https://www.npmjs.com/package/convex-test) and cover
+`recordCall`'s merge-on-upsert behavior (confirming a sparser later event never
+blanks a richer earlier one, and that a late, out-of-order `status-update` can
+never regress a call back out of `ended`), `listCallsByAssistant` scoping by
+assistant, webhook idempotency via `checkAndRecordEvent`, and the dashboard
+queries (`getStats`, `listRecentCalls`, `listRecentWebhookEvents`) used by the
+example app.
+
+## Limitations
+
+- Only `status-update` and `end-of-call-report` message types update the `calls`
+  table. `transcript` (partial live captions), `conversation-update`,
+  `speech-update`, `tool-calls`, and other real-time message types are accepted
+  (and recorded in `webhookEvents` for auditing) but not persisted to `calls` —
+  storing every partial transcript chunk would be high-volume and is better
+  handled with your own streaming UI if you need live captions.
+- Assistant and phone number management (creating, updating, or listing
+  assistants) is out of scope — this component tracks calls, not the resources
+  that place them.
+- Live in-call control (e.g. programmatically ending an active call, or
+  transferring it) is not implemented; only `createCall` (start) and
+  `refreshCall` (poll) are provided.
+- Rate limits are Vapi's own — this component does not implement its own rate
+  limiting or backoff.
+
+## Troubleshooting
+
+**Webhook returns 401** — the `X-Vapi-Secret` header didn't match. Confirm the
+assistant's `server.secret` field is set to exactly the same value as
+`VAPI_WEBHOOK_SECRET` (a `PATCH /assistant/{id}` call, or the dashboard's
+assistant settings, both work).
+
+**Webhook returns 400 "Missing X-Vapi-Secret header"** — the assistant's
+`serverUrl` is set but `server.secret` isn't configured, so Vapi isn't sending
+the header at all.
+
+**Calls never appear in queries** — confirm the assistant's `serverUrl` points
+at your deployment's `.convex.site` domain (not `.convex.cloud`), and that it's
+reachable publicly (Convex HTTP actions are public by default, so this is
+usually a typo in the URL).
+
+**Transcript/summary are missing after a call ends** — these only arrive with
+the `end-of-call-report` message, sent shortly after the call ends; call
+`refreshCall` if you need them sooner than the webhook arrives, or if a delivery
+was dropped.
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md).
+
+<!-- END: Include on https://convex.dev/components -->

package/dist/client/_generated/_ignore.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=_ignore.d.ts.map

package/dist/client/_generated/_ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ignore.d.ts","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":""}

package/dist/client/_generated/_ignore.js

@@ -0,0 +1,3 @@
+"use strict";
+// This is only here so convex-test can detect a _generated folder
+//# sourceMappingURL=_ignore.js.map

package/dist/client/_generated/_ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ignore.js","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":";AAAA,kEAAkE"}