roboport 0.0.1

package/README.md

@@ -0,0 +1,25 @@
+# roboport
+
+Minimal TypeScript framework for building LLM agents.
+
+## Install
+
+```sh
+bun add roboport zod
+```
+
+`zod` is a peer dependency, declare it in your own dependencies when you define
+Zod-backed tools.
+
+## Exports
+
+- `roboport` — agent loop and core `Tool` / `Skill` / `Agent` / `Session` primitives
+- `roboport/models` — `Model` adapters (Anthropic, Google, Moonshot, OpenAI, OpenAI-compatible)
+- `roboport/mcp` — MCP client (transports, auth, server presets)
+- `roboport/harness` — `Harness` bundle and standalone, reusable tools
+- `roboport/skills` — opt-in skill bundle
+- `roboport/triggers` — trigger primitive (cron + GitHub/Grafana/Linear/Telegram receivers)
+
+## Docs
+
+See [github.com/Destiner/roboport](https://github.com/Destiner/roboport).

package/core/agent.d.ts

@@ -0,0 +1,35 @@
+import type { Trigger, TriggerHandler } from '../triggers/core';
+import type { McpClient } from './mcp';
+import type { Message } from './message';
+import type { Model } from './model';
+import { Session } from './session';
+import { Skill } from './skill';
+import { Tool } from './tool';
+declare class Agent {
+    model: Model;
+    system: string;
+    tools: Tool[];
+    skills: Skill[];
+    mcp: McpClient[];
+    cwd?: string;
+    private registrations;
+    private unsubs;
+    constructor({ model, system, tools, skills, mcp, cwd, }: {
+        model: Model;
+        system: string;
+        tools: Tool[];
+        skills: Skill[];
+        mcp?: McpClient[];
+        cwd?: string;
+    });
+    on<T>(trigger: Trigger<T>, handler: TriggerHandler<T>): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    buildSystem(allTools: Tool[]): string;
+    private buildSkillTool;
+    session(init?: {
+        messages?: Message[];
+        cwd?: string;
+    }): Session;
+}
+export { Agent };

package/core/index.d.ts

@@ -0,0 +1,9 @@
+import { Agent } from './agent';
+import type { McpClient } from './mcp';
+import type { Message, TextPart, ThinkingPart, ToolCallPart, ToolResultPart } from './message';
+import { Model, type LiteralUnion, type ThinkingLevel } from './model';
+import { Session, Turn, type TurnEvent } from './session';
+import { Skill } from './skill';
+import type { ModelStreamEvent } from './stream';
+import { Tool, type CreateMessageParams, type CreateMessageResponse, type SearchHit, type SearchOptions, type SessionState, type StopReason, type ToolContext, type ToolRegistry } from './tool';
+export { Agent, Model, Session, Skill, Tool, Turn, type CreateMessageParams, type CreateMessageResponse, type LiteralUnion, type McpClient, type Message, type ModelStreamEvent, type SearchHit, type SearchOptions, type SessionState, type StopReason, type TextPart, type ThinkingLevel, type ThinkingPart, type ToolCallPart, type ToolContext, type ToolRegistry, type ToolResultPart, type TurnEvent, };

package/core/mcp.d.ts

@@ -0,0 +1,6 @@
+import type { Tool } from './tool';
+interface McpClient {
+    connect(): Promise<Tool[]>;
+    disconnect(): Promise<void>;
+}
+export type { McpClient };

package/core/message.d.ts

@@ -0,0 +1,36 @@
+type TextPart = {
+    type: 'text';
+    text: string;
+};
+type ThinkingPart = {
+    type: 'thinking';
+    text: string;
+    signature?: string;
+    redactedData?: string;
+};
+type ToolCallPart = {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+};
+type ToolResultPart = {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+};
+type Message = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: string | TextPart[];
+} | {
+    role: 'assistant';
+    content: (TextPart | ThinkingPart | ToolCallPart)[];
+} | {
+    role: 'tool';
+    content: ToolResultPart[];
+};
+export type { TextPart, ThinkingPart, ToolCallPart, ToolResultPart, Message };

package/core/model.d.ts

@@ -0,0 +1,10 @@
+import type { ModelStreamEvent } from './stream';
+import type { CreateMessageParams, CreateMessageResponse, SearchHit, SearchOptions } from './tool';
+type LiteralUnion<T extends string> = T | (string & {});
+type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+declare abstract class Model {
+    abstract streamMessage(params: CreateMessageParams): AsyncIterable<ModelStreamEvent>;
+    abstract searchWeb(query: string, opts?: SearchOptions): Promise<SearchHit[]>;
+    createMessage(params: CreateMessageParams): Promise<CreateMessageResponse>;
+}
+export { Model, type LiteralUnion, type ThinkingLevel };

package/core/session.d.ts

@@ -0,0 +1,75 @@
+import type { Message, TextPart } from './message';
+type TurnEvent = {
+    type: 'message-start';
+} | {
+    type: 'text-delta';
+    text: string;
+} | {
+    type: 'text';
+    text: string;
+} | {
+    type: 'thinking-delta';
+    text: string;
+} | {
+    type: 'thinking';
+    text: string;
+    signature?: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+} | {
+    type: 'tool-result';
+    toolCallId: string;
+    toolName: string;
+    output: unknown;
+    isError: boolean;
+} | {
+    type: 'message-end';
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+} | {
+    type: 'turn-end';
+} | {
+    type: 'error';
+    error: Error;
+};
+type TurnEmit = (event: TurnEvent) => void;
+interface TurnRunContext {
+    emit: TurnEmit;
+    signal: AbortSignal;
+}
+type TurnRunner = (ctx: TurnRunContext) => Promise<Message[]>;
+declare class Turn implements AsyncIterable<TurnEvent>, PromiseLike<Message[]> {
+    private queue;
+    private waiters;
+    private ended;
+    private iterated;
+    private resultPromise;
+    private abortController;
+    constructor(runner: TurnRunner);
+    private emit;
+    private close;
+    abort(reason?: string): void;
+    [Symbol.asyncIterator](): AsyncIterator<TurnEvent>;
+    then<TResult1 = Message[], TResult2 = never>(onfulfilled?: ((value: Message[]) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+}
+interface SessionInternals {
+    send(prompt: string | TextPart[]): Turn;
+    close(): Promise<void>;
+}
+declare class Session implements AsyncDisposable {
+    private internals;
+    private state;
+    constructor(internals: SessionInternals, state: {
+        messages: Message[];
+    });
+    get messages(): readonly Message[];
+    send(prompt: string | TextPart[]): Turn;
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export { Session, Turn, type SessionInternals, type TurnEmit, type TurnEvent, type TurnRunContext, type TurnRunner, };

package/core/skill.d.ts

@@ -0,0 +1,11 @@
+declare class Skill {
+    name: string;
+    description: string;
+    content: string;
+    constructor({ name, description, content, }: {
+        name: string;
+        description: string;
+        content: string;
+    });
+}
+export { Skill };

package/core/stream.d.ts

@@ -0,0 +1,33 @@
+import type { TextPart, ThinkingPart, ToolCallPart } from './message';
+import type { StopReason } from './tool';
+type ModelStreamEvent = {
+    type: 'text-delta';
+    text: string;
+} | {
+    type: 'text-end';
+    text: string;
+} | {
+    type: 'thinking-delta';
+    text: string;
+} | {
+    type: 'thinking-end';
+    text: string;
+    signature?: string;
+    redactedData?: string;
+} | {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+} | {
+    type: 'message-end';
+    id: string;
+    stopReason: StopReason;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+};
+type AssistantContentPart = TextPart | ThinkingPart | ToolCallPart;
+declare function readSse(response: Response): AsyncGenerator<unknown>;
+export { readSse, type AssistantContentPart, type ModelStreamEvent };

package/core/tool.d.ts

@@ -0,0 +1,77 @@
+import * as z4 from 'zod/v4/core';
+import type { Message, TextPart, ThinkingPart, ToolCallPart } from './message';
+type MaybePromise<T> = T | Promise<T>;
+type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence' | 'pause_turn' | 'refusal';
+interface SessionState {
+    messages: Message[];
+    store: Map<string, unknown>;
+}
+interface ToolRegistry {
+    loaded(): Tool[];
+    deferred(): Tool[];
+    load(names: string[]): {
+        loaded: Tool[];
+        missing: string[];
+    };
+}
+interface SearchHit {
+    title: string;
+    url?: string;
+    pageAge?: string;
+    text?: string;
+}
+interface SearchOptions {
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+    maxUses?: number;
+}
+interface CreateMessageParams {
+    messages: Message[];
+    tools?: Tool[];
+    maxTokens?: number;
+    signal?: AbortSignal;
+}
+interface CreateMessageResponse {
+    id: string;
+    content: (TextPart | ThinkingPart | ToolCallPart)[];
+    stopReason: StopReason;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+interface ToolContext {
+    complete(prompt: string): Promise<string>;
+    searchWeb(query: string, opts?: SearchOptions): Promise<SearchHit[]>;
+    session: SessionState;
+    tools: ToolRegistry;
+    cwd: string;
+}
+type ZodToolInit<TSchema extends z4.$ZodType, TResult> = {
+    name: string;
+    description: string;
+    inputSchema: TSchema;
+    execute: (input: z4.output<TSchema>, ctx: ToolContext) => MaybePromise<TResult>;
+    deferred?: boolean;
+};
+type RawToolInit<TResult> = {
+    name: string;
+    description: string;
+    jsonSchema: object;
+    execute: (input: unknown, ctx: ToolContext) => MaybePromise<TResult>;
+    deferred?: boolean;
+};
+declare class Tool<TSchema extends z4.$ZodType = z4.$ZodType, TResult = unknown> {
+    name: string;
+    description: string;
+    inputSchema?: TSchema;
+    jsonSchema?: object;
+    execute: (input: unknown, ctx: ToolContext) => MaybePromise<TResult>;
+    deferred: boolean;
+    constructor(init: ZodToolInit<TSchema, TResult>);
+    constructor(init: RawToolInit<TResult>);
+    toJsonSchema(): object;
+    parse(input: unknown): unknown;
+}
+declare function createRegistry(tools: Tool[]): ToolRegistry;
+export { Tool, createRegistry, type CreateMessageParams, type CreateMessageResponse, type SearchHit, type SearchOptions, type SessionState, type StopReason, type ToolContext, type ToolRegistry, };

package/env.d.ts

@@ -0,0 +1,8 @@
+export declare const env: {
+    readonly anthropicApiKey: string | undefined;
+    readonly geminiApiKey: string | undefined;
+    readonly moonshotApiKey: string | undefined;
+    readonly openaiApiKey: string | undefined;
+    readonly openaiCodexAuthFile: string | undefined;
+    readonly codexHome: string | undefined;
+};

package/harness/claudeCode.d.ts

@@ -0,0 +1,3 @@
+import { Harness } from './core';
+declare const harness: Harness;
+export default harness;

package/harness/codex.d.ts

@@ -0,0 +1,3 @@
+import { Harness } from './core';
+declare const harness: Harness;
+export default harness;

package/harness/core.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from '../core';
+declare class Harness {
+    system: string;
+    tools: Tool[];
+    constructor(system: string, tools: Tool[]);
+}
+export { Harness };

package/harness/index.d.ts

@@ -0,0 +1,5 @@
+import claudeCode from './claudeCode';
+import codex from './codex';
+import pi from './pi';
+import { bash, editFile, readFile, webFetch, webSearch, writeFile } from './tools';
+export { bash, claudeCode, codex, editFile, pi, readFile, webFetch, webSearch, writeFile, };