@springbrand/agent-runtime 0.1.3-alpha.3 → 0.1.3-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/agent-runtime",
-  "version": "0.1.3-alpha.3",
+  "version": "0.1.3-alpha.5",
   "type": "module",
   "files": [
     "src",
@@ -11,11 +11,13 @@
   },
   "exports": {
     ".": "./src/index.ts",
+    "./adapter/cloudflare": "./src/adapter/cloudflare/index.ts",
     "./contracts": "./src/kernel/public-contracts.ts",
     "./models": "./src/lib/model-catalog.ts"
   },
   "dependencies": {
     "@cloudflare/codemode": "0.5.0",
+    "@cloudflare/sandbox": "0.12.4",
     "@cloudflare/shell": "0.4.3",
     "@cloudflare/think": "0.15.0",
     "@earendil-works/pi-agent-core": "0.83.0",

package/src/adapter/cloudflare/index.ts

@@ -0,0 +1,60 @@
+export {
+  defineCloudflareUniversalAgent,
+  type CloudflareUniversalAgentClass,
+  type CloudflareUniversalAgentInstance,
+} from "./universal-agent/definition";
+export {
+  createPlatformLoader,
+  createWorkspaceLoader,
+  prepareMemory,
+  prepareSandbox,
+  prepareSubagents,
+  prepareWorkspace,
+  workspaceRequired,
+  type CloudflarePlatformBindings,
+  type PlatformLoader,
+  type WorkspaceLoader,
+  type WorkspaceRequirement,
+} from "./universal-agent/preparation";
+export {
+  assembleUniversalAgentTools,
+  selectTools,
+} from "./universal-agent/tools";
+export { createUniversalAgentHooks } from "./universal-agent/hooks";
+
+export {
+  CloudflareSandboxAdapter,
+  createCloudflareSandboxAdapter,
+  type CloudflareSandboxAdapterOptions,
+  type SandboxAdmission,
+  type SandboxObserver,
+} from "./sandbox/adapter";
+export { sandboxIdForSession } from "./sandbox/id";
+export { SANDBOX_HOST_POLICY } from "./sandbox/policy";
+
+export {
+  createWorkspacePortFacade,
+  ScopedWorkspace,
+} from "./workspace/scoped-workspace";
+export type {
+  WorkspaceConditionalWriteResult,
+  WorkspaceFileVersion,
+  WorkspacePublishPort,
+} from "./workspace/publisher";
+
+export {
+  CloudflareSubAgent,
+  type CloudflareSubAgentExecution,
+} from "./subagent/definition";
+export {
+  runCloudflareSubAgent,
+  type CloudflareSubAgentRun,
+} from "./subagent/runner";
+export { createCloudflareSubAgentTools } from "./subagent/tools";
+
+export {
+  createR2SkillSource,
+  prepareRuntimeExtensions,
+  readVerifiedR2Text,
+  type CloudflareRuntimeExtensionSource,
+} from "./resources/runtime-resources";

package/src/adapter/cloudflare/resources/runtime-resources.ts

@@ -0,0 +1,86 @@
+import { r2, type SkillSource } from "agents/skills";
+import type { RuntimeDegradation } from "../../../kernel/degradation";
+import type { RuntimeExtensionConfig } from "../../../kernel/extensions";
+import type { RuntimeExtensionContribution } from "../../../runtime-definition";
+
+export interface CloudflareRuntimeExtensionSource {
+  readonly name: string;
+  readonly manifest: RuntimeExtensionConfig["manifest"];
+  readonly sourceRef: string;
+  readonly sourceHash: string;
+}
+
+function trimSlashes(value: string): string {
+  return value.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+function hex(bytes: ArrayBuffer): string {
+  return [...new Uint8Array(bytes)]
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+export function createR2SkillSource(
+  bucket: R2Bucket,
+  resourceId: string,
+  contentHash: string,
+  contentRef: string,
+): SkillSource {
+  return r2(bucket, {
+    prefix: `${trimSlashes(contentRef)}/`,
+    id: `resource-${resourceId}-${contentHash}`,
+    fingerprint: "metadata",
+  });
+}
+
+export async function readVerifiedR2Text(
+  bucket: R2Bucket,
+  sourceRef: string,
+  sourceHash: string,
+): Promise<string> {
+  const object = await bucket.get(sourceRef);
+  if (!object) throw new Error(`Runtime content not found: ${sourceRef}`);
+  const source = await object.text();
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(source),
+  );
+  if (hex(digest) !== sourceHash) {
+    throw new Error(`Runtime content hash mismatch: ${sourceRef}`);
+  }
+  return source;
+}
+
+export async function prepareRuntimeExtensions(
+  extensions: readonly CloudflareRuntimeExtensionSource[],
+  readSource: (
+    sourceRef: string,
+    sourceHash: string,
+  ) => Promise<string>,
+): Promise<{
+  extensions: RuntimeExtensionContribution[];
+  degradations: RuntimeDegradation[];
+}> {
+  const loaded: RuntimeExtensionContribution[] = [];
+  const degradations: RuntimeDegradation[] = [];
+
+  for (const selected of extensions) {
+    try {
+      const extension: RuntimeExtensionConfig = {
+        manifest: selected.manifest,
+        source: await readSource(selected.sourceRef, selected.sourceHash),
+      };
+      if (extension.manifest.name !== selected.name) {
+        throw new Error("manifest name mismatch");
+      }
+      loaded.push({ name: selected.name, extension });
+    } catch {
+      degradations.push({
+        capability: "extension",
+        reason: "unavailable",
+        detail: selected.name,
+      });
+    }
+  }
+  return { extensions: loaded, degradations };
+}