fauna-api 0.0.0-stage → 1.0.679

package/dist/brands.d.ts

@@ -0,0 +1,2 @@
+export { drawCrown, getFaunaLogoDataUrl, mountCrown, mountPoweredBy, renderCrown, type CrownTheme, type MountCrownOptions, } from "./src/ui/crown.js";
+export { Crown, type CrownProps } from "./src/ui/brands.js";

package/dist/brands.js

@@ -0,0 +1,2 @@
+export { drawCrown, getFaunaLogoDataUrl, mountCrown, mountPoweredBy, renderCrown, } from "./src/ui/crown.js";
+export { Crown } from "./src/ui/brands.js";

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import * as AuthentificationAPI from "./src/authentification.js";
+import * as IntegrationsAPI from "./src/integrations.js";
+import * as DriveAPI from "./src/drive.js";
+import * as GroupsAPI from "./src/groups.js";
+import * as InboxAPI from "./src/inbox.js";
+import * as BillingAPI from "./src/billing.js";
+import * as WebhooksAPI from "./src/webhooks.js";
+import * as MapsAPI from "./src/maps.js";
+import * as TravelAPI from "./src/travel.js";
+import * as PaymentsAPI from "./src/payments.js";
+import * as FriendsAPI from "./src/friends.js";
+import * as ChatsAPI from "./src/chats.js";
+import * as CalendarAPI from "./src/calendar.js";
+import { Ant as AntAPI } from "./src/ant/index.js";
+import { Parrot as ParrotAPI } from "./src/parrot/index.js";
+import { Marmot as MarmotAPI } from "./src/marmot/index.js";
+import { Magpie as MagpieAPI } from "./src/magpie/index.js";
+import { Cicada as CicadaAPI } from "./src/cicada/index.js";
+import { Termite as TermiteAPI } from "./src/termite/index.js";
+import { Extensions as ExtensionsAPI } from "./src/extensions/index.js";
+import * as LiveAPI from "./src/shared/server.js";
+import * as TicketsAPI from "./src/tickets.js";
+import * as RoomsAPI from "./src/rooms.js";
+import * as ViewAPI from "./src/view.js";
+import type * as SchemaAPI from "./src/shared/schema.js";
+export declare namespace Fauna {
+    function setRoute(route: string): void;
+    function getIP(): string;
+    function getPort(): number;
+    function getRoute(): string;
+    function getURL(): string;
+    function ping(): Promise<number>;
+    export import Authentification = AuthentificationAPI;
+    export import Integrations = IntegrationsAPI;
+    export import Drive = DriveAPI;
+    export import Groups = GroupsAPI;
+    export import Inbox = InboxAPI;
+    export import Billing = BillingAPI;
+    export import Webhooks = WebhooksAPI;
+    export import Maps = MapsAPI;
+    export import Travel = TravelAPI;
+    export import Payments = PaymentsAPI;
+    export import Friends = FriendsAPI;
+    export import Chats = ChatsAPI;
+    export import Calendar = CalendarAPI;
+    export import Ant = AntAPI;
+    export import Parrot = ParrotAPI;
+    export import Marmot = MarmotAPI;
+    export import Magpie = MagpieAPI;
+    export import Cicada = CicadaAPI;
+    export import Termite = TermiteAPI;
+    export import Extensions = ExtensionsAPI;
+    export import Live = LiveAPI;
+    export import Tickets = TicketsAPI;
+    export import Rooms = RoomsAPI;
+    export import View = ViewAPI;
+    type Schema = SchemaAPI.Schema;
+    namespace Schema {
+        type ObjectSchema = SchemaAPI.ObjectSchema;
+        type ArraySchema = SchemaAPI.ArraySchema;
+        type PrimitiveSchema = SchemaAPI.PrimitiveSchema;
+    }
+    function throttlingPromise<T>(tasks: (() => Promise<T>)[], max: number): Promise<T[]>;
+}

package/dist/index.js

@@ -0,0 +1,121 @@
+import * as AuthentificationAPI from "./src/authentification.js";
+import * as IntegrationsAPI from "./src/integrations.js";
+import * as DriveAPI from "./src/drive.js";
+import * as GroupsAPI from "./src/groups.js";
+import * as InboxAPI from "./src/inbox.js";
+import * as BillingAPI from "./src/billing.js";
+import * as WebhooksAPI from "./src/webhooks.js";
+import * as MapsAPI from "./src/maps.js";
+import * as TravelAPI from "./src/travel.js";
+import * as PaymentsAPI from "./src/payments.js";
+import * as FriendsAPI from "./src/friends.js";
+import * as ChatsAPI from "./src/chats.js";
+import * as CalendarAPI from "./src/calendar.js";
+import { Ant as AntAPI } from "./src/ant/index.js";
+import { Parrot as ParrotAPI } from "./src/parrot/index.js";
+import { Marmot as MarmotAPI } from "./src/marmot/index.js";
+import { Magpie as MagpieAPI } from "./src/magpie/index.js";
+import { Cicada as CicadaAPI } from "./src/cicada/index.js";
+import { Termite as TermiteAPI } from "./src/termite/index.js";
+import { Extensions as ExtensionsAPI } from "./src/extensions/index.js";
+import * as LiveAPI from "./src/shared/server.js";
+import * as TicketsAPI from "./src/tickets.js";
+import * as RoomsAPI from "./src/rooms.js";
+import * as ViewAPI from "./src/view.js";
+export var Fauna;
+(function (Fauna) {
+    var PREFIX = 'https://';
+    var IP = 'api.faunakit.com';
+    var PORT = 443;
+    function setRoute(route) {
+        const parts_0 = route.split('//');
+        if (parts_0.length > 1) {
+            PREFIX = parts_0[0] + '//';
+            const parts_1 = parts_0[1].split(':');
+            if (parts_1.length > 1) {
+                IP = parts_1[0];
+                PORT = Number(parts_1[1]);
+            }
+            else {
+                IP = parts_1[0];
+            }
+        }
+        else {
+            const parts_1 = parts_0[0].split(':');
+            if (parts_1.length > 1) {
+                IP = parts_1[0];
+                PORT = Number(parts_1[1]);
+            }
+            else {
+                IP = parts_1[0];
+            }
+        }
+    }
+    Fauna.setRoute = setRoute;
+    function getIP() {
+        return IP;
+    }
+    Fauna.getIP = getIP;
+    function getPort() {
+        return PORT;
+    }
+    Fauna.getPort = getPort;
+    function getRoute() {
+        return IP + ':' + PORT;
+    }
+    Fauna.getRoute = getRoute;
+    function getURL() {
+        return PREFIX + IP + ':' + PORT;
+    }
+    Fauna.getURL = getURL;
+    async function ping() {
+        const start = Date.now();
+        await fetch(`${getURL()}/`);
+        return Date.now() - start;
+    }
+    Fauna.ping = ping;
+    Fauna.Authentification = AuthentificationAPI;
+    Fauna.Integrations = IntegrationsAPI;
+    Fauna.Drive = DriveAPI;
+    Fauna.Groups = GroupsAPI;
+    Fauna.Inbox = InboxAPI;
+    Fauna.Billing = BillingAPI;
+    Fauna.Webhooks = WebhooksAPI;
+    Fauna.Maps = MapsAPI;
+    Fauna.Travel = TravelAPI;
+    Fauna.Payments = PaymentsAPI;
+    Fauna.Friends = FriendsAPI;
+    Fauna.Chats = ChatsAPI;
+    Fauna.Calendar = CalendarAPI;
+    Fauna.Ant = AntAPI;
+    Fauna.Parrot = ParrotAPI;
+    Fauna.Marmot = MarmotAPI;
+    Fauna.Magpie = MagpieAPI;
+    Fauna.Cicada = CicadaAPI;
+    Fauna.Termite = TermiteAPI;
+    Fauna.Extensions = ExtensionsAPI;
+    Fauna.Live = LiveAPI;
+    Fauna.Tickets = TicketsAPI;
+    Fauna.Rooms = RoomsAPI;
+    Fauna.View = ViewAPI;
+    async function throttlingPromise(tasks, max) {
+        const results = [];
+        let index = 0;
+        let running = [];
+        async function run() {
+            if (index >= tasks.length)
+                return;
+            const i = index++;
+            const task = tasks[i];
+            const result = await task();
+            results[i] = result;
+            await run();
+        }
+        for (let i = 0; i < Math.min(max, tasks.length); i++) {
+            running.push(run());
+        }
+        await Promise.all(running);
+        return results;
+    }
+    Fauna.throttlingPromise = throttlingPromise;
+})(Fauna || (Fauna = {}));

package/dist/src/ant/chat.d.ts

@@ -0,0 +1,130 @@
+import { Identity } from "./persona.js";
+import { ApiKey, Credentials } from "../authentification.js";
+import { Group } from "../groups.js";
+import { Authorization, Presence, Room, Hooks as ServerHooks } from "../shared/server.js";
+import { ChatRoom, RoomHooks } from "../parrot/room.js";
+import { StreamEvent, type Content, type Tool } from "../parrot/generative.js";
+import { Memory } from "../parrot/agent.js";
+import type { Repository } from "../termite/versioning.js";
+export type ChatLast = {
+    parts: unknown[];
+    role: string;
+    createdAt: Date;
+    position: number;
+    author?: {
+        email: string;
+        displayName?: string;
+        icon?: string;
+    };
+    model?: string;
+};
+export declare function listChats(authorization: Credentials | ApiKey, opts?: {
+    group?: Group;
+}): Promise<{
+    name: string;
+    id: string;
+    last: ChatLast | null;
+}[]>;
+/** Create a chat. `repository` (the owner's) is the computer its personas start from. */
+export declare function createChat(authorization: Credentials | ApiKey, name: string, opts?: {
+    group?: Group;
+    audience?: string[];
+    repository?: Repository;
+}): Promise<{
+    name: string;
+    id: string;
+}>;
+export declare function deleteChat(authorization: Credentials | ApiKey, id: string, opts?: {
+    group?: Group;
+}): Promise<void>;
+export declare function moveChatToGroup(authorization: Credentials | ApiKey, id: string, groupId: string): Promise<{
+    id: string;
+    name: string;
+    groupId: string;
+    remapped: boolean;
+}>;
+export declare function renameChat(authorization: Credentials | ApiKey, id: string, name: string, opts?: {
+    group?: Group;
+}): Promise<void>;
+export declare class Agent {
+    readonly parent: AntChatRoom;
+    readonly id: string;
+    persona: Identity;
+    /** A repository picked for this agent, used directly; null when it follows the chat's. */
+    repository: number | null;
+    constructor(parent: AntChatRoom, id: string, persona: Identity, repository?: number | null);
+    /** Pick a repository for this agent (used directly), or null to follow the chat's again. */
+    setRepository(repository: Repository | null): void;
+    observe(content: string): Promise<Memory>;
+    /** Stream a reply as this agent, under the room's own authorization. `tools` answer the persona's calls to them. */
+    generate(messages: Content[], opts?: {
+        signal?: AbortSignal;
+        tools?: Tool[];
+    }): AsyncGenerator<StreamEvent>;
+    toJSON(): {
+        id: string;
+        persona: Identity;
+    };
+    static fromJSON(json: any, parent: AntChatRoom): Agent;
+}
+export declare class AntChatRoom extends Room {
+    chatId: string;
+    name: string;
+    agents: Map<string, Agent>;
+    /** The owner's Termite repository personas start from, by id; null when it has none. */
+    repository: number | null;
+    /** Who owns the chat: `credentials:{id}` or `group:{id}`. */
+    owner: string;
+    private readonly repositoryWatchers;
+    constructor(endpoint: string, ws: WebSocket, authorization: Authorization, id: string);
+    /** The group that owns the chat, whose repositories it takes; undefined for a person's. */
+    get group(): Group | undefined;
+    /** Attach one of the owner's repositories, or null to detach. Personas' forks of the old one are deleted. */
+    setRepository(repository: Repository | null): Promise<void>;
+    /** Hear about every repository change, from anyone in the room. Returns a function that stops listening. */
+    watchRepository(listener: (repository: number | null) => void): () => void;
+    private applyRepository;
+    hydrate(state: any): void;
+    handleEvent(packet: any): boolean | Promise<void>;
+    upsertAgent(identity: Identity): Agent;
+    removeAgent(id: string): void;
+    /** Lazily mint/open the architect Parrot ChatRoom. */
+    getChat(hooks?: RoomHooks): Promise<{
+        room: ChatRoom;
+        self: Presence;
+        chatId: string;
+    }>;
+    static connect(authorization: Credentials | ApiKey, target: {
+        id: string;
+    }, opts?: {
+        group?: Group;
+        hooks?: ServerHooks;
+        server?: string;
+    }): Promise<{
+        room: AntChatRoom;
+        self: Presence;
+    }>;
+    static join(authorization: Credentials | ApiKey, target: {
+        accessCode: string;
+    }, hooks?: ServerHooks): Promise<{
+        room: AntChatRoom;
+        self: Presence;
+    }>;
+}
+/** Write a standalone fact onto this agent's Parrot graph (`ant/chats/…/memory`). */
+export declare function observeAgent(authorization: Credentials | ApiKey, chatId: string, agentId: string, content: string, opts?: {
+    group?: Group;
+    accessCode?: string;
+}): Promise<Memory>;
+/**
+ * Stream a persona reply for one chat agent (memories under ant/chats/…), with
+ * `tool` and `tool-result` events for its own tools. `tools` are answered here
+ * when the persona calls them, like `use_desktop` asking for a computer.
+ */
+export declare function generateAgent(authorization: Credentials | ApiKey, chatId: string, agentId: string, messages: Content[], opts?: {
+    group?: Group;
+    accessCode?: string;
+    signal?: AbortSignal;
+    tools?: Tool[];
+}): AsyncGenerator<StreamEvent>;
+export { AntChatRoom as ChatRoom };