clawser-embed 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Clawser Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# clawser-embed
+
+Embeddable Clawser agent pod — drop a Clawser-powered agent into any web app.
+
+`EmbeddedPod` extends `browsermesh-pod`'s `Pod` with a minimal messaging API
+(`sendMessage`, `on`/`off`/`emit`) and a lazy-attached agent slot, so a host
+app can wire up its own `ClawserAgent` instance (from the main
+[clawser](https://github.com/johnhenry/clawser) repo) and drive it through a
+stable embedding surface without depending on the full Clawser UI.
+
+## Install
+
+```bash
+npm install clawser-embed browsermesh-pod
+```
+
+## Usage
+
+```js
+import { EmbeddedPod } from 'clawser-embed'
+
+const pod = new EmbeddedPod({ containerId: 'my-agent', agent: myClawserAgent })
+
+pod.on('response', (msg) => console.log(msg))
+
+const { content, toolCalls } = await pod.sendMessage('Summarize this page')
+```
+
+`config.agent` accepts any object shaped like `clawser-agent.js`'s
+`ClawserAgent` — this package doesn't depend on the main Clawser codebase,
+so the agent instance is duck-typed (`sendMessage`, `getEventLog().query()`,
+`run()`).
+
+## Backward compatibility
+
+`ClawserEmbed` is exported as an alias of `EmbeddedPod` for callers migrating
+from an earlier naming.

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "clawser-embed",
+  "version": "0.1.0",
+  "description": "Embeddable Clawser agent pod — drop a Clawser-powered agent into any web app",
+  "type": "module",
+  "main": "./src/index.mjs",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "files": ["src", "LICENSE", "README.md"],
+  "license": "MIT",
+  "repository": { "type": "git", "url": "https://github.com/johnhenry/clawser" },
+  "peerDependencies": {
+    "browsermesh-pod": "^0.1.0"
+  }
+}

package/src/index.mjs

@@ -0,0 +1,136 @@
+// clawser-embed — standalone npm distribution of EmbeddedPod.
+//
+// This is a synced copy of web/clawser-embed.js from the main Clawser repo,
+// adapted for standalone npm distribution: the single import is rewritten
+// from the repo-internal bridge `./packages-pod.js` to the published
+// `browsermesh-pod` package directly. If web/clawser-embed.js changes,
+// mirror the change here (a build step to generate this file automatically
+// is a natural follow-up, not yet built).
+//
+// EmbeddedPod: Drop-in class for embedding the Clawser agent into any web app.
+// Extends Pod with container rendering, messaging, and lazy agent init.
+// Re-exports as ClawserEmbed for backward compatibility.
+
+import { Pod } from 'browsermesh-pod'
+
+// ── EmbeddedPod ────────────────────────────────────────────────
+
+/**
+ * Embeddable Clawser agent pod.
+ * Provides a minimal API for integrating the agent into external web apps.
+ * Extends Pod for identity, discovery, and peer messaging.
+ */
+export class EmbeddedPod extends Pod {
+  #config
+  #agent = null
+  #listeners = new Map()
+
+  /**
+   * @param {object} [config]
+   * @param {string} [config.containerId] - DOM element ID to render into
+   * @param {string} [config.provider] - Default LLM provider
+   * @param {string} [config.model] - Default model
+   * @param {object} [config.tools] - Tool configuration overrides
+   * @param {object} [config.theme] - UI theme overrides
+   * @param {object} [config.agent] - Pre-configured agent instance (a ClawserAgent
+   *   from the main clawser repo; typed as `object` here since this package
+   *   doesn't depend on clawser-agent.js)
+   */
+  constructor(config = {}) {
+    super()
+    this.#config = {
+      containerId: config.containerId || 'clawser',
+      provider: config.provider || null,
+      model: config.model || null,
+      tools: config.tools || {},
+      theme: config.theme || {},
+      ...config,
+    }
+    if (config.agent) this.#agent = config.agent
+  }
+
+  get config() { return { ...this.#config } }
+
+  /** Get the attached agent (if any). */
+  get agent() { return this.#agent }
+
+  /**
+   * Attach or replace the agent instance.
+   * @param {object} agent
+   */
+  setAgent(agent) { this.#agent = agent }
+
+  /**
+   * Send a message to the agent.
+   * @param {string} text - User message
+   * @param {object} [opts] - Options (streaming, model override, etc.)
+   * @returns {Promise<{ content: string, toolCalls?: Array }>}
+   */
+  async sendMessage(text, opts = {}) {
+    if (!this.#agent) {
+      throw new Error('No agent attached. Call setAgent(agent) or pass { agent } in config before sending messages.')
+    }
+
+    // 1. Add the user message to agent history
+    this.#agent.sendMessage(text, opts)
+
+    // Snapshot event log length so we can extract tool_call events from this run
+    const logBefore = this.#agent.getEventLog().query({ type: 'tool_call' }).length
+
+    // 2. Run the agent (handles tool call loops internally)
+    const result = await this.#agent.run()
+
+    // 3. Extract tool calls that occurred during this run from the event log
+    const allToolEvents = this.#agent.getEventLog().query({ type: 'tool_call' })
+    const newToolEvents = allToolEvents.slice(logBefore)
+    const toolCalls = newToolEvents.map(evt => ({
+      id: evt.data.call_id,
+      name: evt.data.name,
+      arguments: evt.data.arguments,
+    }))
+
+    // 4. Return normalized response
+    if (result.status === 1) {
+      return { content: result.data, toolCalls, usage: result.usage, model: result.model }
+    }
+
+    // Error or blocked
+    return { content: result.data || '', toolCalls, error: result.status < 0, usage: result.usage }
+  }
+
+  /**
+   * Register an event listener.
+   * @param {string} event
+   * @param {Function} fn
+   */
+  on(event, fn) {
+    const s = this.#listeners.get(event) || new Set()
+    s.add(fn)
+    this.#listeners.set(event, s)
+  }
+
+  /**
+   * Remove an event listener.
+   * @param {string} event
+   * @param {Function} fn
+   */
+  off(event, fn) {
+    this.#listeners.get(event)?.delete(fn)
+  }
+
+  /**
+   * Emit an event to all registered listeners.
+   * @param {string} event
+   * @param {...any} args
+   */
+  emit(event, ...args) {
+    for (const fn of this.#listeners.get(event) || []) fn(...args)
+  }
+
+  _onMessage(msg) {
+    // Subclass hook — forward pod messages to the event bus
+  }
+}
+
+/** Backward-compatible alias */
+export const ClawserEmbed = EmbeddedPod