needle-cloud 1.10.3 → 2.0.0

package/dist/index.d.ts

@@ -1 +1,465 @@
-export * from "./web/index.js";
+import * as _logto_browser from '@logto/browser';
+import { UserScope } from '@logto/browser';
+import Stripe from 'stripe';
+
+type LogtoUserCustomData$1 = {
+    default_org?: string;
+    machines?: Array<{ id: string, name: string, first_login_at: string, login_expiration_time?: string }>;
+    preferences?: {
+        allow_marketing_emails?: boolean;
+    }
+    ai?: {
+        cli_tools?: "bypass_permissions" | "disabled";
+    }
+}
+
+declare namespace Auth {
+    /** @param {boolean} _debug */
+    function setDebug(_debug: boolean): void;
+    let baseUrl: string;
+    let redirectUri: string;
+    let postSignOutRedirectUri: string;
+    /**
+     * Register a callback to be called when the authentication state changes
+     * @param {Function} callback - The callback to register
+     * @returns {Function} - A function to unregister the callback
+     */
+    function onChanged(callback: Function): Function;
+    /**
+     * Returns a promise that resolves when Auth is initialized
+     * @returns {Promise<boolean>}
+     */
+    function ready(): Promise<boolean>;
+    /**
+     * Initialize the Auth system
+     * @internal
+     * @param {AuthInitOpts} [opts] - Initialization options
+     * @returns {Promise<boolean>}
+     */
+    function init(opts?: AuthInitOpts): Promise<boolean>;
+    /**
+     * Check if the user is currently authenticated
+     * @returns {boolean}
+     */
+    function isAuthenticated(): boolean;
+    /**
+     * Check authentication status with the server
+     * @returns {Promise<boolean>}
+     */
+    function checkIsAuthenticated(): Promise<boolean>;
+    /**
+     * Get the current user information (if fetched previously)
+     * @returns {UserInfoResponse|null}
+     */
+    function getUserInfo(): UserInfoResponse | null;
+    /**
+     * Get the current user ID (sub)
+     * @returns {string|null}
+     */
+    function getUserId(): string | null;
+    /**
+     * Get the user's name or username (if available)
+     * @returns {string|null}
+     */
+    function getName(): string | null;
+    /**
+     * Request user information from the server
+     * @returns {Promise<UserInfoResponse|null>}
+     */
+    function requestUserInfo(): Promise<UserInfoResponse | null>;
+    /**
+     * Request an access token for the configured resource
+     * @param {string | undefined | null} [org_id] - The organization ID (optional). If none is provided the user access token will be requested.
+     * @returns {Promise<string>}
+     */
+    function requestAccessToken(org_id?: string | undefined | null): Promise<string>;
+    /**
+     * Initiate the sign-in process
+     */
+    function signIn(): Promise<void>;
+    /**
+     * Get the user's default team/org ID from their Logto custom_data.
+     * @returns {string | undefined}
+     */
+    function getDefaultTeamId(): string | undefined;
+    /**
+     * Sign out the current user
+     */
+    function signOut(): Promise<void>;
+}
+type UserInfoResponse = _logto_browser.UserInfoResponse;
+type LogtoUserCustomData = LogtoUserCustomData$1;
+type ResourceUrl = "https://cloud.needle.tools/api" | ({} & string);
+type AuthInitOpts = {
+    appId?: string;
+    /**
+     * User scopes. If an empty array is passed
+     */
+    scopes?: string[] | "payment" | "all";
+    debug?: boolean;
+};
+
+/**
+ * Basic web component for login/logout
+ */
+declare class NeedleLoginButton extends HTMLButtonElement {
+    connectedCallback(): void;
+    __unsubscribeOnChange: Function;
+    disconnectedCallback(): void;
+    __update(): void;
+}
+
+/**
+ * The authentication token
+ */
+declare type AuthData$1 = {
+    authToken: string;
+    org?: string | null | undefined;
+    /** @deprecated */
+    roles?: Array<string>;
+    /** @deprecated */
+    roles_org?: Array<string>;
+}
+
+type NeedleLicense = "basic" | "indie" | "pro" | "enterprise" | "edu"
+
+type AiTokenUsageInfo = {
+    /** Total tokens available */
+    max_available: number,
+    /** Tokens used so far */
+    used: number,
+    /** Tokens remaining */
+    remaining: number,
+    /** Usage from 0 to 1, where 1 is all tokens used. */
+    usage01: number,
+    /** The license used for this chat session, or null if no license is used. */
+    license_used: NeedleLicense | null,
+}
+
+
+type RecentChatsResponse$1 = {
+    data: Array<{
+        slug: string,
+        topic: string,
+        created_at: string,
+        updated_at?: string,
+    }>
+}
+
+
+/** Tool definition provided by the client for client-side execution. */
+type ClientToolDefinition$1 = {
+    name: string,
+    description: string,
+    parameters?: Record<string, any>,
+}
+
+/** Context block sent by the client (e.g. page metadata, scene hierarchy). */
+type ClientContext$1 = {
+    type: "text",
+    text: string,
+}
+
+
+type ChatMessageToolCall = {
+    name: string,
+    args: Record<string, any>,
+    result_length?: number,
+    duration_ms?: number,
+}
+
+type ChatMessage = {
+    created_at: string,
+    id: string,
+    role: "assistant" | "tool" | "user",
+    content: string,
+    tool_calls?: ChatMessageToolCall[],
+    metadata?: {
+        tokens?: { input: number, output: number },
+        model?: string,
+        /** True while the AI is still streaming a response. Absent or false when the message is complete. */
+        is_partial?: boolean,
+        /** True when the user stopped generation mid-stream. */
+        interrupted?: boolean,
+    } | null,
+}
+type AIChatGETResponse$1 = {
+    chat_id: string,
+    messages: Array<ChatMessage>,
+    token_usage: AiTokenUsageInfo | null,
+    cli_connected?: boolean,
+    cli_tools_enabled?: boolean,
+}
+
+/** Response type when using stream: false in the request body. */
+type AIChatSyncResponse$1 = {
+    chat_id: string,
+    message_id: string,
+    role: "assistant",
+    content: string,
+    tool_calls?: ChatMessageToolCall[],
+    metadata?: ChatMessage["metadata"],
+    token_usage?: AiTokenUsageInfo | null,
+}
+
+/** Discriminated union for events yielded by the SSE chat stream. */
+type ChatStreamEvent$1 = { /** SSE event id for position tracking. */ id?: number } & (
+    | { type: "delta", content: string }
+    | { type: "message", content: string }
+    | { type: "message_id", message_id: string }
+    | { type: "tool_call", name: string, args: Record<string, any> }
+    | { type: "tool_result", name: string }
+    | { type: "client_tool_request", request_id: string, name: string, args: Record<string, any> }
+    | { type: "error", message: string }
+    | { type: "stopped" }
+    | { type: "status", message: string }
+    | { type: "done", token_usage: AiTokenUsageInfo }
+    | { type: "chat_id", chat_id: string }
+)
+
+/**
+ * @typedef {{ name: string, mimetype: string, buffer:Buffer }} Filelike
+ * @typedef {import("../web.types.js").AuthData} AuthData
+ */
+/**
+ * @param {Array<Filelike>} files
+ * @param {{org?:string|null} & { name?:string, abort?:AbortSignal, }} opts
+ * @returns {Promise<{error:string} | {job_id:string, content_id:string, url?:string | null, skipped?:boolean}>}
+ */
+declare function uploadFiles(files: Array<Filelike>, opts: {
+    org?: string | null;
+} & {
+    name?: string;
+    abort?: AbortSignal;
+}): Promise<{
+    error: string;
+} | {
+    job_id: string;
+    content_id: string;
+    url?: string | null;
+    skipped?: boolean;
+}>;
+type Filelike = {
+    name: string;
+    mimetype: string;
+    buffer: Buffer;
+};
+type AuthData = AuthData$1;
+
+type BaseLicense = {
+    id: string,
+    valid: boolean,
+}
+
+type BaseSubscription = BaseLicense & {
+    /** ISO timestamp */
+    current_period_start: number,
+    /** ISO timestamp */
+    current_period_end: number,
+    renews_at: number | undefined | null,
+    cancels_at: number | undefined | null,
+    status: Stripe.Subscription.Status,
+    recurring?: {
+        interval: "day" | "week" | "month" | "year",
+        interval_count: number | undefined,
+    }
+}
+
+type SeatBasedLicense = BaseSubscription & {
+    mode: "seat-based",
+
+    /** Total available seats */
+    seats: number,
+
+    activated_count?: number,
+    /**
+     * User ids that have activated this license
+     */
+    activated_by?: string[],
+
+    /** Is the license activated by this user? */
+    user_activated?: boolean,
+    /** Is this activation valid */
+    user_activated_valid?: boolean,
+
+    /** This is a user or org name */
+    granted_by?: "self" | "ORG" | (string & {}),
+    granted_by_id?: string,
+}
+
+type UsageBasedLicense = BaseSubscription & {
+    mode: "usage-based",
+}
+
+
+type NeedleEngineLicense = SeatBasedLicense & {
+    type: "Needle Engine",
+    license: NeedleLicense,
+}
+
+
+type NeedleCloudLicense = UsageBasedLicense & {
+    type: "Needle Cloud",
+}
+
+type OneTimePurchase = BaseLicense & {
+    mode: "one-time-purchase",
+    type: string,
+    created_at: string,
+    license?: string,
+    seats?: number,
+};
+
+type License = NeedleEngineLicense | NeedleCloudLicense | OneTimePurchase;
+
+/**
+ * @param {{ org?:string } & { offset?:number, limit?: number }} opts
+ * @returns {Promise<Array<Deployment>>}
+ * @typedef {{ name: string, url: string }} Deployment
+ */
+declare function getDeployments(opts: {
+    org?: string;
+} & {
+    offset?: number;
+    limit?: number;
+}): Promise<Array<Deployment>>;
+/**
+ * Get licenses for a specific user. A product type is optional.
+ * Only valid licenses are returned
+ * @param {{product?:string | string[], includeInvalid?: boolean}} opts
+ * @returns {Promise<null | import("../../../../needle-share/types/stripe.js").License[]>}
+ */
+declare function getUserLicenses(opts: {
+    product?: string | string[];
+    includeInvalid?: boolean;
+}): Promise<null | License[]>;
+/**
+ * Checks if the current user owns a specific product. A product type is optional
+ * @param {{product?:string | string[]}} opts
+ * @returns {Promise<boolean>}
+ */
+declare function ownsProduct(opts: {
+    product?: string | string[];
+}): Promise<boolean>;
+type Deployment = {
+    name: string;
+    url: string;
+};
+
+/**
+ * List recent AI chats for the authenticated user.
+ * @param {ChatAuthOpts} [opts]
+ * @returns {Promise<RecentChatsResponse>}
+ */
+declare function listChats(opts?: ChatAuthOpts): Promise<RecentChatsResponse>;
+/**
+ * Read an AI chat by slug. Returns JSON with messages by default.
+ * When `reconnect: true`, attempts to reconnect to an active SSE stream.
+ * @overload
+ * @param {string} slug
+ * @param {ChatAuthOpts & { offset?: number, limit?: number, personal?: boolean, reconnect?: false }} [opts]
+ * @returns {Promise<AIChatGETResponse>}
+ */
+declare function readChat(slug: string, opts?: ChatAuthOpts & {
+    offset?: number;
+    limit?: number;
+    personal?: boolean;
+    reconnect?: false;
+}): Promise<AIChatGETResponse>;
+/**
+ * @overload
+ * @param {string} slug
+ * @param {ChatAuthOpts & { personal?: boolean, reconnect: true, signal?: AbortSignal }} opts
+ * @returns {Promise<AsyncGenerator<ChatStreamEvent> | null>}
+ */
+declare function readChat(slug: string, opts: ChatAuthOpts & {
+    personal?: boolean;
+    reconnect: true;
+    signal?: AbortSignal;
+}): Promise<AsyncGenerator<ChatStreamEvent> | null>;
+/**
+ * Send a message to an AI chat.
+ * @overload
+ * @param {string} slug
+ * @param {string} message
+ * @param {ChatAuthOpts & { stream?: false, source?: string, personal?: boolean, full_url?: string, pathname?: string, client_tools?: ClientToolDefinition[], context?: ClientContext[] }} [opts]
+ * @returns {Promise<AIChatSyncResponse>}
+ */
+declare function sendChatMessage(slug: string, message: string, opts?: ChatAuthOpts & {
+    stream?: false;
+    source?: string;
+    personal?: boolean;
+    full_url?: string;
+    pathname?: string;
+    client_tools?: ClientToolDefinition[];
+    context?: ClientContext[];
+}): Promise<AIChatSyncResponse>;
+/**
+ * @overload
+ * @param {string} slug
+ * @param {string} message
+ * @param {ChatAuthOpts & { stream: true, source?: string, personal?: boolean, full_url?: string, pathname?: string, client_tools?: ClientToolDefinition[], context?: ClientContext[] }} opts
+ * @returns {Promise<AsyncGenerator<ChatStreamEvent>>}
+ */
+declare function sendChatMessage(slug: string, message: string, opts: ChatAuthOpts & {
+    stream: true;
+    source?: string;
+    personal?: boolean;
+    full_url?: string;
+    pathname?: string;
+    client_tools?: ClientToolDefinition[];
+    context?: ClientContext[];
+}): Promise<AsyncGenerator<ChatStreamEvent>>;
+/**
+ * Interrupt an active AI generation for the given chat slug.
+ * @param {string} slug
+ * @param {ChatAuthOpts & { personal?: boolean }} [opts]
+ * @returns {Promise<void>}
+ */
+declare function interruptChat(slug: string, opts?: ChatAuthOpts & {
+    personal?: boolean;
+}): Promise<void>;
+/**
+ * Submit a client-side tool execution result back to the server.
+ * Call this when you receive a `client_tool_request` event from the SSE stream.
+ * @param {string} requestId - The `request_id` from the `client_tool_request` event
+ * @param {{ result?: any, error?: string }} outcome - The tool result or error
+ * @param {ChatAuthOpts & { personal?: boolean }} [opts]
+ * @returns {Promise<void>}
+ */
+declare function submitToolResult(requestId: string, outcome: {
+    result?: any;
+    error?: string;
+}, opts?: ChatAuthOpts & {
+    personal?: boolean;
+}): Promise<void>;
+type ChatAuthOpts = {
+    org?: string;
+    authToken?: string;
+};
+type RecentChatsResponse = RecentChatsResponse$1;
+type AIChatGETResponse = AIChatGETResponse$1;
+type ChatStreamEvent = ChatStreamEvent$1;
+type ClientToolDefinition = ClientToolDefinition$1;
+type ClientContext = ClientContext$1;
+type AIChatSyncResponse = AIChatSyncResponse$1;
+
+/**
+ * Start the checkout process
+ * @param {{ price_id:string }} args
+ */
+declare function startCheckoutSession(args: {
+    price_id: string;
+}): Promise<{
+    ok: boolean;
+    status: number;
+}>;
+
+declare namespace AuthScopes {
+    let Basic: UserScope[];
+    let Payment: string[];
+    let All: string[];
+}
+
+export { Auth, AuthScopes, NeedleLoginButton, getDeployments, getUserLicenses, interruptChat, listChats, ownsProduct, readChat, sendChatMessage, startCheckoutSession, submitToolResult, uploadFiles };
+export type { AIChatGETResponse, AIChatSyncResponse, AuthData, AuthInitOpts, ChatAuthOpts, ChatStreamEvent, ClientContext, ClientToolDefinition, Deployment, Filelike, LogtoUserCustomData, RecentChatsResponse, ResourceUrl, UserInfoResponse };