@jataware/beaker-client 2.0.0-b.1

package/README.md

@@ -0,0 +1,24 @@
+# beaker-ts typescript library
+
+Beaker-ts is a typescript library that simplifies working with Beaker in the
+browser. Highlights of what beaker-ts provides include:
+
+* Easy creation of Beaker sessions
+  * Connecting to an existing Beaker kernel or spinning up a new one
+  * Ability to send/recieve messages directly to the Beaker kernel
+  * Kernel status tracking
+* A light-weight reactive notebook
+  * Interfaces and classes for all standard Jupyter cells
+  * A new Beaker "LLM Query" cell for interactions with the LLM agent
+  * Full rendering of types registered with Jupyter
+  * Exportable to a standard Jupyter .ipynb file
+  * Tested to be reactive in React and Vue frameworks
+* Session history tracking
+  * Tracks all actions taken in a notebook (in progress)
+  * Savable/Exportable to JSON (coming soon)
+  * Ability to fully roll-back a notebook to a previous point (planned feature)
+
+It is recommended to use the beaker-ts library to create and edit your Beaker
+sessions and notebooks.
+
+

package/dist/extension.d.ts

@@ -0,0 +1,21 @@
+import { JSONObject, PartialJSONObject } from '@lumino/coreutils';
+import { IBeakerShellMessage } from './notebook';
+import { IBeakerFuture } from './util';
+import * as messages from '@jupyterlab/services/lib/kernel/messages';
+import * as nbformat from '@jupyterlab/nbformat';
+declare module "@jupyterlab/services/lib/kernel" {
+    interface KernelConnection {
+        sendBeakerMessage(messageType: string, content: JSONObject, messageId: string, expectReply: boolean, disposeOnDone: boolean): IBeakerFuture;
+    }
+}
+declare module "@jupyterlab/services/lib/kernel/messages" {
+    function createMessage<T extends IBeakerShellMessage>(options: messages.IOptions<T>): T;
+}
+declare module '@jupyterlab/nbformat' {
+    interface IBaseOutput extends PartialJSONObject {
+        output_type: string;
+        metadata?: nbformat.OutputMetadata;
+    }
+}
+declare const _default: {};
+export default _default;

package/dist/extension.js

@@ -0,0 +1,3 @@
+const extension = {};
+
+export { extension as default };

package/dist/history.d.ts

@@ -0,0 +1,39 @@
+import * as nbformat from '@jupyterlab/nbformat';
+export interface IBeakerHistoryEvent {
+    kernel_id: string;
+    kernel_slug: string;
+    context_slug: string;
+    creation_time: Date;
+}
+export interface IBeakerHistoryExecutionEvent extends IBeakerHistoryEvent {
+    cell_id: string;
+    execution_time: Date;
+    execution_duration: number;
+    silent: boolean;
+    execution_id: number;
+    source: nbformat.MultilineString;
+    result: any;
+    stdin: nbformat.MultilineString;
+    stderr: nbformat.MultilineString;
+    success: boolean;
+}
+export interface IBeakerHistoryQueryEvent extends IBeakerHistoryEvent {
+    cell_id: string;
+    execution_time: Date;
+    execution_duration: number;
+    source: nbformat.MultilineString;
+    thoughts: string[];
+    result: nbformat.MultilineString;
+}
+export type BeakerHistoryEvent = IBeakerHistoryExecutionEvent | IBeakerHistoryQueryEvent;
+export interface IBeakerHistory {
+    sessionId: string;
+    events: IBeakerHistoryEvent[];
+}
+export declare class BeakerHistory implements IBeakerHistory {
+    constructor(sessionId: string);
+    addEvent(event: BeakerHistoryEvent): void;
+    clear(): void;
+    sessionId: string;
+    events: IBeakerHistoryEvent[];
+}

package/dist/history.js

@@ -0,0 +1,16 @@
+class BeakerHistory {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+    this.events = [];
+  }
+  addEvent(event) {
+    this.events.push(event);
+  }
+  clear() {
+    this.events.splice(0, this.events.splice.length);
+  }
+  sessionId;
+  events;
+}
+
+export { BeakerHistory };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './session';
+export * from './notebook';
+export * from './render';
+export * from './util';
+export * from './history';

package/dist/index.js

@@ -0,0 +1,10 @@
+import extension from './extension.js';
+export { BeakerSession } from './session.js';
+export { BeakerBaseCell, BeakerCodeCell, BeakerMarkdownCell, BeakerNotebook, BeakerNotebookContent, BeakerQueryCell, BeakerRawCell } from './notebook.js';
+export { BeakerRenderer, JupyterMimeRenderer, MimeRenderer } from './render.js';
+export { BeakerCellFuture, BeakerCellFutures, KernelState, createMessageId } from './util.js';
+export { BeakerHistory } from './history.js';
+
+if (extension === void 0) {
+  throw new Error("Unable to extend Jupyterlab types");
+}

package/dist/notebook.d.ts

@@ -0,0 +1,192 @@
+import { PartialJSONValue, PartialJSONObject } from '@lumino/coreutils';
+import { BeakerSession } from './session';
+import { IBeakerFuture, BeakerCellFuture } from './util';
+import * as nbformat from '@jupyterlab/nbformat';
+import * as messages from '@jupyterlab/services/lib/kernel/messages';
+export interface IBeakerHeader extends messages.IHeader<messages.MessageType> {
+    msg_type: any;
+}
+export interface IBeakerShellMessage extends messages.IShellMessage {
+    header: IBeakerHeader;
+    channel: "shell";
+    content: any;
+    parent_header: any;
+}
+export interface IBeakerIOPubMessage extends messages.IIOPubMessage {
+    header: IBeakerHeader;
+    channel: "iopub";
+    content: any;
+}
+export interface IBeakerAnyMessage extends messages.IMessage {
+    header: IBeakerHeader;
+    content: any;
+}
+export type BeakerCellStatus = messages.Status | "awaiting_input";
+export type BeakerCellExecutionStatus = IBeakerCellExecutionStatusPlain | IBeakerCellExecutionStatusPending | IBeakerCellExecutionStatusOk | IBeakerCellExecutionStatusError;
+export interface IBeakerCellExecutionStatusPlain {
+    status: "none" | "modified" | "abort";
+}
+export interface IBeakerCellExecutionStatusPending {
+    status: "pending";
+    checkpoint_index?: number;
+}
+export interface IBeakerCellExecutionStatusOk {
+    status: "ok";
+    checkpoint_index?: number;
+}
+export interface IBeakerCellExecutionStatusError {
+    status: "error";
+    ename: string;
+    evalue: string;
+    traceback: string[];
+}
+export type BeakerCellType = nbformat.CellType | string | 'query';
+export declare class BeakerBaseCell implements nbformat.IBaseCell {
+    static IPYNB_KEYS: string[];
+    [key: string]: any;
+    id: string;
+    cell_type: BeakerCellType;
+    metadata: Partial<nbformat.ICellMetadata>;
+    source: nbformat.MultilineString;
+    status: BeakerCellStatus;
+    children: BeakerBaseCell[];
+    constructor(content: Partial<nbformat.IBaseCell>);
+    static generateId(): string;
+    fromJSON(obj: any): void;
+    toJSON(): this;
+    fromIPynb(obj: any): void;
+    toIPynb(): nbformat.IBaseCell | nbformat.IBaseCell[];
+}
+type BeakerQueryTextEventType = "response" | "user_question" | "user_answer" | "abort";
+export interface IBeakerQueryTextEvent extends PartialJSONObject {
+    type: BeakerQueryTextEventType;
+    content: string;
+}
+type BeakerQueryCellEventType = "code_cell";
+export interface IBeakerQueryCellEvent extends PartialJSONObject {
+    type: BeakerQueryCellEventType;
+    content: {
+        cell_id: string;
+        parent_id: string;
+        metadata: PartialJSONObject;
+    };
+}
+type BeakerQueryErrorEventType = "error";
+export interface IBeakerQueryErrorEvent extends PartialJSONObject {
+    type: BeakerQueryErrorEventType;
+    content: {
+        ename: string;
+        evalue: string;
+        traceback: string[];
+    };
+}
+export type BeakerToolCallState = "pending" | "running" | "done" | "error" | "cancelled";
+export interface IBeakerToolCall extends PartialJSONObject {
+    tool_call_id: string;
+    tool_name: string;
+    tool_input: any;
+    state: BeakerToolCallState;
+    started_at?: string;
+    ended_at?: string;
+    output_preview?: string;
+    output_truncated?: boolean;
+    error?: {
+        ename: string;
+        evalue: string;
+        traceback?: string[];
+    };
+}
+type BeakerQueryThoughtType = "thought";
+export interface IBeakerQueryThoughtEvent extends PartialJSONObject {
+    type: BeakerQueryThoughtType;
+    content: {
+        thought: string;
+        thought_id: string;
+        tool_calls: IBeakerToolCall[];
+    };
+}
+export type BeakerQueryEventType = BeakerQueryTextEventType | BeakerQueryCellEventType | BeakerQueryErrorEventType | BeakerQueryThoughtType;
+export type BeakerQueryEvent = IBeakerQueryTextEvent | IBeakerQueryCellEvent | IBeakerQueryErrorEvent | IBeakerQueryThoughtEvent;
+export interface IQueryCell extends nbformat.IBaseCell {
+    cell_type: 'query';
+    events: BeakerQueryEvent[];
+}
+export declare class BeakerRawCell extends BeakerBaseCell implements nbformat.IRawCell {
+    cell_type: "raw";
+    attachments?: nbformat.IAttachments;
+    metadata: Partial<nbformat.IRawCellMetadata>;
+    constructor(content: nbformat.ICell);
+    execute(session: BeakerSession): IBeakerFuture | null;
+}
+export declare class BeakerCodeCell extends BeakerBaseCell implements nbformat.ICodeCell {
+    cell_type: "code";
+    outputs: nbformat.IOutput[];
+    execution_count: nbformat.ExecutionCount;
+    metadata: Partial<nbformat.ICodeCellMetadata>;
+    last_execution?: BeakerCellExecutionStatus;
+    busy?: boolean;
+    constructor(content: Partial<nbformat.ICell>);
+    execute(session: BeakerSession, syntheticFuture?: BeakerCellFuture): IBeakerFuture | null;
+    rollback(session: BeakerSession): IBeakerFuture | null;
+    reset_execution_state(): void;
+    toIPynb(): nbformat.ICodeCell;
+}
+export declare class BeakerMarkdownCell extends BeakerBaseCell implements nbformat.IMarkdownCell {
+    static IPYNB_KEYS: string[];
+    cell_type: "markdown";
+    attachments?: nbformat.IAttachments;
+    constructor(content: Partial<nbformat.ICell>);
+    execute(session: BeakerSession): IBeakerFuture | null;
+    toIPynb(): nbformat.IBaseCell | nbformat.IBaseCell[];
+}
+export declare class BeakerQueryCell extends BeakerBaseCell implements IQueryCell {
+    cell_type: "query";
+    events: BeakerQueryEvent[];
+    _current_input_request_message?: messages.IInputRequestMsg;
+    _toolCallIndex: Map<string, {
+        eventIndex: number;
+        slot: number;
+    }>;
+    constructor(content: Partial<nbformat.ICell>);
+    execute(session: BeakerSession, includeNotebookState?: boolean): IBeakerFuture | null;
+    respond(response: string, session: BeakerSession): void;
+    toMultipleCells(): [BeakerMarkdownCell, ...BeakerBaseCell[]];
+    fromIPynb(obj: any): void;
+    toIPynb(): [nbformat.IMarkdownCell, ...nbformat.IBaseCell[]];
+}
+export type IBeakerCell = BeakerCodeCell | BeakerMarkdownCell | BeakerRawCell | nbformat.IUnrecognizedCell;
+export declare class BeakerNotebookContent implements nbformat.INotebookContent {
+    [key: string]: PartialJSONValue;
+    nbformat: number;
+    nbformat_minor: number;
+    metadata: nbformat.INotebookMetadata;
+    cells: BeakerBaseCell[];
+}
+export declare class BeakerNotebook {
+    constructor();
+    toJSON(): {
+        [key: string]: PartialJSONValue;
+        nbformat: number;
+        nbformat_minor: number;
+        metadata: nbformat.INotebookMetadata;
+        cells: BeakerBaseCell[];
+    };
+    fromJSON(obj: any): void;
+    loadFromIPynb(obj: any): void;
+    toIPynb(): {
+        nbformat: number;
+        nbformat_minor: number;
+        cells: nbformat.IBaseCell[];
+        metadata: nbformat.INotebookMetadata;
+    };
+    addCell(cell: IBeakerCell | nbformat.ICell): void;
+    insertCell(cell: IBeakerCell | nbformat.ICell, position: number): void;
+    removeCell(index: number): void;
+    cutCell(index: number): IBeakerCell | null;
+    moveCell(fromIndex: number, toIndex: number): void;
+    setSubkernelInfo(sessionInfo: any): void;
+    content: BeakerNotebookContent;
+    cells: IBeakerCell[];
+    private subkernelInfo?;
+}
+export {};