@artinet/cruiser 0.1.5 → 0.1.7

package/README.md

@@ -25,6 +25,7 @@ Universal adapters for multi-agent interoperability.
 | **Claude Agent SDK** | `@artinet/cruiser/claude`    | Text ✅ |
 | **LangChain**        | `@artinet/cruiser/langchain` | Text ✅ |
 | **Strands (AWS)**    | `@artinet/cruiser/strands`   | Text ✅ |
+| **OpenClaw**         | `@artinet/cruiser/openclaw`  | Text ✅ |
 
 ## Installation
 
@@ -49,6 +50,11 @@ npm install langchain @langchain/core
 
 # Strands (AWS)
 npm install @strands-agents/sdk
+
+# OpenClaw
+# openclaw runs as a gateway service/CLI
+# see: https://github.com/openclaw/openclaw
+# Cruiser's OpenClaw dock uses the standard Gateway WebSocket protocol.
 ```
 
 ## Quick Start
@@ -58,18 +64,18 @@ npm install @strands-agents/sdk
 Create an agent from any of the supported frameworks and dock it onto artinet:
 
 ```typescript
-import { Agent } from "@openai/agents";
-import { dock } from "@artinet/cruiser/openai";
-import { serve } from "@artinet/sdk";
+import { Agent } from '@openai/agents';
+import { dock } from '@artinet/cruiser/openai';
+import { serve } from '@artinet/sdk';
 
 // 1. Create your agent
 const agent = new Agent({
-  name: "assistant",
-  instructions: "You are a helpful assistant",
+    name: 'assistant',
+    instructions: 'You are a helpful assistant',
 });
 
 // 2. Dock it onto artinet
-const artinetAgent = await dock(agent, { name: "My Assistant" });
+const artinetAgent = await dock(agent, { name: 'My Assistant' });
 
 // 3. Spin it up as an A2A compatible Server
 serve({ agent: artinetAgent, port: 3000 });
@@ -82,35 +88,33 @@ serve({ agent: artinetAgent, port: 3000 });
 Create interoperable multi-agent systems:
 
 ```typescript
-import { serve, cr8 } from "@artinet/sdk";
-import { dock as dockMastra } from "@artinet/cruiser/mastra";
-import { dock as dockOpenAI } from "@artinet/cruiser/openai";
-import { Agent as MastraAgent } from "@mastra/core/agent";
-import { Agent as OpenAIAgent } from "@openai/agents";
-import { MastraModel } from "./mastra-model";
+import { serve, cr8 } from '@artinet/sdk';
+import { dock as dockMastra } from '@artinet/cruiser/mastra';
+import { dock as dockOpenAI } from '@artinet/cruiser/openai';
+import { Agent as MastraAgent } from '@mastra/core/agent';
+import { Agent as OpenAIAgent } from '@openai/agents';
+import { MastraModel } from './mastra-model';
 
 // Use agents from different frameworks
-const researcher = await dockOpenAI(
-  new OpenAIAgent({ name: "researcher", instructions: "Research topics" }),
-  { name: "Researcher" }
-);
+const researcher = await dockOpenAI(new OpenAIAgent({ name: 'researcher', instructions: 'Research topics' }), {
+    name: 'Researcher',
+});
 
-const writer = await dockMastra(
-  new MastraAgent({ name: "writer", instructions: "Write content", model }),
-  { name: "Writer" }
-);
+const writer = await dockMastra(new MastraAgent({ name: 'writer', instructions: 'Write content', model }), {
+    name: 'Writer',
+});
 
 // Chain them together
-const agent = cr8("Orchestrator Agent")
-  // The researcher will receive the incoming user message
-  .sendMessage({ agent: researcher })
-  // The results are passed to the writer with additional instructions
-  .sendMessage({
-    agent: writer,
-    message: "use the research results to create a publishable article",
-  }).agent;
-
-console.log(await agent.sendMessage("I want to learn about the Roman Empire."));
+const agent = cr8('Orchestrator Agent')
+    // The researcher will receive the incoming user message
+    .sendMessage({ agent: researcher })
+    // The results are passed to the writer with additional instructions
+    .sendMessage({
+        agent: writer,
+        message: 'use the research results to create a publishable article',
+    }).agent;
+
+console.log(await agent.sendMessage('I want to learn about the Roman Empire.'));
 ```
 
 - For more information on how to chain agent requests see the [artinet-sdk](https://github.com/the-artinet-project/artinet-sdk/blob/main/docs/create.md#agent-orchestration)
@@ -132,23 +136,23 @@ Each adapter exports a `dock` function with the same signature:
 ### Describe your agent
 
 ```typescript
-import { dock } from "@artinet/cruiser/openai";
+import { dock } from '@artinet/cruiser/openai';
 
 const artinetAgent = await dock(
-  myAgent,
-  {
-    name: "Production Assistant",
-    description: "Enterprise-grade AI assistant",
-    skills: [
-      { id: "search", name: "Web Search", description: "Search the internet" },
-      { id: "code", name: "Code Generation", description: "Write code" },
-    ],
-  },
-  {
-    // Most adapters allow for framework specific options to be passed
-    maxTurns: 10,
-    signal: abortController.signal,
-  }
+    myAgent,
+    {
+        name: 'Production Assistant',
+        description: 'Enterprise-grade AI assistant',
+        skills: [
+            { id: 'search', name: 'Web Search', description: 'Search the internet' },
+            { id: 'code', name: 'Code Generation', description: 'Write code' },
+        ],
+    },
+    {
+        // Most adapters allow for framework specific options to be passed
+        maxTurns: 10,
+        signal: abortController.signal,
+    },
 );
 ```
 

package/dist/index.d.ts

@@ -17,6 +17,7 @@
  * | Claude     | `@artinet/cruiser/claude`      | {@link ClaudeAgent}  |
  * | LangChain  | `@artinet/cruiser/langchain`   | {@link ReactAgent}   |
  * | Mastra     | `@artinet/cruiser/mastra`      | {@link MastraAgent}  |
+ * | OpenClaw   | `@artinet/cruiser/openclaw`    | {@link OpenClawAgent}|
  * | OpenAI     | `@artinet/cruiser/openai`      | {@link OpenAIAgent}  |
  * | Strands    | `@artinet/cruiser/strands`     | {@link StrandsAgent} |
  *

package/dist/index.js

@@ -17,6 +17,7 @@
  * | Claude     | `@artinet/cruiser/claude`      | {@link ClaudeAgent}  |
  * | LangChain  | `@artinet/cruiser/langchain`   | {@link ReactAgent}   |
  * | Mastra     | `@artinet/cruiser/mastra`      | {@link MastraAgent}  |
+ * | OpenClaw   | `@artinet/cruiser/openclaw`    | {@link OpenClawAgent}|
  * | OpenAI     | `@artinet/cruiser/openai`      | {@link OpenAIAgent}  |
  * | Strands    | `@artinet/cruiser/strands`     | {@link StrandsAgent} |
  *

package/dist/mastra/index.d.ts

@@ -40,9 +40,9 @@
  *
  * @see {@link https://mastra.ai/docs} Mastra Documentation
  */
-import { OutputSchema } from "@mastra/core/stream";
-import { Agent as MastraAgent, AgentExecutionOptions } from "@mastra/core/agent";
-import { Dock, Park } from "../corsair.js";
+import { OutputSchema } from '@mastra/core/stream';
+import { Agent as MastraAgent, AgentExecutionOptions } from '@mastra/core/agent';
+import { Dock, Park } from '../corsair.js';
 /**
  * Docks a Mastra agent onto artinet.
  *
@@ -104,8 +104,8 @@ import { Dock, Park } from "../corsair.js";
  * });
  * ```
  */
-export declare const dock: Dock<MastraAgent, AgentExecutionOptions<OutputSchema | undefined, "aisdk" | "mastra">>;
+export declare const dock: Dock<MastraAgent, AgentExecutionOptions<OutputSchema | undefined>>;
 /**
  * @deprecated Use {@link dock} instead.
  */
-export declare const park: Park<MastraAgent, AgentExecutionOptions<OutputSchema | undefined, "aisdk" | "mastra">>;
+export declare const park: Park<MastraAgent, AgentExecutionOptions<OutputSchema | undefined>>;

package/dist/mastra/index.js

@@ -40,9 +40,9 @@
  *
  * @see {@link https://mastra.ai/docs} Mastra Documentation
  */
-import * as sdk from "@artinet/sdk";
-import { getAgentCard, convertToCoreMessage } from "./utils.js";
-import { v4 as uuidv4 } from "uuid";
+import * as sdk from '@artinet/sdk';
+import { getAgentCard, convertToCoreMessage } from './utils.js';
+import { v4 as uuidv4 } from 'uuid';
 /**
  * Docks a Mastra agent onto artinet.
  *
@@ -135,7 +135,7 @@ export const dock = async (agent, card, options) => {
             contextId: task.contextId,
             message: sdk.describe.message({
                 messageId: uuidv4(),
-                role: "agent",
+                role: 'agent',
                 parts: [sdk.describe.part.text(result.text)],
                 metadata,
             }),

package/dist/mastra/utils.d.ts

@@ -9,10 +9,10 @@
  *
  * @see {@link https://github.com/mastra-ai/mastra} Mastra Source
  */
-import * as sdk from "@artinet/sdk";
-import { AgentExecutionOptions, Agent as MastraAgent } from "@mastra/core/agent";
-import { CoreMessage } from "@mastra/core/llm";
-import { OutputSchema } from "@mastra/core/stream";
+import * as sdk from '@artinet/sdk';
+import { AgentExecutionOptions, Agent as MastraAgent } from '@mastra/core/agent';
+import { CoreMessage } from '@mastra/core/llm';
+import { OutputSchema } from '@mastra/core/stream';
 /**
  * Builds an {@link sdk.A2A.AgentCard} from Mastra agent configuration.
  *
@@ -36,10 +36,10 @@ import { OutputSchema } from "@mastra/core/stream";
  * });
  * ```
  */
-export declare function getAgentCard<OUTPUT extends OutputSchema = undefined, FORMAT extends "aisdk" | "mastra" = "mastra">({ agent, card, options: _options, }: {
+export declare function getAgentCard<OUTPUT extends OutputSchema = undefined>({ agent, card, options: _options, }: {
     agent: MastraAgent;
     card?: sdk.A2A.AgentCardParams;
-    options?: AgentExecutionOptions<OUTPUT, FORMAT>;
+    options?: AgentExecutionOptions<OUTPUT>;
 }): Promise<sdk.A2A.AgentCard>;
 /**
  * Converts an {@link sdk.A2A.Message} to Mastra's {@link CoreMessage} format.

package/dist/mastra/utils.js

@@ -9,7 +9,7 @@
  *
  * @see {@link https://github.com/mastra-ai/mastra} Mastra Source
  */
-import * as sdk from "@artinet/sdk";
+import * as sdk from '@artinet/sdk';
 /**
  * Converts Mastra {@link SystemMessage} instructions to a plain string.
  *
@@ -27,25 +27,25 @@ import * as sdk from "@artinet/sdk";
  */
 function convertInstructionsToString(message) {
     if (!message) {
-        return "";
+        return '';
     }
-    if (typeof message === "string") {
+    if (typeof message === 'string') {
         return message;
     }
     if (Array.isArray(message)) {
         return message
             .map((m) => {
-            if (typeof m === "string") {
+            if (typeof m === 'string') {
                 return m;
             }
             // Safely extract content from message objects
-            return typeof m.content === "string" ? m.content : "";
+            return typeof m.content === 'string' ? m.content : '';
         })
             .filter((content) => content) // Remove empty strings
-            .join("\n");
+            .join('\n');
     }
     // Handle single message object - safely extract content
-    return typeof message.content === "string" ? message.content : "";
+    return typeof message.content === 'string' ? message.content : '';
 }
 /**
  * Builds an {@link sdk.A2A.AgentCard} from Mastra agent configuration.
@@ -71,23 +71,23 @@ function convertInstructionsToString(message) {
  * ```
  */
 export async function getAgentCard({ agent, card, options: _options, }) {
-    const [instructions, tools] = await Promise.all([agent.getInstructions(), agent.getTools()]);
+    const [instructions, tools = {}] = await Promise.all([agent.getInstructions(), agent.listTools?.() ?? Promise.resolve({})]);
     const agentCard = sdk.describe.card({
         name: agent.id,
-        ...(typeof card === "string" ? { name: card } : card),
+        ...(typeof card === 'string' ? { name: card } : card),
         description: convertInstructionsToString(instructions),
         capabilities: {
             streaming: true,
             pushNotifications: true,
             stateTransitionHistory: false,
         },
-        defaultInputModes: ["text"],
-        defaultOutputModes: ["text"],
+        defaultInputModes: ['text'],
+        defaultOutputModes: ['text'],
         skills: Object.entries(tools).map(([toolId, tool]) => ({
             id: toolId,
             name: toolId,
             description: tool.description || `Tool: ${toolId}`,
-            tags: ["tool"],
+            tags: ['tool'],
         })),
     });
     return agentCard;
@@ -112,7 +112,7 @@ export async function getAgentCard({ agent, card, options: _options, }) {
  */
 export function convertToCoreMessage(message) {
     return {
-        role: message.role === "user" ? "user" : "assistant",
+        role: message.role === 'user' ? 'user' : 'assistant',
         content: message.parts.map((msg) => convertToCoreMessagePart(msg)),
     };
 }
@@ -131,21 +131,21 @@ export function convertToCoreMessage(message) {
  */
 function convertToCoreMessagePart(part) {
     switch (part.kind) {
-        case "text":
+        case 'text':
             return {
-                type: "text",
+                type: 'text',
                 text: part.text,
             };
-        case "file":
+        case 'file':
             return {
-                type: "file",
-                data: "uri" in part.file && part.file.uri
+                type: 'file',
+                data: 'uri' in part.file && part.file.uri
                     ? new URL(part.file.uri)
                     : /**Appeasing the type system */
                         part.file.bytes,
-                mimeType: part.file.mimeType ?? "unknown",
+                mimeType: part.file.mimeType ?? 'unknown',
             };
-        case "data":
-            throw new Error("Data parts are not supported in core messages");
+        case 'data':
+            throw new Error('Data parts are not supported in core messages');
     }
 }

package/dist/openclaw/auth.d.ts

@@ -0,0 +1,48 @@
+import type { OpenClawAgent } from './utils.js';
+type StoredAuthFile = {
+    version: 1;
+    device?: {
+        id: string;
+        publicKey: string;
+        privateKeyPem: string;
+    };
+    tokens?: {
+        operator?: {
+            token: string;
+            role?: string;
+            scopes?: string[];
+            updatedAtMs: number;
+        };
+    };
+};
+export type ResolvedDeviceIdentity = {
+    id: string;
+    publicKey: string;
+    privateKeyPem: string;
+};
+export declare function resolveAuthFilePath(agent: OpenClawAgent): string | undefined;
+export declare function readStoredAuth(path: string | undefined): StoredAuthFile | undefined;
+export declare function writeStoredAuth(path: string | undefined, auth: StoredAuthFile): void;
+export declare function resolveOrCreateDeviceIdentity({ agent, authFilePath, }: {
+    agent: OpenClawAgent;
+    authFilePath: string | undefined;
+}): ResolvedDeviceIdentity | undefined;
+export declare function createSignedDevicePayload({ identity, scopes, token, nonce, }: {
+    identity: ResolvedDeviceIdentity;
+    scopes: string[];
+    token?: string;
+    nonce?: string;
+}): {
+    id: string;
+    publicKey: string;
+    signature: string;
+    signedAt: number;
+    nonce?: string;
+};
+export declare function persistConnectAuth({ authFilePath, payload, scopes, deviceIdentity, }: {
+    authFilePath: string | undefined;
+    payload: unknown;
+    scopes: string[];
+    deviceIdentity?: ResolvedDeviceIdentity;
+}): void;
+export {};

package/dist/openclaw/auth.js

@@ -0,0 +1,152 @@
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, sign } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+function base64UrlEncode(buffer) {
+    return buffer.toString('base64').replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/g, '');
+}
+function derivePublicKeyRawFromPem(publicKeyPem) {
+    const key = createPublicKey(publicKeyPem);
+    const spki = key.export({ type: 'spki', format: 'der' });
+    if (spki.length === ED25519_SPKI_PREFIX.length + 32 &&
+        spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
+        return spki.subarray(ED25519_SPKI_PREFIX.length);
+    }
+    return spki;
+}
+function fingerprintPublicKey(publicKeyBase64Url) {
+    return createHash('sha256')
+        .update(Buffer.from(publicKeyBase64Url.replaceAll('-', '+').replaceAll('_', '/'), 'base64'))
+        .digest('hex');
+}
+function buildDeviceAuthPayload({ version, deviceId, clientId, clientMode, role, scopes, signedAt, token, nonce, }) {
+    const base = [version, deviceId, clientId, clientMode, role, scopes.join(','), String(signedAt), token ?? ''];
+    if (version === 'v2') {
+        base.push(nonce ?? '');
+    }
+    return base.join('|');
+}
+export function resolveAuthFilePath(agent) {
+    if (agent.autoDeviceAuth === false) {
+        return undefined;
+    }
+    if (agent.authFilePath && agent.authFilePath.trim().length > 0) {
+        return agent.authFilePath.trim();
+    }
+    return join(homedir(), 'artinet-openclaw.auth');
+}
+export function readStoredAuth(path) {
+    if (!path || !existsSync(path)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (parsed.version !== 1) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeStoredAuth(path, auth) {
+    if (!path) {
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(auth, null, 2)}\n`, { encoding: 'utf8' });
+}
+export function resolveOrCreateDeviceIdentity({ agent, authFilePath, }) {
+    const manual = agent.device;
+    if (manual?.id && manual.publicKey && manual.privateKeyPem) {
+        return {
+            id: manual.id,
+            publicKey: manual.publicKey,
+            privateKeyPem: manual.privateKeyPem,
+        };
+    }
+    const stored = readStoredAuth(authFilePath);
+    if (stored?.device?.id && stored.device.publicKey && stored.device.privateKeyPem) {
+        return stored.device;
+    }
+    if (agent.autoDeviceAuth === false) {
+        return undefined;
+    }
+    const keyPair = generateKeyPairSync('ed25519');
+    const publicKeyPem = keyPair.publicKey.export({ type: 'spki', format: 'pem' }).toString();
+    const privateKeyPem = keyPair.privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
+    const publicKey = base64UrlEncode(derivePublicKeyRawFromPem(publicKeyPem));
+    const identity = {
+        id: fingerprintPublicKey(publicKey),
+        publicKey,
+        privateKeyPem,
+    };
+    const nextAuth = stored ?? { version: 1 };
+    nextAuth.device = identity;
+    writeStoredAuth(authFilePath, nextAuth);
+    return identity;
+}
+export function createSignedDevicePayload({ identity, scopes, token, nonce, }) {
+    const signedAt = Date.now();
+    const version = nonce ? 'v2' : 'v1';
+    const payload = buildDeviceAuthPayload({
+        version,
+        deviceId: identity.id,
+        clientId: 'cli',
+        clientMode: 'cli',
+        role: 'operator',
+        scopes,
+        signedAt,
+        token,
+        nonce,
+    });
+    const signature = base64UrlEncode(sign(null, Buffer.from(payload, 'utf8'), createPrivateKey(identity.privateKeyPem)));
+    return {
+        id: identity.id,
+        publicKey: identity.publicKey,
+        signature,
+        signedAt,
+        ...(nonce ? { nonce } : {}),
+    };
+}
+export function persistConnectAuth({ authFilePath, payload, scopes, deviceIdentity, }) {
+    if (!authFilePath) {
+        return;
+    }
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        return;
+    }
+    const record = payload;
+    const auth = record.auth;
+    if (!auth || typeof auth !== 'object' || Array.isArray(auth)) {
+        return;
+    }
+    const authRecord = auth;
+    const deviceToken = authRecord.deviceToken;
+    if (typeof deviceToken !== 'string' || deviceToken.trim().length === 0) {
+        return;
+    }
+    const role = typeof authRecord.role === 'string' ? authRecord.role : 'operator';
+    const resolvedScopes = Array.isArray(authRecord.scopes)
+        ? authRecord.scopes.filter((scope) => typeof scope === 'string')
+        : scopes;
+    const existing = readStoredAuth(authFilePath) ?? { version: 1 };
+    const next = {
+        ...existing,
+        tokens: {
+            ...(existing.tokens ?? {}),
+            operator: {
+                token: deviceToken,
+                role,
+                scopes: resolvedScopes,
+                updatedAtMs: Date.now(),
+            },
+        },
+    };
+    if (deviceIdentity) {
+        next.device = deviceIdentity;
+    }
+    writeStoredAuth(authFilePath, next);
+}

package/dist/openclaw/client.d.ts

@@ -0,0 +1,37 @@
+import type { OpenClawAgent, OpenClawResult } from './utils.js';
+export declare class OpenClawGatewayClient {
+    private readonly url;
+    private readonly authToken?;
+    private readonly authPassword?;
+    private readonly device?;
+    private readonly deviceIdentity?;
+    private readonly authFilePath;
+    private readonly scopes;
+    private readonly connectTimeoutMs;
+    private readonly clientId;
+    private socket;
+    private connectPromise;
+    private isConnected;
+    private connectRequestId;
+    private pendingRequests;
+    constructor({ url, authToken, authPassword, agent, device, scopes, connectTimeoutMs, }: {
+        url: string;
+        authToken?: string;
+        authPassword?: string;
+        agent: OpenClawAgent;
+        device?: OpenClawAgent['device'];
+        scopes?: string[];
+        connectTimeoutMs: number;
+    });
+    ensureConnected(): Promise<void>;
+    requestAgentRun({ message, agentId, sessionKey, timeoutMs, }: {
+        message: string;
+        agentId: string;
+        sessionKey?: string;
+        timeoutMs: number;
+    }): Promise<OpenClawResult>;
+    private handleMessage;
+    private sendConnectRequest;
+    private sendFrame;
+    private rejectAllPending;
+}