@erdoai/server 0.1.4

package/README.md

@@ -0,0 +1,104 @@
+# @erdoai/server
+
+Server-side TypeScript client for invoking Erdo AI agents.
+
+## Installation
+
+```bash
+npm install @erdoai/server
+```
+
+## Usage
+
+### Basic Invocation
+
+```typescript
+import { ErdoClient } from '@erdoai/server';
+
+const client = new ErdoClient({
+  endpoint: 'https://api.erdo.ai',
+  authToken: process.env.ERDO_API_KEY,
+});
+
+// Get final result
+const result = await client.invoke('data-analyst', {
+  messages: [{ role: 'user', content: 'What were our top products last month?' }],
+});
+
+console.log(result.messages);
+```
+
+### Streaming
+
+```typescript
+for await (const event of client.invokeStream('data-analyst', {
+  messages: [{ role: 'user', content: 'Analyze our sales data' }],
+})) {
+  switch (event.type) {
+    case 'content':
+      console.log('New content:', event.payload);
+      break;
+    case 'status':
+      console.log('Status:', event.payload);
+      break;
+    case 'error':
+      console.error('Error:', event.payload);
+      break;
+  }
+}
+```
+
+### Environment Variables
+
+The client can be configured via environment variables:
+
+```bash
+ERDO_ENDPOINT=https://api.erdo.ai
+ERDO_AUTH_TOKEN=your-api-key
+```
+
+```typescript
+// Uses environment variables automatically
+const client = new ErdoClient();
+```
+
+## API Reference
+
+### `ErdoClient`
+
+```typescript
+class ErdoClient {
+  constructor(options?: {
+    endpoint?: string;   // API endpoint (default: env or https://api.erdo.ai)
+    authToken?: string;  // API key (default: env ERDO_AUTH_TOKEN)
+  });
+
+  invoke(botKey: string, params: InvokeParams): Promise<InvokeResult>;
+  invokeStream(botKey: string, params: InvokeParams): AsyncGenerator<SSEEvent>;
+}
+```
+
+### `InvokeParams`
+
+```typescript
+interface InvokeParams {
+  messages?: Message[];              // Messages to send to the agent
+  parameters?: Record<string, any>;  // Parameters to pass to the agent
+  datasets?: string[];               // Dataset slugs to include
+  mode?: InvocationMode;             // Invocation mode
+}
+```
+
+### `SSEEvent`
+
+```typescript
+interface SSEEvent {
+  type: 'content' | 'status' | 'error' | 'done';
+  payload: any;
+  metadata?: Record<string, any>;
+}
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { ErdoClientConfig, InvokeParams, InvokeResult, SSEEvent } from '@erdoai/types';
+
+/**
+ * Erdo Client for invoking agents
+ *
+ * Ported from: erdo-python-sdk/erdo/invoke/client.py and invoke.py
+ */
+
+declare class ErdoClient {
+    private readonly endpoint;
+    private readonly authToken;
+    constructor(config?: Partial<ErdoClientConfig>);
+    /**
+     * Invoke an agent and wait for the complete result
+     */
+    invoke(botKey: string, params?: InvokeParams): Promise<InvokeResult>;
+    /**
+     * Invoke an agent and stream SSE events
+     */
+    invokeStream(botKey: string, params?: InvokeParams): AsyncGenerator<SSEEvent, void, unknown>;
+    /**
+     * Collect all events from an invocation
+     */
+    private collectEvents;
+    /**
+     * Make the HTTP request to invoke an agent
+     */
+    private makeRequest;
+    /**
+     * Extract structured result from SSE events
+     *
+     * Ported from: erdo-python-sdk/erdo/invoke/invoke.py - _extract_result_data()
+     */
+    private extractResult;
+}
+/**
+ * Invoke an agent with a clean API
+ *
+ * @example
+ * ```typescript
+ * import { invoke } from '@erdoai/server';
+ *
+ * const result = await invoke('org.my-agent', {
+ *   messages: [{ role: 'user', content: 'Analyze Q4 sales' }],
+ *   mode: 'replay',
+ * });
+ * ```
+ */
+declare function invoke(botKey: string, params?: InvokeParams): Promise<InvokeResult>;
+/**
+ * Invoke an agent and stream events
+ *
+ * @example
+ * ```typescript
+ * import { invokeStream } from '@erdoai/server';
+ *
+ * for await (const event of invokeStream('org.my-agent', params)) {
+ *   console.log(event.type, event.payload);
+ * }
+ * ```
+ */
+declare function invokeStream(botKey: string, params?: InvokeParams): AsyncGenerator<SSEEvent, void, unknown>;
+
+/**
+ * Configuration management for Erdo TypeScript SDK
+ *
+ * Ported from: erdo-python-sdk/erdo/config/config.py
+ */
+
+/**
+ * Get configuration from environment variables
+ */
+declare function getConfigFromEnv(): ErdoClientConfig;
+/**
+ * Merge user config with environment config
+ */
+declare function resolveConfig(userConfig?: Partial<ErdoClientConfig>): Required<ErdoClientConfig>;
+
+/**
+ * SSE Client for Server-Sent Events streaming
+ *
+ * Ported from: erdo-python-sdk/erdo/invoke/client.py
+ */
+
+/**
+ * Parse SSE events from a ReadableStream
+ */
+declare function parseSSEStream(response: Response): AsyncGenerator<SSEEvent, void, unknown>;
+/**
+ * Collect all events from an SSE stream
+ */
+declare function collectSSEEvents(response: Response): Promise<SSEEvent[]>;
+
+export { ErdoClient, collectSSEEvents, getConfigFromEnv, invoke, invokeStream, parseSSEStream, resolveConfig };

package/dist/index.js

@@ -0,0 +1,241 @@
+// src/config.ts
+var DEFAULT_ENDPOINT = "https://api.erdo.ai";
+function getConfigFromEnv() {
+  const env = typeof process !== "undefined" ? process.env : {};
+  return {
+    endpoint: env.ERDO_ENDPOINT || env.NEXT_PUBLIC_ERDO_ENDPOINT || DEFAULT_ENDPOINT,
+    authToken: env.ERDO_AUTH_TOKEN || env.NEXT_PUBLIC_ERDO_API_KEY
+  };
+}
+function resolveConfig(userConfig) {
+  const envConfig = getConfigFromEnv();
+  const endpoint = userConfig?.endpoint || envConfig.endpoint || DEFAULT_ENDPOINT;
+  const authToken = userConfig?.authToken || envConfig.authToken;
+  if (!authToken) {
+    throw new Error(
+      "No auth token configured. Set ERDO_AUTH_TOKEN environment variable or pass authToken to ErdoClient."
+    );
+  }
+  return {
+    endpoint,
+    authToken
+  };
+}
+
+// src/streaming/sse-client.ts
+async function* parseSSEStream(response) {
+  if (!response.body) {
+    throw new Error("Response body is null");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        if (buffer.trim()) {
+          const event = parseSSELine(buffer);
+          if (event) {
+            yield event;
+          }
+        }
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const event = parseSSELine(line);
+        if (event) {
+          yield event;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseSSELine(line) {
+  const trimmedLine = line.trim();
+  if (!trimmedLine) {
+    return null;
+  }
+  if (trimmedLine.startsWith("data: ")) {
+    const data = trimmedLine.slice(6);
+    if (!data.trim()) {
+      return null;
+    }
+    try {
+      return JSON.parse(data);
+    } catch {
+      return { raw: data };
+    }
+  }
+  return null;
+}
+async function collectSSEEvents(response) {
+  const events = [];
+  for await (const event of parseSSEStream(response)) {
+    events.push(event);
+  }
+  return events;
+}
+
+// src/client.ts
+var ErdoClient = class {
+  endpoint;
+  authToken;
+  constructor(config) {
+    const resolved = resolveConfig(config);
+    this.endpoint = resolved.endpoint;
+    this.authToken = resolved.authToken;
+  }
+  /**
+   * Invoke an agent and wait for the complete result
+   */
+  async invoke(botKey, params = {}) {
+    const events = await this.collectEvents(botKey, params);
+    return this.extractResult(botKey, events);
+  }
+  /**
+   * Invoke an agent and stream SSE events
+   */
+  async *invokeStream(botKey, params = {}) {
+    const response = await this.makeRequest(botKey, params);
+    yield* parseSSEStream(response);
+  }
+  /**
+   * Collect all events from an invocation
+   */
+  async collectEvents(botKey, params) {
+    const response = await this.makeRequest(botKey, params);
+    return collectSSEEvents(response);
+  }
+  /**
+   * Make the HTTP request to invoke an agent
+   */
+  async makeRequest(botKey, params) {
+    const url = `${this.endpoint}/bots/${botKey}/invoke`;
+    const invokeParams = {};
+    if (params.messages) {
+      invokeParams.messages = params.messages;
+    }
+    if (params.parameters) {
+      invokeParams.parameters = params.parameters;
+    }
+    if (params.datasets) {
+      invokeParams.dataset_slugs = params.datasets;
+    }
+    if (params.mode) {
+      invokeParams.mode = params.mode;
+    }
+    if (params.manualMocks) {
+      invokeParams.manual_mocks = params.manualMocks;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(invokeParams)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API request failed with status ${response.status}: ${errorText}`);
+    }
+    return response;
+  }
+  /**
+   * Extract structured result from SSE events
+   *
+   * Ported from: erdo-python-sdk/erdo/invoke/invoke.py - _extract_result_data()
+   */
+  extractResult(botKey, events) {
+    const messages = [];
+    const steps = [];
+    const stepsSeenKeys = /* @__PURE__ */ new Set();
+    let finalResult;
+    let invocationId;
+    for (const event of events) {
+      if (!event) continue;
+      const payload = event.payload;
+      const metadata = event.metadata;
+      if (payload && typeof payload === "object") {
+        if ("invocation_id" in payload && !invocationId) {
+          invocationId = payload.invocation_id;
+        }
+      }
+      if (payload && typeof payload === "object" && "action_type" in payload && "key" in payload) {
+        const stepKey = payload.key;
+        if (!stepsSeenKeys.has(stepKey)) {
+          stepsSeenKeys.add(stepKey);
+          steps.push({
+            key: stepKey,
+            action: payload.action_type,
+            status: "completed"
+          });
+        }
+      }
+      if (payload && typeof payload === "object" && "output" in payload && metadata?.user_visibility === "visible") {
+        const output = payload.output;
+        if (output && typeof output === "object" && "content" in output) {
+          const contentArray = output.content;
+          if (Array.isArray(contentArray)) {
+            for (const item of contentArray) {
+              if (item.content_type === "text") {
+                const role = metadata?.role || "assistant";
+                messages.push({
+                  role,
+                  content: item.content || ""
+                });
+              }
+            }
+          }
+        }
+      }
+      if (payload && typeof payload === "object" && "status" in payload && "output" in payload) {
+        finalResult = {
+          status: payload.status,
+          parameters: payload.parameters,
+          output: payload.output,
+          message: payload.message,
+          error: payload.error
+        };
+      }
+    }
+    return {
+      success: true,
+      botId: botKey,
+      invocationId,
+      result: finalResult,
+      messages,
+      events,
+      steps
+    };
+  }
+};
+var defaultClient = null;
+function getDefaultClient() {
+  if (!defaultClient) {
+    defaultClient = new ErdoClient();
+  }
+  return defaultClient;
+}
+async function invoke(botKey, params = {}) {
+  return getDefaultClient().invoke(botKey, params);
+}
+async function* invokeStream(botKey, params = {}) {
+  yield* getDefaultClient().invokeStream(botKey, params);
+}
+export {
+  ErdoClient,
+  collectSSEEvents,
+  getConfigFromEnv,
+  invoke,
+  invokeStream,
+  parseSSEStream,
+  resolveConfig
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@erdoai/server",
+  "version": "0.1.4",
+  "description": "Erdo server SDK for invoking agents",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "erdo",
+    "ai",
+    "agent",
+    "sdk"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/erdoai/erdo-ts-sdk.git",
+    "directory": "packages/server"
+  },
+  "dependencies": {
+    "@erdoai/types": "workspace:^"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
+  }
+}