@kaoruisaac/pedelec 0.4.8 → 0.4.10

package/README.md

@@ -27,6 +27,7 @@ A web application can use Pedelec to:
 - open an application-managed workspace with the native directory picker or an explicit path;
 - send user instructions and receive streamed assistant text;
 - expose narrowly scoped browser-side tools to the agent;
+- register those same tools with WebMCP when the browser provides `document.modelContext`;
 - resume or end sessions; and
 - upload and list completed workspace assets; and
 - show connection, approval, provider, and lifecycle state in the UI.
@@ -204,6 +205,47 @@ await session.sendText("Please help me analyze the current page state");
 
 `sendText()` resolves after Core reports the matching semantic operation as completed. An `idle` status or bridge request response alone does not complete it. If the session is already handling a previous prompt, the new `sendText()` call is rejected to prevent multiple concurrent requests from running in the same session.
 
+## Share App Tools with WebMCP
+
+The same `defineTool()` definitions can be registered for a browser WebMCP agent. `webmcp()` does not start a Pedelec Session and does not require the Extension or Desktop. Pedelec binds the tools when `document.modelContext.registerTool` is available; otherwise `available` is `false`.
+
+```ts
+import { Pedelec, defineTool } from "@kaoruisaac/pedelec";
+
+const pedelec = new Pedelec();
+
+const getCurrentPage = defineTool({
+  name: "get_current_page",
+  description: "Read the current browser page title and URL.",
+  argsSchema: {
+    type: "object",
+    properties: {},
+    required: [],
+  },
+  handler: async () => ({
+    title: document.title,
+    url: location.href,
+  }),
+});
+
+const tools = [getCurrentPage] as const;
+
+const webMcpBinding = await pedelec.webmcp({
+  skills: { tools },
+});
+
+const session = await pedelec.createSession({
+  skills: {
+    guidance: "Use browser tools when useful.",
+    tools,
+  },
+});
+
+webMcpBinding.dispose();
+```
+
+A handler shared by Session and WebMCP should depend only on `args` and ordinary application or browser state. WebMCP execution does not receive a Pedelec `ToolCallContext`.
+
 ## End and resume a session
 
 ```ts

package/dist/index.d.ts

@@ -101,6 +101,16 @@ export type SkillsInput<TTools extends readonly ToolDefinition[] = readonly Tool
     tools: TTools;
     denoModules?: readonly AgentDenoModuleDefinition[];
 };
+export type WebMcpSkillsInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
+    tools: TTools;
+};
+export type WebMcpInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
+    skills: WebMcpSkillsInput<TTools>;
+};
+export type WebMcpBinding = {
+    available: boolean;
+    dispose(): void;
+};
 export type ToolNameOf<TTools extends readonly ToolDefinition[]> = Extract<TTools[number]["name"], string>;
 export type SerializableToolManifest = {
     name: string;
@@ -388,6 +398,7 @@ export declare class Pedelec {
     constructor(options?: PedelecOptions);
     createSession(): Promise<PedelecSession<string>>;
     createSession<const TTools extends readonly ToolDefinition[]>(input: CreateSessionInput<TTools>): Promise<PedelecSession<ToolNameOf<TTools>>>;
+    webmcp<const TTools extends readonly ToolDefinition[]>(input: WebMcpInput<TTools>): Promise<WebMcpBinding>;
     /** @internal */
     createSessionInternal<const TTools extends readonly ToolDefinition[]>(input?: CreateSessionInput<TTools>, workspace?: PedelecWorkspace): Promise<PedelecSession<ToolNameOf<TTools>>>;
     private uploadDenoModuleArtifact;

package/dist/index.js

@@ -145,6 +145,7 @@ function downloadBrowserFile(client, request) {
 }
 const MAX_ASSET_UPLOAD_BYTES = 100 * 1024 * 1024;
 const TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
+const WEBMCP_TOOL_NAME_MAX_LENGTH = 128;
 export function defineTool(tool) {
     return tool;
 }
@@ -191,26 +192,13 @@ function normalizeWorkspaceDenoModules(value) {
         };
     });
 }
-function normalizeSkillsInput(value) {
-    const handlers = new Map();
-    if (value === undefined)
-        return { handlers, denoModules: [] };
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw makeError("INVALID_INPUT", "skills must be an object");
-    }
-    const skills = value;
-    if (typeof skills.guidance !== "string") {
-        throw makeError("INVALID_INPUT", "skills.guidance must be a string");
-    }
-    if (!Array.isArray(skills.tools)) {
+function normalizeToolDefinitions(value, options = {}) {
+    if (!Array.isArray(value)) {
         throw makeError("INVALID_INPUT", "skills.tools must be an array");
     }
-    if (skills.denoModules !== undefined && !Array.isArray(skills.denoModules)) {
-        throw makeError("INVALID_INPUT", "skills.denoModules must be an array");
-    }
+    const handlers = new Map();
     const seen = new Set();
-    const seenDenoModuleNames = new Set();
-    const tools = skills.tools.map((tool, index) => {
+    const tools = value.map((tool, index) => {
         if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
             throw makeError("INVALID_INPUT", "skills.tools entries must be objects", { index });
         }
@@ -218,6 +206,12 @@ function normalizeSkillsInput(value) {
         if (typeof rawTool.name !== "string" || !TOOL_NAME_PATTERN.test(rawTool.name)) {
             throw makeError("INVALID_INPUT", "tool name is invalid", { index, toolName: rawTool.name });
         }
+        if (options.enforceWebMcpNameLimit && rawTool.name.length > WEBMCP_TOOL_NAME_MAX_LENGTH) {
+            throw makeError("INVALID_INPUT", "WebMCP tool name must be at most 128 characters", {
+                index,
+                toolName: rawTool.name,
+            });
+        }
         if (seen.has(rawTool.name)) {
             throw makeError("INVALID_INPUT", "duplicate tool name", { toolName: rawTool.name });
         }
@@ -236,6 +230,11 @@ function normalizeSkillsInput(value) {
         if (rawTool.handler !== undefined && typeof rawTool.handler !== "function") {
             throw makeError("INVALID_INPUT", "tool handler must be a function", { toolName: rawTool.name });
         }
+        if (options.requireHandler && typeof rawTool.handler !== "function") {
+            throw makeError("INVALID_INPUT", "WebMCP tool handler must be a function", {
+                toolName: rawTool.name,
+            });
+        }
         if (rawTool.input !== undefined) {
             throw makeError("INVALID_INPUT", "tool input is no longer supported; use argsSchema", {
                 toolName: rawTool.name,
@@ -251,6 +250,26 @@ function normalizeSkillsInput(value) {
             ...(rawTool.timeoutMs === undefined ? {} : { timeoutMs: rawTool.timeoutMs }),
         };
     });
+    return { tools, handlers };
+}
+function normalizeSkillsInput(value) {
+    if (value === undefined)
+        return { handlers: new Map(), denoModules: [] };
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw makeError("INVALID_INPUT", "skills must be an object");
+    }
+    const skills = value;
+    if (typeof skills.guidance !== "string") {
+        throw makeError("INVALID_INPUT", "skills.guidance must be a string");
+    }
+    if (!Array.isArray(skills.tools)) {
+        throw makeError("INVALID_INPUT", "skills.tools must be an array");
+    }
+    if (skills.denoModules !== undefined && !Array.isArray(skills.denoModules)) {
+        throw makeError("INVALID_INPUT", "skills.denoModules must be an array");
+    }
+    const { tools, handlers } = normalizeToolDefinitions(skills.tools);
+    const seenDenoModuleNames = new Set();
     const denoModules = (skills.denoModules ?? []).map((module, index) => {
         if (!module || typeof module !== "object" || Array.isArray(module)) {
             throw makeError("INVALID_INPUT", "skills.denoModules entries must be objects", { index });
@@ -342,6 +361,43 @@ function normalizeToolArgsSchema(argsSchema, toolName) {
         });
     }
 }
+function normalizeWebMcpInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw makeError("INVALID_INPUT", "input must be an object");
+    }
+    const input = value;
+    if (!input.skills || typeof input.skills !== "object" || Array.isArray(input.skills)) {
+        throw makeError("INVALID_INPUT", "skills must be an object");
+    }
+    return normalizeToolDefinitions(input.skills.tools, {
+        requireHandler: true,
+        enforceWebMcpNameLimit: true,
+    });
+}
+function webMcpModelContext(pageWindow) {
+    const document = pageWindow?.document;
+    const modelContext = document?.modelContext;
+    if (!modelContext || typeof modelContext.registerTool !== "function")
+        return null;
+    return modelContext;
+}
+function unavailableWebMcpBinding() {
+    return {
+        available: false,
+        dispose() { },
+    };
+}
+function invokeWebMcpHandler(handler, args) {
+    // WebMCP has no Pedelec session. Call the shared handler with args only.
+    return handler(args);
+}
+function webMcpRegistrationError(error, toolName) {
+    const normalized = normalizeError(error, "WEBMCP_REGISTRATION_FAILED", "WebMCP tool registration failed");
+    if (normalized.code === "WEBMCP_REGISTRATION_FAILED" && normalized.details === undefined && toolName) {
+        return makeError(normalized.code, normalized.message, { toolName });
+    }
+    return normalized;
+}
 export class PedelecWorkspace {
     client;
     workspaceId;
@@ -498,6 +554,41 @@ export class Pedelec {
     async createSession(input = {}) {
         return this.createSessionInternal(input);
     }
+    async webmcp(input) {
+        const normalized = normalizeWebMcpInput(input);
+        const modelContext = webMcpModelContext(this.pageWindow);
+        if (!modelContext)
+            return unavailableWebMcpBinding();
+        const controller = new AbortController();
+        let registeringToolName;
+        try {
+            for (const tool of normalized.tools) {
+                registeringToolName = tool.name;
+                const handler = normalized.handlers.get(tool.name);
+                if (!handler) {
+                    throw makeError("INVALID_INPUT", "WebMCP tool handler must be a function", {
+                        toolName: tool.name,
+                    });
+                }
+                await modelContext.registerTool({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.argsSchema,
+                    execute: async (args) => invokeWebMcpHandler(handler, args),
+                }, { signal: controller.signal });
+            }
+        }
+        catch (error) {
+            controller.abort();
+            throw webMcpRegistrationError(error, registeringToolName);
+        }
+        return {
+            available: true,
+            dispose() {
+                controller.abort();
+            },
+        };
+    }
     /** @internal */
     async createSessionInternal(input = {}, workspace) {
         const resolvedOrPromise = this.resolveCreateSessionInput(input);

package/dist/index.type-test.js

@@ -265,6 +265,50 @@ async function workspaceFileTransferTypes() {
     void parsed;
     void downloaded;
 }
+async function sharedAppToolsBindToWebMcpAndSession() {
+    const pedelec = new Pedelec();
+    const sharedTool = defineTool({
+        name: "get_selection",
+        description: "Get selected text.",
+        argsSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+        handler: async () => ({ text: "..." }),
+    });
+    const binding = await pedelec.webmcp({
+        skills: {
+            tools: [sharedTool],
+        },
+    });
+    binding.available;
+    binding.dispose();
+    const tools = [sharedTool];
+    await pedelec.webmcp({
+        skills: { tools },
+    });
+    await pedelec.createSession({
+        skills: {
+            guidance: "Use available browser tools.",
+            tools,
+        },
+    });
+    await pedelec.webmcp({
+        skills: {
+            tools,
+            // @ts-expect-error WebMCP skills do not include guidance
+            guidance: "not part of WebMCP",
+        },
+    });
+    await pedelec.webmcp({
+        skills: {
+            tools,
+            // @ts-expect-error WebMCP skills do not include denoModules
+            denoModules: [spriteTools],
+        },
+    });
+}
 function directoryPickerIsRemoved() {
     const pedelec = new Pedelec();
     // @ts-expect-error directoryPicker was removed in favor of openWorkspace
@@ -292,6 +336,7 @@ void listAssetsHasPublicTypes;
 void availabilityHasPublicType;
 void workspacePublicTypeContract;
 void workspaceFileTransferTypes;
+void sharedAppToolsBindToWebMcpAndSession;
 void directoryPickerIsRemoved;
 void publicSecurityTypesAreRestricted;
 const baseContext = {

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.4.8";
+export declare const SDK_VERSION = "0.4.10";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // Generated from sdk/package.json. Do not edit manually.
-export const SDK_VERSION = "0.4.8";
+export const SDK_VERSION = "0.4.10";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaoruisaac/pedelec",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",