@meshagent/meshagent 0.44.12 → 0.45.0

package/dist/esm/sqlite-client.js

@@ -0,0 +1,625 @@
+import { Schema, Table, tableFromIPC, tableToIPC } from "apache-arrow";
+import { RoomServerException } from "./room-server-client.js";
+import { BinaryContent, ControlContent, EmptyContent, ErrorContent, JsonContent } from "./response.js";
+import { DatasetValueEncoder } from "./datasets-client.js";
+const ARROW_IPC_STREAM_MIME_TYPE = "application/vnd.apache.arrow.stream";
+const globalScope = globalThis;
+async function* toAsyncArrowIterable(chunks) {
+    if (Symbol.asyncIterator in chunks) {
+        for await (const chunk of chunks) {
+            yield chunk;
+        }
+        return;
+    }
+    for (const chunk of chunks) {
+        yield chunk;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function bytesToBase64(bytes) {
+    if (globalScope.Buffer) {
+        return globalScope.Buffer.from(bytes).toString("base64");
+    }
+    if (!globalScope.btoa) {
+        throw new Error("base64 encoding is not available in this runtime");
+    }
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return globalScope.btoa(binary);
+}
+function encodeRecordValue(value) {
+    if (value instanceof DatasetValueEncoder) {
+        return value.encodeDatasetValue();
+    }
+    if (value instanceof Uint8Array) {
+        return {
+            binary: bytesToBase64(value),
+        };
+    }
+    if (value instanceof Date) {
+        return {
+            timestamp: value.toISOString().replace("+00:00", "Z"),
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            list: value.map((item) => encodeRecordValue(item)),
+        };
+    }
+    if (isRecord(value)) {
+        throw new RoomServerException("sqlite object values must use DatasetStruct or DatasetJson");
+    }
+    return value;
+}
+function buildWhereClause(where) {
+    if (where != null && typeof where === "object" && !Array.isArray(where)) {
+        return Object.fromEntries(Object.entries(where).map(([key, value]) => [key, encodeRecordValue(value)]));
+    }
+    if (typeof where === "string") {
+        return where;
+    }
+    return null;
+}
+function schemaToIPC(schema) {
+    return tableToIPC(new Table(schema, []), "stream");
+}
+function tableFromIPCBytes(data) {
+    const table = tableFromIPC(data);
+    if (table instanceof Promise) {
+        throw new RoomServerException("unexpected async Arrow IPC result");
+    }
+    return table;
+}
+function tableFromChunks(chunks) {
+    if (chunks.length === 0) {
+        return new Table(new Schema([]), []);
+    }
+    const [first, ...rest] = chunks;
+    return first.concat(...rest);
+}
+function schemaFromIPCBytes(data) {
+    return tableFromIPCBytes(data).schema;
+}
+class SqliteArrowWriteInputStream {
+    constructor(start, chunks, schema) {
+        this.start = start;
+        this.schema = schema;
+        this.pulls = [];
+        this.closed = false;
+        this.source = toAsyncArrowIterable(chunks)[Symbol.asyncIterator]();
+    }
+    requestNext() {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.pulls.shift();
+        if (waiter) {
+            waiter();
+            return;
+        }
+        this.pulls.push(() => undefined);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        while (this.pulls.length > 0) {
+            const waiter = this.pulls.shift();
+            waiter?.();
+        }
+        void this.source.return?.();
+    }
+    async waitForPull() {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.pulls.shift();
+        if (waiter) {
+            waiter();
+            return;
+        }
+        await new Promise((resolve) => {
+            this.pulls.push(resolve);
+        });
+    }
+    async *stream() {
+        yield new BinaryContent({
+            data: this.schema == null ? new Uint8Array() : schemaToIPC(this.schema),
+            headers: this.start,
+        });
+        while (!this.closed) {
+            await this.waitForPull();
+            if (this.closed) {
+                return;
+            }
+            const nextChunk = await this.source.next();
+            if (nextChunk.done) {
+                return;
+            }
+            if (nextChunk.value.numRows === 0) {
+                continue;
+            }
+            yield new BinaryContent({
+                data: tableToIPC(nextChunk.value, "stream"),
+                headers: { kind: "data", content_type: ARROW_IPC_STREAM_MIME_TYPE },
+            });
+        }
+    }
+}
+class SqliteArrowReadInputStream {
+    constructor(start) {
+        this.start = start;
+        this.pulls = [];
+        this.closed = false;
+    }
+    requestNext() {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.pulls.shift();
+        if (waiter) {
+            waiter();
+            return;
+        }
+        this.pulls.push(() => undefined);
+    }
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        while (this.pulls.length > 0) {
+            const waiter = this.pulls.shift();
+            waiter?.();
+        }
+    }
+    async waitForPull() {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.pulls.shift();
+        if (waiter) {
+            waiter();
+            return;
+        }
+        await new Promise((resolve) => {
+            this.pulls.push(resolve);
+        });
+    }
+    async *stream() {
+        yield new BinaryContent({ data: new Uint8Array(), headers: this.start });
+        while (!this.closed) {
+            await this.waitForPull();
+            if (this.closed) {
+                return;
+            }
+            yield new BinaryContent({ data: new Uint8Array(), headers: { kind: "pull" } });
+        }
+    }
+}
+export class SqliteDatabaseClient {
+    constructor(client, database, namespace) {
+        this.client = client;
+        this.database = database;
+        this.namespace = namespace;
+    }
+    async createDatabase({ mode = "create" } = {}) {
+        return this.client.createDatabase({ name: this.database, namespace: this.namespace, mode });
+    }
+    async dropDatabase({ ignoreMissing = false } = {}) {
+        return this.client.dropDatabase({ name: this.database, namespace: this.namespace, ignoreMissing });
+    }
+    async inspectDatabase() {
+        return this.client.inspectDatabase({ name: this.database, namespace: this.namespace });
+    }
+    async listTables() {
+        return this.client.listTables({ database: this.database, namespace: this.namespace });
+    }
+    async createTableWithSchema(params) {
+        return this.client.createTableWithSchema({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async createTableFromData(params) {
+        return this.client.createTableFromData({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async dropTable(params) {
+        return this.client.dropTable({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async renameTable(params) {
+        return this.client.renameTable({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async inspect(params) {
+        return this.client.inspect({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async addColumns(params) {
+        return this.client.addColumns({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async dropColumns(params) {
+        return this.client.dropColumns({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async insert(params) {
+        return this.client.insert({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async update(params) {
+        return this.client.update({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async delete(params) {
+        return this.client.delete({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async search(params) {
+        return this.client.search({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async searchTable(params) {
+        return this.client.searchTable({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async searchStream(params) {
+        return this.client.searchStream({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async count(params) {
+        return this.client.count({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async sql(params) {
+        return this.client.sql({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async sqlTable(params) {
+        return this.client.sqlTable({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async *sqlStream(params) {
+        yield* this.client.sqlStream({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async executeSql(params) {
+        return this.client.executeSql({ ...params, database: this.database, namespace: this.namespace });
+    }
+    async executeSqlStatement(params) {
+        return this.client.executeSqlStatement({ ...params, database: this.database, namespace: this.namespace });
+    }
+}
+export class SqliteClient {
+    constructor({ room }) {
+        this.room = room;
+    }
+    unexpectedResponseError(operation) {
+        return new RoomServerException(`unexpected return type from sqlite.${operation}`);
+    }
+    database(name, { namespace } = {}) {
+        return new SqliteDatabaseClient(this, name, namespace);
+    }
+    async invoke(operation, input) {
+        return await this.room.invokeContent({ toolkit: "sqlite", tool: operation, input });
+    }
+    async invokeContent(operation, input) {
+        return await this.room.invokeContent({ toolkit: "sqlite", tool: operation, input });
+    }
+    async invokeStream(operation, input) {
+        return await this.room.invokeStream({ toolkit: "sqlite", tool: operation, input });
+    }
+    async drainWriteStream(operation, input) {
+        const response = await this.invokeStream(operation, input.stream());
+        try {
+            for await (const chunk of response) {
+                if (chunk instanceof ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        return;
+                    }
+                    throw this.unexpectedResponseError(operation);
+                }
+                if (!(chunk instanceof BinaryContent) || chunk.headers.kind !== "pull") {
+                    throw this.unexpectedResponseError(operation);
+                }
+                input.requestNext();
+            }
+        }
+        finally {
+            input.close();
+        }
+    }
+    async *streamArrow(operation, start) {
+        const input = new SqliteArrowReadInputStream(start);
+        const response = await this.invokeStream(operation, input.stream());
+        input.requestNext();
+        try {
+            for await (const chunk of response) {
+                if (chunk instanceof ErrorContent) {
+                    throw new RoomServerException(chunk.text, chunk.code);
+                }
+                if (chunk instanceof ControlContent) {
+                    if (chunk.method === "close") {
+                        return;
+                    }
+                    throw this.unexpectedResponseError(operation);
+                }
+                if (!(chunk instanceof BinaryContent) || chunk.headers.kind !== "data") {
+                    throw this.unexpectedResponseError(operation);
+                }
+                yield tableFromIPCBytes(chunk.data);
+                input.requestNext();
+            }
+        }
+        finally {
+            input.close();
+        }
+    }
+    async listDatabases({ namespace } = {}) {
+        const response = await this.invoke("list_databases", { namespace: namespace ?? null });
+        if (!(response instanceof JsonContent) || !Array.isArray(response.json.databases)) {
+            throw this.unexpectedResponseError("list_databases");
+        }
+        return response.json.databases;
+    }
+    async createDatabase({ name, namespace, mode = "create" }) {
+        const response = await this.invoke("create_database", { name, namespace: namespace ?? null, mode });
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("create_database");
+        }
+    }
+    async dropDatabase({ name, namespace, ignoreMissing = false }) {
+        const response = await this.invoke("drop_database", { name, namespace: namespace ?? null, ignore_missing: ignoreMissing });
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("drop_database");
+        }
+    }
+    async inspectDatabase({ name, namespace }) {
+        const response = await this.invoke("inspect_database", { name, namespace: namespace ?? null });
+        if (!(response instanceof JsonContent) || typeof response.json.name !== "string" || typeof response.json.tables !== "number") {
+            throw this.unexpectedResponseError("inspect_database");
+        }
+        return {
+            name: response.json.name,
+            namespace: Array.isArray(response.json.namespace) ? response.json.namespace : null,
+            tables: response.json.tables,
+            sizeBytes: typeof response.json.size_bytes === "number" ? response.json.size_bytes : 0,
+        };
+    }
+    async listTables({ database, namespace }) {
+        const response = await this.invoke("list_tables", { database, namespace: namespace ?? null });
+        if (!(response instanceof JsonContent) || !Array.isArray(response.json.tables)) {
+            throw this.unexpectedResponseError("list_tables");
+        }
+        return response.json.tables;
+    }
+    async createTable({ database, name, data, schema, mode = "create", namespace, }) {
+        const input = new SqliteArrowWriteInputStream({
+            kind: "start",
+            database,
+            name,
+            mode,
+            namespace: namespace ?? null,
+        }, data ?? [], schema);
+        await this.drainWriteStream("create_table", input);
+    }
+    async createTableWithSchema({ database, name, schema, data, mode = "create", namespace }) {
+        return this.createTable({
+            database,
+            name,
+            schema,
+            data: data == null ? undefined : data instanceof Table ? [data] : data,
+            mode,
+            namespace,
+        });
+    }
+    async createTableFromData({ database, name, data, mode = "create", namespace }) {
+        return this.createTable({
+            database,
+            name,
+            data: data == null ? undefined : data instanceof Table ? [data] : data,
+            mode,
+            namespace,
+        });
+    }
+    async dropTable({ database, name, ignoreMissing = false, namespace }) {
+        const response = await this.invoke("drop_table", { database, name, ignore_missing: ignoreMissing, namespace: namespace ?? null });
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("drop_table");
+        }
+    }
+    async renameTable({ database, name, newName, namespace }) {
+        const response = await this.invoke("rename_table", { database, name, new_name: newName, namespace: namespace ?? null });
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("rename_table");
+        }
+    }
+    async inspect({ database, table, namespace }) {
+        const response = await this.invoke("inspect", { database, table, namespace: namespace ?? null });
+        if (!(response instanceof BinaryContent)) {
+            throw this.unexpectedResponseError("inspect");
+        }
+        return schemaFromIPCBytes(response.data);
+    }
+    async addColumns({ database, table, newColumns, namespace }) {
+        const response = await this.invokeContent("add_columns", new BinaryContent({
+            data: schemaToIPC(newColumns),
+            headers: {
+                database,
+                table,
+                namespace: namespace ?? null,
+                content_type: ARROW_IPC_STREAM_MIME_TYPE,
+            },
+        }));
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("add_columns");
+        }
+    }
+    async dropColumns({ database, table, columns, namespace }) {
+        const response = await this.invoke("drop_columns", { database, table, columns, namespace: namespace ?? null });
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("drop_columns");
+        }
+    }
+    async insert({ database, table, records, namespace }) {
+        await this.insertStream({ database, table, chunks: [records], namespace });
+    }
+    async insertStream({ database, table, chunks, namespace }) {
+        const input = new SqliteArrowWriteInputStream({
+            kind: "start",
+            database,
+            table,
+            namespace: namespace ?? null,
+        }, chunks);
+        await this.drainWriteStream("insert", input);
+    }
+    async update({ database, table, where, values, params, namespace }) {
+        const response = await this.invoke("update", {
+            database,
+            table,
+            where,
+            values: Object.entries(values).map(([column, value]) => ({ column, value_json: JSON.stringify(encodeRecordValue(value)) })),
+            params: params ?? null,
+            namespace: namespace ?? null,
+        });
+        if (!(response instanceof JsonContent) || typeof response.json.rows_affected !== "number") {
+            throw this.unexpectedResponseError("update");
+        }
+        return response.json.rows_affected;
+    }
+    async delete({ database, table, where, params, namespace }) {
+        const response = await this.invoke("delete", { database, table, where, params: params ?? null, namespace: namespace ?? null });
+        if (!(response instanceof JsonContent) || typeof response.json.rows_affected !== "number") {
+            throw this.unexpectedResponseError("delete");
+        }
+        return response.json.rows_affected;
+    }
+    async search({ database, table, where, params, offset, limit, select, namespace }) {
+        const results = [];
+        for await (const chunk of this.searchStream({ database, table, where, params, offset, limit, select, namespace })) {
+            results.push(chunk);
+        }
+        return results;
+    }
+    async searchTable({ database, table, where, params, offset, limit, select, namespace }) {
+        return tableFromChunks(await this.search({ database, table, where, params, offset, limit, select, namespace }));
+    }
+    async *searchStream({ database, table, where, params, offset, limit, select, namespace }) {
+        yield* this.streamArrow("search", {
+            kind: "start",
+            database,
+            table,
+            where: buildWhereClause(where),
+            params: params ?? null,
+            offset: offset ?? null,
+            limit: limit ?? null,
+            select: select ?? null,
+            namespace: namespace ?? null,
+        });
+    }
+    async count({ database, table, where, params, namespace }) {
+        const response = await this.invoke("count", {
+            database,
+            table,
+            where: buildWhereClause(where),
+            params: params ?? null,
+            namespace: namespace ?? null,
+        });
+        if (!(response instanceof JsonContent) || typeof response.json.count !== "number" || !Number.isInteger(response.json.count)) {
+            throw this.unexpectedResponseError("count");
+        }
+        return response.json.count;
+    }
+    async sql({ database, query, params, namespace }) {
+        const results = [];
+        for await (const chunk of this.sqlStream({ database, query, params, namespace })) {
+            results.push(chunk);
+        }
+        return results;
+    }
+    async sqlTable({ database, query, params, namespace }) {
+        return tableFromChunks(await this.sql({ database, query, params, namespace }));
+    }
+    async openSqlQuery({ database, query, params, namespace }) {
+        const response = await this.invokeContent("open_sql_query", new BinaryContent({
+            data: new Uint8Array(),
+            headers: { database, query, params: params ?? null, namespace: namespace ?? null },
+        }));
+        if (!(response instanceof BinaryContent)) {
+            throw this.unexpectedResponseError("open_sql_query");
+        }
+        const queryId = response.headers.query_id;
+        if (typeof queryId !== "string" || queryId === "") {
+            throw this.unexpectedResponseError("open_sql_query");
+        }
+        return {
+            schema: schemaFromIPCBytes(response.data),
+            kind: "query",
+            queryId,
+        };
+    }
+    async executeSql({ database, query, params, namespace }) {
+        const response = await this.invokeContent("execute_sql", new BinaryContent({
+            data: new Uint8Array(),
+            headers: { database, query, params: params ?? null, namespace: namespace ?? null },
+        }));
+        if (response instanceof BinaryContent) {
+            if (response.headers.kind !== "query") {
+                throw this.unexpectedResponseError("execute_sql");
+            }
+            const queryId = response.headers.query_id;
+            if (typeof queryId !== "string" || queryId === "") {
+                throw this.unexpectedResponseError("execute_sql");
+            }
+            return {
+                kind: "query",
+                schema: schemaFromIPCBytes(response.data),
+                queryId,
+            };
+        }
+        if (response instanceof JsonContent) {
+            if (response.json.kind !== "statement"
+                || typeof response.json.rows_affected !== "number"
+                || !Number.isInteger(response.json.rows_affected)) {
+                throw this.unexpectedResponseError("execute_sql");
+            }
+            return {
+                kind: "statement",
+                rowsAffected: response.json.rows_affected,
+            };
+        }
+        throw this.unexpectedResponseError("execute_sql");
+    }
+    async *sqlStream({ database, query, params, namespace }) {
+        const result = await this.executeSql({ database, query, params, namespace });
+        if (result.kind === "statement") {
+            throw new RoomServerException(`SQL statement did not return rows; rows_affected=${result.rowsAffected}`);
+        }
+        try {
+            yield* this.readSqlQuery({ queryId: result.queryId });
+        }
+        finally {
+            await this.closeSqlQuery({ queryId: result.queryId });
+        }
+    }
+    async *readSqlQuery({ queryId }) {
+        yield* this.streamArrow("read_sql_query", { kind: "start", query_id: queryId });
+    }
+    async closeSqlQuery({ queryId }) {
+        const response = await this.invoke("close_sql_query", { query_id: queryId });
+        if (!(response instanceof EmptyContent)) {
+            throw this.unexpectedResponseError("close_sql_query");
+        }
+    }
+    async cancelSqlQuery({ queryId }) {
+        const response = await this.invoke("cancel_sql_query", { query_id: queryId });
+        if (!(response instanceof JsonContent)
+            || !["cancelled", "cancelling", "not_cancellable"].includes(response.json.status)) {
+            throw this.unexpectedResponseError("cancel_sql_query");
+        }
+        return { status: response.json.status };
+    }
+    async executeSqlStatement({ database, query, params, namespace }) {
+        const response = await this.invokeContent("execute_sql_statement", new BinaryContent({
+            data: new Uint8Array(),
+            headers: { database, query, params: params ?? null, namespace: namespace ?? null },
+        }));
+        if (!(response instanceof JsonContent)
+            || typeof response.json.rows_affected !== "number"
+            || !Number.isInteger(response.json.rows_affected)) {
+            throw this.unexpectedResponseError("execute_sql_statement");
+        }
+        return response.json.rows_affected;
+    }
+}

package/dist/esm/toolkit-config.d.ts

@@ -12,6 +12,11 @@ export declare class MCPHeader {
     toJson(): Record<string, string>;
 }
 export type MCPRequireApproval = "always" | "never";
+export interface MeshagentProxyConfig {
+    apiUrl: string;
+    apiKey: string;
+    user?: string | null;
+}
 export declare class MCPServer {
     readonly serverLabel: string;
     readonly authorization?: string;
@@ -67,9 +72,10 @@ export declare class Connector {
     isConnected(room: RoomClient, agentName: string): Promise<boolean>;
     authenticate(client: RoomClient, agent: RemoteParticipant, redirectUri: string | URL): Promise<string | null>;
 }
-export declare function mcpConnectorsFromRoomServices({ services, agentName, }: {
+export declare function mcpConnectorsFromRoomServices({ services, agentName, meshagentProxyConfig, }: {
     services: Iterable<ServiceSpec>;
     agentName?: string | null;
+    meshagentProxyConfig?: MeshagentProxyConfig | null;
 }): Connector[];
 export declare class OpenAIConnectors {
     static readonly dropbox: Connector;