@acontext/acontext 0.0.1

package/dist/messages.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Support for constructing session messages.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcontextMessage = exports.AcontextMessageSchema = exports.MessagePart = exports.MessagePartSchema = void 0;
+exports.buildAcontextMessage = buildAcontextMessage;
+const zod_1 = require("zod");
+exports.MessagePartSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    text: zod_1.z.string().nullable().optional(),
+    meta: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable().optional(),
+    file_field: zod_1.z.string().nullable().optional(),
+});
+class MessagePart {
+    constructor(data) {
+        this.type = data.type;
+        this.text = data.text ?? null;
+        this.meta = data.meta ?? null;
+        this.file_field = data.file_field ?? null;
+    }
+    static textPart(text, options) {
+        return new MessagePart({
+            type: 'text',
+            text,
+            meta: options?.meta ?? null,
+        });
+    }
+    static fileFieldPart(fileField, options) {
+        return new MessagePart({
+            type: 'file',
+            file_field: fileField,
+            meta: options?.meta ?? null,
+        });
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            text: this.text ?? null,
+            meta: this.meta ?? null,
+            file_field: this.file_field ?? null,
+        };
+    }
+}
+exports.MessagePart = MessagePart;
+exports.AcontextMessageSchema = zod_1.z.object({
+    role: zod_1.z.enum(['user', 'assistant', 'system']),
+    parts: zod_1.z.array(exports.MessagePartSchema),
+    meta: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable().optional(),
+});
+class AcontextMessage {
+    constructor(data) {
+        this.role = data.role;
+        this.parts = data.parts.map((p) => p instanceof MessagePart ? p : new MessagePart(p));
+        this.meta = data.meta ?? null;
+    }
+    toJSON() {
+        return {
+            role: this.role,
+            parts: this.parts.map((p) => p.toJSON()),
+            meta: this.meta ?? null,
+        };
+    }
+}
+exports.AcontextMessage = AcontextMessage;
+function buildAcontextMessage(options) {
+    if (!['user', 'assistant', 'system'].includes(options.role)) {
+        throw new Error("role must be one of {'user', 'assistant', 'system'}");
+    }
+    const normalizedParts = options.parts.map((part) => {
+        if (part instanceof MessagePart) {
+            return part;
+        }
+        if (typeof part === 'string') {
+            return MessagePart.textPart(part);
+        }
+        if (typeof part === 'object' && part !== null) {
+            if (!('type' in part)) {
+                throw new Error("mapping message parts must include a 'type'");
+            }
+            return new MessagePart(part);
+        }
+        throw new TypeError('unsupported message part type');
+    });
+    return new AcontextMessage({
+        role: options.role,
+        parts: normalizedParts,
+        meta: options.meta ?? null,
+    });
+}

package/dist/resources/blocks.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Block endpoints.
+ */
+import { RequesterProtocol } from '../client-types';
+import { Block } from '../types';
+export declare class BlocksAPI {
+    private requester;
+    constructor(requester: RequesterProtocol);
+    list(spaceId: string, options?: {
+        parentId?: string | null;
+        blockType?: string | null;
+    }): Promise<Block[]>;
+    create(spaceId: string, options: {
+        blockType: string;
+        parentId?: string | null;
+        title?: string | null;
+        props?: Record<string, unknown> | null;
+    }): Promise<Block>;
+    delete(spaceId: string, blockId: string): Promise<void>;
+    getProperties(spaceId: string, blockId: string): Promise<Block>;
+    updateProperties(spaceId: string, blockId: string, options: {
+        title?: string | null;
+        props?: Record<string, unknown> | null;
+    }): Promise<void>;
+    move(spaceId: string, blockId: string, options: {
+        parentId?: string | null;
+        sort?: number | null;
+    }): Promise<void>;
+    updateSort(spaceId: string, blockId: string, options: {
+        sort: number;
+    }): Promise<void>;
+}

package/dist/resources/blocks.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Block endpoints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlocksAPI = void 0;
+const types_1 = require("../types");
+class BlocksAPI {
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async list(spaceId, options) {
+        const params = {};
+        if (options?.parentId !== undefined && options?.parentId !== null) {
+            params.parent_id = options.parentId;
+        }
+        if (options?.blockType !== undefined && options?.blockType !== null) {
+            params.type = options.blockType;
+        }
+        const data = await this.requester.request('GET', `/space/${spaceId}/block`, {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return Array.isArray(data) ? data.map((item) => types_1.BlockSchema.parse(item)) : [];
+    }
+    async create(spaceId, options) {
+        const payload = { type: options.blockType };
+        if (options.parentId !== undefined && options.parentId !== null) {
+            payload.parent_id = options.parentId;
+        }
+        if (options.title !== undefined && options.title !== null) {
+            payload.title = options.title;
+        }
+        if (options.props !== undefined && options.props !== null) {
+            payload.props = options.props;
+        }
+        const data = await this.requester.request('POST', `/space/${spaceId}/block`, {
+            jsonData: payload,
+        });
+        return types_1.BlockSchema.parse(data);
+    }
+    async delete(spaceId, blockId) {
+        await this.requester.request('DELETE', `/space/${spaceId}/block/${blockId}`);
+    }
+    async getProperties(spaceId, blockId) {
+        const data = await this.requester.request('GET', `/space/${spaceId}/block/${blockId}/properties`);
+        return types_1.BlockSchema.parse(data);
+    }
+    async updateProperties(spaceId, blockId, options) {
+        const payload = {};
+        if (options.title !== undefined && options.title !== null) {
+            payload.title = options.title;
+        }
+        if (options.props !== undefined && options.props !== null) {
+            payload.props = options.props;
+        }
+        if (Object.keys(payload).length === 0) {
+            throw new Error('title or props must be provided');
+        }
+        await this.requester.request('PUT', `/space/${spaceId}/block/${blockId}/properties`, {
+            jsonData: payload,
+        });
+    }
+    async move(spaceId, blockId, options) {
+        const payload = {};
+        if (options.parentId !== undefined && options.parentId !== null) {
+            payload.parent_id = options.parentId;
+        }
+        if (options.sort !== undefined && options.sort !== null) {
+            payload.sort = options.sort;
+        }
+        if (Object.keys(payload).length === 0) {
+            throw new Error('parentId or sort must be provided');
+        }
+        await this.requester.request('PUT', `/space/${spaceId}/block/${blockId}/move`, {
+            jsonData: payload,
+        });
+    }
+    async updateSort(spaceId, blockId, options) {
+        await this.requester.request('PUT', `/space/${spaceId}/block/${blockId}/sort`, {
+            jsonData: { sort: options.sort },
+        });
+    }
+}
+exports.BlocksAPI = BlocksAPI;

package/dist/resources/disks.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Disk and artifact endpoints.
+ */
+import { RequesterProtocol } from '../client-types';
+import { FileUpload } from '../uploads';
+import { Artifact, Disk, GetArtifactResp, ListArtifactsResp, ListDisksOutput, UpdateArtifactResp } from '../types';
+export declare class DisksAPI {
+    artifacts: DiskArtifactsAPI;
+    private requester;
+    constructor(requester: RequesterProtocol);
+    list(options?: {
+        limit?: number | null;
+        cursor?: string | null;
+        timeDesc?: boolean | null;
+    }): Promise<ListDisksOutput>;
+    create(): Promise<Disk>;
+    delete(diskId: string): Promise<void>;
+}
+export declare class DiskArtifactsAPI {
+    private requester;
+    constructor(requester: RequesterProtocol);
+    upsert(diskId: string, options: {
+        file: FileUpload | [string, Buffer | NodeJS.ReadableStream] | [string, Buffer | NodeJS.ReadableStream, string | null];
+        filePath?: string | null;
+        meta?: Record<string, unknown> | null;
+    }): Promise<Artifact>;
+    get(diskId: string, options: {
+        filePath: string;
+        filename: string;
+        withPublicUrl?: boolean | null;
+        withContent?: boolean | null;
+        expire?: number | null;
+    }): Promise<GetArtifactResp>;
+    update(diskId: string, options: {
+        filePath: string;
+        filename: string;
+        meta: Record<string, unknown>;
+    }): Promise<UpdateArtifactResp>;
+    delete(diskId: string, options: {
+        filePath: string;
+        filename: string;
+    }): Promise<void>;
+    list(diskId: string, options?: {
+        path?: string | null;
+    }): Promise<ListArtifactsResp>;
+}

package/dist/resources/disks.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Disk and artifact endpoints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskArtifactsAPI = exports.DisksAPI = void 0;
+const uploads_1 = require("../uploads");
+const utils_1 = require("../utils");
+const types_1 = require("../types");
+class DisksAPI {
+    constructor(requester) {
+        this.requester = requester;
+        this.artifacts = new DiskArtifactsAPI(requester);
+    }
+    async list(options) {
+        const params = (0, utils_1.buildParams)({
+            limit: options?.limit ?? null,
+            cursor: options?.cursor ?? null,
+            time_desc: options?.timeDesc ?? null,
+        });
+        const data = await this.requester.request('GET', '/disk', {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.ListDisksOutputSchema.parse(data);
+    }
+    async create() {
+        const data = await this.requester.request('POST', '/disk');
+        return types_1.DiskSchema.parse(data);
+    }
+    async delete(diskId) {
+        await this.requester.request('DELETE', `/disk/${diskId}`);
+    }
+}
+exports.DisksAPI = DisksAPI;
+class DiskArtifactsAPI {
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async upsert(diskId, options) {
+        const upload = (0, uploads_1.normalizeFileUpload)(options.file);
+        const files = {
+            file: upload.asFormData(),
+        };
+        const form = {};
+        if (options.filePath) {
+            form.file_path = options.filePath;
+        }
+        if (options.meta !== undefined && options.meta !== null) {
+            form.meta = JSON.stringify(options.meta);
+        }
+        const data = await this.requester.request('POST', `/disk/${diskId}/artifact`, {
+            data: Object.keys(form).length > 0 ? form : undefined,
+            files,
+        });
+        return types_1.ArtifactSchema.parse(data);
+    }
+    async get(diskId, options) {
+        const fullPath = `${options.filePath.replace(/\/$/, '')}/${options.filename}`;
+        const params = (0, utils_1.buildParams)({
+            file_path: fullPath,
+            with_public_url: options.withPublicUrl ?? null,
+            with_content: options.withContent ?? null,
+            expire: options.expire ?? null,
+        });
+        const data = await this.requester.request('GET', `/disk/${diskId}/artifact`, {
+            params,
+        });
+        return types_1.GetArtifactRespSchema.parse(data);
+    }
+    async update(diskId, options) {
+        const fullPath = `${options.filePath.replace(/\/$/, '')}/${options.filename}`;
+        const payload = {
+            file_path: fullPath,
+            meta: JSON.stringify(options.meta),
+        };
+        const data = await this.requester.request('PUT', `/disk/${diskId}/artifact`, {
+            jsonData: payload,
+        });
+        return types_1.UpdateArtifactRespSchema.parse(data);
+    }
+    async delete(diskId, options) {
+        const fullPath = `${options.filePath.replace(/\/$/, '')}/${options.filename}`;
+        const params = { file_path: fullPath };
+        await this.requester.request('DELETE', `/disk/${diskId}/artifact`, {
+            params,
+        });
+    }
+    async list(diskId, options) {
+        const params = {};
+        if (options?.path !== undefined && options?.path !== null) {
+            params.path = options.path;
+        }
+        const data = await this.requester.request('GET', `/disk/${diskId}/artifact/ls`, {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.ListArtifactsRespSchema.parse(data);
+    }
+}
+exports.DiskArtifactsAPI = DiskArtifactsAPI;

package/dist/resources/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resource API exports
+ */
+export * from './spaces';
+export * from './sessions';
+export * from './disks';
+export * from './blocks';

package/dist/resources/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Resource API exports
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./spaces"), exports);
+__exportStar(require("./sessions"), exports);
+__exportStar(require("./disks"), exports);
+__exportStar(require("./blocks"), exports);

package/dist/resources/sessions.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Sessions endpoints.
+ */
+import { RequesterProtocol } from '../client-types';
+import { AcontextMessage } from '../messages';
+import { FileUpload } from '../uploads';
+import { GetMessagesOutput, GetTasksOutput, ListSessionsOutput, Message, Session } from '../types';
+export type MessageBlob = AcontextMessage | Record<string, unknown>;
+export declare class SessionsAPI {
+    private requester;
+    constructor(requester: RequesterProtocol);
+    list(options?: {
+        spaceId?: string | null;
+        notConnected?: boolean | null;
+        limit?: number | null;
+        cursor?: string | null;
+        timeDesc?: boolean | null;
+    }): Promise<ListSessionsOutput>;
+    create(options?: {
+        spaceId?: string | null;
+        configs?: Record<string, unknown>;
+    }): Promise<Session>;
+    delete(sessionId: string): Promise<void>;
+    updateConfigs(sessionId: string, options: {
+        configs: Record<string, unknown>;
+    }): Promise<void>;
+    getConfigs(sessionId: string): Promise<Session>;
+    connectToSpace(sessionId: string, options: {
+        spaceId: string;
+    }): Promise<void>;
+    getTasks(sessionId: string, options?: {
+        limit?: number | null;
+        cursor?: string | null;
+        timeDesc?: boolean | null;
+    }): Promise<GetTasksOutput>;
+    sendMessage(sessionId: string, blob: MessageBlob, options?: {
+        format?: 'acontext' | 'openai' | 'anthropic';
+        fileField?: string | null;
+        file?: FileUpload | null;
+    }): Promise<Message>;
+    getMessages(sessionId: string, options?: {
+        limit?: number | null;
+        cursor?: string | null;
+        withAssetPublicUrl?: boolean | null;
+        format?: 'acontext' | 'openai' | 'anthropic';
+        timeDesc?: boolean | null;
+    }): Promise<GetMessagesOutput>;
+}

package/dist/resources/sessions.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Sessions endpoints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionsAPI = void 0;
+const messages_1 = require("../messages");
+const utils_1 = require("../utils");
+const types_1 = require("../types");
+class SessionsAPI {
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async list(options) {
+        const params = {};
+        if (options?.spaceId) {
+            params.space_id = options.spaceId;
+        }
+        Object.assign(params, (0, utils_1.buildParams)({
+            not_connected: options?.notConnected ?? null,
+            limit: options?.limit ?? null,
+            cursor: options?.cursor ?? null,
+            time_desc: options?.timeDesc ?? null,
+        }));
+        const data = await this.requester.request('GET', '/session', {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.ListSessionsOutputSchema.parse(data);
+    }
+    async create(options) {
+        const payload = {};
+        if (options?.spaceId) {
+            payload.space_id = options.spaceId;
+        }
+        if (options?.configs !== undefined) {
+            payload.configs = options.configs;
+        }
+        const data = await this.requester.request('POST', '/session', {
+            jsonData: Object.keys(payload).length > 0 ? payload : undefined,
+        });
+        return types_1.SessionSchema.parse(data);
+    }
+    async delete(sessionId) {
+        await this.requester.request('DELETE', `/session/${sessionId}`);
+    }
+    async updateConfigs(sessionId, options) {
+        const payload = { configs: options.configs };
+        await this.requester.request('PUT', `/session/${sessionId}/configs`, {
+            jsonData: payload,
+        });
+    }
+    async getConfigs(sessionId) {
+        const data = await this.requester.request('GET', `/session/${sessionId}/configs`);
+        return types_1.SessionSchema.parse(data);
+    }
+    async connectToSpace(sessionId, options) {
+        const payload = { space_id: options.spaceId };
+        await this.requester.request('POST', `/session/${sessionId}/connect_to_space`, {
+            jsonData: payload,
+        });
+    }
+    async getTasks(sessionId, options) {
+        const params = (0, utils_1.buildParams)({
+            limit: options?.limit ?? null,
+            cursor: options?.cursor ?? null,
+            time_desc: options?.timeDesc ?? null,
+        });
+        const data = await this.requester.request('GET', `/session/${sessionId}/task`, {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.GetTasksOutputSchema.parse(data);
+    }
+    async sendMessage(sessionId, blob, options) {
+        const format = options?.format ?? 'openai';
+        if (!['acontext', 'openai', 'anthropic'].includes(format)) {
+            throw new Error("format must be one of {'acontext', 'openai', 'anthropic'}");
+        }
+        if (options?.file && !options?.fileField) {
+            throw new Error('fileField is required when file is provided');
+        }
+        const payload = {
+            format,
+        };
+        if (format === 'acontext') {
+            if (blob instanceof messages_1.AcontextMessage) {
+                payload.blob = blob.toJSON();
+            }
+            else {
+                // Try to parse as AcontextMessageInput
+                // MessageBlob can be Record<string, unknown>, which may not match AcontextMessageInput exactly
+                const message = new messages_1.AcontextMessage(blob);
+                payload.blob = message.toJSON();
+            }
+        }
+        else {
+            payload.blob = blob;
+        }
+        if (options?.file && options?.fileField) {
+            const formData = {
+                payload: JSON.stringify(payload),
+            };
+            const files = {
+                [options.fileField]: options.file.asFormData(),
+            };
+            const data = await this.requester.request('POST', `/session/${sessionId}/messages`, {
+                data: formData,
+                files,
+            });
+            return types_1.MessageSchema.parse(data);
+        }
+        else {
+            const data = await this.requester.request('POST', `/session/${sessionId}/messages`, {
+                jsonData: payload,
+            });
+            return types_1.MessageSchema.parse(data);
+        }
+    }
+    async getMessages(sessionId, options) {
+        const params = {};
+        if (options?.format !== undefined) {
+            params.format = options.format;
+        }
+        Object.assign(params, (0, utils_1.buildParams)({
+            limit: options?.limit ?? null,
+            cursor: options?.cursor ?? null,
+            with_asset_public_url: options?.withAssetPublicUrl ?? null,
+            time_desc: options?.timeDesc ?? null,
+        }));
+        const data = await this.requester.request('GET', `/session/${sessionId}/messages`, {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.GetMessagesOutputSchema.parse(data);
+    }
+}
+exports.SessionsAPI = SessionsAPI;

package/dist/resources/spaces.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Spaces endpoints.
+ */
+import { RequesterProtocol } from '../client-types';
+import { ListSpacesOutput, Space } from '../types';
+export declare class SpacesAPI {
+    private requester;
+    constructor(requester: RequesterProtocol);
+    list(options?: {
+        limit?: number | null;
+        cursor?: string | null;
+        timeDesc?: boolean | null;
+    }): Promise<ListSpacesOutput>;
+    create(options?: {
+        configs?: Record<string, unknown>;
+    }): Promise<Space>;
+    delete(spaceId: string): Promise<void>;
+    updateConfigs(spaceId: string, options: {
+        configs: Record<string, unknown>;
+    }): Promise<void>;
+    getConfigs(spaceId: string): Promise<Space>;
+}

package/dist/resources/spaces.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Spaces endpoints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacesAPI = void 0;
+const utils_1 = require("../utils");
+const types_1 = require("../types");
+class SpacesAPI {
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async list(options) {
+        const params = (0, utils_1.buildParams)({
+            limit: options?.limit ?? null,
+            cursor: options?.cursor ?? null,
+            time_desc: options?.timeDesc ?? null,
+        });
+        const data = await this.requester.request('GET', '/space', {
+            params: Object.keys(params).length > 0 ? params : undefined,
+        });
+        return types_1.ListSpacesOutputSchema.parse(data);
+    }
+    async create(options) {
+        const payload = {};
+        if (options?.configs !== undefined) {
+            payload.configs = options.configs;
+        }
+        const data = await this.requester.request('POST', '/space', {
+            jsonData: Object.keys(payload).length > 0 ? payload : undefined,
+        });
+        return types_1.SpaceSchema.parse(data);
+    }
+    async delete(spaceId) {
+        await this.requester.request('DELETE', `/space/${spaceId}`);
+    }
+    async updateConfigs(spaceId, options) {
+        const payload = { configs: options.configs };
+        await this.requester.request('PUT', `/space/${spaceId}/configs`, {
+            jsonData: payload,
+        });
+    }
+    async getConfigs(spaceId) {
+        const data = await this.requester.request('GET', `/space/${spaceId}/configs`);
+        return types_1.SpaceSchema.parse(data);
+    }
+}
+exports.SpacesAPI = SpacesAPI;

package/dist/types/block.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Type definitions for block resources.
+ */
+import { z } from 'zod';
+export declare const BlockSchema: z.ZodType<Block>;
+export type Block = {
+    id: string;
+    space_id: string;
+    type: string;
+    parent_id?: string | null;
+    title: string;
+    props: Record<string, unknown>;
+    sort: number;
+    is_archived: boolean;
+    created_at: string;
+    updated_at: string;
+    children?: Block[] | null;
+};

package/dist/types/block.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Type definitions for block resources.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockSchema = void 0;
+const zod_1 = require("zod");
+exports.BlockSchema = zod_1.z.lazy(() => zod_1.z.object({
+    id: zod_1.z.string(),
+    space_id: zod_1.z.string(),
+    type: zod_1.z.string(),
+    parent_id: zod_1.z.string().nullable().optional(),
+    title: zod_1.z.string(),
+    props: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+    sort: zod_1.z.number(),
+    is_archived: zod_1.z.boolean(),
+    created_at: zod_1.z.string(),
+    updated_at: zod_1.z.string(),
+    children: zod_1.z.array(exports.BlockSchema).nullable().optional(),
+}));