@kognitivedev/cloud-platforms 0.2.29

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/.turbo/turbo-test.log

@@ -0,0 +1,11 @@
+$ vitest run
+
+ RUN  v3.2.4 /Users/vserifsaglam/work/memory-experiment/packages/cloud-platforms
+
+ ✓ src/__tests__/client.test.ts (4 tests) 5ms
+
+ Test Files  1 passed (1)
+      Tests  4 passed (4)
+   Start at  17:30:10
+   Duration  786ms (transform 56ms, setup 0ms, collect 62ms, tests 5ms, environment 0ms, prepare 328ms)
+

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# @kognitivedev/cloud-platforms
+
+## 0.2.29
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/agents@0.2.29
+  - @kognitivedev/client-core@0.2.29
+  - @kognitivedev/tools@0.2.29

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import type { AgentContextAdapter } from "@kognitivedev/agents";
+import type { CloudPlatformsClient, CloudPlatformsConfig, CloudPlatformsContextAdapterOptions, CloudPlatformToolsInput, ConnectLinkInput, ConnectLinkResult, ExecutePlatformActionInput, ListPlatformActionsInput, PlatformAction, PlatformActionResult, PlatformCatalog, PlatformConnection, PlatformTool, PlatformToolDefinition, SyncConnectionsInput } from "./types";
+export declare class CloudPlatforms implements CloudPlatformsClient {
+    private readonly transport;
+    constructor(config: CloudPlatformsConfig);
+    catalog(): Promise<PlatformCatalog>;
+    connections(): Promise<PlatformConnection[]>;
+    connectLink(input: ConnectLinkInput): Promise<ConnectLinkResult>;
+    syncConnections(input?: SyncConnectionsInput): Promise<PlatformConnection[]>;
+    actions(input?: ListPlatformActionsInput): Promise<PlatformAction[]>;
+    toolDefinitions(input?: CloudPlatformToolsInput): Promise<PlatformToolDefinition[]>;
+    tools(input?: CloudPlatformToolsInput): Promise<PlatformTool[]>;
+    execute(input: ExecutePlatformActionInput): Promise<PlatformActionResult>;
+    contextAdapter(options?: CloudPlatformsContextAdapterOptions): AgentContextAdapter;
+}

package/dist/client.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPlatforms = void 0;
+const client_core_1 = require("@kognitivedev/client-core");
+const validation_1 = require("./validation");
+const CLOUD_PLATFORMS_PATH = "/api/cloud/platforms";
+function requireNonEmptyConfigValue(value, name) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`CloudPlatforms requires ${name}`);
+    }
+    return value.trim();
+}
+function normalizeSelectedConnectionIds(input) {
+    return (0, validation_1.validateOptionalStringArray)(input === null || input === void 0 ? void 0 : input.selectedConnectionIds, "selectedConnectionIds");
+}
+function getPlatformsMetadata(metadata) {
+    if (!(0, validation_1.isPlainObject)(metadata)) {
+        return null;
+    }
+    const platforms = metadata.platforms;
+    return (0, validation_1.isPlainObject)(platforms) ? platforms : null;
+}
+function getSelectedConnectionIdsFromMetadata(metadata) {
+    const platforms = getPlatformsMetadata(metadata);
+    if (!platforms) {
+        return undefined;
+    }
+    return (0, validation_1.validateOptionalStringArray)(platforms.selectedConnectionIds, "metadata.platforms.selectedConnectionIds");
+}
+function getApprovalFromMetadata(metadata) {
+    const platforms = getPlatformsMetadata(metadata);
+    if (!platforms) {
+        return undefined;
+    }
+    const approval = platforms.approval;
+    if (!(0, validation_1.isPlainObject)(approval)) {
+        return undefined;
+    }
+    return Object.assign(Object.assign(Object.assign({ approved: approval.approved === true }, (typeof approval.toolCallId === "string" ? { toolCallId: approval.toolCallId } : {})), (typeof approval.approvedBy === "string" ? { approvedBy: approval.approvedBy } : {})), (typeof approval.approvedAt === "string" ? { approvedAt: approval.approvedAt } : {}));
+}
+function parseToolInput(value) {
+    if (!(0, validation_1.isPlainObject)(value)) {
+        throw new Error("Platform tool input must be an object");
+    }
+    if (typeof value.connectionId !== "string" || !value.connectionId.trim()) {
+        throw new Error("Platform tool input requires connectionId");
+    }
+    const args = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (key !== "connectionId") {
+            args[key] = (0, validation_1.cloneUnknown)(entry);
+        }
+    }
+    return {
+        connectionId: value.connectionId.trim(),
+        arguments: args,
+    };
+}
+function createPlatformTool(client, definition) {
+    return {
+        id: definition.id,
+        description: definition.description,
+        inputSchema: (0, validation_1.cloneUnknown)(definition.inputSchema),
+        outputSchema: (0, validation_1.cloneUnknown)(definition.outputSchema),
+        requireApproval: definition.requireApproval,
+        execute: async (input, context) => {
+            const parsed = parseToolInput(input);
+            return client.execute({
+                actionSlug: definition.actionSlug,
+                connectionId: parsed.connectionId,
+                arguments: parsed.arguments,
+                approval: getApprovalFromMetadata(context.metadata),
+            });
+        },
+        toModelOutput: (output) => JSON.stringify(output.result),
+    };
+}
+class CloudPlatforms {
+    constructor(config) {
+        const apiKey = requireNonEmptyConfigValue(config.apiKey, "apiKey");
+        const baseUrl = requireNonEmptyConfigValue(config.baseUrl, "baseUrl");
+        this.transport = new client_core_1.HttpTransport({
+            apiKey,
+            baseUrl,
+            fetch: config.fetch,
+            timeout: config.timeout,
+            logLevel: config.logLevel,
+        });
+    }
+    async catalog() {
+        const response = await this.transport.json(`${CLOUD_PLATFORMS_PATH}/catalog`);
+        return (0, validation_1.decodeCatalog)(response);
+    }
+    async connections() {
+        const response = await this.transport.json(`${CLOUD_PLATFORMS_PATH}/connections`);
+        return (0, validation_1.decodeConnectionsEnvelope)(response);
+    }
+    async connectLink(input) {
+        const response = await this.transport.json(`${CLOUD_PLATFORMS_PATH}/connect-link`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+        return (0, validation_1.decodeConnectLink)(response);
+    }
+    async syncConnections(input = {}) {
+        const response = await this.transport.json(`${CLOUD_PLATFORMS_PATH}/connections/sync`, {
+            method: "POST",
+            body: JSON.stringify(input),
+        });
+        return (0, validation_1.decodeConnectionsEnvelope)(response);
+    }
+    async actions(input = {}) {
+        const response = await this.transport.json(`${CLOUD_PLATFORMS_PATH}/actions`);
+        const actions = (0, validation_1.decodeActionsEnvelope)(response);
+        if (!input.toolkitSlug) {
+            return actions;
+        }
+        return actions.filter((action) => action.toolkitSlug === input.toolkitSlug);
+    }
+    async toolDefinitions(input = {}) {
+        const selectedConnectionIds = normalizeSelectedConnectionIds(input);
+        const path = selectedConnectionIds
+            ? (0, client_core_1.withQuery)(`${CLOUD_PLATFORMS_PATH}/tools`, { selectedConnectionIds: selectedConnectionIds.join(",") })
+            : `${CLOUD_PLATFORMS_PATH}/tools`;
+        const response = await this.transport.json(path);
+        return (0, validation_1.decodeToolsEnvelope)(response);
+    }
+    async tools(input = {}) {
+        const definitions = await this.toolDefinitions(input);
+        return definitions.map((definition) => createPlatformTool(this, definition));
+    }
+    async execute(input) {
+        const response = await this.transport.json(`${CLOUD_PLATFORMS_PATH}/actions/${encodeURIComponent(input.actionSlug)}/execute`, {
+            method: "POST",
+            body: JSON.stringify(Object.assign({ connectionId: input.connectionId, arguments: input.arguments }, (input.approval ? { approval: input.approval } : {}))),
+        });
+        return (0, validation_1.decodeActionResult)(response);
+    }
+    contextAdapter(options = {}) {
+        return {
+            resolve: async (input) => {
+                const metadataSelectedConnectionIds = getSelectedConnectionIdsFromMetadata(input.metadata);
+                const selectedConnectionIds = metadataSelectedConnectionIds !== null && metadataSelectedConnectionIds !== void 0 ? metadataSelectedConnectionIds : options.selectedConnectionIds;
+                const tools = await this.tools({ selectedConnectionIds });
+                return { tools };
+            },
+        };
+    }
+}
+exports.CloudPlatforms = CloudPlatforms;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { CloudPlatforms } from "./client";
+export { CloudPlatformsValidationError } from "./validation";
+export type { CloudPlatformsClient, CloudPlatformsConfig, CloudPlatformsContextAdapterOptions, CloudPlatformToolsInput, ConnectLinkInput, ConnectLinkResult, ExecutePlatformActionInput, ListPlatformActionsInput, PlatformAction, PlatformActionResult, PlatformApprovalMetadata, PlatformCatalog, PlatformConnection, PlatformTool, PlatformToolConnection, PlatformToolDefinition, PlatformToolkit, SyncConnectionsInput, } from "./types";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPlatformsValidationError = exports.CloudPlatforms = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "CloudPlatforms", { enumerable: true, get: function () { return client_1.CloudPlatforms; } });
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "CloudPlatformsValidationError", { enumerable: true, get: function () { return validation_1.CloudPlatformsValidationError; } });

package/dist/types.d.ts

@@ -0,0 +1,117 @@
+import type { AgentContextAdapter } from "@kognitivedev/agents";
+import type { LogLevel } from "@kognitivedev/client-core";
+import type { Tool } from "@kognitivedev/tools";
+export interface CloudPlatformsConfig {
+    apiKey: string;
+    baseUrl: string;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    timeout?: number;
+    logLevel?: LogLevel;
+}
+export interface PlatformToolkit {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    iconUrl: string | null;
+    categories: string[];
+    managedAuthSchemes: string[];
+}
+export interface PlatformAction {
+    id: string;
+    slug: string;
+    toolkitSlug: string;
+    name: string;
+    description: string | null;
+    version: string | null;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    tags: string[];
+    isDangerous: boolean;
+    requireApproval: boolean;
+}
+export interface PlatformConnection {
+    id: string;
+    toolkitSlug: string;
+    alias: string | null;
+    displayName: string | null;
+    status: string;
+    externalAccountLabel: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    lastSyncedAt: string;
+    lastVerifiedAt: string | null;
+}
+export interface PlatformCatalog {
+    toolkits: PlatformToolkit[];
+    actions: PlatformAction[];
+    lastSyncedAt: string | null;
+}
+export interface ConnectLinkInput {
+    toolkitSlug: string;
+    alias?: string | null;
+}
+export interface ConnectLinkResult {
+    toolkitSlug: string;
+    connectionRequestId: string;
+    redirectUrl: string;
+}
+export interface SyncConnectionsInput {
+    toolkitSlugs?: string[];
+}
+export interface ListPlatformActionsInput {
+    toolkitSlug?: string;
+}
+export interface CloudPlatformToolsInput {
+    selectedConnectionIds?: string[];
+}
+export interface PlatformToolConnection {
+    id: string;
+    label: string;
+    toolkitSlug: string;
+}
+export interface PlatformToolDefinition {
+    id: string;
+    actionSlug: string;
+    toolkitSlug: string;
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema: Record<string, unknown>;
+    requireApproval: boolean;
+    connections: PlatformToolConnection[];
+}
+export interface PlatformApprovalMetadata {
+    approved: boolean;
+    toolCallId?: string;
+    approvedBy?: string;
+    approvedAt?: string;
+}
+export interface ExecutePlatformActionInput {
+    actionSlug: string;
+    connectionId: string;
+    arguments: Record<string, unknown>;
+    approval?: PlatformApprovalMetadata;
+}
+export interface PlatformActionResult {
+    actionSlug: string;
+    toolkitSlug: string;
+    connectionId: string;
+    version: string | null;
+    result: unknown;
+}
+export interface CloudPlatformsContextAdapterOptions {
+    selectedConnectionIds?: string[];
+}
+export type PlatformTool = Tool<Record<string, unknown>, PlatformActionResult>;
+export interface CloudPlatformsClient {
+    catalog(): Promise<PlatformCatalog>;
+    connections(): Promise<PlatformConnection[]>;
+    connectLink(input: ConnectLinkInput): Promise<ConnectLinkResult>;
+    syncConnections(input?: SyncConnectionsInput): Promise<PlatformConnection[]>;
+    actions(input?: ListPlatformActionsInput): Promise<PlatformAction[]>;
+    tools(input?: CloudPlatformToolsInput): Promise<PlatformTool[]>;
+    execute(input: ExecutePlatformActionInput): Promise<PlatformActionResult>;
+    contextAdapter(options?: CloudPlatformsContextAdapterOptions): AgentContextAdapter;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validation.d.ts

@@ -0,0 +1,23 @@
+import type { ConnectLinkResult, PlatformAction, PlatformActionResult, PlatformCatalog, PlatformConnection, PlatformToolkit, PlatformToolConnection, PlatformToolDefinition } from "./types";
+export declare class CloudPlatformsValidationError extends Error {
+    readonly path: string;
+    readonly expected: string;
+    readonly actual: unknown;
+    constructor(path: string, expected: string, actual: unknown);
+}
+type PlainObject = Record<string, unknown>;
+export declare function isPlainObject(value: unknown): value is PlainObject;
+export declare function cloneUnknown<T>(value: T): T;
+export declare function decodeToolkit(value: unknown, path: string): PlatformToolkit;
+export declare function decodeAction(value: unknown, path: string): PlatformAction;
+export declare function decodeConnection(value: unknown, path: string): PlatformConnection;
+export declare function decodeCatalog(value: unknown, path?: string): PlatformCatalog;
+export declare function decodeConnectionsEnvelope(value: unknown): PlatformConnection[];
+export declare function decodeActionsEnvelope(value: unknown): PlatformAction[];
+export declare function decodeToolConnection(value: unknown, path: string): PlatformToolConnection;
+export declare function decodeToolDefinition(value: unknown, path: string): PlatformToolDefinition;
+export declare function decodeToolsEnvelope(value: unknown): PlatformToolDefinition[];
+export declare function decodeConnectLink(value: unknown): ConnectLinkResult;
+export declare function decodeActionResult(value: unknown): PlatformActionResult;
+export declare function validateOptionalStringArray(value: unknown, path: string): string[] | undefined;
+export {};

package/dist/validation.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPlatformsValidationError = void 0;
+exports.isPlainObject = isPlainObject;
+exports.cloneUnknown = cloneUnknown;
+exports.decodeToolkit = decodeToolkit;
+exports.decodeAction = decodeAction;
+exports.decodeConnection = decodeConnection;
+exports.decodeCatalog = decodeCatalog;
+exports.decodeConnectionsEnvelope = decodeConnectionsEnvelope;
+exports.decodeActionsEnvelope = decodeActionsEnvelope;
+exports.decodeToolConnection = decodeToolConnection;
+exports.decodeToolDefinition = decodeToolDefinition;
+exports.decodeToolsEnvelope = decodeToolsEnvelope;
+exports.decodeConnectLink = decodeConnectLink;
+exports.decodeActionResult = decodeActionResult;
+exports.validateOptionalStringArray = validateOptionalStringArray;
+class CloudPlatformsValidationError extends Error {
+    constructor(path, expected, actual) {
+        super(`${path} must be ${expected}`);
+        this.name = "CloudPlatformsValidationError";
+        this.path = path;
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+exports.CloudPlatformsValidationError = CloudPlatformsValidationError;
+function isPlainObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function cloneUnknown(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneUnknown(entry));
+    }
+    if (isPlainObject(value)) {
+        const cloned = {};
+        for (const [key, entry] of Object.entries(value)) {
+            cloned[key] = cloneUnknown(entry);
+        }
+        return cloned;
+    }
+    return value;
+}
+function invalid(path, expected, actual) {
+    throw new CloudPlatformsValidationError(path, expected, actual);
+}
+function expectObject(value, path) {
+    if (!isPlainObject(value)) {
+        invalid(path, "an object", value);
+    }
+    return value;
+}
+function expectArray(value, path) {
+    if (!Array.isArray(value)) {
+        invalid(path, "an array", value);
+    }
+    return value;
+}
+function expectString(value, path) {
+    if (typeof value !== "string") {
+        invalid(path, "a string", value);
+    }
+    return value;
+}
+function expectBoolean(value, path) {
+    if (typeof value !== "boolean") {
+        invalid(path, "a boolean", value);
+    }
+    return value;
+}
+function expectNullableString(value, path) {
+    if (value === null) {
+        return null;
+    }
+    return expectString(value, path);
+}
+function expectRecord(value, path) {
+    return cloneUnknown(expectObject(value, path));
+}
+function expectStringArray(value, path) {
+    return expectArray(value, path).map((entry, index) => expectString(entry, `${path}[${index}]`));
+}
+function optionalStringArray(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectStringArray(value, path);
+}
+function decodeToolkit(value, path) {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        slug: expectString(object.slug, `${path}.slug`),
+        name: expectString(object.name, `${path}.name`),
+        description: expectNullableString(object.description, `${path}.description`),
+        iconUrl: expectNullableString(object.iconUrl, `${path}.iconUrl`),
+        categories: expectStringArray(object.categories, `${path}.categories`),
+        managedAuthSchemes: expectStringArray(object.managedAuthSchemes, `${path}.managedAuthSchemes`),
+    };
+}
+function decodeAction(value, path) {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        slug: expectString(object.slug, `${path}.slug`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+        name: expectString(object.name, `${path}.name`),
+        description: expectNullableString(object.description, `${path}.description`),
+        version: expectNullableString(object.version, `${path}.version`),
+        inputSchema: expectRecord(object.inputSchema, `${path}.inputSchema`),
+        outputSchema: expectRecord(object.outputSchema, `${path}.outputSchema`),
+        tags: expectStringArray(object.tags, `${path}.tags`),
+        isDangerous: expectBoolean(object.isDangerous, `${path}.isDangerous`),
+        requireApproval: expectBoolean(object.requireApproval, `${path}.requireApproval`),
+    };
+}
+function decodeConnection(value, path) {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+        alias: expectNullableString(object.alias, `${path}.alias`),
+        displayName: expectNullableString(object.displayName, `${path}.displayName`),
+        status: expectString(object.status, `${path}.status`),
+        externalAccountLabel: expectNullableString(object.externalAccountLabel, `${path}.externalAccountLabel`),
+        metadata: expectRecord(object.metadata, `${path}.metadata`),
+        createdAt: expectString(object.createdAt, `${path}.createdAt`),
+        updatedAt: expectString(object.updatedAt, `${path}.updatedAt`),
+        lastSyncedAt: expectString(object.lastSyncedAt, `${path}.lastSyncedAt`),
+        lastVerifiedAt: expectNullableString(object.lastVerifiedAt, `${path}.lastVerifiedAt`),
+    };
+}
+function decodeCatalog(value, path = "catalog") {
+    const object = expectObject(value, path);
+    return {
+        toolkits: expectArray(object.toolkits, `${path}.toolkits`).map((entry, index) => decodeToolkit(entry, `${path}.toolkits[${index}]`)),
+        actions: expectArray(object.actions, `${path}.actions`).map((entry, index) => decodeAction(entry, `${path}.actions[${index}]`)),
+        lastSyncedAt: expectNullableString(object.lastSyncedAt, `${path}.lastSyncedAt`),
+    };
+}
+function decodeConnectionsEnvelope(value) {
+    const object = expectObject(value, "response");
+    return expectArray(object.connections, "response.connections").map((entry, index) => decodeConnection(entry, `response.connections[${index}]`));
+}
+function decodeActionsEnvelope(value) {
+    const object = expectObject(value, "response");
+    return expectArray(object.actions, "response.actions").map((entry, index) => decodeAction(entry, `response.actions[${index}]`));
+}
+function decodeToolConnection(value, path) {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        label: expectString(object.label, `${path}.label`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+    };
+}
+function decodeToolDefinition(value, path) {
+    const object = expectObject(value, path);
+    return {
+        id: expectString(object.id, `${path}.id`),
+        actionSlug: expectString(object.actionSlug, `${path}.actionSlug`),
+        toolkitSlug: expectString(object.toolkitSlug, `${path}.toolkitSlug`),
+        name: expectString(object.name, `${path}.name`),
+        description: expectString(object.description, `${path}.description`),
+        inputSchema: expectRecord(object.inputSchema, `${path}.inputSchema`),
+        outputSchema: expectRecord(object.outputSchema, `${path}.outputSchema`),
+        requireApproval: expectBoolean(object.requireApproval, `${path}.requireApproval`),
+        connections: expectArray(object.connections, `${path}.connections`).map((entry, index) => decodeToolConnection(entry, `${path}.connections[${index}]`)),
+    };
+}
+function decodeToolsEnvelope(value) {
+    const object = expectObject(value, "response");
+    return expectArray(object.tools, "response.tools").map((entry, index) => decodeToolDefinition(entry, `response.tools[${index}]`));
+}
+function decodeConnectLink(value) {
+    const object = expectObject(value, "response");
+    return {
+        toolkitSlug: expectString(object.toolkitSlug, "response.toolkitSlug"),
+        connectionRequestId: expectString(object.connectionRequestId, "response.connectionRequestId"),
+        redirectUrl: expectString(object.redirectUrl, "response.redirectUrl"),
+    };
+}
+function decodeActionResult(value) {
+    const object = expectObject(value, "response");
+    return {
+        actionSlug: expectString(object.actionSlug, "response.actionSlug"),
+        toolkitSlug: expectString(object.toolkitSlug, "response.toolkitSlug"),
+        connectionId: expectString(object.connectionId, "response.connectionId"),
+        version: expectNullableString(object.version, "response.version"),
+        result: cloneUnknown(object.result),
+    };
+}
+function validateOptionalStringArray(value, path) {
+    return optionalStringArray(value, path);
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@kognitivedev/cloud-platforms",
+  "version": "0.2.29",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --noCheck",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@kognitivedev/agents": "^0.2.29",
+    "@kognitivedev/client-core": "^0.2.29",
+    "@kognitivedev/tools": "^0.2.29"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0",
+    "zod": "^3.23.8"
+  },
+  "peerDependencies": {
+    "zod": ">=3.23.0"
+  },
+  "description": "Provider-neutral cloud platform connector SDK for Kognitive hosted APIs",
+  "keywords": [
+    "kognitive",
+    "cloud",
+    "platforms",
+    "connectors",
+    "tools"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/cloud-platforms"
+  },
+  "homepage": "https://kognitive.dev"
+}