@pasko70/pibo 1.0.5 → 1.2.0

package/dist/plugins/context-files.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, isAbsolute, join, resolve } from "node:path";
@@ -132,6 +132,18 @@ function uniquePath(dir, filename, currentPath) {
 function managedFileName(label) {
     return `${slugSegment(label)}.md`;
 }
+function labelFromManagedPath(path) {
+    const filename = path.split(/[\\/]/).pop() ?? path;
+    const extension = extname(filename);
+    const stem = extension ? filename.slice(0, -extension.length) : filename;
+    const words = stem
+        .replace(/[_-]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!words)
+        return "Context File";
+    return words.replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
 function profileForManaged(file) {
     return {
         key: file.key,
@@ -313,10 +325,12 @@ class ContextFileService {
         }
     }
     list(context) {
+        this.discoverGlobalManagedFiles(context, false);
         const catalog = context.channelContext.getCapabilityCatalog?.().contextFiles ?? [];
         return catalog.map((file) => this.resolveCatalogInfo(context, file));
     }
     async read(context, key) {
+        this.discoverGlobalManagedFiles(context, false);
         const managed = this.managed.get(key);
         if (managed) {
             const file = this.resolveManagedInfo(context, managed);
@@ -364,7 +378,7 @@ class ContextFileService {
             kind: "working",
             contentHash: hashContextFileContent(markdown),
             content: markdown,
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             note: "Managed context file created",
         });
         const updated = this.store.updateFile({
@@ -375,7 +389,7 @@ class ContextFileService {
         this.upsertManaged(updated);
         const document = await this.read(context, updated.key);
         this.snapshots.set(updated.key, this.snapshotFromInfo(document));
-        this.emitChanged(context, "context-file.created", "web", webSession.ownerScope, document);
+        this.emitChanged(context, "context-file.created", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     async createLinkedCopy(context, sourceKey, body, webSession) {
@@ -402,7 +416,7 @@ class ContextFileService {
             kind: "source-snapshot",
             contentHash: sourceDescriptor.contentHash,
             content: sourceDescriptor.content ?? "",
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             sourceHashAtCreation: sourceDescriptor.contentHash,
             note: "Plugin source linked",
         });
@@ -411,7 +425,7 @@ class ContextFileService {
             kind: "working",
             contentHash: sourceDescriptor.contentHash,
             content: sourceDescriptor.content ?? "",
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             basedOnRevisionId: sourceRevision.id,
             sourceHashAtCreation: sourceDescriptor.contentHash,
             note: "Managed working copy created from plugin source",
@@ -425,7 +439,7 @@ class ContextFileService {
         this.upsertManaged(updated);
         const document = await this.read(context, updated.key);
         this.snapshots.set(updated.key, this.snapshotFromInfo(document));
-        this.emitChanged(context, "context-file.linked_from_plugin", "web", webSession.ownerScope, document);
+        this.emitChanged(context, "context-file.linked_from_plugin", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     async update(context, key, body, webSession) {
@@ -439,12 +453,12 @@ class ContextFileService {
         if (current.markdown === markdown)
             return current;
         const updatedRecord = await this.writeWorkingContent(record, markdown, {
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             note: "Managed context file updated",
         });
         const updated = await this.read(context, updatedRecord.key);
         this.snapshots.set(updated.key, this.snapshotFromInfo(updated));
-        this.emitChanged(context, "context-file.updated", "web", webSession.ownerScope, updated);
+        this.emitChanged(context, "context-file.updated", "web", webSession.authSession.identity.userId, updated);
         return updated;
     }
     async updateMetadata(context, key, body, webSession) {
@@ -473,7 +487,7 @@ class ContextFileService {
         this.upsertManaged(updated);
         const document = await this.read(context, key);
         this.snapshots.set(key, this.snapshotFromInfo(document));
-        this.emitChanged(context, "context-file.metadata_updated", "web", webSession.ownerScope, document);
+        this.emitChanged(context, "context-file.metadata_updated", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     async resetToSource(context, key, webSession) {
@@ -481,15 +495,15 @@ class ContextFileService {
         if (!record.sourceRef)
             throw new PiboWebHttpError("Only linked managed files can be reset to source", 400);
         const liveSource = this.requireLiveSourceForRecord(context, record);
-        this.ensureSourceSnapshot(record, liveSource, webSession.ownerScope, "Source snapshot refreshed during reset");
+        this.ensureSourceSnapshot(record, liveSource, webSession.authSession.identity.userId, "Source snapshot refreshed during reset");
         const updatedRecord = await this.writeWorkingContent(record, liveSource.content ?? "", {
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             sourceHash: liveSource.contentHash,
             note: "Working copy reset to source",
         });
         const document = await this.read(context, updatedRecord.key);
         this.snapshots.set(updatedRecord.key, this.snapshotFromInfo(document));
-        this.emitChanged(context, "context-file.reset_to_source", "web", webSession.ownerScope, document);
+        this.emitChanged(context, "context-file.reset_to_source", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     async adoptSource(context, key, webSession) {
@@ -497,15 +511,15 @@ class ContextFileService {
         if (!record.sourceRef)
             throw new PiboWebHttpError("Only linked managed files can adopt a source", 400);
         const liveSource = this.requireLiveSourceForRecord(context, record);
-        this.ensureSourceSnapshot(record, liveSource, webSession.ownerScope, "Source snapshot adopted");
+        this.ensureSourceSnapshot(record, liveSource, webSession.authSession.identity.userId, "Source snapshot adopted");
         const updatedRecord = await this.writeWorkingContent(record, liveSource.content ?? "", {
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             sourceHash: liveSource.contentHash,
             note: "Plugin source adopted",
         });
         const document = await this.read(context, updatedRecord.key);
         this.snapshots.set(updatedRecord.key, this.snapshotFromInfo(document));
-        this.emitChanged(context, "context-file.source_adopted", "web", webSession.ownerScope, document);
+        this.emitChanged(context, "context-file.source_adopted", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     async restoreRevision(context, key, body, webSession) {
@@ -515,13 +529,13 @@ class ContextFileService {
         if (!revision || revision.contextFileKey !== key)
             throw new PiboWebHttpError(`Unknown revision "${revisionId}"`, 404);
         const updatedRecord = await this.writeWorkingContent(record, revision.content, {
-            actorId: webSession.ownerScope,
+            actorId: webSession.authSession.identity.userId,
             basedOnRevisionId: revision.id,
             note: `Revision restored from ${revision.id}`,
         });
         const document = await this.read(context, updatedRecord.key);
         this.snapshots.set(updatedRecord.key, this.snapshotFromInfo(document));
-        this.emitChanged(context, "context-file.revision_restored", "web", webSession.ownerScope, document);
+        this.emitChanged(context, "context-file.revision_restored", "web", webSession.authSession.identity.userId, document);
         return document;
     }
     listRevisions(context, key) {
@@ -558,12 +572,13 @@ class ContextFileService {
         this.store.deleteFile(key);
         this.api.removeContextFile(key);
         this.snapshots.delete(key);
-        this.emitChanged(context, "context-file.removed", "web", webSession.ownerScope, file);
+        this.emitChanged(context, "context-file.removed", "web", webSession.authSession.identity.userId, file);
         return { removed: key };
     }
     startWatcher(context) {
         if (this.pollTimer)
             return;
+        this.discoverGlobalManagedFiles(context, false);
         for (const file of this.list(context))
             this.snapshots.set(file.key, this.snapshotFromInfo(file));
         this.pollTimer = setInterval(() => {
@@ -578,6 +593,7 @@ class ContextFileService {
         this.pollTimer = undefined;
     }
     async poll(context) {
+        this.discoverGlobalManagedFiles(context, true);
         for (const file of this.list(context)) {
             const nextSnapshot = this.snapshotFromInfo(file);
             const previous = this.snapshots.get(file.key);
@@ -590,6 +606,70 @@ class ContextFileService {
             emitContextFileEvent(context, eventType, "filesystem", undefined, contextFilePayload(file));
         }
     }
+    discoverGlobalManagedFiles(context, emitEvents) {
+        let entries;
+        try {
+            entries = readdirSync(this.paths.globalDir, { withFileTypes: true });
+        }
+        catch (error) {
+            const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+            if (code === "ENOENT")
+                return [];
+            throw error;
+        }
+        const knownPaths = new Set([...this.managed.values()].map((file) => resolve(file.managedPath)));
+        const usedKeys = new Set([
+            ...this.managed.keys(),
+            ...(context.channelContext.getCapabilityCatalog?.().contextFiles ?? []).map((file) => file.key),
+        ]);
+        const discovered = [];
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const extension = extname(entry.name).toLowerCase();
+            if (extension !== ".md" && extension !== ".markdown")
+                continue;
+            const absolutePath = resolve(this.paths.globalDir, entry.name);
+            if (knownPaths.has(absolutePath))
+                continue;
+            const snapshot = snapshotFromSync(absolutePath);
+            if (!snapshot.exists || !snapshot.version)
+                continue;
+            const label = labelFromManagedPath(entry.name);
+            const record = this.store.createFile({
+                key: uniqueKey(`ctx:${slugSegment(entry.name.slice(0, -extension.length) || entry.name)}`, usedKeys),
+                label,
+                managedPath: absolutePath,
+                scope: "global",
+                createdAt: snapshot.updatedAt,
+                updatedAt: snapshot.updatedAt,
+            });
+            const revision = this.store.appendRevision({
+                contextFileKey: record.key,
+                kind: "working",
+                contentHash: snapshot.version,
+                content: snapshot.content ?? "",
+                createdAt: snapshot.updatedAt,
+                note: "Global context file discovered on disk",
+            });
+            const updated = this.store.updateFile({
+                ...record,
+                activeRevisionId: revision.id,
+                updatedAt: snapshot.updatedAt ?? new Date().toISOString(),
+            });
+            this.upsertManaged(updated);
+            this.managed.set(updated.key, updated);
+            knownPaths.add(absolutePath);
+            usedKeys.add(updated.key);
+            const info = this.resolveManagedInfo(context, updated);
+            discovered.push(updated);
+            if (emitEvents) {
+                this.snapshots.set(updated.key, this.snapshotFromInfo(info));
+                this.emitChanged(context, "context-file.created", "filesystem", undefined, info);
+            }
+        }
+        return discovered;
+    }
     resolveCatalogInfo(context, file) {
         const managed = this.managed.get(file.key);
         if (managed)

package/dist/plugins/dev-auth.js

@@ -0,0 +1,124 @@
+import { randomBytes } from "node:crypto";
+import { definePiboPlugin } from "./registry.js";
+const COOKIE_NAME = "pibo_dev_session";
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 7; // 7 days
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function generateToken() {
+    return randomBytes(32).toString("hex");
+}
+function setCookie(value, maxAge = COOKIE_MAX_AGE) {
+    return `${COOKIE_NAME}=${value}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${maxAge}`;
+}
+function clearCookie() {
+    return `${COOKIE_NAME}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`;
+}
+function getCookieValue(headers) {
+    const cookie = headers.get("cookie");
+    if (!cookie)
+        return undefined;
+    const match = cookie.match(new RegExp(`${COOKIE_NAME}=([^;]+)`));
+    return match?.[1];
+}
+function firstHeaderValue(value) {
+    return value?.split(",")[0]?.trim() || undefined;
+}
+function isLoopbackHost(value) {
+    if (!value)
+        return false;
+    try {
+        const hostname = new URL(`http://${value}`).hostname;
+        return LOOPBACK_HOSTS.has(hostname);
+    }
+    catch {
+        return false;
+    }
+}
+export function isLoopbackDevAuthRequest(request) {
+    const host = firstHeaderValue(request.headers.get("host"));
+    const forwardedHost = firstHeaderValue(request.headers.get("x-forwarded-host"));
+    return isLoopbackHost(host) && (!forwardedHost || isLoopbackHost(forwardedHost));
+}
+function createDevAuthService() {
+    const containerToken = generateToken();
+    const debugSession = {
+        identity: {
+            userId: "dev-user-001",
+            email: "dev@pibo.local",
+            name: "Dev User",
+            image: undefined,
+            provider: "dev",
+        },
+        sessionId: "dev-session-001",
+        expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1000),
+    };
+    return {
+        name: "dev-auth",
+        async start() {
+            console.error("[dev-auth] Debug auth service started");
+        },
+        stop() { },
+        async getSession(headers) {
+            const token = getCookieValue(headers);
+            if (token === containerToken)
+                return debugSession;
+            return undefined;
+        },
+        async requireSession(headers) {
+            const session = await this.getSession(headers);
+            if (!session) {
+                const err = new Error("Unauthenticated");
+                err.statusCode = 401;
+                throw err;
+            }
+            return session;
+        },
+        async handleRequest(request) {
+            if (!isLoopbackDevAuthRequest(request)) {
+                return Response.json({ error: "Dev auth only accepts loopback requests" }, { status: 403 });
+            }
+            const url = new URL(request.url);
+            if (url.pathname === "/api/auth/sign-in/social") {
+                // Simulate the Google OAuth redirect — go straight to callback
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        location: "/api/auth/callback/google?code=dev",
+                    },
+                });
+            }
+            if (url.pathname === "/api/auth/callback/google") {
+                // Set session cookie and redirect to app
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        "Set-Cookie": setCookie(containerToken),
+                        location: "/apps/chat",
+                    },
+                });
+            }
+            if (url.pathname === "/api/auth/sign-out") {
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        "Set-Cookie": clearCookie(),
+                        location: "/apps/chat",
+                    },
+                });
+            }
+            if (url.pathname === "/api/auth/session") {
+                const session = await this.getSession(request.headers);
+                return Response.json(session ?? null);
+            }
+            return new Response("Not found", { status: 404 });
+        },
+    };
+}
+export function createPiboDevAuthPlugin() {
+    return definePiboPlugin({
+        id: "pibo.dev-auth",
+        name: "Dev Auth",
+        register(api) {
+            api.registerAuthService(createDevAuthService());
+        },
+    });
+}

package/dist/plugins/native-tooling.js

@@ -0,0 +1,15 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const PIBO_NATIVE_TOOLING_CONTEXT_FILE_KEY = "Pibo Native Tooling";
+const PROJECT_ROOT = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+export const PIBO_NATIVE_TOOLING_CONTEXT_FILE_PATH = resolve(PROJECT_ROOT, "context/pibo-native-tooling.md");
+export function registerPiboNativeTooling(api) {
+    api.registerContextFile({
+        key: PIBO_NATIVE_TOOLING_CONTEXT_FILE_KEY,
+        label: "Pibo Native Tooling",
+        path: PIBO_NATIVE_TOOLING_CONTEXT_FILE_PATH,
+    });
+}
+export function addPiboNativeToolingContext(builder, context) {
+    return builder.addContextFile(context.getContextFile(PIBO_NATIVE_TOOLING_CONTEXT_FILE_KEY));
+}

package/dist/plugins/registry.js

@@ -30,8 +30,10 @@ export class PiboPluginRegistry {
     channels = new Map();
     authService;
     webApps = new Map();
+    capabilityPackages = new Map();
     eventListeners = new Set();
     productEventListeners = new Set();
+    ralphStopConditions = new Map();
     pluginIds = new Set();
     pluginNames = new Map();
     eventErrors = [];
@@ -69,6 +71,12 @@ export class PiboPluginRegistry {
     registerSkill(skill) {
         this.addUnique(this.skills, skill.name, skill, "skill");
     }
+    unregisterSkill(name) {
+        return this.skills.delete(name);
+    }
+    getRegisteredSkillNames() {
+        return [...this.skills.keys()];
+    }
     registerContextFile(contextFile) {
         this.addUnique(this.contextFiles, contextFileKey(contextFile), contextFile, "context file");
     }
@@ -122,6 +130,33 @@ export class PiboPluginRegistry {
         this.validateWebAppRoutes(app);
         this.webApps.set(app.name, app);
     }
+    registerCapabilityPackage(pkg) {
+        this.addUnique(this.capabilityPackages, pkg.name, { ...pkg, toolNames: [...pkg.toolNames] }, "capability package");
+    }
+    registerRalphStopCondition(condition, pluginId) {
+        if (!condition.type.trim())
+            throw new Error('Ralph stop condition type is required');
+        if (!condition.name.trim())
+            throw new Error(`Ralph stop condition "${condition.type}" name is required`);
+        if (condition.phases.length === 0)
+            throw new Error(`Ralph stop condition "${condition.type}" must support at least one phase`);
+        this.addUnique(this.ralphStopConditions, condition.type, { definition: { ...condition, phases: [...condition.phases] }, pluginId }, 'Ralph stop condition');
+    }
+    getRalphStopConditionDefinitions() {
+        return [...this.ralphStopConditions.values()].map((entry) => entry.definition);
+    }
+    getRalphStopConditionInfos() {
+        return [...this.ralphStopConditions.values()].map((entry) => ({
+            type: entry.definition.type,
+            name: entry.definition.name,
+            description: entry.definition.description,
+            phases: [...entry.definition.phases],
+            optionsSchema: entry.definition.optionsSchema,
+            defaultOptions: entry.definition.defaultOptions,
+            pluginId: entry.pluginId,
+            pluginName: entry.pluginId ? this.pluginNames.get(entry.pluginId) : undefined,
+        }));
+    }
     onEvent(listener) {
         this.eventListeners.add(listener);
     }
@@ -158,6 +193,12 @@ export class PiboPluginRegistry {
                 model: sessionContext.model ? { ...sessionContext.model } : undefined,
                 mainModel: sessionContext.mainModel ? { ...sessionContext.mainModel } : undefined,
                 subagentModel: sessionContext.subagentModel ? { ...sessionContext.subagentModel } : undefined,
+                thinkingLevel: sessionContext.thinkingLevel,
+                mainThinkingLevel: sessionContext.mainThinkingLevel,
+                subagentThinkingLevel: sessionContext.subagentThinkingLevel,
+                fast: sessionContext.fast,
+                mainFast: sessionContext.mainFast,
+                subagentFast: sessionContext.subagentFast,
                 builtinTools: sessionContext.builtinTools,
                 builtinToolNames: [...sessionContext.builtinToolNames],
                 autoContextFiles: sessionContext.autoContextFiles,
@@ -171,7 +212,7 @@ export class PiboPluginRegistry {
                 name: tool.name,
                 description: tool.description,
                 yieldable: tool.yieldable !== false,
-                hasDefinition: tool.definition !== undefined,
+                hasDefinition: tool.definition !== undefined || tool.createDefinition !== undefined,
                 pluginId: tool.pluginId,
                 pluginName: tool.pluginId ? this.pluginNames.get(tool.pluginId) : undefined,
                 ...(tool.providerTool ? { providerTool: tool.providerTool } : {}),
@@ -179,6 +220,9 @@ export class PiboPluginRegistry {
             skills: [...this.skills.values()].map((skill) => ({
                 name: skill.name,
                 path: skill.path,
+                kind: skill.kind ?? "plugin",
+                pluginId: skill.pluginId,
+                pluginName: skill.pluginId ? this.pluginNames.get(skill.pluginId) : undefined,
             })),
             subagents: [...this.subagents.values()].map((subagent) => ({
                 name: subagent.name,
@@ -211,10 +255,16 @@ export class PiboPluginRegistry {
                         "pibo_run_ack",
                     ],
                 },
+                ...[...this.capabilityPackages.values()].map((pkg) => ({
+                    ...pkg,
+                    toolNames: [...pkg.toolNames],
+                    pluginName: pkg.pluginId ? this.pluginNames.get(pkg.pluginId) : pkg.pluginName,
+                })),
             ],
             piboTools: listInstalledCliToolAgentContexts(),
             mcpServers: [],
             piPackages: listPiPackages(),
+            ralphStopConditions: this.getRalphStopConditionInfos(),
         };
     }
     resolveProfileName(name) {
@@ -276,13 +326,25 @@ export class PiboPluginRegistry {
     }
     createApi(pluginId) {
         const withPluginToolContext = (tool) => ({ ...tool, pluginId: tool.pluginId ?? pluginId });
+        const withPluginSkillContext = (skill) => (skill.kind === "user"
+            ? skill
+            : {
+                ...skill,
+                kind: skill.kind ?? "plugin",
+                pluginId: skill.pluginId ?? pluginId,
+            });
         const withPluginContext = (contextFile) => (contextFile.source === "managed" ? contextFile : { ...contextFile, pluginId: contextFile.pluginId ?? pluginId });
+        const withPluginPackageContext = (pkg) => ({
+            ...pkg,
+            toolNames: [...pkg.toolNames],
+            pluginId: pkg.pluginId ?? pluginId,
+        });
         return {
             registerTool: (tool) => this.registerTool(withPluginToolContext(tool)),
             registerTools: (tools) => this.registerTools(tools.map(withPluginToolContext)),
             registerSubagent: (subagent) => this.registerSubagent(subagent),
             registerSubagents: (subagents) => this.registerSubagents(subagents),
-            registerSkill: (skill) => this.registerSkill(skill),
+            registerSkill: (skill) => this.registerSkill(withPluginSkillContext(skill)),
             registerContextFile: (contextFile) => this.registerContextFile(withPluginContext(contextFile)),
             upsertContextFile: (contextFile) => this.upsertContextFile(withPluginContext(contextFile)),
             removeContextFile: (key) => this.removeContextFile(key),
@@ -291,6 +353,8 @@ export class PiboPluginRegistry {
             registerChannel: (channel) => this.registerChannel(channel),
             registerAuthService: (service) => this.registerAuthService(service),
             registerWebApp: (app) => this.registerWebApp(app),
+            registerCapabilityPackage: (pkg) => this.registerCapabilityPackage(withPluginPackageContext(pkg)),
+            registerRalphStopCondition: (condition) => this.registerRalphStopCondition(condition, pluginId),
             onEvent: (listener) => this.onEvent(listener),
             emitProductEvent: (event) => this.emitProductEvent(event),
             onProductEvent: (listener) => this.onProductEvent(listener),

package/dist/plugins/web-annotations.js

@@ -0,0 +1,27 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createWebAnnotationsWebApp } from "../web-annotations/api.js";
+import { WEB_ANNOTATION_TOOL_NAMES, createWebAnnotationToolProfiles } from "../web-annotations/tools.js";
+import { definePiboPlugin } from "./registry.js";
+const PIBO_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../..");
+function webAnnotationsSkillPath() {
+    return resolve(PIBO_PACKAGE_ROOT, "skills", "builtin", "web-annotations", "SKILL.md");
+}
+export const piboWebAnnotationsPlugin = definePiboPlugin({
+    id: "pibo.web-annotations",
+    name: "Pibo Web Annotations",
+    register(api) {
+        api.registerTools(createWebAnnotationToolProfiles());
+        api.registerWebApp(createWebAnnotationsWebApp());
+        api.registerCapabilityPackage({
+            name: "web-annotation-agent-tools",
+            description: "Expose session-scoped Web Annotation tools for listing, reading, watching, and lifecycle updates.",
+            toolNames: [...WEB_ANNOTATION_TOOL_NAMES],
+        });
+        api.registerSkill({
+            name: "web-annotations",
+            path: webAnnotationsSkillPath(),
+            kind: "builtin",
+        });
+    },
+});

package/dist/providers/minimax.js

@@ -0,0 +1,70 @@
+import { getModels } from "@mariozechner/pi-ai";
+import { OPENAI_COMPLETIONS_API, registerOpenAiCompatProvider, resetOpenAiCompatProviderRegistration, unregisterOpenAiCompatProvider, } from "./openai-compat.js";
+export const MINIMAX_PROVIDER_ID = "minimax";
+export const MINIMAX_CN_PROVIDER_ID = "minimax-cn";
+export const MINIMAX_DEFAULT_BASE_URL = "https://api.minimax.io/v1";
+export const MINIMAX_CN_DEFAULT_BASE_URL = "https://api.minimax.cn/v1";
+export const MINIMAX_API_KEY_ENV = "MINIMAX_API_KEY";
+export const MINIMAX_CN_API_KEY_ENV = "MINIMAX_API_KEY";
+export const MINIMAX_M3_MODEL = {
+    id: "MiniMax-M3",
+    name: "MiniMax-M3",
+    reasoning: true,
+    contextWindow: 1000000,
+    maxTokens: 131072,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    input: ["text", "image"],
+};
+function resolveBaseUrl(providerId, defaultBaseUrl) {
+    const envKey = `PIBO_${providerId.toUpperCase().replace(/-/g, "_")}_BASE_URL`;
+    const envOverride = process.env[envKey];
+    return envOverride && envOverride.length > 0 ? envOverride : defaultBaseUrl;
+}
+function buildMiniMaxSpec(providerId = MINIMAX_PROVIDER_ID, customModels = [MINIMAX_M3_MODEL]) {
+    const defaultBaseUrl = providerId === MINIMAX_CN_PROVIDER_ID
+        ? MINIMAX_CN_DEFAULT_BASE_URL
+        : MINIMAX_DEFAULT_BASE_URL;
+    return {
+        id: providerId,
+        baseUrl: resolveBaseUrl(providerId, defaultBaseUrl),
+        apiKeyEnv: providerId === MINIMAX_CN_PROVIDER_ID
+            ? MINIMAX_CN_API_KEY_ENV
+            : MINIMAX_API_KEY_ENV,
+        models: customModels,
+    };
+}
+export function isMiniMaxProvider(provider) {
+    return provider === MINIMAX_PROVIDER_ID || provider === MINIMAX_CN_PROVIDER_ID;
+}
+export function findMiniMaxModel(modelRegistry, model) {
+    if (!model?.provider || !model.id)
+        return undefined;
+    if (!isMiniMaxProvider(model.provider))
+        return undefined;
+    return modelRegistry.find(model.provider, model.id);
+}
+export function getBuiltInMiniMaxModels(providerId = MINIMAX_PROVIDER_ID) {
+    try {
+        return getModels(providerId);
+    }
+    catch {
+        return [];
+    }
+}
+export function registerMiniMaxProvider(modelRegistry, options = {}) {
+    const providerId = options.providerId ?? MINIMAX_PROVIDER_ID;
+    const spec = buildMiniMaxSpec(providerId, options.customModels ?? [MINIMAX_M3_MODEL]);
+    const baseModels = options.baseModels ?? getBuiltInMiniMaxModels(providerId);
+    return registerOpenAiCompatProvider(modelRegistry, spec, { baseModels });
+}
+export function unregisterMiniMaxProvider(modelRegistry, options = {}) {
+    const providerId = options.providerId ?? MINIMAX_PROVIDER_ID;
+    unregisterOpenAiCompatProvider(modelRegistry, providerId);
+}
+export function resetMiniMaxProviderRegistration() {
+    resetOpenAiCompatProviderRegistration();
+}
+export function getDefaultMiniMaxModels() {
+    return [MINIMAX_M3_MODEL];
+}
+export { OPENAI_COMPLETIONS_API };

package/dist/providers/openai-compat.js

@@ -0,0 +1,48 @@
+export const OPENAI_COMPLETIONS_API = "openai-completions";
+export function buildOpenAiCompatConfig(spec, baseModels = []) {
+    const baseEntries = baseModels
+        .filter((model) => model.provider === spec.id)
+        .map((model) => ({
+        id: model.id,
+        name: model.name,
+        api: OPENAI_COMPLETIONS_API,
+        baseUrl: spec.baseUrl,
+        reasoning: Boolean(model.reasoning),
+        input: [...model.input],
+        cost: { ...model.cost },
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+    }));
+    const customEntries = spec.models.map((model) => ({
+        id: model.id,
+        name: model.name,
+        api: OPENAI_COMPLETIONS_API,
+        baseUrl: spec.baseUrl,
+        reasoning: model.reasoning ?? false,
+        input: [...model.input],
+        cost: { ...model.cost },
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+    }));
+    const byId = new Map();
+    for (const entry of baseEntries)
+        byId.set(entry.id, entry);
+    for (const entry of customEntries)
+        byId.set(entry.id, entry);
+    return {
+        baseUrl: spec.baseUrl,
+        api: OPENAI_COMPLETIONS_API,
+        apiKey: spec.apiKeyEnv,
+        models: [...byId.values()],
+    };
+}
+export function registerOpenAiCompatProvider(modelRegistry, spec, options = {}) {
+    const config = buildOpenAiCompatConfig(spec, options.baseModels);
+    modelRegistry.registerProvider(spec.id, config);
+    return { registered: true, models: config.models.length };
+}
+export function unregisterOpenAiCompatProvider(modelRegistry, providerId) {
+    modelRegistry.unregisterProvider(providerId);
+}
+export function resetOpenAiCompatProviderRegistration() {
+}