@lakitu/sdk 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lakitu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -2,14 +2,75 @@
   <img src="assets/laki2-banner.jpeg" alt="Lakitu Banner" width="100%">
 </p>
 
-# Lakitu
+# @lakitu/sdk
 
-> AI agent runtime using **code execution**, not JSON tool calls.
+> Self-hosted AI agent framework for [Convex](https://convex.dev) + [E2B](https://e2b.dev) with **code execution**.
 
-Lakitu is an autonomous development environment that runs in an [E2B](https://e2b.dev) sandbox. The agent writes TypeScript code that imports from **KSAs** (Knowledge, Skills, and Abilities), which gets executed in the sandbox.
+Lakitu runs AI agents in secure E2B sandboxes where they write and execute TypeScript code. Instead of JSON tool calls, agents import from **KSAs** (Knowledge, Skills, and Abilities) — plain TypeScript modules.
+
+## Quick Start
+
+```bash
+# In your Convex project
+npx @lakitu/sdk init
+
+# Build your E2B sandbox template
+npx @lakitu/sdk build
+
+# Publish template to E2B
+npx @lakitu/sdk publish
+```
+
+## Installation
+
+```bash
+npm install @lakitu/sdk
+# or
+bun add @lakitu/sdk
+```
+
+## CLI Commands
+
+### `npx @lakitu/sdk init`
+
+Initialize Lakitu in your Convex project:
+
+```bash
+npx @lakitu/sdk init
+npx @lakitu/sdk init --dir ./convex  # Custom convex directory
+npx @lakitu/sdk init --skip-install  # Skip npm install
+```
+
+This creates:
+```
+convex/
+└── lakitu/
+    ├── config.ts      # Lakitu configuration
+    └── example.ts     # Example KSA to get started
+```
+
+### `npx @lakitu/sdk build`
+
+Build your E2B sandbox template with pre-deployed Convex functions:
+
+```bash
+npx @lakitu/sdk build           # Build both base + custom templates
+npx @lakitu/sdk build --base    # Build base template only
+npx @lakitu/sdk build --custom  # Build custom template only
+```
+
+### `npx @lakitu/sdk publish`
+
+Manage your E2B templates:
+
+```bash
+npx @lakitu/sdk publish
+```
 
 ## The Code Execution Model
 
+Traditional agents use JSON tool calls. Lakitu agents write code:
+
 ```
 Traditional Agent:          Lakitu Agent:
 ┌─────────────────┐         ┌─────────────────┐
@@ -28,52 +89,176 @@ Traditional Agent:          Lakitu Agent:
     └─────────┘              └───────────────┘
 ```
 
-**Why?** Token efficiency (no tool schemas), composability (chain operations in code), debuggability (read exactly what ran).
+**Why code execution?**
+- **Token efficient** — No tool schemas sent every request
+- **Composable** — Chain operations naturally in code
+- **Debuggable** — See exactly what code ran
+- **Model agnostic** — Any LLM that generates code works
 
-## KSAs (Knowledge, Skills, and Abilities)
+---
 
-KSAs are TypeScript modules the agent imports. They combine:
-- **Knowledge**: JSDoc documentation
-- **Skills**: Executable functions
-- **Abilities**: What the agent can accomplish
+## KSA SDK
 
-### Available KSAs
+KSAs (Knowledge, Skills, and Abilities) are capability modules that agents use via code execution. The SDK provides a type-safe builder API for defining KSAs.
 
-| Category | KSA | Functions |
-|----------|-----|-----------|
-| **System** | `file` | `read`, `write`, `edit`, `glob`, `grep`, `ls` |
-| | `browser` | `open`, `screenshot`, `click`, `type`, `getText` |
-| | `beads` | `create`, `update`, `close`, `list`, `getReady` |
-| | `pdf` | `generate` |
-| **Research** | `web` | `search`, `scrape`, `news` |
-| | `news` | `trending`, `monitorBrand`, `analyzeSentiment` |
-| | `social` | `tiktokProfile`, `instagramPosts`, `twitterPosts`, `searchSocial` |
-| **Data** | `companies` | `enrichDomain`, `searchCompanies`, `getTechStack` |
-| **Create** | `email` | `send`, `sendText`, `sendWithAttachment` |
+### Defining a KSA
+
+```typescript
+import { defineKSA, fn, service, primitive } from "@lakitu/sdk";
+
+export const myKSA = defineKSA("myKsa")
+  .description("Description of what this KSA does")
+  .category("skills")  // "core" | "skills" | "deliverables"
+  .group("research")   // Optional subcategory
+  .icon("mdi-search")  // Optional MDI icon
+
+  // Add functions
+  .fn("search", fn()
+    .description("Search for something")
+    .param("query", { type: "string", required: true })
+    .param("limit", { type: "number", default: 10 })
+    .returns<SearchResult[]>()
+    .impl(service("services.Search.internal.query")
+      .mapArgs(({ query, limit }) => ({ q: query, max: limit }))
+      .mapResult(r => r.results)
+    )
+  )
 
-### Example Agent Code
+  .fn("readFile", fn()
+    .description("Read a local file")
+    .param("path", { type: "string", required: true })
+    .impl(primitive("file.read"))
+  )
+
+  .build();
+```
+
+### SDK Exports
 
 ```typescript
-import { search, scrape } from './ksa/web';
-import { enrichDomain } from './ksa/companies';
-import { send } from './ksa/email';
-
-// Research a company
-const results = await search('Stripe payments company');
-const content = await scrape(results[0].url);
-
-// Enrich with company data
-const company = await enrichDomain('stripe.com');
-console.log(`${company.name}: ${company.industry}, ${company.employeeRange} employees`);
-
-// Send findings
-await send({
-  to: 'user@example.com',
-  subject: 'Company Research: Stripe',
-  text: `Industry: ${company.industry}\nEmployees: ${company.employeeRange}`
+import {
+  // Builders
+  defineKSA,     // Create a KSA definition
+  fn,            // Create a function definition
+  service,       // Service implementation (calls cloud Convex)
+  primitive,     // Primitive implementation (local sandbox ops)
+  composite,     // Composite implementation (chain operations)
+
+  // Registry utilities
+  createRegistry,
+  getFunction,
+
+  // Types
+  type KSADef,
+  type FunctionDef,
+  type ParamDef,
+  type Implementation,
+} from "@lakitu/sdk";
+```
+
+### Implementation Types
+
+#### Service Implementation
+Calls a Convex function via the cloud gateway:
+
+```typescript
+.impl(service("services.MyService.internal.action")
+  .mapArgs(({ input }) => ({ data: input }))  // Transform args
+  .mapResult(r => r.value)                     // Transform result
+)
+```
+
+#### Primitive Implementation
+Uses local sandbox capabilities (file, shell, browser):
+
+```typescript
+.impl(primitive("file.read"))
+.impl(primitive("shell.exec"))
+.impl(primitive("browser.screenshot"))
+```
+
+Available primitives:
+- `file.read`, `file.write`, `file.edit`, `file.glob`, `file.grep`, `file.ls`, `file.exists`, `file.stat`
+- `shell.exec`
+- `browser.open`, `browser.screenshot`, `browser.click`, `browser.type`, `browser.getHtml`, `browser.getText`, `browser.close`
+
+#### Composite Implementation
+Chain multiple operations:
+
+```typescript
+.impl(composite()
+  .call("file.read", { filePath: "./config.json" }, "config")
+  .call("myKsa.process", ctx => ({ data: ctx.vars.config }), "result")
+  .return(ctx => ctx.vars.result)
+)
+```
+
+### Parameter Types
+
+```typescript
+.param("name", { type: "string", required: true })
+.param("count", { type: "number", default: 10 })
+.param("enabled", { type: "boolean", default: false })
+.param("tags", { type: "array" })
+.param("options", { type: "object" })
+```
+
+---
+
+## Configuration
+
+After running `init`, configure Lakitu in `convex/lakitu/config.ts`:
+
+```typescript
+import { Lakitu } from "@lakitu/sdk";
+
+export default Lakitu.configure({
+  // E2B template name (build with: npx lakitu build)
+  template: "lakitu",
+
+  // Default model for agent
+  model: "anthropic/claude-sonnet-4-20250514",
+
+  // KSA modules to enable
+  ksas: [
+    // Built-in KSAs
+    "file",
+    "shell", 
+    "browser",
+    "beads",
+
+    // Custom KSAs
+    "./myCustomKsa",
+  ],
+
+  // Sandbox pool settings
+  pool: {
+    min: 0,
+    max: 5,
+    idleTimeout: 300_000,
+  },
 });
 ```
 
+---
+
+## Built-in KSAs
+
+| Category | KSA | Functions |
+|----------|-----|-----------|
+| **Core** | `file` | `read`, `write`, `edit`, `glob`, `grep`, `ls` |
+| | `shell` | `exec` |
+| | `browser` | `open`, `screenshot`, `click`, `type`, `getText` |
+| | `beads` | `create`, `update`, `close`, `list`, `getReady` |
+| **Skills** | `web` | `search`, `scrape` |
+| | `news` | `trending`, `search`, `analyze` |
+| | `social` | `tiktok`, `instagram`, `twitter`, `search` |
+| | `companies` | `enrich`, `search`, `techStack` |
+| **Deliverables** | `pdf` | `generate` |
+| | `email` | `send`, `sendBulk` |
+
+---
+
 ## Architecture
 
 ```
@@ -92,7 +277,7 @@ await send({
 │                                    ▼                                     │
 │  ┌─────────────────────────────────────────────────────────────────┐    │
 │  │                      CLOUD GATEWAY                               │    │
-│  │  HTTP → Convex Services (OpenRouter, APITube, ScrapeCreators)   │    │
+│  │  HTTP → Convex Services (OpenRouter, external APIs)              │    │
 │  └─────────────────────────────────────────────────────────────────┘    │
 │                                                                          │
 │  ┌─────────────────────────────────────────────────────────────────┐    │
@@ -102,65 +287,78 @@ await send({
 └─────────────────────────────────────────────────────────────────────────┘
 ```
 
-## Directory Structure
-
-```
-lakitu/
-├── ksa/                    # KSA modules (agent imports these)
-│   ├── _shared/            # Shared utilities
-│   │   └── gateway.ts      # Cloud gateway client
-│   ├── _templates/         # Templates for new KSAs
-│   ├── web.ts              # Web search & scraping
-│   ├── news.ts             # News research & monitoring
-│   ├── social.ts           # Social media scraping
-│   ├── companies.ts        # Company data enrichment
-│   ├── email.ts            # Email sending
-│   ├── file.ts             # File operations
-│   ├── browser.ts          # Browser automation
-│   ├── beads.ts            # Task tracking
-│   ├── pdf.ts              # PDF generation
-│   └── index.ts            # Discovery & exports
-│
-├── convex/                 # Convex backend
-│   ├── agent/              # Agent loop implementation
-│   │   └── codeExecLoop.ts # Code execution loop (no tool schemas)
-│   ├── actions/            # Convex actions
-│   │   └── codeExec.ts     # Code execution runtime
-│   ├── prompts/            # System prompts
-│   │   └── codeExec.ts     # KSA documentation for agent
-│   └── tools/              # LEGACY: Being removed
-│
-├── shared/                 # Shared types
-│   └── chain-of-thought.ts # Execution tracing
-│
-└── runtime/                # CLI commands for bash
-```
-
-## Adding New KSAs
-
-See `ksa/README.md` for detailed instructions. Quick steps:
-
-1. Copy template from `ksa/_templates/`
-2. Implement functions (use `callGateway()` for external services)
-3. Add to `ksa/index.ts` registry
-4. Document in system prompt (`convex/prompts/codeExec.ts`)
-
-## Scripts
-
-| Command | Description |
-|---------|-------------|
-| `bun dev` | Start local Convex dev server |
-| `bun deploy` | Deploy to Convex cloud |
-| `bun test` | Run unit tests |
-| `bun typecheck` | TypeScript type check |
-
-## Related Documentation
-
-- `CLAUDE.md` - Instructions for AI agents working on this codebase
-- `ksa/README.md` - KSA documentation and extension guide
-- `convex/prompts/codeExec.ts` - System prompt with KSA examples
+---
+
+## Example: Custom KSA
+
+Create `convex/lakitu/weather.ts`:
+
+```typescript
+import { defineKSA, fn, service } from "@lakitu/sdk";
+
+export const weatherKSA = defineKSA("weather")
+  .description("Weather data and forecasts")
+  .category("skills")
+  .group("data")
+
+  .fn("current", fn()
+    .description("Get current weather for a location")
+    .param("location", { type: "string", required: true, description: "City name or coordinates" })
+    .impl(service("services.Weather.internal.getCurrent"))
+  )
+
+  .fn("forecast", fn()
+    .description("Get weather forecast")
+    .param("location", { type: "string", required: true })
+    .param("days", { type: "number", default: 7 })
+    .impl(service("services.Weather.internal.getForecast"))
+  )
+
+  .build();
+
+export default weatherKSA;
+```
+
+The agent can then use it:
+
+```typescript
+import { current, forecast } from './ksa/weather';
+
+const weather = await current("San Francisco");
+console.log(`Current: ${weather.temp}°F, ${weather.condition}`);
+
+const nextWeek = await forecast("San Francisco", 7);
+for (const day of nextWeek) {
+  console.log(`${day.date}: ${day.high}°F / ${day.low}°F`);
+}
+```
+
+---
+
+## Environment Variables
+
+For `build` command:
+- `E2B_API_KEY` — Your E2B API key (or run `e2b auth login`)
+
+---
+
+## Requirements
+
+- [Convex](https://convex.dev) project
+- [E2B](https://e2b.dev) account (for sandbox hosting)
+- Node.js 18+ or Bun
+
+---
 
 ## Links
 
+- [npm package](https://www.npmjs.com/package/@lakitu/sdk)
+- [GitHub](https://github.com/shinyobjectz/lakitu)
 - [E2B Documentation](https://e2b.dev/docs)
 - [Convex Documentation](https://docs.convex.dev)
+
+---
+
+## License
+
+MIT

package/convex/cloud/workflows/sandboxConvex.ts

@@ -626,7 +626,9 @@ export const runConvexSandbox = internalAction({
                 maxTokens: configObj.maxTokens,
                 temperature: configObj.temperature,
                 gatewayConfig: {
-                    convexUrl: CLOUD_CONVEX_URL,
+                    // IMPORTANT: Use GATEWAY_URL (.convex.site) not CLOUD_CONVEX_URL (.convex.cloud)
+                    // HTTP actions are served from .convex.site, not .convex.cloud
+                    convexUrl: GATEWAY_URL,
                     jwt: sandboxJwt,
                 },
             };
@@ -652,7 +654,7 @@ export const runConvexSandbox = internalAction({
             }
 
             console.log(
-                `[sandboxConvex] Calling agent with gatewayConfig.convexUrl=${CLOUD_CONVEX_URL}, jwt length=${sandboxJwt.length}`,
+                `[sandboxConvex] Calling agent with gatewayConfig.convexUrl=${GATEWAY_URL}, jwt length=${sandboxJwt.length}`,
             );
 
             // Call the sandbox Convex to start the agent using Convex client

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakitu/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Self-hosted AI agent framework for Convex + E2B with code execution",
   "type": "module",
   "main": "./dist/sdk/index.js",
@@ -59,7 +59,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/project-social/lakitu"
+    "url": "https://github.com/shinyobjectz/lakitu"
   },
   "license": "MIT",
   "dependencies": {

package/convex/_generated/api.d.ts

@@ -1,45 +0,0 @@
-/* eslint-disable */
-/**
- * Generated `api` utility.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-import type {
-  ApiFromModules,
-  FilterApi,
-  FunctionReference,
-} from "convex/server";
-
-declare const fullApi: ApiFromModules<{}>;
-
-/**
- * A utility for referencing Convex functions in your app's public API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = api.myModule.myFunction;
- * ```
- */
-export declare const api: FilterApi<
-  typeof fullApi,
-  FunctionReference<any, "public">
->;
-
-/**
- * A utility for referencing Convex functions in your app's internal API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = internal.myModule.myFunction;
- * ```
- */
-export declare const internal: FilterApi<
-  typeof fullApi,
-  FunctionReference<any, "internal">
->;
-
-export declare const components: {};

package/convex/_generated/api.js

@@ -1,23 +0,0 @@
-/* eslint-disable */
-/**
- * Generated `api` utility.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-import { anyApi, componentsGeneric } from "convex/server";
-
-/**
- * A utility for referencing Convex functions in your app's API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = api.myModule.myFunction;
- * ```
- */
-export const api = anyApi;
-export const internal = anyApi;
-export const components = componentsGeneric();

package/convex/_generated/dataModel.d.ts

@@ -1,58 +0,0 @@
-/* eslint-disable */
-/**
- * Generated data model types.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-import { AnyDataModel } from "convex/server";
-import type { GenericId } from "convex/values";
-
-/**
- * No `schema.ts` file found!
- *
- * This generated code has permissive types like `Doc = any` because
- * Convex doesn't know your schema. If you'd like more type safety, see
- * https://docs.convex.dev/using/schemas for instructions on how to add a
- * schema file.
- *
- * After you change a schema, rerun codegen with `npx convex dev`.
- */
-
-/**
- * The names of all of your Convex tables.
- */
-export type TableNames = string;
-
-/**
- * The type of a document stored in Convex.
- */
-export type Doc = any;
-
-/**
- * An identifier for a document in Convex.
- *
- * Convex documents are uniquely identified by their `Id`, which is accessible
- * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
- *
- * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
- *
- * IDs are just strings at runtime, but this type can be used to distinguish them from other
- * strings when type checking.
- */
-export type Id<TableName extends TableNames = TableNames> =
-  GenericId<TableName>;
-
-/**
- * A type describing your Convex data model.
- *
- * This type includes information about what tables you have, the type of
- * documents stored in those tables, and the indexes defined on them.
- *
- * This type is used to parameterize methods like `queryGeneric` and
- * `mutationGeneric` to make them type-safe.
- */
-export type DataModel = AnyDataModel;

package/convex/_generated/server.d.ts

@@ -1,143 +0,0 @@
-/* eslint-disable */
-/**
- * Generated utilities for implementing server-side Convex query and mutation functions.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-import {
-  ActionBuilder,
-  HttpActionBuilder,
-  MutationBuilder,
-  QueryBuilder,
-  GenericActionCtx,
-  GenericMutationCtx,
-  GenericQueryCtx,
-  GenericDatabaseReader,
-  GenericDatabaseWriter,
-} from "convex/server";
-import type { DataModel } from "./dataModel.js";
-
-/**
- * Define a query in this Convex app's public API.
- *
- * This function will be allowed to read your Convex database and will be accessible from the client.
- *
- * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
- * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
- */
-export declare const query: QueryBuilder<DataModel, "public">;
-
-/**
- * Define a query that is only accessible from other Convex functions (but not from the client).
- *
- * This function will be allowed to read from your Convex database. It will not be accessible from the client.
- *
- * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
- * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
- */
-export declare const internalQuery: QueryBuilder<DataModel, "internal">;
-
-/**
- * Define a mutation in this Convex app's public API.
- *
- * This function will be allowed to modify your Convex database and will be accessible from the client.
- *
- * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
- * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
- */
-export declare const mutation: MutationBuilder<DataModel, "public">;
-
-/**
- * Define a mutation that is only accessible from other Convex functions (but not from the client).
- *
- * This function will be allowed to modify your Convex database. It will not be accessible from the client.
- *
- * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
- * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
- */
-export declare const internalMutation: MutationBuilder<DataModel, "internal">;
-
-/**
- * Define an action in this Convex app's public API.
- *
- * An action is a function which can execute any JavaScript code, including non-deterministic
- * code and code with side-effects, like calling third-party services.
- * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
- * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
- *
- * @param func - The action. It receives an {@link ActionCtx} as its first argument.
- * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
- */
-export declare const action: ActionBuilder<DataModel, "public">;
-
-/**
- * Define an action that is only accessible from other Convex functions (but not from the client).
- *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
- * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
- */
-export declare const internalAction: ActionBuilder<DataModel, "internal">;
-
-/**
- * Define an HTTP action.
- *
- * The wrapped function will be used to respond to HTTP requests received
- * by a Convex deployment if the requests matches the path and method where
- * this action is routed. Be sure to route your httpAction in `convex/http.js`.
- *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument
- * and a Fetch API `Request` object as its second.
- * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
- */
-export declare const httpAction: HttpActionBuilder;
-
-/**
- * A set of services for use within Convex query functions.
- *
- * The query context is passed as the first argument to any Convex query
- * function run on the server.
- *
- * This differs from the {@link MutationCtx} because all of the services are
- * read-only.
- */
-export type QueryCtx = GenericQueryCtx<DataModel>;
-
-/**
- * A set of services for use within Convex mutation functions.
- *
- * The mutation context is passed as the first argument to any Convex mutation
- * function run on the server.
- */
-export type MutationCtx = GenericMutationCtx<DataModel>;
-
-/**
- * A set of services for use within Convex action functions.
- *
- * The action context is passed as the first argument to any Convex action
- * function run on the server.
- */
-export type ActionCtx = GenericActionCtx<DataModel>;
-
-/**
- * An interface to read from the database within Convex query functions.
- *
- * The two entry points are {@link DatabaseReader.get}, which fetches a single
- * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
- * building a query.
- */
-export type DatabaseReader = GenericDatabaseReader<DataModel>;
-
-/**
- * An interface to read from and write to the database within Convex mutation
- * functions.
- *
- * Convex guarantees that all writes within a single mutation are
- * executed atomically, so you never have to worry about partial writes leaving
- * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
- * for the guarantees Convex provides your functions.
- */
-export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/convex/_generated/server.js

@@ -1,93 +0,0 @@
-/* eslint-disable */
-/**
- * Generated utilities for implementing server-side Convex query and mutation functions.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-import {
-  actionGeneric,
-  httpActionGeneric,
-  queryGeneric,
-  mutationGeneric,
-  internalActionGeneric,
-  internalMutationGeneric,
-  internalQueryGeneric,
-} from "convex/server";
-
-/**
- * Define a query in this Convex app's public API.
- *
- * This function will be allowed to read your Convex database and will be accessible from the client.
- *
- * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
- * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
- */
-export const query = queryGeneric;
-
-/**
- * Define a query that is only accessible from other Convex functions (but not from the client).
- *
- * This function will be allowed to read from your Convex database. It will not be accessible from the client.
- *
- * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
- * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
- */
-export const internalQuery = internalQueryGeneric;
-
-/**
- * Define a mutation in this Convex app's public API.
- *
- * This function will be allowed to modify your Convex database and will be accessible from the client.
- *
- * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
- * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
- */
-export const mutation = mutationGeneric;
-
-/**
- * Define a mutation that is only accessible from other Convex functions (but not from the client).
- *
- * This function will be allowed to modify your Convex database. It will not be accessible from the client.
- *
- * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
- * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
- */
-export const internalMutation = internalMutationGeneric;
-
-/**
- * Define an action in this Convex app's public API.
- *
- * An action is a function which can execute any JavaScript code, including non-deterministic
- * code and code with side-effects, like calling third-party services.
- * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
- * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
- *
- * @param func - The action. It receives an {@link ActionCtx} as its first argument.
- * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
- */
-export const action = actionGeneric;
-
-/**
- * Define an action that is only accessible from other Convex functions (but not from the client).
- *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
- * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
- */
-export const internalAction = internalActionGeneric;
-
-/**
- * Define an HTTP action.
- *
- * The wrapped function will be used to respond to HTTP requests received
- * by a Convex deployment if the requests matches the path and method where
- * this action is routed. Be sure to route your httpAction in `convex/http.js`.
- *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument
- * and a Fetch API `Request` object as its second.
- * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
- */
-export const httpAction = httpActionGeneric;