fix: add streaming + v2 compat, tsup => bun build

.gitignore

@@ -1,5 +1,42 @@
+# Dependencies
 node_modules
-.turbo
+
+# Build outputs
 dist
+build
+*.tsbuildinfo
+.turbo
+.turbo-tsconfig.json
+
+# Environment files
 .env
-.eliza**
+.env.local
+.env.production
+.env.bak
+
+# IDE
+.idea
+.vscode
+.zed
+.DS_Store
+
+# Test coverage
+coverage
+.nyc_output
+
+# Logs
+*.log
+logs
+
+# Cache
+cache
+.cache
+tokencache
+
+# Temporary files
+*.tmp
+*.temp
+.tmp
+
+# Bundler artifacts
+tsup.config.bundled_*.mjs

README.md

@@ -154,6 +154,24 @@ const object = await runtime.useModel(ModelType.OBJECT_LARGE, {
 - You can pre-download models using `ollama pull modelname`
 - Check model availability with `ollama list`
 
+## Publishing (standalone repo)
+
+When developing in a monorepo you keep `@elizaos/core` as `workspace:*`. When publishing from the standalone repo (e.g. after syncing from monorepo), the published package must use a real version so consumers can install.
+
+- **After syncing from monorepo:** run `bun run prepare-publish` to set `@elizaos/core` to the version in `publishCoreVersion` (or set `CORE_VERSION` env). Commit that change so installs work in the standalone repo.
+- **Before every publish:** `prepublishOnly` runs automatically and ensures the packed tarball has the correct core version even if `package.json` still has `workspace:*`.
+- To change the published core version, update `publishCoreVersion` in `package.json` (or use `CORE_VERSION=1.8.0 bun run prepare-publish`).
+
+### Git hooks (monorepo)
+
+To always **commit** the verified core version and **check out** with `workspace:*` for local dev, install the hooks from the plugin directory (in the monorepo):
+
+```bash
+cd packages/plugin-ollama && bun run install-git-hooks
+```
+
+- **pre-commit:** Sets `@elizaos/core` to `publishCoreVersion` and stages `package.json`, so every commit has the publishable version.
+- **post-checkout:** In a monorepo only, sets `@elizaos/core` back to `workspace:*` after checkout so installs use the local workspace. Not run when this repo is the standalone plugin repo (so installs keep working there).
 
 ## License
 

build.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env bun
+import { $ } from "bun";
+
+async function build() {
+  const totalStart = Date.now();
+  const pkg = await Bun.file("package.json").json();
+  const externalDeps = [
+    ...Object.keys(pkg.dependencies ?? {}),
+    ...Object.keys(pkg.peerDependencies ?? {}),
+  ];
+
+  // Use the clean script from package.json
+  if (pkg.scripts?.clean) {
+    console.log("🧹 Cleaning...");
+    await $`bun run clean`.quiet();
+  }
+
+  const esmStart = Date.now();
+  console.log("🔨 Building @elizaos/plugin-ollama...");
+  const esmResult = await Bun.build({
+    entrypoints: ["src/index.ts"],
+    outdir: "dist",
+    target: "node",
+    format: "esm",
+    sourcemap: "external",
+    minify: false,
+    external: externalDeps,
+  });
+  if (!esmResult.success) {
+    console.error(esmResult.logs);
+    throw new Error("ESM build failed");
+  }
+  console.log(`✅ Build complete in ${((Date.now() - esmStart) / 1000).toFixed(2)}s`);
+
+  const dtsStart = Date.now();
+  if (true) { // Always generate .d.ts
+    console.log("📝 Generating TypeScript declarations...");
+    try {
+      await $`tsc --project tsconfig.build.json`;
+      console.log(`✅ Declarations generated in ${((Date.now() - dtsStart) / 1000).toFixed(2)}s`);
+    } catch (error) {
+      console.warn(`⚠️  TypeScript declaration generation had errors (${((Date.now() - dtsStart) / 1000).toFixed(2)}s)`);
+      console.warn("   Build will continue - fix type errors when possible");
+    }
+  } else {
+    console.log("🔍 Type checking...");
+    try {
+      await $`tsc --noEmit --incremental --project tsconfig.build.json`;
+      console.log(`✅ Type check passed in ${((Date.now() - dtsStart) / 1000).toFixed(2)}s`);
+    } catch (error) {
+      console.warn(`⚠️  Type checking had errors (${((Date.now() - dtsStart) / 1000).toFixed(2)}s)`);
+      console.warn("   Build will continue - fix type errors when possible");
+    }
+  }
+
+  console.log(`🎉 All builds finished in ${((Date.now() - totalStart) / 1000).toFixed(2)}s`);
+}
+
+build().catch((err) => {
+  console.error("Build failed:", err);
+  process.exit(1);
+});

package.json

@@ -23,22 +23,27 @@
   ],
   "dependencies": {
     "@ai-sdk/ui-utils": "^1.2.8",
-    "@elizaos/core": "^1.0.0",
+    "@elizaos/core": "1.7.2",
     "ai": "^4.3.9",
     "js-tiktoken": "^1.0.18",
     "ollama-ai-provider": "^1.2.0",
     "tsup": "8.4.0"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
+    "build": "bun run build.ts",
+    "dev": "bun run build.ts --watch",
     "lint": "prettier --write ./src",
     "clean": "rm -rf dist .turbo node_modules .turbo-tsconfig.json tsconfig.tsbuildinfo",
     "format": "prettier --write ./src",
     "format:check": "prettier --check ./src",
     "test": "bun test",
-    "postinstall": "bun scripts/install-ollama.js"
+    "postinstall": "bun scripts/install-ollama.js",
+    "prepare-publish": "bun run scripts/rewrite-core-version.ts",
+    "restore-workspace": "bun run scripts/rewrite-core-version.ts --restore",
+    "prepublishOnly": "bun run scripts/rewrite-core-version.ts",
+    "install-git-hooks": "bun run scripts/install-git-hooks.ts"
   },
+  "publishCoreVersion": "1.7.2",
   "publishConfig": {
     "access": "public"
   },

scripts/git-hooks/post-checkout

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Post-checkout: in a monorepo, set @elizaos/core back to workspace:* so dev uses local core.
+# Skip when this is the standalone repo (no workspace to link).
+set -e
+ROOT="$(git rev-parse --show-toplevel)"
+if [ -f "$ROOT/packages/plugin-ollama/package.json" ] && grep -q '"publishCoreVersion"' "$ROOT/packages/plugin-ollama/package.json" 2>/dev/null; then
+  PLUGIN_DIR="$ROOT/packages/plugin-ollama"
+  (cd "$PLUGIN_DIR" && bun run scripts/rewrite-core-version.ts --restore)
+fi
+# If repo root has publishCoreVersion (standalone), do not restore — keep committed version for installs.
+exit 0

scripts/git-hooks/pre-commit

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Pre-commit: ensure @elizaos/core is the verified version from publishCoreVersion so we commit the publishable state.
+set -e
+ROOT="$(git rev-parse --show-toplevel)"
+if [ -f "$ROOT/packages/plugin-ollama/package.json" ] && grep -q '"publishCoreVersion"' "$ROOT/packages/plugin-ollama/package.json" 2>/dev/null; then
+  PLUGIN_DIR="$ROOT/packages/plugin-ollama"
+else
+  [ -f "$ROOT/package.json" ] && grep -q '"publishCoreVersion"' "$ROOT/package.json" 2>/dev/null || exit 0
+  PLUGIN_DIR="$ROOT"
+fi
+(cd "$PLUGIN_DIR" && bun run scripts/rewrite-core-version.ts)
+git add "$PLUGIN_DIR/package.json"
+exit 0

scripts/install-git-hooks.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+/**
+ * Install git hooks so that:
+ * - pre-commit: commit with @elizaos/core = publishCoreVersion (verified for publish)
+ * - post-checkout: in monorepo, restore workspace:* for local dev
+ *
+ * Run from plugin dir: bun run scripts/install-git-hooks.ts
+ * Uses git rev-parse to find .git (works when plugin is in monorepo or standalone).
+ */
+import { $ } from "bun";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+
+const pluginDir = join(import.meta.dir, "..");
+const gitDir = (await $`git -C "${pluginDir}" rev-parse --git-dir`.text()).trim();
+const hooksDir = join(pluginDir, gitDir, "hooks");
+const hooksSource = join(pluginDir, "scripts", "git-hooks");
+
+await mkdir(hooksDir, { recursive: true });
+
+for (const name of ["pre-commit", "post-checkout"]) {
+  const src = join(hooksSource, name);
+  const dest = join(hooksDir, name);
+  const content = await Bun.file(src).text();
+  await writeFile(dest, content, { mode: 0o755 });
+  console.log(`Installed ${name} -> ${dest}`);
+}
+console.log("Git hooks installed. Pre-commit will use publishCoreVersion; post-checkout will restore workspace:* in monorepo.");

scripts/rewrite-core-version.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env bun
+/**
+ * For standalone publish: replace workspace:* with a real @elizaos/core version
+ * so installs work outside the monorepo. Run after syncing from monorepo or in
+ * prepublishOnly. Use --restore to set back to workspace:* (e.g. after publish).
+ *
+ * Usage:
+ *   bun run scripts/rewrite-core-version.ts           # set to publish version
+ *   bun run scripts/rewrite-core-version.ts --restore # set back to workspace:*
+ *
+ * Version: from package.json "publishCoreVersion" or env CORE_VERSION or "1.7.2"
+ */
+
+const RESTORE = process.argv.includes("--restore");
+const pkgPath = new URL("../package.json", import.meta.url);
+const pkg = (await Bun.file(pkgPath).json()) as Record<string, unknown> & {
+  dependencies?: Record<string, string>;
+  publishCoreVersion?: string;
+};
+const coreVersion =
+  process.env.CORE_VERSION ?? pkg.publishCoreVersion ?? "1.7.2";
+const deps = pkg.dependencies ?? {};
+const current = deps["@elizaos/core"];
+
+if (RESTORE) {
+  if (current !== coreVersion) {
+    console.log(`@elizaos/core is "${current}", not "${coreVersion}", skipping restore`);
+    process.exit(0);
+  }
+  deps["@elizaos/core"] = "workspace:*";
+  console.log('Set @elizaos/core to "workspace:*"');
+} else {
+  if (current === coreVersion) {
+    console.log(`@elizaos/core already "${coreVersion}"`);
+    process.exit(0);
+  }
+  deps["@elizaos/core"] = coreVersion;
+  console.log(`Set @elizaos/core to "${coreVersion}"`);
+}
+
+await Bun.write(pkgPath, JSON.stringify(pkg, null, 2) + "\n");