@marimo-team/islands 0.25.1-dev3 → 0.25.1-dev31

package/src/core/ai/context/providers/tables.ts

@@ -17,16 +17,16 @@ export interface TableContextItem extends AIContextItem {
 }
 
 export class TableContextProvider extends AIContextProvider<TableContextItem> {
-  readonly title = "Tables";
-  readonly mentionPrefix = "@";
-  readonly contextType = "data";
+  public readonly title = "Tables";
+  public readonly mentionPrefix = "@";
+  public readonly contextType = "data";
   private tablesMap: DatasetTablesMap;
-  constructor(tablesMap: DatasetTablesMap) {
+  public constructor(tablesMap: DatasetTablesMap) {
     super();
     this.tablesMap = tablesMap;
   }
 
-  getItems(): TableContextItem[] {
+  public getItems(): TableContextItem[] {
     return [...this.tablesMap.entries()].map(([tableName, table]) => ({
       uri: this.asURI(tableName),
       name: tableName,
@@ -36,7 +36,7 @@ export class TableContextProvider extends AIContextProvider<TableContextItem> {
     }));
   }
 
-  formatContext(item: TableContextItem): string {
+  public formatContext(item: TableContextItem): string {
     const { data } = item;
     const { columns, source, num_rows, num_columns, name, variable_name } =
       data;
@@ -90,7 +90,7 @@ export class TableContextProvider extends AIContextProvider<TableContextItem> {
     });
   }
 
-  formatCompletion(item: TableContextItem): Completion {
+  public formatCompletion(item: TableContextItem): Completion {
     const tableName = item.data.name;
     const table = item.data;
     return {

package/src/core/ai/context/providers/variable.ts

@@ -16,20 +16,20 @@ export interface VariableContextItem extends AIContextItem {
 }
 
 export class VariableContextProvider extends AIContextProvider<VariableContextItem> {
-  readonly title = "Variables";
-  readonly mentionPrefix = "@";
-  readonly contextType = "variable";
+  public readonly title = "Variables";
+  public readonly mentionPrefix = "@";
+  public readonly contextType = "variable";
 
   private variables: Variables;
   private tablesMap: DatasetTablesMap;
 
-  constructor(variables: Variables, tablesMap: DatasetTablesMap) {
+  public constructor(variables: Variables, tablesMap: DatasetTablesMap) {
     super();
     this.variables = variables;
     this.tablesMap = tablesMap;
   }
 
-  getItems(): VariableContextItem[] {
+  public getItems(): VariableContextItem[] {
     const ignore = new Set(this.tablesMap.keys());
 
     return Object.entries(this.variables).flatMap(([name, variable]) => {
@@ -51,7 +51,7 @@ export class VariableContextProvider extends AIContextProvider<VariableContextIt
     });
   }
 
-  formatCompletion(item: VariableContextItem): Completion {
+  public formatCompletion(item: VariableContextItem): Completion {
     const { data } = item;
     const { variable } = data;
     return {
@@ -66,7 +66,7 @@ export class VariableContextProvider extends AIContextProvider<VariableContextIt
     };
   }
 
-  formatContext(item: VariableContextItem): string {
+  public formatContext(item: VariableContextItem): string {
     const { data } = item;
     const { variable } = data;
     return contextToXml({

package/src/core/ai/context/registry.ts

@@ -36,35 +36,35 @@ export abstract class AIContextProvider<
   T extends AIContextItem = AIContextItem,
 > {
   /** Human-readable title for this context type */
-  abstract readonly title: string;
+  public abstract readonly title: string;
 
   /** Prefix used for mentions (e.g., "@" for variables, "#" for files) */
-  abstract readonly mentionPrefix: "@" | "#";
+  public abstract readonly mentionPrefix: "@" | "#";
 
   /** Context type identifier used in ContextLocatorId */
-  abstract readonly contextType: string;
+  public abstract readonly contextType: string;
 
   /** Get all available items of this context type */
-  abstract getItems(): T[];
+  public abstract getItems(): T[];
 
   /** Format the context for inclusion in AI prompt */
-  abstract formatContext(item: T): string;
+  public abstract formatContext(item: T): string;
 
   /** Format completion */
-  abstract formatCompletion(item: T): Completion;
+  public abstract formatCompletion(item: T): Completion;
 
   /** Get attachments for context items (optional, async) */
-  async getAttachments(_items: T[]): Promise<FileUIPart[]> {
+  public async getAttachments(_items: T[]): Promise<FileUIPart[]> {
     // Default implementation returns no attachments
     return [];
   }
 
-  asURI(id: string): ContextLocatorId {
+  public asURI(id: string): ContextLocatorId {
     return `${this.contextType}://${id}` as ContextLocatorId;
   }
 
   /** Parse context IDs from input text using the provider's mention prefix */
-  parseContextIds(input: string): ContextLocatorId[] {
+  public parseContextIds(input: string): ContextLocatorId[] {
     // Match @type://id, e.g., @data://users
     const regex = new RegExp(
       `${this.mentionPrefix}([\\w-]+):\\/\\/([\\w./-]+)`,
@@ -112,7 +112,7 @@ export class AIContextRegistry<T extends AIContextItem> {
   /**
    * Register a new context provider
    */
-  register<U extends AIContextItem>(
+  public register<U extends AIContextItem>(
     provider: AIContextProvider<U>,
     // oxlint-disable-next-line typescript/prefer-return-this-type
   ): AIContextRegistry<U | T> {
@@ -123,28 +123,28 @@ export class AIContextRegistry<T extends AIContextItem> {
   /**
    * Get all registered providers
    */
-  getProviders(): Set<AIContextProvider<T>> {
+  public getProviders(): Set<AIContextProvider<T>> {
     return this.providers;
   }
 
   /**
    * Get a specific provider by type
    */
-  getProvider(type: string): AIContextProvider | undefined {
+  public getProvider(type: string): AIContextProvider | undefined {
     return [...this.providers].find(
       (provider) => provider.contextType === type,
     );
   }
 
   @Memoize()
-  getAllItems(): T[] {
+  public getAllItems(): T[] {
     return [...this.providers].flatMap((provider) => provider.getItems());
   }
 
   /**
    * Parse context IDs from input across all providers
    */
-  parseAllContextIds(input: string): ContextLocatorId[] {
+  public parseAllContextIds(input: string): ContextLocatorId[] {
     return [...this.providers].flatMap((provider) =>
       provider.parseContextIds(input),
     );
@@ -167,7 +167,7 @@ export class AIContextRegistry<T extends AIContextItem> {
   /**
    * Resolve only the requested context items, querying each matching provider
    */
-  resolveItems(contextIds: ContextLocatorId[]): T[] {
+  public resolveItems(contextIds: ContextLocatorId[]): T[] {
     if (contextIds.length === 0) {
       return [];
     }
@@ -215,14 +215,14 @@ export class AIContextRegistry<T extends AIContextItem> {
   /**
    * Get context information for mentioned items
    */
-  getContextInfo(contextIds: ContextLocatorId[]): T[] {
+  public getContextInfo(contextIds: ContextLocatorId[]): T[] {
     return this.resolveItems(contextIds);
   }
 
   /**
    * Format context for AI prompt inclusion
    */
-  formatContextForAI(contextIds: ContextLocatorId[]): string {
+  public formatContextForAI(contextIds: ContextLocatorId[]): string {
     const contextInfo = this.resolveItems(contextIds);
 
     if (contextInfo.length === 0) {
@@ -240,7 +240,7 @@ export class AIContextRegistry<T extends AIContextItem> {
   /**
    * Get attachments for mentioned items
    */
-  async getAttachmentsForContext(
+  public async getAttachmentsForContext(
     contextIds: ContextLocatorId[],
   ): Promise<FileUIPart[]> {
     const contextInfo = this.resolveItems(contextIds);

package/src/core/ai/ids/ids.ts

@@ -33,19 +33,19 @@ export type ShortModelId = TypedString<"ShortModelId">;
 export type QualifiedModelId = `${ProviderId}/${ShortModelId}`;
 
 export class AiModelId {
-  readonly providerId: ProviderId;
-  readonly shortModelId: ShortModelId;
+  public readonly providerId: ProviderId;
+  public readonly shortModelId: ShortModelId;
 
-  constructor(providerId: ProviderId, shortModelId: ShortModelId) {
+  public constructor(providerId: ProviderId, shortModelId: ShortModelId) {
     this.providerId = providerId;
     this.shortModelId = shortModelId;
   }
 
-  get id(): QualifiedModelId {
+  public get id(): QualifiedModelId {
     return `${this.providerId}/${this.shortModelId}`;
   }
 
-  static parse(id: string): AiModelId {
+  public static parse(id: string): AiModelId {
     if (!id.includes("/")) {
       const providerId = guessProviderId(id);
       return new AiModelId(providerId, id as ShortModelId);

package/src/core/ai/model-registry.ts

@@ -93,7 +93,7 @@ export class AiModelRegistry {
     this.buildMaps();
   }
 
-  static getProviderInfo(providerId: ProviderId) {
+  public static getProviderInfo(providerId: ProviderId) {
     const { providerMap } = getProviderMap();
     return providerMap.get(providerId);
   }
@@ -104,7 +104,10 @@ export class AiModelRegistry {
    *
    * Models should be in the format of `provider_id/short_model_id`.
    */
-  static create(opts: { customModels?: string[]; displayedModels?: string[] }) {
+  public static create(opts: {
+    customModels?: string[];
+    displayedModels?: string[];
+  }) {
     const { customModels = [], displayedModels = [] } = opts;
     return new AiModelRegistry(
       customModels.map((model) => AiModelId.parse(model).id),
@@ -196,23 +199,23 @@ export class AiModelRegistry {
     return { modelsByProviderMap, modelsMap };
   }
 
-  getDisplayedModels() {
+  public getDisplayedModels() {
     return this.displayedModels;
   }
 
-  getCustomModels() {
+  public getCustomModels() {
     return this.customModels;
   }
 
-  getModelsByProvider(provider: ProviderId) {
+  public getModelsByProvider(provider: ProviderId) {
     return this.modelsByProviderMap.get(provider) || [];
   }
 
-  getGroupedModelsByProvider() {
+  public getGroupedModelsByProvider() {
     return this.modelsByProviderMap;
   }
 
-  getListModelsByProvider(): [ProviderId, AiModel[]][] {
+  public getListModelsByProvider(): [ProviderId, AiModel[]][] {
     const modelsByProvider = this.getGroupedModelsByProvider();
     const arrayModels = [...modelsByProvider.entries()];
     const providerToOrderIdx = getProviderMap().providerToOrderIdx;
@@ -227,11 +230,11 @@ export class AiModelRegistry {
     return arrayModels;
   }
 
-  getModelsMap() {
+  public getModelsMap() {
     return this.modelsMap;
   }
 
-  getModel(qualifiedModelId: QualifiedModelId) {
+  public getModel(qualifiedModelId: QualifiedModelId) {
     return this.modelsMap.get(qualifiedModelId);
   }
 }

package/src/core/ai/staged-cells.ts

@@ -305,11 +305,11 @@ class StagedCellReconciler {
   private readonly actions: StagedCellReconcilerActions;
   private marimoImportCellId: CellId | null = null;
 
-  constructor(actions: StagedCellReconcilerActions) {
+  public constructor(actions: StagedCellReconcilerActions) {
     this.actions = actions;
   }
 
-  reconcile(completionCells: GeneratedCell[]) {
+  public reconcile(completionCells: GeneratedCell[]) {
     for (const [idx, cell] of completionCells.entries()) {
       if (idx < this.createdCells.length) {
         const existingCell = this.createdCells[idx];
@@ -336,7 +336,7 @@ class StagedCellReconciler {
     this.syncMarimoImport(completionCells);
   }
 
-  discard(stagedCells: StagedAICells) {
+  public discard(stagedCells: StagedAICells) {
     for (const { cellId } of this.createdCells.toReversed()) {
       if (stagedCells.has(cellId)) {
         this.actions.deleteStagedCell(cellId);
@@ -350,17 +350,17 @@ class StagedCellReconciler {
     this.marimoImportCellId = null;
   }
 
-  accept() {
+  public accept() {
     for (const cellId of this.stagedCellIds()) {
       this.actions.removeStagedCell(cellId);
     }
   }
 
-  hasStagedCells(stagedCells: StagedAICells) {
+  public hasStagedCells(stagedCells: StagedAICells) {
     return this.stagedCellIds().some((cellId) => stagedCells.has(cellId));
   }
 
-  stagedCellIds() {
+  public stagedCellIds() {
     const cellIds = this.createdCells.map(({ cellId }) => cellId);
     if (this.marimoImportCellId) {
       cellIds.push(this.marimoImportCellId);

package/src/core/ai/tools/base.ts

@@ -26,12 +26,12 @@ export type StatusValue = "success" | "error" | "warning";
  * );
  */
 export class ToolExecutionError extends Error {
-  readonly code: string;
-  readonly isRetryable: boolean;
-  readonly suggestedFix?: string;
-  readonly meta?: Record<string, unknown>;
+  public readonly code: string;
+  public readonly isRetryable: boolean;
+  public readonly suggestedFix?: string;
+  public readonly meta?: Record<string, unknown>;
 
-  constructor(
+  public constructor(
     message: string,
     code = "TOOL_ERROR",
     isRetryable = false,
@@ -46,7 +46,7 @@ export class ToolExecutionError extends Error {
     this.meta = meta;
   }
 
-  toStructuredString(): string {
+  public toStructuredString(): string {
     const stringError = JSON.stringify({
       message: this.message,
       code: this.code,

package/src/core/ai/tools/edit-notebook-tool.ts

@@ -76,13 +76,13 @@ export class EditNotebookTool implements AiTool<
   EditNotebookInput,
   ToolOutputBase
 > {
-  readonly name = "edit_notebook_tool";
-  readonly description = description;
-  readonly schema = editNotebookSchema;
-  readonly outputSchema = toolOutputBaseSchema;
-  readonly mode: CopilotMode[] = ["agent"];
+  public readonly name = "edit_notebook_tool";
+  public readonly description = description;
+  public readonly schema = editNotebookSchema;
+  public readonly outputSchema = toolOutputBaseSchema;
+  public readonly mode: CopilotMode[] = ["agent"];
 
-  handler = async (
+  public handler = async (
     { edit }: EditNotebookInput,
     toolContext: ToolNotebookContext,
   ): Promise<ToolOutputBase> => {

package/src/core/ai/tools/registry.ts

@@ -36,11 +36,11 @@ export class FrontendToolRegistry {
   /** All registered tools */
   private tools = new Map<string, StoredTool>();
 
-  constructor(tools: StoredTool[] = []) {
+  public constructor(tools: StoredTool[] = []) {
     this.tools = new Map(tools.map((tool) => [tool.name, tool]));
   }
 
-  has(toolName: string) {
+  public has(toolName: string) {
     return this.tools.has(toolName);
   }
 
@@ -52,7 +52,7 @@ export class FrontendToolRegistry {
     return tool;
   }
 
-  async invoke<TName extends string>({
+  public async invoke<TName extends string>({
     toolName,
     rawArgs,
     toolContext,
@@ -127,7 +127,7 @@ export class FrontendToolRegistry {
   }
 
   @Memoize()
-  getToolSchemas(mode: CopilotMode): FrontendToolDefinition[] {
+  public getToolSchemas(mode: CopilotMode): FrontendToolDefinition[] {
     const tools = [...this.tools.values()].filter((tool) =>
       tool.mode.includes(mode),
     );

package/src/core/ai/tools/run-cells-tool.ts

@@ -54,10 +54,10 @@ export class RunStaleCellsTool implements AiTool<
   EmptyToolInput,
   RunStaleCellsOutput
 > {
-  readonly name = "run_stale_cells_tool";
-  readonly description = description;
-  readonly schema = z.object({});
-  readonly outputSchema = toolOutputBaseSchema.extend({
+  public readonly name = "run_stale_cells_tool";
+  public readonly description = description;
+  public readonly schema = z.object({});
+  public readonly outputSchema = toolOutputBaseSchema.extend({
     cellsToOutput: z
       .record(
         z.string(),
@@ -72,15 +72,15 @@ export class RunStaleCellsTool implements AiTool<
       )
       .optional(),
   }) satisfies z.ZodType<RunStaleCellsOutput>;
-  readonly mode: CopilotMode[] = ["agent"];
+  public readonly mode: CopilotMode[] = ["agent"];
 
   private readonly postExecutionDelay: number;
 
-  constructor(opts?: { postExecutionDelay?: number }) {
+  public constructor(opts?: { postExecutionDelay?: number }) {
     this.postExecutionDelay = opts?.postExecutionDelay ?? POST_EXECUTION_DELAY;
   }
 
-  handler = async (
+  public handler = async (
     _args: EmptyToolInput,
     toolContext: ToolNotebookContext,
   ): Promise<RunStaleCellsOutput> => {

package/src/core/ai/tools/sample-tool.ts

@@ -36,18 +36,18 @@ interface Output extends ToolOutputBase {
 
 /** A sample frontend tool that demonstrates real tool output structure */
 export class TestFrontendTool implements AiTool<Input, Output> {
-  readonly name = "test_frontend_tool";
-  readonly description = description;
-  readonly schema = z.object({ name: z.string() });
-  readonly outputSchema = toolOutputBaseSchema.extend({
+  public readonly name = "test_frontend_tool";
+  public readonly description = description;
+  public readonly schema = z.object({ name: z.string() });
+  public readonly outputSchema = toolOutputBaseSchema.extend({
     data: z.object({
       greeting: z.string(),
       timestamp: z.string(),
     }),
   });
-  readonly mode: CopilotMode[] = ["ask"];
+  public readonly mode: CopilotMode[] = ["ask"];
 
-  async handler({ name }: Input): Promise<Output> {
+  public async handler({ name }: Input): Promise<Output> {
     // Example: Validate input and throw ToolExecutionError on invalid data
     if (!name.trim()) {
       throw new ToolExecutionError(

package/src/core/codemirror/cells/debugger-decorations.ts

@@ -48,9 +48,12 @@ function createLineDecoration(
 
 class CurrentLineHighlighter implements PluginValue {
   private unsubscribe: () => void;
-  decorations: DecorationSet;
+  public decorations: DecorationSet;
 
-  constructor(view: EditorView, lineObservable: Observable<number | null>) {
+  public constructor(
+    view: EditorView,
+    lineObservable: Observable<number | null>,
+  ) {
     this.decorations = createLineDecoration(view.state, lineObservable.get());
     this.unsubscribe = lineObservable.sub((line) => {
       this.decorations = createLineDecoration(view.state, line);
@@ -59,11 +62,11 @@ class CurrentLineHighlighter implements PluginValue {
     });
   }
 
-  update(update: ViewUpdate) {
+  public update(update: ViewUpdate) {
     this.decorations = this.decorations.map(update.changes);
   }
 
-  destroy() {
+  public destroy() {
     this.unsubscribe();
   }
 }
@@ -88,7 +91,7 @@ export function debuggerLineHighlighter(
 // --- Breakpoint gutter ------------------------------------------------------
 
 class BreakpointMarker extends GutterMarker {
-  override toDOM() {
+  public override toDOM() {
     const dot = document.createElement("div");
     dot.className = "cm-breakpoint-marker";
     return dot;
@@ -130,7 +133,10 @@ function buildBreakpointMarkers(state: EditorState): RangeSet<GutterMarker> {
 class BreakpointSync implements PluginValue {
   private unsubscribe: () => void;
 
-  constructor(view: EditorView, observable: Observable<ReadonlySet<number>>) {
+  public constructor(
+    view: EditorView,
+    observable: Observable<ReadonlySet<number>>,
+  ) {
     const apply = (lines: ReadonlySet<number>) => {
       view.dispatch({ effects: setBreakpointLines.of(lines) });
     };
@@ -144,7 +150,7 @@ class BreakpointSync implements PluginValue {
     this.unsubscribe = observable.sub(apply);
   }
 
-  destroy() {
+  public destroy() {
     this.unsubscribe();
   }
 }

package/src/core/codemirror/cells/line-timing-decorations.ts

@@ -42,16 +42,16 @@ class LineTimerWidget extends WidgetType {
 
   private readonly startedAtMs: number;
 
-  constructor(startedAtMs: number) {
+  public constructor(startedAtMs: number) {
     super();
     this.startedAtMs = startedAtMs;
   }
 
-  override eq(other: LineTimerWidget): boolean {
+  public override eq(other: LineTimerWidget): boolean {
     return other.startedAtMs === this.startedAtMs;
   }
 
-  override toDOM(): HTMLElement {
+  public override toDOM(): HTMLElement {
     const el = document.createElement("span");
     el.className = "cm-line-timer";
     el.setAttribute("aria-hidden", "true");
@@ -68,7 +68,7 @@ class LineTimerWidget extends WidgetType {
     return el;
   }
 
-  override destroy(dom: HTMLElement): void {
+  public override destroy(dom: HTMLElement): void {
     const interval = LineTimerWidget.intervals.get(dom);
     if (interval !== undefined) {
       window.clearInterval(interval);
@@ -76,7 +76,7 @@ class LineTimerWidget extends WidgetType {
     }
   }
 
-  override ignoreEvent(): boolean {
+  public override ignoreEvent(): boolean {
     return true;
   }
 }
@@ -112,9 +112,9 @@ function createTimingDecorations(
 
 class ActiveLineTimer implements PluginValue {
   private unsubscribe: () => void;
-  decorations: DecorationSet;
+  public decorations: DecorationSet;
 
-  constructor(
+  public constructor(
     view: EditorView,
     infoObservable: Observable<ActiveLineInfo | null>,
   ) {
@@ -129,11 +129,11 @@ class ActiveLineTimer implements PluginValue {
     });
   }
 
-  update(update: ViewUpdate) {
+  public update(update: ViewUpdate) {
     this.decorations = this.decorations.map(update.changes);
   }
 
-  destroy() {
+  public destroy() {
     this.unsubscribe();
   }
 }

package/src/core/codemirror/cells/traceback-decorations.ts

@@ -91,9 +91,12 @@ function unfoldErrorLines(view: EditorView, errors: TracebackInfos) {
  */
 class ErrorHighlighter implements PluginValue {
   private unsubscribe: () => void;
-  decorations: DecorationSet;
+  public decorations: DecorationSet;
 
-  constructor(view: EditorView, errorsObservable: Observable<TracebackInfos>) {
+  public constructor(
+    view: EditorView,
+    errorsObservable: Observable<TracebackInfos>,
+  ) {
     const errors = errorsObservable.get();
     this.decorations = createErrorDecorations(view.state, errors);
     unfoldErrorLines(view, errors);
@@ -113,11 +116,11 @@ class ErrorHighlighter implements PluginValue {
     });
   }
 
-  update(update: ViewUpdate) {
+  public update(update: ViewUpdate) {
     this.decorations = this.decorations.map(update.changes);
   }
 
-  destroy() {
+  public destroy() {
     this.unsubscribe();
   }
 }