roboport 0.2.0 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Timur Badretdinov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/mcp/clients/github.d.ts

@@ -0,0 +1,12 @@
+import { Mcp as McpBase } from '../core';
+type Options = {
+    token: string;
+    name?: string;
+    toolsets?: string[];
+    readOnly?: boolean;
+    deferred?: boolean;
+};
+declare class Mcp extends McpBase {
+    constructor(opts: Options);
+}
+export default Mcp;

package/mcp/clients/slack.d.ts

@@ -0,0 +1,23 @@
+import { Tool, type McpClient } from '../../core';
+type Options = {
+    /**
+     * Slack bot token (`xoxb-…`). Requires these OAuth scopes:
+     * `chat:write` (post_message, reply_in_thread),
+     * `channels:read` (list_channels),
+     * `channels:history` (get_channel_history),
+     * `users:read` (list_users, get_user),
+     * `reactions:write` (add_reaction).
+     */
+    botToken: string;
+    name?: string;
+    deferred?: boolean;
+};
+declare class Mcp implements McpClient {
+    private auth;
+    private nameSpace;
+    private deferred;
+    constructor(opts: Options);
+    connect(): Promise<Tool[]>;
+    disconnect(): Promise<void>;
+}
+export default Mcp;

package/mcp/core.d.ts

@@ -13,6 +13,7 @@ type HttpTransportConfig = {
     auth?: AuthProvider;
 };
 type McpTransportConfig = StdioTransportConfig | HttpTransportConfig;
+declare function validateMcpName(name: string): void;
 declare class Mcp implements McpClient {
     name: string;
     transport: McpTransportConfig;
@@ -27,4 +28,4 @@ declare class Mcp implements McpClient {
     disconnect(): Promise<void>;
     private wrap;
 }
-export { Mcp, type McpTransportConfig, type StdioTransportConfig, type HttpTransportConfig, };
+export { Mcp, validateMcpName, type McpTransportConfig, type StdioTransportConfig, type HttpTransportConfig, };

package/mcp/index.d.ts

@@ -1,7 +1,9 @@
 import { BearerAuth, OAuthAuth, type AuthProvider, type OAuthAuthOptions } from './auth';
+import Github from './clients/github';
 import Grafana from './clients/grafana';
 import Linear from './clients/linear';
+import Slack from './clients/slack';
 import Tenderly from './clients/tenderly';
 import { Mcp, type HttpTransportConfig, type McpTransportConfig, type StdioTransportConfig } from './core';
 import { FileStorage, MemoryStorage, type OAuthStorage, type TokenSet } from './storage';
-export { BearerAuth, FileStorage, Grafana, Linear, Mcp, MemoryStorage, OAuthAuth, Tenderly, type AuthProvider, type HttpTransportConfig, type McpTransportConfig, type OAuthAuthOptions, type OAuthStorage, type StdioTransportConfig, type TokenSet, };
+export { BearerAuth, FileStorage, Github, Grafana, Linear, Mcp, MemoryStorage, OAuthAuth, Slack, Tenderly, type AuthProvider, type HttpTransportConfig, type McpTransportConfig, type OAuthAuthOptions, type OAuthStorage, type StdioTransportConfig, type TokenSet, };

package/mcp/index.js

@@ -884,179 +884,6 @@ class Skill {
   }
 }
 
-// src/mcp/clients/grafana.ts
-var EMPTY_OBJECT = {
-  type: "object",
-  properties: {},
-  additionalProperties: false
-};
-var TOOLS = [
-  {
-    name: "list_datasources",
-    description: "List all configured Grafana datasources.",
-    inputSchema: EMPTY_OBJECT,
-    call: (_, ctx) => request(ctx, "GET", "/api/datasources")
-  },
-  {
-    name: "get_datasource",
-    description: "Fetch a single datasource by UID.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        uid: { type: "string", description: "Datasource UID." }
-      },
-      required: ["uid"],
-      additionalProperties: false
-    },
-    call: (args, ctx) => request(ctx, "GET", `/api/datasources/uid/${encodeURIComponent(String(args.uid))}`)
-  },
-  {
-    name: "query",
-    description: "Run one or more queries against Grafana datasources via /api/ds/query. Pass the query array as Grafana expects (each item needs refId and datasource.uid).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        queries: {
-          type: "array",
-          description: "Array of query objects (refId, datasource, expr/range/etc.).",
-          items: { type: "object" }
-        },
-        from: {
-          type: "string",
-          description: 'Range start, e.g. "now-1h" or epoch ms as string.'
-        },
-        to: {
-          type: "string",
-          description: 'Range end, e.g. "now" or epoch ms as string.'
-        }
-      },
-      required: ["queries"],
-      additionalProperties: false
-    },
-    call: (args, ctx) => request(ctx, "POST", "/api/ds/query", {
-      queries: args.queries,
-      from: args.from ?? "now-1h",
-      to: args.to ?? "now"
-    })
-  },
-  {
-    name: "search_dashboards",
-    description: "Search dashboards by name, tag, or folder.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: "Substring match on dashboard title."
-        },
-        tag: {
-          type: "array",
-          items: { type: "string" },
-          description: "Filter by tags."
-        },
-        folderUIDs: {
-          type: "array",
-          items: { type: "string" },
-          description: "Limit to specific folder UIDs."
-        },
-        limit: { type: "number", description: "Max results (default 100)." }
-      },
-      additionalProperties: false
-    },
-    call: (args, ctx) => {
-      const params = new URLSearchParams;
-      params.set("type", "dash-db");
-      if (typeof args.query === "string")
-        params.set("query", args.query);
-      if (typeof args.limit === "number")
-        params.set("limit", String(args.limit));
-      for (const tag of args.tag ?? [])
-        params.append("tag", tag);
-      for (const uid of args.folderUIDs ?? [])
-        params.append("folderUIDs", uid);
-      return request(ctx, "GET", `/api/search?${params.toString()}`);
-    }
-  },
-  {
-    name: "get_dashboard",
-    description: "Fetch a dashboard JSON by UID.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        uid: { type: "string", description: "Dashboard UID." }
-      },
-      required: ["uid"],
-      additionalProperties: false
-    },
-    call: (args, ctx) => request(ctx, "GET", `/api/dashboards/uid/${encodeURIComponent(String(args.uid))}`)
-  },
-  {
-    name: "list_folders",
-    description: "List dashboard folders.",
-    inputSchema: EMPTY_OBJECT,
-    call: (_, ctx) => request(ctx, "GET", "/api/folders")
-  },
-  {
-    name: "list_alert_rules",
-    description: "List provisioned alert rules.",
-    inputSchema: EMPTY_OBJECT,
-    call: (_, ctx) => request(ctx, "GET", "/api/v1/provisioning/alert-rules")
-  }
-];
-async function request(ctx, method, path, body) {
-  const headers = {
-    accept: "application/json",
-    authorization: await ctx.auth.getHeader()
-  };
-  if (body !== undefined)
-    headers["content-type"] = "application/json";
-  const res = await fetch(`${ctx.baseUrl}${path}`, {
-    method,
-    headers,
-    body: body !== undefined ? JSON.stringify(body) : undefined
-  });
-  const text = await res.text();
-  if (!res.ok) {
-    throw new Error(`Grafana ${method} ${path} failed: ${res.status} ${text}`);
-  }
-  if (!text)
-    return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-class Mcp {
-  baseUrl;
-  auth;
-  nameSpace;
-  deferred;
-  constructor(opts) {
-    this.baseUrl = opts.url.replace(/\/$/, "");
-    this.auth = new BearerAuth(opts.serviceAccountToken);
-    this.nameSpace = opts.name ?? "grafana";
-    this.deferred = opts.deferred ?? true;
-  }
-  async connect() {
-    const ctx = { baseUrl: this.baseUrl, auth: this.auth };
-    return TOOLS.map((def) => new Tool({
-      name: `mcp__${this.nameSpace}__${def.name}`,
-      description: def.description,
-      jsonSchema: def.inputSchema,
-      deferred: this.deferred,
-      execute: async (input) => {
-        const args = input ?? {};
-        const result = await def.call(args, ctx);
-        return typeof result === "string" ? result : JSON.stringify(result);
-      }
-    }));
-  }
-  async disconnect() {}
-}
-var grafana_default = Mcp;
-
 // src/mcp/core.ts
 var PROTOCOL_VERSION = "2024-11-05";
 
@@ -1256,6 +1083,11 @@ class HttpTransport {
     await this.send(req, undefined);
   }
 }
+function validateMcpName(name) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error(`Invalid MCP name "${name}": use only letters, digits, underscores, and hyphens.`);
+  }
+}
 function formatContent(content) {
   if (content.length === 1 && content[0]?.type === "text") {
     return content[0].text ?? "";
@@ -1264,7 +1096,7 @@ function formatContent(content) {
 `);
 }
 
-class Mcp2 {
+class Mcp {
   name;
   transport;
   deferred;
@@ -1274,9 +1106,7 @@ class Mcp2 {
     transport,
     deferred
   }) {
-    if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-      throw new Error(`Invalid MCP name "${name}": use only letters, digits, underscores, and hyphens.`);
-    }
+    validateMcpName(name);
     this.name = name;
     this.transport = transport;
     this.deferred = deferred ?? true;
@@ -1324,10 +1154,210 @@ class Mcp2 {
   }
 }
 
+// src/mcp/clients/github.ts
+var GITHUB_MCP_URL = "https://api.githubcopilot.com/mcp/";
+
+class Mcp2 extends Mcp {
+  constructor(opts) {
+    const headers = {};
+    if (opts.toolsets?.length) {
+      headers["X-MCP-Toolsets"] = opts.toolsets.join(",");
+    }
+    if (opts.readOnly) {
+      headers["X-MCP-Readonly"] = "true";
+    }
+    super({
+      name: opts.name ?? "github",
+      deferred: opts.deferred,
+      transport: {
+        type: "http",
+        url: GITHUB_MCP_URL,
+        headers,
+        auth: new BearerAuth(opts.token)
+      }
+    });
+  }
+}
+var github_default = Mcp2;
+
+// src/mcp/clients/grafana.ts
+var EMPTY_OBJECT = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var TOOLS = [
+  {
+    name: "list_datasources",
+    description: "List all configured Grafana datasources.",
+    inputSchema: EMPTY_OBJECT,
+    call: (_, ctx) => request(ctx, "GET", "/api/datasources")
+  },
+  {
+    name: "get_datasource",
+    description: "Fetch a single datasource by UID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        uid: { type: "string", description: "Datasource UID." }
+      },
+      required: ["uid"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request(ctx, "GET", `/api/datasources/uid/${encodeURIComponent(String(args.uid))}`)
+  },
+  {
+    name: "query",
+    description: "Run one or more queries against Grafana datasources via /api/ds/query. Pass the query array as Grafana expects (each item needs refId and datasource.uid).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        queries: {
+          type: "array",
+          description: "Array of query objects (refId, datasource, expr/range/etc.).",
+          items: { type: "object" }
+        },
+        from: {
+          type: "string",
+          description: 'Range start, e.g. "now-1h" or epoch ms as string.'
+        },
+        to: {
+          type: "string",
+          description: 'Range end, e.g. "now" or epoch ms as string.'
+        }
+      },
+      required: ["queries"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request(ctx, "POST", "/api/ds/query", {
+      queries: args.queries,
+      from: args.from ?? "now-1h",
+      to: args.to ?? "now"
+    })
+  },
+  {
+    name: "search_dashboards",
+    description: "Search dashboards by name, tag, or folder.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Substring match on dashboard title."
+        },
+        tag: {
+          type: "array",
+          items: { type: "string" },
+          description: "Filter by tags."
+        },
+        folderUIDs: {
+          type: "array",
+          items: { type: "string" },
+          description: "Limit to specific folder UIDs."
+        },
+        limit: { type: "number", description: "Max results (default 100)." }
+      },
+      additionalProperties: false
+    },
+    call: (args, ctx) => {
+      const params = new URLSearchParams;
+      params.set("type", "dash-db");
+      if (typeof args.query === "string")
+        params.set("query", args.query);
+      if (typeof args.limit === "number")
+        params.set("limit", String(args.limit));
+      for (const tag of args.tag ?? [])
+        params.append("tag", tag);
+      for (const uid of args.folderUIDs ?? [])
+        params.append("folderUIDs", uid);
+      return request(ctx, "GET", `/api/search?${params.toString()}`);
+    }
+  },
+  {
+    name: "get_dashboard",
+    description: "Fetch a dashboard JSON by UID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        uid: { type: "string", description: "Dashboard UID." }
+      },
+      required: ["uid"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request(ctx, "GET", `/api/dashboards/uid/${encodeURIComponent(String(args.uid))}`)
+  },
+  {
+    name: "list_folders",
+    description: "List dashboard folders.",
+    inputSchema: EMPTY_OBJECT,
+    call: (_, ctx) => request(ctx, "GET", "/api/folders")
+  },
+  {
+    name: "list_alert_rules",
+    description: "List provisioned alert rules.",
+    inputSchema: EMPTY_OBJECT,
+    call: (_, ctx) => request(ctx, "GET", "/api/v1/provisioning/alert-rules")
+  }
+];
+async function request(ctx, method, path, body) {
+  const headers = {
+    accept: "application/json",
+    authorization: await ctx.auth.getHeader()
+  };
+  if (body !== undefined)
+    headers["content-type"] = "application/json";
+  const res = await fetch(`${ctx.baseUrl}${path}`, {
+    method,
+    headers,
+    body: body !== undefined ? JSON.stringify(body) : undefined
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(`Grafana ${method} ${path} failed: ${res.status} ${text}`);
+  }
+  if (!text)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+class Mcp3 {
+  baseUrl;
+  auth;
+  nameSpace;
+  deferred;
+  constructor(opts) {
+    this.baseUrl = opts.url.replace(/\/$/, "");
+    this.auth = new BearerAuth(opts.serviceAccountToken);
+    this.nameSpace = opts.name ?? "grafana";
+    validateMcpName(this.nameSpace);
+    this.deferred = opts.deferred ?? true;
+  }
+  async connect() {
+    const ctx = { baseUrl: this.baseUrl, auth: this.auth };
+    return TOOLS.map((def) => new Tool({
+      name: `mcp__${this.nameSpace}__${def.name}`,
+      description: def.description,
+      jsonSchema: def.inputSchema,
+      deferred: this.deferred,
+      execute: async (input) => {
+        const args = input ?? {};
+        const result = await def.call(args, ctx);
+        return typeof result === "string" ? result : JSON.stringify(result);
+      }
+    }));
+  }
+  async disconnect() {}
+}
+var grafana_default = Mcp3;
+
 // src/mcp/clients/linear.ts
 var LINEAR_MCP_URL = "https://mcp.linear.app/mcp";
 
-class Mcp3 extends Mcp2 {
+class Mcp4 extends Mcp {
   constructor(opts) {
     super({
       name: opts.name ?? "linear",
@@ -1339,12 +1369,217 @@ class Mcp3 extends Mcp2 {
     });
   }
 }
-var linear_default = Mcp3;
+var linear_default = Mcp4;
+
+// src/mcp/clients/slack.ts
+var SLACK_API_URL = "https://slack.com/api";
+var TOOLS2 = [
+  {
+    name: "post_message",
+    description: "Post a message to a Slack channel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: {
+          type: "string",
+          description: "Channel ID (e.g. C012AB3CD) or name (e.g. #general)."
+        },
+        text: { type: "string", description: "Message text." }
+      },
+      required: ["channel", "text"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "chat.postMessage", {
+      channel: args.channel,
+      text: args.text
+    })
+  },
+  {
+    name: "reply_in_thread",
+    description: "Reply to an existing message thread in a Slack channel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", description: "Channel ID or name." },
+        thread_ts: {
+          type: "string",
+          description: "Timestamp (ts) of the parent message to reply to."
+        },
+        text: { type: "string", description: "Reply text." }
+      },
+      required: ["channel", "thread_ts", "text"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "chat.postMessage", {
+      channel: args.channel,
+      thread_ts: args.thread_ts,
+      text: args.text
+    })
+  },
+  {
+    name: "list_channels",
+    description: "List channels in the workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        types: {
+          type: "string",
+          description: 'Comma-separated channel types (default "public_channel").'
+        },
+        limit: { type: "number", description: "Max results (default 100)." },
+        cursor: { type: "string", description: "Pagination cursor." },
+        exclude_archived: {
+          type: "boolean",
+          description: "Omit archived channels (default true)."
+        }
+      },
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "conversations.list", {
+      types: args.types ?? "public_channel",
+      limit: args.limit ?? 100,
+      cursor: args.cursor,
+      exclude_archived: args.exclude_archived ?? true
+    })
+  },
+  {
+    name: "get_channel_history",
+    description: "Fetch recent messages from a channel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", description: "Channel ID." },
+        limit: { type: "number", description: "Max messages (default 100)." },
+        cursor: { type: "string", description: "Pagination cursor." },
+        oldest: {
+          type: "string",
+          description: "Only messages after this ts."
+        },
+        latest: {
+          type: "string",
+          description: "Only messages before this ts."
+        }
+      },
+      required: ["channel"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "conversations.history", {
+      channel: args.channel,
+      limit: args.limit ?? 100,
+      cursor: args.cursor,
+      oldest: args.oldest,
+      latest: args.latest
+    })
+  },
+  {
+    name: "list_users",
+    description: "List users in the workspace.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max results (default 100)." },
+        cursor: { type: "string", description: "Pagination cursor." }
+      },
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "users.list", {
+      limit: args.limit ?? 100,
+      cursor: args.cursor
+    })
+  },
+  {
+    name: "get_user",
+    description: "Fetch a single user by ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        user: { type: "string", description: "User ID (e.g. U012AB3CD)." }
+      },
+      required: ["user"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "users.info", { user: args.user })
+  },
+  {
+    name: "add_reaction",
+    description: "Add an emoji reaction to a message.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel: { type: "string", description: "Channel ID." },
+        timestamp: {
+          type: "string",
+          description: "Timestamp (ts) of the target message."
+        },
+        name: {
+          type: "string",
+          description: 'Emoji name without colons (e.g. "thumbsup").'
+        }
+      },
+      required: ["channel", "timestamp", "name"],
+      additionalProperties: false
+    },
+    call: (args, ctx) => request2(ctx, "reactions.add", {
+      channel: args.channel,
+      timestamp: args.timestamp,
+      name: args.name
+    })
+  }
+];
+async function request2(ctx, method, params) {
+  const body = new URLSearchParams;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined || value === null)
+      continue;
+    body.set(key, String(value));
+  }
+  const res = await fetch(`${SLACK_API_URL}/${method}`, {
+    method: "POST",
+    headers: {
+      authorization: await ctx.auth.getHeader(),
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    body
+  });
+  const json = await res.json();
+  if (!json.ok) {
+    throw new Error(`Slack ${method} failed: ${json.error ?? res.status}`);
+  }
+  return json;
+}
+
+class Mcp5 {
+  auth;
+  nameSpace;
+  deferred;
+  constructor(opts) {
+    this.auth = new BearerAuth(opts.botToken);
+    this.nameSpace = opts.name ?? "slack";
+    validateMcpName(this.nameSpace);
+    this.deferred = opts.deferred ?? true;
+  }
+  async connect() {
+    const ctx = { auth: this.auth };
+    return TOOLS2.map((def) => new Tool({
+      name: `mcp__${this.nameSpace}__${def.name}`,
+      description: def.description,
+      jsonSchema: def.inputSchema,
+      deferred: this.deferred,
+      execute: async (input) => {
+        const args = input ?? {};
+        const result = await def.call(args, ctx);
+        return typeof result === "string" ? result : JSON.stringify(result);
+      }
+    }));
+  }
+  async disconnect() {}
+}
+var slack_default = Mcp5;
 
 // src/mcp/clients/tenderly.ts
 var TENDERLY_MCP_URL = "https://mcp.tenderly.co/mcp";
 
-class Mcp4 extends Mcp2 {
+class Mcp6 extends Mcp {
   constructor(opts) {
     const auth = new OAuthAuth({
       serverUrl: TENDERLY_MCP_URL,
@@ -1362,14 +1597,16 @@ class Mcp4 extends Mcp2 {
     });
   }
 }
-var tenderly_default = Mcp4;
+var tenderly_default = Mcp6;
 export {
   tenderly_default as Tenderly,
+  slack_default as Slack,
   OAuthAuth,
   MemoryStorage,
-  Mcp2 as Mcp,
+  Mcp,
   linear_default as Linear,
   grafana_default as Grafana,
+  github_default as Github,
   FileStorage,
   BearerAuth
 };

package/models/anthropic.d.ts

@@ -1,7 +1,7 @@
 import { Model, type CreateMessageParams, type LiteralUnion, type ModelStreamEvent, type SearchHit, type SearchOptions, type ThinkingLevel } from '../core';
 declare const ANTHROPIC_MODELS: readonly ["claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-sonnet-4-5", "claude-haiku-4-5"];
 type AnthropicModelName = LiteralUnion<(typeof ANTHROPIC_MODELS)[number]>;
-declare class AnthropicModel extends Model {
+declare class Anthropic extends Model {
     modelName: string;
     apiKey: string;
     thinking: ThinkingLevel;
@@ -12,4 +12,4 @@ declare class AnthropicModel extends Model {
     streamMessage(params: CreateMessageParams): AsyncIterable<ModelStreamEvent>;
     searchWeb(query: string, opts?: SearchOptions): Promise<SearchHit[]>;
 }
-export { AnthropicModel, ANTHROPIC_MODELS };
+export { Anthropic, ANTHROPIC_MODELS };

package/models/google.d.ts

@@ -1,8 +1,8 @@
 import type { LiteralUnion, SearchHit, SearchOptions, ThinkingLevel } from '../core';
-import { OpenAICompatibleModel } from './openai-compatible';
+import { OpenAICompatible } from './openai-compatible';
 declare const GEMINI_MODELS: readonly ["gemini-3.5-flash", "gemini-3.1-pro", "gemini-3.1-flash-lite", "gemini-3-flash"];
 type GeminiModelName = LiteralUnion<(typeof GEMINI_MODELS)[number]>;
-declare class GeminiModel extends OpenAICompatibleModel {
+declare class Gemini extends OpenAICompatible {
     constructor(modelName: GeminiModelName, options?: {
         apiKey?: string;
         baseUrl?: string;
@@ -11,4 +11,4 @@ declare class GeminiModel extends OpenAICompatibleModel {
     protected applyThinking(body: Record<string, unknown>): void;
     searchWeb(query: string, opts?: SearchOptions): Promise<SearchHit[]>;
 }
-export { GeminiModel, GEMINI_MODELS };
+export { Gemini, GEMINI_MODELS };

package/models/index.d.ts

@@ -1,6 +1,6 @@
-import { ANTHROPIC_MODELS, AnthropicModel } from './anthropic';
-import { GEMINI_MODELS, GeminiModel } from './google';
-import { MOONSHOT_MODELS, MoonshotModel } from './moonshot';
-import { OPENAI_MODELS, OpenAIModel } from './openai';
-import { OpenAICompatibleModel } from './openai-compatible';
-export { AnthropicModel, GeminiModel, MoonshotModel, OpenAIModel, OpenAICompatibleModel, ANTHROPIC_MODELS, GEMINI_MODELS, MOONSHOT_MODELS, OPENAI_MODELS, };
+import { ANTHROPIC_MODELS, Anthropic } from './anthropic';
+import { GEMINI_MODELS, Gemini } from './google';
+import { MOONSHOT_MODELS, Moonshot } from './moonshot';
+import { OPENAI_MODELS, OpenAI } from './openai';
+import { OpenAICompatible } from './openai-compatible';
+export { Anthropic, Gemini, Moonshot, OpenAI, OpenAICompatible, ANTHROPIC_MODELS, GEMINI_MODELS, MOONSHOT_MODELS, OPENAI_MODELS, };

package/models/index.js

@@ -742,7 +742,7 @@ function toWire(messages) {
   return { system, wireMessages };
 }
 
-class AnthropicModel extends Model {
+class Anthropic extends Model {
   modelName;
   apiKey;
   thinking;
@@ -1009,7 +1009,7 @@ function parseToolArguments(raw) {
   }
 }
 
-class OpenAICompatibleModel extends Model {
+class OpenAICompatible extends Model {
   modelName;
   apiKey;
   baseUrl;
@@ -1220,7 +1220,7 @@ var GEMINI_MODELS = [
   "gemini-3-flash"
 ];
 
-class GeminiModel extends OpenAICompatibleModel {
+class Gemini extends OpenAICompatible {
   constructor(modelName, options) {
     const key = options?.apiKey ?? env.geminiApiKey;
     if (!key) {
@@ -1276,7 +1276,7 @@ class GeminiModel extends OpenAICompatibleModel {
 // src/models/moonshot.ts
 var MOONSHOT_MODELS = ["kimi-k2.6", "kimi-k2.5"];
 
-class MoonshotModel extends OpenAICompatibleModel {
+class Moonshot extends OpenAICompatible {
   constructor(modelName, options) {
     const key = options?.apiKey ?? env.moonshotApiKey;
     if (!key) {
@@ -1672,7 +1672,7 @@ function mapResponsesStatus(status) {
   }
 }
 
-class OpenAIModel extends OpenAICompatibleModel {
+class OpenAI extends OpenAICompatible {
   codexAuth;
   constructor(modelName, options) {
     const auth = options?.auth ?? { type: "apiKey" };
@@ -2036,13 +2036,13 @@ function extractSearchHits(json) {
   return hits;
 }
 export {
-  OpenAIModel,
-  OpenAICompatibleModel,
+  OpenAICompatible,
+  OpenAI,
   OPENAI_MODELS,
-  MoonshotModel,
+  Moonshot,
   MOONSHOT_MODELS,
-  GeminiModel,
+  Gemini,
   GEMINI_MODELS,
-  AnthropicModel,
+  Anthropic,
   ANTHROPIC_MODELS
 };

package/models/moonshot.d.ts

@@ -1,8 +1,8 @@
 import type { LiteralUnion, SearchHit, SearchOptions, ThinkingLevel } from '../core';
-import { OpenAICompatibleModel, type OpenAIAssistantWireMessage } from './openai-compatible';
+import { OpenAICompatible, type OpenAIAssistantWireMessage } from './openai-compatible';
 declare const MOONSHOT_MODELS: readonly ["kimi-k2.6", "kimi-k2.5"];
 type MoonshotModelName = LiteralUnion<(typeof MOONSHOT_MODELS)[number]>;
-declare class MoonshotModel extends OpenAICompatibleModel {
+declare class Moonshot extends OpenAICompatible {
     constructor(modelName: MoonshotModelName, options?: {
         apiKey?: string;
         baseUrl?: string;
@@ -13,4 +13,4 @@ declare class MoonshotModel extends OpenAICompatibleModel {
     searchWeb(query: string, opts?: SearchOptions): Promise<SearchHit[]>;
     private chat;
 }
-export { MoonshotModel, MOONSHOT_MODELS };
+export { Moonshot, MOONSHOT_MODELS };

package/models/openai-compatible.d.ts

@@ -23,7 +23,7 @@ type OpenAIWireMessage = {
     tool_call_id: string;
     content: string;
 };
-declare abstract class OpenAICompatibleModel extends Model {
+declare abstract class OpenAICompatible extends Model {
     modelName: string;
     apiKey: string;
     baseUrl: string;
@@ -38,4 +38,4 @@ declare abstract class OpenAICompatibleModel extends Model {
     protected adaptAssistantWire(msg: OpenAIAssistantWireMessage): OpenAIAssistantWireMessage;
     protected applyThinking(body: Record<string, unknown>): void;
 }
-export { OpenAICompatibleModel, type OpenAIAssistantWireMessage };
+export { OpenAICompatible, type OpenAIAssistantWireMessage };

package/models/openai.d.ts

@@ -1,24 +1,24 @@
 import type { CreateMessageParams, LiteralUnion, ModelStreamEvent, SearchHit, SearchOptions, ThinkingLevel } from '../core';
-import { OpenAICompatibleModel } from './openai-compatible';
+import { OpenAICompatible } from './openai-compatible';
 declare const OPENAI_MODELS: readonly ["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.4-nano", "gpt-5.3-codex"];
 type OpenAIModelName = LiteralUnion<(typeof OPENAI_MODELS)[number]>;
 type OpenAIApiKeyAuthOptions = {
     type: 'apiKey';
     apiKey?: string;
 };
-type OpenAICodexAuthModelOptions = {
+type OpenAICodexAuthOptions = {
     type: 'codex';
     authFile?: string;
 };
-type OpenAIAuthOptions = OpenAIApiKeyAuthOptions | OpenAICodexAuthModelOptions;
-type OpenAIModelOptions = {
+type OpenAIAuthOptions = OpenAIApiKeyAuthOptions | OpenAICodexAuthOptions;
+type OpenAIOptions = {
     auth?: OpenAIAuthOptions;
     baseUrl?: string;
     thinking?: ThinkingLevel;
 };
-declare class OpenAIModel extends OpenAICompatibleModel {
+declare class OpenAI extends OpenAICompatible {
     private codexAuth?;
-    constructor(modelName: OpenAIModelName, options?: OpenAIModelOptions);
+    constructor(modelName: OpenAIModelName, options?: OpenAIOptions);
     streamMessage(params: CreateMessageParams): AsyncIterable<ModelStreamEvent>;
     protected applyThinking(body: Record<string, unknown>): void;
     searchWeb(query: string, opts?: SearchOptions): Promise<SearchHit[]>;
@@ -26,4 +26,4 @@ declare class OpenAIModel extends OpenAICompatibleModel {
     private fetchResponsesBuffered;
     private responsesEndpoint;
 }
-export { OpenAIModel, OPENAI_MODELS, type OpenAIAuthOptions, type OpenAIModelOptions, };
+export { OpenAI, OPENAI_MODELS, type OpenAIAuthOptions, type OpenAIOptions };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "roboport",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Minimal TypeScript framework for building LLM agents.",
   "author": {
     "name": "Timur Badretdinov",
     "url": "https://github.com/Destiner"
   },
-  "license": "UNLICENSED",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Destiner/roboport.git",