@o-zakstam/voltagent-convex 1.1.1 → 1.1.3

package/dist/component/schema.d.ts

@@ -0,0 +1,535 @@
+declare const _default: import("convex/server").SchemaDefinition<{
+    conversations: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        title: string;
+        userId: string;
+        resourceId: string;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, any>;
+        visibleId: string;
+    }, {
+        visibleId: import("convex/values").VString<string, "required">;
+        resourceId: import("convex/values").VString<string, "required">;
+        userId: import("convex/values").VString<string, "required">;
+        title: import("convex/values").VString<string, "required">;
+        metadata: import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>;
+        createdAt: import("convex/values").VString<string, "required">;
+        updatedAt: import("convex/values").VString<string, "required">;
+    }, "required", "title" | "userId" | "resourceId" | "createdAt" | "updatedAt" | "metadata" | `metadata.${string}` | "visibleId">, {
+        by_visible_id: ["visibleId", "_creationTime"];
+        by_user_id: ["userId", "_creationTime"];
+        by_resource_id: ["resourceId", "_creationTime"];
+        by_user_id_and_updated_at: ["userId", "updatedAt", "_creationTime"];
+    }, {}, {}>;
+    messages: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        metadata?: Record<string, any> | undefined;
+        userId: string;
+        createdAt: string;
+        parts: ({
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            text: string;
+            type: "text";
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            mimeType?: string | undefined;
+            type: "image";
+            image: string;
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            data: string;
+            type: "file";
+            mimeType: string;
+        } | {
+            providerExecuted?: boolean | undefined;
+            state?: "partial-call" | "call" | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            toolCallId: string;
+            type: "tool-call";
+            args: Record<string, any>;
+            toolName: string;
+        } | {
+            providerExecuted?: boolean | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            result?: any;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            isError?: boolean | undefined;
+            toolCallId: string;
+            type: "tool-result";
+            toolName: string;
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            signature?: string | undefined;
+            text: string;
+            type: "reasoning";
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            data: string;
+            type: "redacted-reasoning";
+        } | {
+            title?: string | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            url?: string | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            mediaType?: string | undefined;
+            id: string;
+            type: "source";
+            sourceType: "url" | "document";
+        })[];
+        conversationId: string;
+        role: string;
+        visibleId: string;
+    }, {
+        visibleId: import("convex/values").VString<string, "required">;
+        conversationId: import("convex/values").VString<string, "required">;
+        userId: import("convex/values").VString<string, "required">;
+        role: import("convex/values").VString<string, "required">;
+        parts: import("convex/values").VArray<({
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            text: string;
+            type: "text";
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            mimeType?: string | undefined;
+            type: "image";
+            image: string;
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            data: string;
+            type: "file";
+            mimeType: string;
+        } | {
+            providerExecuted?: boolean | undefined;
+            state?: "partial-call" | "call" | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            toolCallId: string;
+            type: "tool-call";
+            args: Record<string, any>;
+            toolName: string;
+        } | {
+            providerExecuted?: boolean | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            result?: any;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            isError?: boolean | undefined;
+            toolCallId: string;
+            type: "tool-result";
+            toolName: string;
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            signature?: string | undefined;
+            text: string;
+            type: "reasoning";
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            data: string;
+            type: "redacted-reasoning";
+        } | {
+            title?: string | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            url?: string | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            mediaType?: string | undefined;
+            id: string;
+            type: "source";
+            sourceType: "url" | "document";
+        })[], import("convex/values").VUnion<{
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            text: string;
+            type: "text";
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            mimeType?: string | undefined;
+            type: "image";
+            image: string;
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            data: string;
+            type: "file";
+            mimeType: string;
+        } | {
+            providerExecuted?: boolean | undefined;
+            state?: "partial-call" | "call" | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            toolCallId: string;
+            type: "tool-call";
+            args: Record<string, any>;
+            toolName: string;
+        } | {
+            providerExecuted?: boolean | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            result?: any;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            isError?: boolean | undefined;
+            toolCallId: string;
+            type: "tool-result";
+            toolName: string;
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            signature?: string | undefined;
+            text: string;
+            type: "reasoning";
+        } | {
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            data: string;
+            type: "redacted-reasoning";
+        } | {
+            title?: string | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            url?: string | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            mediaType?: string | undefined;
+            id: string;
+            type: "source";
+            sourceType: "url" | "document";
+        }, [import("convex/values").VObject<{
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            text: string;
+            type: "text";
+        }, {
+            type: import("convex/values").VLiteral<"text", "required">;
+            text: import("convex/values").VString<string, "required">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "text" | "type" | "providerOptions" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}`>, import("convex/values").VObject<{
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            mimeType?: string | undefined;
+            type: "image";
+            image: string;
+        }, {
+            type: import("convex/values").VLiteral<"image", "required">;
+            image: import("convex/values").VString<string, "required">;
+            mimeType: import("convex/values").VString<string | undefined, "optional">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "type" | "providerOptions" | "image" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "mimeType">, import("convex/values").VObject<{
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            data: string;
+            type: "file";
+            mimeType: string;
+        }, {
+            type: import("convex/values").VLiteral<"file", "required">;
+            data: import("convex/values").VString<string, "required">;
+            filename: import("convex/values").VString<string | undefined, "optional">;
+            mimeType: import("convex/values").VString<string, "required">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "data" | "type" | "providerOptions" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "mimeType" | "filename">, import("convex/values").VObject<{
+            providerExecuted?: boolean | undefined;
+            state?: "partial-call" | "call" | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            toolCallId: string;
+            type: "tool-call";
+            args: Record<string, any>;
+            toolName: string;
+        }, {
+            type: import("convex/values").VLiteral<"tool-call", "required">;
+            toolCallId: import("convex/values").VString<string, "required">;
+            toolName: import("convex/values").VString<string, "required">;
+            args: import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>;
+            state: import("convex/values").VUnion<"partial-call" | "call" | undefined, [import("convex/values").VLiteral<"partial-call", "required">, import("convex/values").VLiteral<"call", "required">], "optional", never>;
+            providerExecuted: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "toolCallId" | "providerExecuted" | "state" | "type" | "providerOptions" | "args" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "toolName" | `args.${string}`>, import("convex/values").VObject<{
+            providerExecuted?: boolean | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            result?: any;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            isError?: boolean | undefined;
+            toolCallId: string;
+            type: "tool-result";
+            toolName: string;
+        }, {
+            type: import("convex/values").VLiteral<"tool-result", "required">;
+            toolCallId: import("convex/values").VString<string, "required">;
+            toolName: import("convex/values").VString<string, "required">;
+            result: import("convex/values").VAny<any, "optional", string>;
+            isError: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            providerExecuted: import("convex/values").VBoolean<boolean | undefined, "optional">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "toolCallId" | "providerExecuted" | "type" | "providerOptions" | "result" | `result.${string}` | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "toolName" | "isError">, import("convex/values").VObject<{
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            signature?: string | undefined;
+            text: string;
+            type: "reasoning";
+        }, {
+            type: import("convex/values").VLiteral<"reasoning", "required">;
+            text: import("convex/values").VString<string, "required">;
+            signature: import("convex/values").VString<string | undefined, "optional">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "text" | "type" | "providerOptions" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "signature">, import("convex/values").VObject<{
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            data: string;
+            type: "redacted-reasoning";
+        }, {
+            type: import("convex/values").VLiteral<"redacted-reasoning", "required">;
+            data: import("convex/values").VString<string, "required">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "data" | "type" | "providerOptions" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}`>, import("convex/values").VObject<{
+            title?: string | undefined;
+            providerOptions?: Record<string, Record<string, any>> | undefined;
+            url?: string | undefined;
+            providerMetadata?: Record<string, Record<string, any>> | undefined;
+            filename?: string | undefined;
+            mediaType?: string | undefined;
+            id: string;
+            type: "source";
+            sourceType: "url" | "document";
+        }, {
+            type: import("convex/values").VLiteral<"source", "required">;
+            sourceType: import("convex/values").VUnion<"url" | "document", [import("convex/values").VLiteral<"url", "required">, import("convex/values").VLiteral<"document", "required">], "required", never>;
+            id: import("convex/values").VString<string, "required">;
+            url: import("convex/values").VString<string | undefined, "optional">;
+            title: import("convex/values").VString<string | undefined, "optional">;
+            mediaType: import("convex/values").VString<string | undefined, "optional">;
+            filename: import("convex/values").VString<string | undefined, "optional">;
+            providerOptions: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+            providerMetadata: import("convex/values").VRecord<Record<string, Record<string, any>> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VRecord<Record<string, any>, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "required", string>, "optional", string>;
+        }, "required", "id" | "title" | "type" | "providerOptions" | "url" | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "filename" | "sourceType" | "mediaType">], "required", "id" | "data" | "text" | "toolCallId" | "title" | "providerExecuted" | "state" | "type" | "providerOptions" | "args" | "image" | "url" | "result" | `result.${string}` | "providerMetadata" | `providerOptions.${string}` | `providerMetadata.${string}` | "mimeType" | "filename" | "toolName" | `args.${string}` | "isError" | "signature" | "sourceType" | "mediaType">, "required">;
+        metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "optional", string>;
+        createdAt: import("convex/values").VString<string, "required">;
+    }, "required", "userId" | "createdAt" | "metadata" | "parts" | "conversationId" | "role" | `metadata.${string}` | "visibleId">, {
+        by_conversation_id: ["conversationId", "_creationTime"];
+        by_conversation_id_and_created_at: ["conversationId", "createdAt", "_creationTime"];
+        by_conversation_id_and_user_id: ["conversationId", "userId", "_creationTime"];
+        by_user_id: ["userId", "_creationTime"];
+        by_visible_id: ["visibleId", "_creationTime"];
+    }, {}, {}>;
+    users: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        metadata?: Record<string, any> | undefined;
+        createdAt: string;
+        updatedAt: string;
+        visibleId: string;
+    }, {
+        visibleId: import("convex/values").VString<string, "required">;
+        metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "optional", string>;
+        createdAt: import("convex/values").VString<string, "required">;
+        updatedAt: import("convex/values").VString<string, "required">;
+    }, "required", "createdAt" | "updatedAt" | "metadata" | `metadata.${string}` | "visibleId">, {
+        by_visible_id: ["visibleId", "_creationTime"];
+    }, {}, {}>;
+    workflowStates: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        input?: any;
+        output?: any;
+        userId?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+        conversationId?: string | undefined;
+        context?: any[][] | undefined;
+        suspension?: {
+            reason?: string | undefined;
+            suspendedStepIndex?: number | undefined;
+            lastEventSequence?: number | undefined;
+            suspendData?: any;
+            checkpoint?: {
+                stepExecutionState?: any;
+                completedStepsData?: any[] | undefined;
+            } | undefined;
+            suspendedAt: string;
+        } | undefined;
+        events?: {
+            input?: any;
+            output?: any;
+            status?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            context?: Record<string, any> | undefined;
+            from?: string | undefined;
+            name?: string | undefined;
+            endTime?: string | undefined;
+            id: string;
+            type: string;
+            startTime: string;
+        }[] | undefined;
+        cancellation?: {
+            reason?: string | undefined;
+            cancelledAt: string;
+        } | undefined;
+        status: string;
+        createdAt: string;
+        updatedAt: string;
+        workflowId: string;
+        workflowName: string;
+        visibleId: string;
+    }, {
+        visibleId: import("convex/values").VString<string, "required">;
+        workflowId: import("convex/values").VString<string, "required">;
+        workflowName: import("convex/values").VString<string, "required">;
+        status: import("convex/values").VString<string, "required">;
+        input: import("convex/values").VAny<any, "optional", string>;
+        context: import("convex/values").VArray<any[][] | undefined, import("convex/values").VArray<any[], import("convex/values").VAny<any, "required", string>, "required">, "optional">;
+        suspension: import("convex/values").VObject<{
+            reason?: string | undefined;
+            suspendedStepIndex?: number | undefined;
+            lastEventSequence?: number | undefined;
+            suspendData?: any;
+            checkpoint?: {
+                stepExecutionState?: any;
+                completedStepsData?: any[] | undefined;
+            } | undefined;
+            suspendedAt: string;
+        } | undefined, {
+            suspendedAt: import("convex/values").VString<string, "required">;
+            reason: import("convex/values").VString<string | undefined, "optional">;
+            suspendedStepIndex: import("convex/values").VFloat64<number | undefined, "optional">;
+            lastEventSequence: import("convex/values").VFloat64<number | undefined, "optional">;
+            suspendData: import("convex/values").VAny<any, "optional", string>;
+            checkpoint: import("convex/values").VObject<{
+                stepExecutionState?: any;
+                completedStepsData?: any[] | undefined;
+            } | undefined, {
+                stepExecutionState: import("convex/values").VAny<any, "optional", string>;
+                completedStepsData: import("convex/values").VArray<any[] | undefined, import("convex/values").VAny<any, "required", string>, "optional">;
+            }, "optional", "stepExecutionState" | "completedStepsData" | `stepExecutionState.${string}`>;
+        }, "optional", "suspendedAt" | "reason" | "suspendedStepIndex" | "lastEventSequence" | "suspendData" | "checkpoint" | `suspendData.${string}` | "checkpoint.stepExecutionState" | "checkpoint.completedStepsData" | `checkpoint.stepExecutionState.${string}`>;
+        events: import("convex/values").VArray<{
+            input?: any;
+            output?: any;
+            status?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            context?: Record<string, any> | undefined;
+            from?: string | undefined;
+            name?: string | undefined;
+            endTime?: string | undefined;
+            id: string;
+            type: string;
+            startTime: string;
+        }[] | undefined, import("convex/values").VObject<{
+            input?: any;
+            output?: any;
+            status?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            context?: Record<string, any> | undefined;
+            from?: string | undefined;
+            name?: string | undefined;
+            endTime?: string | undefined;
+            id: string;
+            type: string;
+            startTime: string;
+        }, {
+            id: import("convex/values").VString<string, "required">;
+            type: import("convex/values").VString<string, "required">;
+            name: import("convex/values").VString<string | undefined, "optional">;
+            from: import("convex/values").VString<string | undefined, "optional">;
+            startTime: import("convex/values").VString<string, "required">;
+            endTime: import("convex/values").VString<string | undefined, "optional">;
+            status: import("convex/values").VString<string | undefined, "optional">;
+            input: import("convex/values").VAny<any, "optional", string>;
+            output: import("convex/values").VAny<any, "optional", string>;
+            metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "optional", string>;
+            context: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "optional", string>;
+        }, "required", "id" | "input" | "output" | "type" | "status" | "metadata" | "context" | "from" | `metadata.${string}` | "name" | "startTime" | "endTime" | `input.${string}` | `output.${string}` | `context.${string}`>, "optional">;
+        output: import("convex/values").VAny<any, "optional", string>;
+        cancellation: import("convex/values").VObject<{
+            reason?: string | undefined;
+            cancelledAt: string;
+        } | undefined, {
+            cancelledAt: import("convex/values").VString<string, "required">;
+            reason: import("convex/values").VString<string | undefined, "optional">;
+        }, "optional", "reason" | "cancelledAt">;
+        userId: import("convex/values").VString<string | undefined, "optional">;
+        conversationId: import("convex/values").VString<string | undefined, "optional">;
+        metadata: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "optional", string>;
+        createdAt: import("convex/values").VString<string, "required">;
+        updatedAt: import("convex/values").VString<string, "required">;
+    }, "required", "input" | "output" | "status" | "userId" | "createdAt" | "updatedAt" | "metadata" | "workflowId" | "workflowName" | "conversationId" | "context" | "suspension" | "events" | "cancellation" | `metadata.${string}` | `input.${string}` | `output.${string}` | "visibleId" | "suspension.suspendedAt" | "suspension.reason" | "suspension.suspendedStepIndex" | "suspension.lastEventSequence" | "suspension.suspendData" | "suspension.checkpoint" | `suspension.suspendData.${string}` | "suspension.checkpoint.stepExecutionState" | "suspension.checkpoint.completedStepsData" | `suspension.checkpoint.stepExecutionState.${string}` | "cancellation.reason" | "cancellation.cancelledAt">, {
+        by_visible_id: ["visibleId", "_creationTime"];
+        by_workflow_id: ["workflowId", "_creationTime"];
+        by_status: ["status", "_creationTime"];
+        by_workflow_id_and_status: ["workflowId", "status", "_creationTime"];
+        by_created_at: ["createdAt", "_creationTime"];
+    }, {}, {}>;
+    conversationSteps: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        operationId?: string | undefined;
+        content?: string | undefined;
+        agentName?: string | undefined;
+        arguments?: Record<string, any> | undefined;
+        result?: any;
+        usage?: {
+            promptTokens?: number | undefined;
+            completionTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+        subAgentId?: string | undefined;
+        subAgentName?: string | undefined;
+        type: string;
+        userId: string;
+        createdAt: string;
+        conversationId: string;
+        role: string;
+        agentId: string;
+        stepIndex: number;
+        visibleId: string;
+    }, {
+        visibleId: import("convex/values").VString<string, "required">;
+        conversationId: import("convex/values").VString<string, "required">;
+        userId: import("convex/values").VString<string, "required">;
+        agentId: import("convex/values").VString<string, "required">;
+        agentName: import("convex/values").VString<string | undefined, "optional">;
+        operationId: import("convex/values").VString<string | undefined, "optional">;
+        stepIndex: import("convex/values").VFloat64<number, "required">;
+        type: import("convex/values").VString<string, "required">;
+        role: import("convex/values").VString<string, "required">;
+        content: import("convex/values").VString<string | undefined, "optional">;
+        arguments: import("convex/values").VRecord<Record<string, any> | undefined, import("convex/values").VString<string, "required">, import("convex/values").VAny<any, "required", string>, "optional", string>;
+        result: import("convex/values").VAny<any, "optional", string>;
+        usage: import("convex/values").VObject<{
+            promptTokens?: number | undefined;
+            completionTokens?: number | undefined;
+            totalTokens?: number | undefined;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined, {
+            promptTokens: import("convex/values").VFloat64<number | undefined, "optional">;
+            completionTokens: import("convex/values").VFloat64<number | undefined, "optional">;
+            totalTokens: import("convex/values").VFloat64<number | undefined, "optional">;
+            reasoningTokens: import("convex/values").VFloat64<number | undefined, "optional">;
+            cachedInputTokens: import("convex/values").VFloat64<number | undefined, "optional">;
+        }, "optional", "promptTokens" | "completionTokens" | "totalTokens" | "reasoningTokens" | "cachedInputTokens">;
+        subAgentId: import("convex/values").VString<string | undefined, "optional">;
+        subAgentName: import("convex/values").VString<string | undefined, "optional">;
+        createdAt: import("convex/values").VString<string, "required">;
+    }, "required", "type" | "userId" | "createdAt" | "conversationId" | "role" | "operationId" | "content" | "agentId" | "agentName" | "stepIndex" | "arguments" | "result" | "usage" | "subAgentId" | "subAgentName" | `arguments.${string}` | `result.${string}` | "visibleId" | "usage.promptTokens" | "usage.completionTokens" | "usage.totalTokens" | "usage.reasoningTokens" | "usage.cachedInputTokens">, {
+        by_visible_id: ["visibleId", "_creationTime"];
+        by_conversation_id: ["conversationId", "_creationTime"];
+        by_conversation_id_and_step_index: ["conversationId", "stepIndex", "_creationTime"];
+        by_conversation_id_and_operation_id: ["conversationId", "operationId", "_creationTime"];
+        by_user_id: ["userId", "_creationTime"];
+    }, {}, {}>;
+}, true>;
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/dist/component/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuHA,wBAMG"}