@convex-dev/agent 0.2.12 → 0.3.1

package/src/client/types.ts

@@ -22,19 +22,12 @@ import type {
   generateObject,
 } from "ai";
 import type {
-  Auth,
-  Expand,
-  FunctionArgs,
-  FunctionReference,
-  FunctionReturnType,
   GenericActionCtx,
   GenericDataModel,
-  StorageActionWriter,
-  StorageReader,
+  GenericMutationCtx,
+  GenericQueryCtx,
   WithoutSystemFields,
 } from "convex/server";
-import type { GenericId } from "convex/values";
-import type { api } from "../component/_generated/api.js";
 import type {
   MessageDoc,
   ProviderMetadata,
@@ -43,6 +36,7 @@ import type {
   ThreadDoc,
 } from "../validators.js";
 import type { StreamingOptions } from "./streaming.js";
+import type { ComponentApi } from "../component/_generated/component.js";
 
 export type AgentPrompt = {
   /**
@@ -331,7 +325,7 @@ export type RawRequestResponseHandler = (
   },
 ) => void | Promise<void>;
 
-export type AgentComponent = UseApi<typeof api>;
+export type AgentComponent = ComponentApi;
 
 export type TextArgs<
   AgentTools extends ToolSet,
@@ -620,54 +614,12 @@ export type SyncStreamsReturnValue =
   | undefined;
 
 /* Type utils follow */
-type RunQueryCtx = {
-  runQuery: <Query extends FunctionReference<"query", "internal">>(
-    query: Query,
-    args: FunctionArgs<Query>,
-  ) => Promise<FunctionReturnType<Query>>;
-};
-export type MutationCtx = RunQueryCtx & {
-  runMutation: <Mutation extends FunctionReference<"mutation", "internal">>(
-    mutation: Mutation,
-    args: FunctionArgs<Mutation>,
-  ) => Promise<FunctionReturnType<Mutation>>;
-};
-export type UserActionCtx = GenericActionCtx<GenericDataModel>;
-export type ActionCtx = MutationCtx & {
-  runAction<Action extends FunctionReference<"action", "internal">>(
-    action: Action,
-    args: FunctionArgs<Action>,
-  ): Promise<FunctionReturnType<Action>>;
-  auth: Auth;
-  storage: StorageActionWriter;
-};
-export type QueryCtx = RunQueryCtx & { storage: StorageReader };
-
-export type OpaqueIds<T> =
-  T extends GenericId<infer _T>
-    ? string
-    : T extends (infer U)[]
-      ? OpaqueIds<U>[]
-      : T extends ArrayBuffer
-        ? ArrayBuffer
-        : T extends object
-          ? { [K in keyof T]: OpaqueIds<T[K]> }
-          : T;
-
-export type UseApi<API> = Expand<{
-  [mod in keyof API]: API[mod] extends FunctionReference<
-    infer FType,
-    "public",
-    infer FArgs,
-    infer FReturnType,
-    infer FComponentPath
-  >
-    ? FunctionReference<
-        FType,
-        "internal",
-        OpaqueIds<FArgs>,
-        OpaqueIds<FReturnType>,
-        FComponentPath
-      >
-    : UseApi<API[mod]>;
-}>;
+export type QueryCtx = Pick<GenericQueryCtx<GenericDataModel>, "runQuery">;
+export type MutationCtx = Pick<
+  GenericMutationCtx<GenericDataModel>,
+  "runQuery" | "runMutation"
+>;
+export type ActionCtx = Pick<
+  GenericActionCtx<GenericDataModel>,
+  "runQuery" | "runMutation" | "runAction" | "storage" | "auth"
+>;

package/src/component/_generated/api.ts

@@ -0,0 +1,64 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type * as apiKeys from "../apiKeys.js";
+import type * as files from "../files.js";
+import type * as messages from "../messages.js";
+import type * as streams from "../streams.js";
+import type * as threads from "../threads.js";
+import type * as users from "../users.js";
+import type * as vector_index from "../vector/index.js";
+import type * as vector_tables from "../vector/tables.js";
+
+import type {
+  ApiFromModules,
+  FilterApi,
+  FunctionReference,
+} from "convex/server";
+import { anyApi, componentsGeneric } from "convex/server";
+
+const fullApi: ApiFromModules<{
+  apiKeys: typeof apiKeys;
+  files: typeof files;
+  messages: typeof messages;
+  streams: typeof streams;
+  threads: typeof threads;
+  users: typeof users;
+  "vector/index": typeof vector_index;
+  "vector/tables": typeof vector_tables;
+}> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "public">
+> = anyApi as any;
+
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal: FilterApi<
+  typeof fullApi,
+  FunctionReference<any, "internal">
+> = anyApi as any;
+
+export const components = componentsGeneric() as unknown as {};