@vistagenic/vista 0.2.16 → 0.3.2

package/dist/ai/stream.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStream = void 0;
+exports.createAIStreamResponse = createAIStreamResponse;
+class AgentStream {
+    source;
+    constructor(source) {
+        this.source = source;
+    }
+    [Symbol.asyncIterator]() {
+        return this.source[Symbol.asyncIterator]();
+    }
+    /**
+     * Converts the stream into a Server-Sent Events (SSE) Response.
+     * Format is compatible with UI clients and standard EventSource.
+     */
+    toDataStreamResponse(init) {
+        const encoder = new TextEncoder();
+        const source = this.source;
+        const stream = new ReadableStream({
+            async start(controller) {
+                try {
+                    for await (const chunk of source) {
+                        const line = `data: ${JSON.stringify(chunk)}\n\n`;
+                        controller.enqueue(encoder.encode(line));
+                    }
+                    controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+                    controller.close();
+                }
+                catch (error) {
+                    const errChunk = {
+                        type: 'error',
+                        error: error?.message || 'Stream processing error',
+                    };
+                    controller.enqueue(encoder.encode(`data: ${JSON.stringify(errChunk)}\n\n`));
+                    controller.close();
+                }
+            },
+        });
+        const headers = new Headers(init?.headers);
+        headers.set('Content-Type', 'text/event-stream; charset=utf-8');
+        headers.set('Cache-Control', 'no-cache, no-transform');
+        headers.set('Connection', 'keep-alive');
+        return new Response(stream, {
+            ...init,
+            status: init?.status ?? 200,
+            headers,
+        });
+    }
+    /**
+     * Converts the stream into a simple text-only Response stream.
+     */
+    toTextStreamResponse(init) {
+        const encoder = new TextEncoder();
+        const source = this.source;
+        const stream = new ReadableStream({
+            async start(controller) {
+                try {
+                    for await (const chunk of source) {
+                        if (chunk.type === 'text-delta' && chunk.textDelta) {
+                            controller.enqueue(encoder.encode(chunk.textDelta));
+                        }
+                    }
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        const headers = new Headers(init?.headers);
+        if (!headers.has('Content-Type')) {
+            headers.set('Content-Type', 'text/plain; charset=utf-8');
+        }
+        headers.set('Cache-Control', 'no-cache');
+        return new Response(stream, {
+            ...init,
+            status: init?.status ?? 200,
+            headers,
+        });
+    }
+    /**
+     * Collects all text and events from the stream into a single result.
+     */
+    async collect() {
+        let text = '';
+        const toolCalls = [];
+        let usage;
+        for await (const chunk of this.source) {
+            if (chunk.type === 'text-delta' && chunk.textDelta) {
+                text += chunk.textDelta;
+            }
+            else if (chunk.type === 'tool-call' && chunk.toolCall) {
+                toolCalls.push(chunk.toolCall);
+            }
+            else if (chunk.type === 'done' && chunk.usage) {
+                usage = chunk.usage;
+            }
+        }
+        return { text, toolCalls, usage };
+    }
+}
+exports.AgentStream = AgentStream;
+function createAIStreamResponse(stream, init) {
+    if (stream instanceof AgentStream) {
+        return stream.toDataStreamResponse(init);
+    }
+    return new AgentStream(stream).toDataStreamResponse(init);
+}

package/dist/ai/tool.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition, ToolContext } from './types';
+export interface ToolOptions<TParams = any, TResult = any> {
+    name: string;
+    description: string;
+    parameters?: any;
+    execute: (args: TParams, context?: ToolContext) => Promise<TResult> | TResult;
+}
+export declare function tool<TParams = any, TResult = any>(options: ToolOptions<TParams, TResult>): ToolDefinition<TParams, TResult>;
+export declare function formatToolForOpenAI(tool: ToolDefinition): any;
+export declare function formatToolForAnthropic(tool: ToolDefinition): any;
+export declare function formatToolForGemini(tool: ToolDefinition): any;

package/dist/ai/tool.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tool = tool;
+exports.formatToolForOpenAI = formatToolForOpenAI;
+exports.formatToolForAnthropic = formatToolForAnthropic;
+exports.formatToolForGemini = formatToolForGemini;
+function tool(options) {
+    if (!options.name || typeof options.name !== 'string') {
+        throw new Error('Tool must have a valid string name');
+    }
+    if (!options.description || typeof options.description !== 'string') {
+        throw new Error(`Tool "${options.name}" must have a description`);
+    }
+    if (typeof options.execute !== 'function') {
+        throw new Error(`Tool "${options.name}" must have an execute function`);
+    }
+    return {
+        name: options.name,
+        description: options.description,
+        parameters: options.parameters || { type: 'object', properties: {} },
+        execute: options.execute,
+    };
+}
+function formatToolForOpenAI(tool) {
+    return {
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters || { type: 'object', properties: {} },
+        },
+    };
+}
+function formatToolForAnthropic(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters || { type: 'object', properties: {} },
+    };
+}
+function formatToolForGemini(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters || { type: 'object', properties: {} },
+    };
+}

package/dist/ai/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Vista AI Core Types
+ */
+export type Role = 'system' | 'user' | 'assistant' | 'tool';
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, any> | string;
+}
+export interface ToolResult {
+    toolCallId: string;
+    name: string;
+    result: any;
+    isError?: boolean;
+}
+export interface Message {
+    role: Role;
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+}
+export interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+export interface ModelOptions {
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    headers?: Record<string, string>;
+}
+export interface GenerateTextOptions {
+    messages: Message[];
+    systemPrompt?: string;
+    tools?: ToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+    abortSignal?: AbortSignal;
+}
+export interface GenerateTextResult {
+    text: string;
+    toolCalls?: ToolCall[];
+    usage?: TokenUsage;
+    finishReason?: 'stop' | 'tool-calls' | 'length' | 'error' | string;
+    raw?: any;
+}
+export type StreamChunkType = 'text-delta' | 'tool-call' | 'tool-result' | 'step-finish' | 'error' | 'done';
+export interface StreamChunk {
+    type: StreamChunkType;
+    textDelta?: string;
+    toolCall?: ToolCall;
+    toolResult?: ToolResult;
+    usage?: TokenUsage;
+    error?: string;
+}
+export interface LanguageModel {
+    provider: string;
+    modelName: string;
+    generateText(options: GenerateTextOptions): Promise<GenerateTextResult>;
+    streamText(options: GenerateTextOptions): AsyncIterable<StreamChunk>;
+}
+export interface ToolContext {
+    step: number;
+    messages: Message[];
+    agentName?: string;
+    abortSignal?: AbortSignal;
+}
+export interface ToolDefinition<TParams = any, TResult = any> {
+    name: string;
+    description: string;
+    parameters?: any;
+    execute: (args: TParams, context?: ToolContext) => Promise<TResult> | TResult;
+}
+export interface AgentStep {
+    stepNumber: number;
+    prompt: Message[];
+    text: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
+    usage?: TokenUsage;
+}
+export interface AgentExecutionResult {
+    text: string;
+    messages: Message[];
+    steps: AgentStep[];
+    usage: TokenUsage;
+    finishReason: string;
+}
+export interface ObservabilityHandler {
+    onStepStart?: (stepNumber: number) => void;
+    onStepFinish?: (step: AgentStep) => void;
+    onToolCall?: (call: ToolCall) => void;
+    onToolResult?: (result: ToolResult) => void;
+    onError?: (error: Error) => void;
+}
+export interface AgentMemory {
+    get(sessionId: string): Promise<Message[]> | Message[];
+    save(sessionId: string, messages: Message[]): Promise<void> | void;
+    clear(sessionId: string): Promise<void> | void;
+}
+export interface AgentConfig {
+    name: string;
+    model: string | LanguageModel;
+    systemPrompt?: string | (() => string | Promise<string>);
+    tools?: (ToolDefinition | any)[];
+    memory?: boolean | AgentMemory;
+    maxSteps?: number;
+    temperature?: number;
+    maxTokens?: number;
+    observability?: boolean | ObservabilityHandler;
+    onStepFinish?: (step: AgentStep) => void | Promise<void>;
+}

package/dist/ai/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Vista AI Core Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/auth/core.d.ts

@@ -0,0 +1,140 @@
+export interface AuthUser {
+    id: string;
+    name?: string | null;
+    email?: string | null;
+    image?: string | null;
+}
+export interface AuthSession {
+    user: AuthUser;
+    expires: string;
+}
+export interface JWTPayload extends AuthSession {
+    iat: number;
+    exp: number;
+}
+export interface Account {
+    provider: string;
+    type: 'oauth' | 'oidc' | 'credentials';
+    providerAccountId: string;
+    access_token?: string;
+    refresh_token?: string;
+    token_type?: string;
+    scope?: string;
+    id_token?: string;
+}
+export interface Adapter {
+    createUser?(user: AuthUser): Promise<AuthUser> | AuthUser;
+    getUser?(id: string): Promise<AuthUser | null> | AuthUser | null;
+    getUserByEmail?(email: string): Promise<AuthUser | null> | AuthUser | null;
+    getUserByAccount?(provider: string, providerAccountId: string): Promise<AuthUser | null> | AuthUser | null;
+    linkAccount?(userId: string, account: Account): Promise<void> | void;
+}
+export interface OAuthProvider {
+    id: string;
+    name: string;
+    type: 'oauth';
+    clientId: string;
+    clientSecret: string;
+    authorization: {
+        url: string;
+        params?: Record<string, string>;
+    };
+    token: string;
+    userinfo: string;
+    profile(profile: any): AuthUser | Promise<AuthUser>;
+}
+export interface CredentialsProvider {
+    id: string;
+    name: string;
+    type: 'credentials';
+    credentials: Record<string, {
+        label?: string;
+        type?: string;
+    }>;
+    authorize(credentials: Record<string, string>): Promise<AuthUser | null> | AuthUser | null;
+}
+export type AuthProvider = OAuthProvider | CredentialsProvider;
+export interface AuthCallbacks {
+    signIn?: (params: {
+        user: AuthUser;
+        account?: Account | null;
+    }) => boolean | Promise<boolean>;
+    jwt?: (params: {
+        token: JWTPayload;
+        user?: AuthUser;
+    }) => JWTPayload | Promise<JWTPayload>;
+    session?: (params: {
+        session: AuthSession;
+        token: JWTPayload;
+    }) => AuthSession | Promise<AuthSession>;
+    redirect?: (params: {
+        url: string;
+        baseUrl: string;
+    }) => string | Promise<string>;
+    authorized?: (params: {
+        auth: AuthSession | null;
+        request: Request;
+    }) => boolean | Response | Promise<boolean | Response>;
+}
+export interface AuthConfig {
+    providers: AuthProvider[];
+    adapter?: Adapter;
+    secret?: string;
+    session?: {
+        strategy?: 'jwt' | 'database';
+        maxAge?: number;
+        cookieName?: string;
+    };
+    pages?: {
+        signIn?: string;
+        error?: string;
+    };
+    callbacks?: AuthCallbacks;
+    trustHost?: boolean;
+    basePath?: string;
+}
+export interface ResolvedAuthConfig extends AuthConfig {
+    secret: string;
+    session: {
+        strategy: 'jwt' | 'database';
+        maxAge: number;
+        cookieName: string;
+    };
+    basePath: string;
+}
+export declare function hashPassword(password: string, salt?: string): string;
+export declare function verifyPassword(password: string, stored: string): boolean;
+export declare function randomToken(bytes?: number): string;
+export declare function encryptJwt(payload: JWTPayload, secret: string): string;
+export declare function decryptJwt(token: string, secret: string): JWTPayload | null;
+export declare function pkcePair(): {
+    verifier: string;
+    challenge: string;
+};
+export declare class MemoryAdapter implements Adapter {
+    users: Map<string, AuthUser>;
+    accounts: Map<string, string>;
+    createUser(user: AuthUser): AuthUser;
+    getUser(id: string): AuthUser | null;
+    getUserByEmail(email: string): AuthUser | null;
+    getUserByAccount(provider: string, providerAccountId: string): AuthUser | null;
+    linkAccount(userId: string, account: Account): void;
+}
+export declare function GitHub(options: {
+    clientId?: string;
+    clientSecret?: string;
+}): OAuthProvider;
+export declare function Google(options?: {
+    clientId?: string;
+    clientSecret?: string;
+}): OAuthProvider;
+export declare function Credentials(options: {
+    id?: string;
+    name?: string;
+    credentials?: Record<string, {
+        label?: string;
+        type?: string;
+    }>;
+    authorize: CredentialsProvider['authorize'];
+}): CredentialsProvider;
+export declare function resolveAuthConfig(config: AuthConfig): ResolvedAuthConfig;

package/dist/auth/core.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAdapter = void 0;
+exports.hashPassword = hashPassword;
+exports.verifyPassword = verifyPassword;
+exports.randomToken = randomToken;
+exports.encryptJwt = encryptJwt;
+exports.decryptJwt = decryptJwt;
+exports.pkcePair = pkcePair;
+exports.GitHub = GitHub;
+exports.Google = Google;
+exports.Credentials = Credentials;
+exports.resolveAuthConfig = resolveAuthConfig;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function hashPassword(password, salt) {
+    const usedSalt = salt || node_crypto_1.default.randomBytes(16).toString('hex');
+    const derived = node_crypto_1.default.scryptSync(password, usedSalt, 32).toString('hex');
+    return `${usedSalt}:${derived}`;
+}
+function verifyPassword(password, stored) {
+    const [salt, hash] = stored.split(':');
+    if (!salt || !hash)
+        return false;
+    const derived = node_crypto_1.default.scryptSync(password, salt, 32);
+    const actual = Buffer.from(hash, 'hex');
+    if (derived.length !== actual.length)
+        return false;
+    return node_crypto_1.default.timingSafeEqual(derived, actual);
+}
+function randomToken(bytes = 32) {
+    return node_crypto_1.default.randomBytes(bytes).toString('base64url');
+}
+function deriveKey(secret) {
+    return node_crypto_1.default.createHash('sha256').update(secret).digest();
+}
+function encryptJwt(payload, secret) {
+    const iv = node_crypto_1.default.randomBytes(12);
+    const cipher = node_crypto_1.default.createCipheriv('aes-256-gcm', deriveKey(secret), iv);
+    const encrypted = Buffer.concat([cipher.update(JSON.stringify(payload), 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, tag, encrypted]).toString('base64url');
+}
+function decryptJwt(token, secret) {
+    try {
+        const buffer = Buffer.from(token, 'base64url');
+        const iv = buffer.subarray(0, 12);
+        const tag = buffer.subarray(12, 28);
+        const encrypted = buffer.subarray(28);
+        const decipher = node_crypto_1.default.createDecipheriv('aes-256-gcm', deriveKey(secret), iv);
+        decipher.setAuthTag(tag);
+        const json = Buffer.concat([decipher.update(encrypted), decipher.final()]).toString('utf8');
+        const payload = JSON.parse(json);
+        if (payload.exp * 1000 < Date.now()) {
+            return null;
+        }
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+function pkcePair() {
+    const verifier = randomToken(32);
+    const challenge = node_crypto_1.default.createHash('sha256').update(verifier).digest('base64url');
+    return { verifier, challenge };
+}
+class MemoryAdapter {
+    users = new Map();
+    accounts = new Map();
+    createUser(user) {
+        this.users.set(user.id, user);
+        return user;
+    }
+    getUser(id) {
+        return this.users.get(id) ?? null;
+    }
+    getUserByEmail(email) {
+        return Array.from(this.users.values()).find((user) => user.email === email) ?? null;
+    }
+    getUserByAccount(provider, providerAccountId) {
+        const userId = this.accounts.get(`${provider}:${providerAccountId}`);
+        return userId ? this.getUser(userId) : null;
+    }
+    linkAccount(userId, account) {
+        this.accounts.set(`${account.provider}:${account.providerAccountId}`, userId);
+    }
+}
+exports.MemoryAdapter = MemoryAdapter;
+function GitHub(options) {
+    return {
+        id: 'github',
+        name: 'GitHub',
+        type: 'oauth',
+        clientId: options.clientId || process.env.AUTH_GITHUB_ID || process.env.GITHUB_ID || '',
+        clientSecret: options.clientSecret || process.env.AUTH_GITHUB_SECRET || process.env.GITHUB_SECRET || '',
+        authorization: {
+            url: 'https://github.com/login/oauth/authorize',
+            params: { scope: 'read:user user:email' },
+        },
+        token: 'https://github.com/login/oauth/access_token',
+        userinfo: 'https://api.github.com/user',
+        profile(profile) {
+            return {
+                id: String(profile.id),
+                name: profile.name || profile.login,
+                email: profile.email,
+                image: profile.avatar_url,
+            };
+        },
+    };
+}
+function Google(options = {}) {
+    return {
+        id: 'google',
+        name: 'Google',
+        type: 'oauth',
+        clientId: options.clientId || process.env.AUTH_GOOGLE_ID || process.env.GOOGLE_ID || '',
+        clientSecret: options.clientSecret || process.env.AUTH_GOOGLE_SECRET || process.env.GOOGLE_SECRET || '',
+        authorization: {
+            url: 'https://accounts.google.com/o/oauth2/v2/auth',
+            params: { scope: 'openid email profile', response_type: 'code' },
+        },
+        token: 'https://oauth2.googleapis.com/token',
+        userinfo: 'https://openidconnect.googleapis.com/v1/userinfo',
+        profile(profile) {
+            return {
+                id: String(profile.sub || profile.id),
+                name: profile.name,
+                email: profile.email,
+                image: profile.picture,
+            };
+        },
+    };
+}
+function Credentials(options) {
+    return {
+        id: options.id || 'credentials',
+        name: options.name || 'Credentials',
+        type: 'credentials',
+        credentials: options.credentials || {
+            email: { label: 'Email', type: 'email' },
+            password: { label: 'Password', type: 'password' },
+        },
+        authorize: options.authorize,
+    };
+}
+function resolveAuthConfig(config) {
+    const secret = config.secret || process.env.AUTH_SECRET || process.env.NEXTAUTH_SECRET;
+    if (!secret) {
+        throw new Error('AUTH_SECRET is required. Set it in the environment or pass secret to VistaAuth().');
+    }
+    return {
+        ...config,
+        secret,
+        basePath: config.basePath || '/api/auth',
+        session: {
+            strategy: config.session?.strategy || 'jwt',
+            maxAge: config.session?.maxAge ?? 30 * 24 * 60 * 60,
+            cookieName: config.session?.cookieName || 'vista.session-token',
+        },
+    };
+}

package/dist/auth/index.d.ts

@@ -1,8 +1,20 @@
-import React from 'react';
-export declare function AuthProvider({ children }: {
-    children: React.ReactNode;
-}): import("react/jsx-runtime").JSX.Element;
-export declare const useAuth: () => {
-    user: any;
-    login: () => void;
-};
+import { type AuthConfig, type AuthSession, type ResolvedAuthConfig } from './core';
+export * from './core';
+export declare function VistaAuth(config: AuthConfig): {
+    handlers: {
+        GET: (request: Request) => Promise<Response>;
+        POST: (request: Request) => Promise<Response>;
+    };
+    auth: (request?: Request) => Promise<AuthSession | null>;
+    signIn: (providerId?: string, options?: Record<string, string>) => Promise<Response>;
+    signOut: () => Promise<Response>;
+    authMiddleware: (authorized?: (params: {
+        auth: AuthSession | null;
+        request: Request;
+    }) => boolean | Response | Promise<boolean | Response>) => ({ request, next }: {
+        request: any;
+        next: () => Promise<Response>;
+    }) => Promise<Response>;
+    config: ResolvedAuthConfig;
+};
+export default VistaAuth;