@enclave-vm/react 0.0.1 → 2.9.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,288 @@
+# @enclave-vm/react
+
+[![npm version](https://img.shields.io/npm/v/@enclave-vm/react.svg)](https://www.npmjs.com/package/@enclave-vm/react)
+[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
+
+> React hooks and components for the EnclaveJS streaming runtime
+
+The @enclave-vm/react package provides React bindings for EnclaveJS, including hooks for code execution, connection management, and pre-built components for common use cases like code editors and output displays.
+
+## Features
+
+- **React Hooks**: `useEnclave`, `useExecution`, `useSession` hooks
+- **Context Provider**: Share client instance across components
+- **TypeScript Support**: Full type definitions
+- **SSR Compatible**: Works with Next.js and other SSR frameworks
+- **Suspense Ready**: Built-in support for React Suspense
+
+## Installation
+
+```bash
+npm install @enclave-vm/react @enclave-vm/client
+# or
+yarn add @enclave-vm/react @enclave-vm/client
+# or
+pnpm add @enclave-vm/react @enclave-vm/client
+```
+
+## Quick Start
+
+```tsx
+import { EnclaveProvider, useEnclave } from '@enclave-vm/react';
+
+function App() {
+  return (
+    <EnclaveProvider url="wss://runtime.example.com">
+      <CodeRunner />
+    </EnclaveProvider>
+  );
+}
+
+function CodeRunner() {
+  const { execute, isConnected, isExecuting } = useEnclave();
+  const [result, setResult] = useState(null);
+
+  const runCode = async () => {
+    const res = await execute(`
+      const user = await callTool('getUser', { id: 1 });
+      return user.name;
+    `);
+    setResult(res.value);
+  };
+
+  return (
+    <div>
+      <button onClick={runCode} disabled={!isConnected || isExecuting}>
+        {isExecuting ? 'Running...' : 'Run Code'}
+      </button>
+      {result && <div>Result: {result}</div>}
+    </div>
+  );
+}
+```
+
+## Hooks
+
+### useEnclave
+
+Main hook for interacting with the EnclaveJS runtime:
+
+```tsx
+import { useEnclave } from '@enclave-vm/react';
+
+function MyComponent() {
+  const {
+    // Connection
+    isConnected,
+    connect,
+    disconnect,
+
+    // Execution
+    execute,
+    stream,
+    isExecuting,
+
+    // Session
+    sessionId,
+    createSession,
+    destroySession,
+
+    // Events
+    onToolCall,
+    onToolResult,
+    onLog,
+    onError,
+  } = useEnclave();
+
+  // Subscribe to tool calls
+  useEffect(() => {
+    const unsubscribe = onToolCall((call) => {
+      console.log('Tool called:', call.name);
+    });
+    return unsubscribe;
+  }, [onToolCall]);
+
+  return <div>{isConnected ? 'Connected' : 'Disconnected'}</div>;
+}
+```
+
+### useExecution
+
+Hook for managing individual code executions:
+
+```tsx
+import { useExecution } from '@enclave-vm/react';
+
+function ExecutionComponent() {
+  const { execute, result, error, isLoading, toolCalls } = useExecution();
+
+  return (
+    <div>
+      <button onClick={() => execute('return 1 + 1')} disabled={isLoading}>
+        Execute
+      </button>
+
+      {isLoading && <div>Executing...</div>}
+      {error && <div>Error: {error.message}</div>}
+      {result && <div>Result: {JSON.stringify(result.value)}</div>}
+
+      <div>
+        <h3>Tool Calls:</h3>
+        {toolCalls.map((call) => (
+          <div key={call.id}>
+            {call.name}: {JSON.stringify(call.args)}
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}
+```
+
+### useSession
+
+Hook for persistent session management:
+
+```tsx
+import { useSession } from '@enclave-vm/react';
+
+function SessionComponent() {
+  const { session, create, destroy, execute, isActive } = useSession();
+
+  useEffect(() => {
+    create({ timeout: 60000 });
+    return () => destroy();
+  }, []);
+
+  if (!isActive) return <div>No active session</div>;
+
+  return (
+    <div>
+      <div>Session: {session.id}</div>
+      <button onClick={() => execute('return Date.now()')}>Get Time</button>
+    </div>
+  );
+}
+```
+
+## Provider Options
+
+```tsx
+import { EnclaveProvider } from '@enclave-vm/react';
+
+function App() {
+  return (
+    <EnclaveProvider
+      url="wss://runtime.example.com"
+      auth={{ token: 'your-token' }}
+      autoConnect={true}
+      reconnect={{
+        enabled: true,
+        maxAttempts: 5,
+      }}
+      onConnected={() => console.log('Connected!')}
+      onDisconnected={() => console.log('Disconnected')}
+      onError={(error) => console.error(error)}
+    >
+      <App />
+    </EnclaveProvider>
+  );
+}
+```
+
+## Streaming Results
+
+Handle streaming execution with real-time updates:
+
+```tsx
+import { useEnclave } from '@enclave-vm/react';
+
+function StreamingComponent() {
+  const { stream } = useEnclave();
+  const [items, setItems] = useState([]);
+
+  const runStreaming = async () => {
+    setItems([]);
+    await stream(
+      `
+      for (const i of [1, 2, 3, 4, 5]) {
+        const data = await callTool('processItem', { id: i });
+        yield data;
+      }
+    `,
+      {
+        onYield: (value) => {
+          setItems((prev) => [...prev, value]);
+        },
+      },
+    );
+  };
+
+  return (
+    <div>
+      <button onClick={runStreaming}>Start Streaming</button>
+      <ul>
+        {items.map((item, i) => (
+          <li key={i}>{JSON.stringify(item)}</li>
+        ))}
+      </ul>
+    </div>
+  );
+}
+```
+
+## Error Boundaries
+
+Use with React error boundaries:
+
+```tsx
+import { EnclaveErrorBoundary } from '@enclave-vm/react';
+
+function App() {
+  return (
+    <EnclaveErrorBoundary
+      fallback={(error, reset) => (
+        <div>
+          <p>Something went wrong: {error.message}</p>
+          <button onClick={reset}>Try again</button>
+        </div>
+      )}
+    >
+      <CodeRunner />
+    </EnclaveErrorBoundary>
+  );
+}
+```
+
+## Server Components (Next.js)
+
+For Next.js App Router, use client components:
+
+```tsx
+// components/code-runner.tsx
+'use client';
+
+import { EnclaveProvider, useEnclave } from '@enclave-vm/react';
+
+export function CodeRunner() {
+  return (
+    <EnclaveProvider url={process.env.NEXT_PUBLIC_ENCLAVE_URL!}>
+      <RunnerInner />
+    </EnclaveProvider>
+  );
+}
+```
+
+## Related Packages
+
+| Package                                     | Description                       |
+| ------------------------------------------- | --------------------------------- |
+| [@enclave-vm/types](../enclavejs-types)     | Type definitions and Zod schemas  |
+| [@enclave-vm/client](../enclavejs-client)   | Browser/Node.js client SDK        |
+| [@enclave-vm/stream](../enclavejs-stream)   | Streaming protocol implementation |
+| [@enclave-vm/runtime](../enclavejs-runtime) | Standalone runtime worker         |
+
+## License
+
+Apache-2.0

package/esm/index.mjs

@@ -0,0 +1,169 @@
+// libs/enclavejs-react/src/EnclaveProvider.tsx
+import { createContext, useContext, useMemo, useRef } from "react";
+import { EnclaveClient } from "@enclave-vm/client";
+import { jsx } from "react/jsx-runtime";
+var EnclaveContext = createContext(null);
+function EnclaveProvider({
+  config,
+  client: providedClient,
+  children
+}) {
+  const clientRef = useRef(null);
+  const client = useMemo(() => {
+    if (providedClient) {
+      return providedClient;
+    }
+    if (!clientRef.current) {
+      clientRef.current = new EnclaveClient(config);
+    }
+    return clientRef.current;
+  }, [providedClient, config]);
+  const contextValue = useMemo(
+    () => ({
+      client,
+      config
+    }),
+    [client, config]
+  );
+  return /* @__PURE__ */ jsx(EnclaveContext.Provider, { value: contextValue, children });
+}
+function useEnclaveContext() {
+  const context = useContext(EnclaveContext);
+  if (!context) {
+    throw new Error(
+      "useEnclaveContext must be used within an EnclaveProvider. Wrap your component tree with <EnclaveProvider config={{...}}>."
+    );
+  }
+  return context;
+}
+function useEnclaveClient() {
+  const { client } = useEnclaveContext();
+  return client;
+}
+
+// libs/enclavejs-react/src/useEnclaveSession.ts
+import { useState, useCallback, useRef as useRef2 } from "react";
+function useEnclaveSession(options = {}) {
+  const client = useEnclaveClient();
+  const [state, setState] = useState("idle");
+  const [sessionId, setSessionId] = useState(null);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const [stdout, setStdout] = useState("");
+  const [events, setEvents] = useState([]);
+  const handleRef = useRef2(null);
+  const reset = useCallback(() => {
+    setState("idle");
+    setSessionId(null);
+    setResult(null);
+    setError(null);
+    setStdout("");
+    setEvents([]);
+    handleRef.current = null;
+  }, []);
+  const execute = useCallback(
+    async (code) => {
+      setState("running");
+      setResult(null);
+      setError(null);
+      setStdout("");
+      setEvents([]);
+      options.onStart?.();
+      const limits = {};
+      if (options.timeoutMs !== void 0) {
+        limits.sessionTtlMs = options.timeoutMs;
+      }
+      if (options.maxToolCalls !== void 0) {
+        limits.maxToolCalls = options.maxToolCalls;
+      }
+      if (options.heartbeatIntervalMs !== void 0) {
+        limits.heartbeatIntervalMs = options.heartbeatIntervalMs;
+      }
+      const handle = client.executeStream(code, {
+        sessionId: options.sessionId,
+        limits: Object.keys(limits).length > 0 ? limits : void 0,
+        onEvent: (event) => {
+          setEvents((prev) => [...prev, event]);
+        },
+        onStdout: (chunk) => {
+          setStdout((prev) => prev + chunk);
+          options.onStdout?.(chunk);
+        },
+        onLog: (level, message, data) => {
+          options.onLog?.(level, message, data);
+        },
+        onToolCall: (callId, toolName, args) => {
+          options.onToolCall?.(callId, toolName, args);
+        },
+        onToolResultApplied: (callId) => {
+          options.onToolResultApplied?.(callId);
+        },
+        onError: (code2, message) => {
+          options.onError?.({ code: code2, message });
+        }
+      });
+      handleRef.current = handle;
+      setSessionId(handle.sessionId);
+      try {
+        const sessionResult = await handle.wait();
+        if (sessionResult.success) {
+          setState("completed");
+          setResult(sessionResult);
+        } else if (sessionResult.error?.code === "CANCELLED") {
+          setState("cancelled");
+          setResult(sessionResult);
+        } else {
+          setState("error");
+          setResult(sessionResult);
+          setError(sessionResult.error ?? { message: "Unknown error" });
+          options.onError?.(sessionResult.error ?? { message: "Unknown error" });
+        }
+        options.onComplete?.(sessionResult);
+        return sessionResult;
+      } catch (err) {
+        const errorInfo = {
+          code: "UNEXPECTED_ERROR",
+          message: err instanceof Error ? err.message : "Unknown error"
+        };
+        setState("error");
+        setError(errorInfo);
+        options.onError?.(errorInfo);
+        const errorResult = {
+          success: false,
+          sessionId: handle.sessionId,
+          error: errorInfo,
+          events: handle.getEvents()
+        };
+        setResult(errorResult);
+        options.onComplete?.(errorResult);
+        return errorResult;
+      } finally {
+        handleRef.current = null;
+      }
+    },
+    [client, options]
+  );
+  const cancel = useCallback(async (reason) => {
+    if (handleRef.current) {
+      await handleRef.current.cancel(reason);
+    }
+  }, []);
+  return {
+    execute,
+    cancel,
+    state,
+    isRunning: state === "running",
+    sessionId,
+    result,
+    error,
+    stdout,
+    events,
+    reset
+  };
+}
+export {
+  EnclaveProvider,
+  useEnclaveClient,
+  useEnclaveContext,
+  useEnclaveSession
+};

package/esm/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "sideEffects": false,
+  "main": "./index.mjs",
+  "module": "./index.mjs"
+}

package/index.js

@@ -0,0 +1,199 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/enclavejs-react/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EnclaveProvider: () => EnclaveProvider,
+  useEnclaveClient: () => useEnclaveClient,
+  useEnclaveContext: () => useEnclaveContext,
+  useEnclaveSession: () => useEnclaveSession
+});
+module.exports = __toCommonJS(index_exports);
+
+// libs/enclavejs-react/src/EnclaveProvider.tsx
+var import_react = require("react");
+var import_client = require("@enclave-vm/client");
+var import_jsx_runtime = require("react/jsx-runtime");
+var EnclaveContext = (0, import_react.createContext)(null);
+function EnclaveProvider({
+  config,
+  client: providedClient,
+  children
+}) {
+  const clientRef = (0, import_react.useRef)(null);
+  const client = (0, import_react.useMemo)(() => {
+    if (providedClient) {
+      return providedClient;
+    }
+    if (!clientRef.current) {
+      clientRef.current = new import_client.EnclaveClient(config);
+    }
+    return clientRef.current;
+  }, [providedClient, config]);
+  const contextValue = (0, import_react.useMemo)(
+    () => ({
+      client,
+      config
+    }),
+    [client, config]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(EnclaveContext.Provider, { value: contextValue, children });
+}
+function useEnclaveContext() {
+  const context = (0, import_react.useContext)(EnclaveContext);
+  if (!context) {
+    throw new Error(
+      "useEnclaveContext must be used within an EnclaveProvider. Wrap your component tree with <EnclaveProvider config={{...}}>."
+    );
+  }
+  return context;
+}
+function useEnclaveClient() {
+  const { client } = useEnclaveContext();
+  return client;
+}
+
+// libs/enclavejs-react/src/useEnclaveSession.ts
+var import_react2 = require("react");
+function useEnclaveSession(options = {}) {
+  const client = useEnclaveClient();
+  const [state, setState] = (0, import_react2.useState)("idle");
+  const [sessionId, setSessionId] = (0, import_react2.useState)(null);
+  const [result, setResult] = (0, import_react2.useState)(null);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [stdout, setStdout] = (0, import_react2.useState)("");
+  const [events, setEvents] = (0, import_react2.useState)([]);
+  const handleRef = (0, import_react2.useRef)(null);
+  const reset = (0, import_react2.useCallback)(() => {
+    setState("idle");
+    setSessionId(null);
+    setResult(null);
+    setError(null);
+    setStdout("");
+    setEvents([]);
+    handleRef.current = null;
+  }, []);
+  const execute = (0, import_react2.useCallback)(
+    async (code) => {
+      setState("running");
+      setResult(null);
+      setError(null);
+      setStdout("");
+      setEvents([]);
+      options.onStart?.();
+      const limits = {};
+      if (options.timeoutMs !== void 0) {
+        limits.sessionTtlMs = options.timeoutMs;
+      }
+      if (options.maxToolCalls !== void 0) {
+        limits.maxToolCalls = options.maxToolCalls;
+      }
+      if (options.heartbeatIntervalMs !== void 0) {
+        limits.heartbeatIntervalMs = options.heartbeatIntervalMs;
+      }
+      const handle = client.executeStream(code, {
+        sessionId: options.sessionId,
+        limits: Object.keys(limits).length > 0 ? limits : void 0,
+        onEvent: (event) => {
+          setEvents((prev) => [...prev, event]);
+        },
+        onStdout: (chunk) => {
+          setStdout((prev) => prev + chunk);
+          options.onStdout?.(chunk);
+        },
+        onLog: (level, message, data) => {
+          options.onLog?.(level, message, data);
+        },
+        onToolCall: (callId, toolName, args) => {
+          options.onToolCall?.(callId, toolName, args);
+        },
+        onToolResultApplied: (callId) => {
+          options.onToolResultApplied?.(callId);
+        },
+        onError: (code2, message) => {
+          options.onError?.({ code: code2, message });
+        }
+      });
+      handleRef.current = handle;
+      setSessionId(handle.sessionId);
+      try {
+        const sessionResult = await handle.wait();
+        if (sessionResult.success) {
+          setState("completed");
+          setResult(sessionResult);
+        } else if (sessionResult.error?.code === "CANCELLED") {
+          setState("cancelled");
+          setResult(sessionResult);
+        } else {
+          setState("error");
+          setResult(sessionResult);
+          setError(sessionResult.error ?? { message: "Unknown error" });
+          options.onError?.(sessionResult.error ?? { message: "Unknown error" });
+        }
+        options.onComplete?.(sessionResult);
+        return sessionResult;
+      } catch (err) {
+        const errorInfo = {
+          code: "UNEXPECTED_ERROR",
+          message: err instanceof Error ? err.message : "Unknown error"
+        };
+        setState("error");
+        setError(errorInfo);
+        options.onError?.(errorInfo);
+        const errorResult = {
+          success: false,
+          sessionId: handle.sessionId,
+          error: errorInfo,
+          events: handle.getEvents()
+        };
+        setResult(errorResult);
+        options.onComplete?.(errorResult);
+        return errorResult;
+      } finally {
+        handleRef.current = null;
+      }
+    },
+    [client, options]
+  );
+  const cancel = (0, import_react2.useCallback)(async (reason) => {
+    if (handleRef.current) {
+      await handleRef.current.cancel(reason);
+    }
+  }, []);
+  return {
+    execute,
+    cancel,
+    state,
+    isRunning: state === "running",
+    sessionId,
+    result,
+    error,
+    stdout,
+    events,
+    reset
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnclaveProvider,
+  useEnclaveClient,
+  useEnclaveContext,
+  useEnclaveSession
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enclave-vm/react",
-  "version": "0.0.1",
+  "version": "2.9.1",
   "description": "React hooks and components for the EnclaveJS streaming runtime",
   "author": "AgentFront <info@agentfront.dev>",
   "homepage": "https://github.com/agentfront/enclave",
@@ -20,21 +20,22 @@
   "bugs": {
     "url": "https://github.com/agentfront/enclave/issues"
   },
-  "main": "./src/index.js",
-  "types": "./src/index.d.ts",
+  "main": "./index.js",
+  "module": "./esm/index.mjs",
+  "types": "./index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./src/index.d.ts",
-      "import": "./src/index.js",
-      "default": "./src/index.js"
+      "types": "./index.d.ts",
+      "import": "./esm/index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
     }
   },
   "dependencies": {
-    "@enclave-vm/client": "0.0.1"
+    "@enclave-vm/client": "2.9.1"
   },
   "peerDependencies": {
     "react": ">=17.0.0"
-  },
-  "type": "commonjs"
+  }
 }

package/src/EnclaveProvider.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnclaveContext = void 0;
-exports.EnclaveProvider = EnclaveProvider;
-exports.useEnclaveContext = useEnclaveContext;
-exports.useEnclaveClient = useEnclaveClient;
-const jsx_runtime_1 = require("react/jsx-runtime");
-/**
- * EnclaveProvider
- *
- * React context provider for the EnclaveJS client.
- *
- * @packageDocumentation
- */
-const react_1 = require("react");
-const client_1 = require("@enclave-vm/client");
-/**
- * React context for the Enclave client
- */
-const EnclaveContext = (0, react_1.createContext)(null);
-exports.EnclaveContext = EnclaveContext;
-/**
- * EnclaveProvider component
- *
- * Provides the EnclaveClient to child components via React context.
- *
- * @example
- * ```tsx
- * function App() {
- *   return (
- *     <EnclaveProvider config={{ baseUrl: 'https://api.example.com' }}>
- *       <MyComponent />
- *     </EnclaveProvider>
- *   );
- * }
- * ```
- */
-function EnclaveProvider({ config, client: providedClient, children, }) {
-    // Use ref to ensure client is only created once
-    const clientRef = (0, react_1.useRef)(null);
-    // Create or use provided client
-    const client = (0, react_1.useMemo)(() => {
-        if (providedClient) {
-            return providedClient;
-        }
-        // Create new client if not already created
-        if (!clientRef.current) {
-            clientRef.current = new client_1.EnclaveClient(config);
-        }
-        return clientRef.current;
-    }, [providedClient, config]);
-    // Memoize context value
-    const contextValue = (0, react_1.useMemo)(() => ({
-        client,
-        config,
-    }), [client, config]);
-    return (0, jsx_runtime_1.jsx)(EnclaveContext.Provider, { value: contextValue, children: children });
-}
-/**
- * useEnclaveContext hook
- *
- * Access the Enclave context directly. Throws if used outside EnclaveProvider.
- *
- * @internal
- */
-function useEnclaveContext() {
-    const context = (0, react_1.useContext)(EnclaveContext);
-    if (!context) {
-        throw new Error('useEnclaveContext must be used within an EnclaveProvider. ' +
-            'Wrap your component tree with <EnclaveProvider config={{...}}>.');
-    }
-    return context;
-}
-/**
- * useEnclaveClient hook
- *
- * Get the EnclaveClient instance from context.
- *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const client = useEnclaveClient();
- *
- *   const handleClick = async () => {
- *     const result = await client.execute('return 1 + 1');
- *     console.log(result.value);
- *   };
- *
- *   return <button onClick={handleClick}>Execute</button>;
- * }
- * ```
- */
-function useEnclaveClient() {
-    const { client } = useEnclaveContext();
-    return client;
-}
-//# sourceMappingURL=EnclaveProvider.js.map

package/src/EnclaveProvider.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EnclaveProvider.js","sourceRoot":"","sources":["../../src/EnclaveProvider.tsx"],"names":[],"mappings":";;;AAiCA,0CAgCC;AASD,8CAWC;AAqBD,4CAGC;;AA7GD;;;;;;GAMG;AAEH,iCAA0E;AAC1E,+CAAmD;AAGnD;;GAEG;AACH,MAAM,cAAc,GAAG,IAAA,qBAAa,EAA6B,IAAI,CAAC,CAAC;AAgG9D,wCAAc;AA9FvB;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,eAAe,CAAC,EAC9B,MAAM,EACN,MAAM,EAAE,cAAc,EACtB,QAAQ,GACa;IACrB,gDAAgD;IAChD,MAAM,SAAS,GAAG,IAAA,cAAM,EAAuB,IAAI,CAAC,CAAC;IAErD,gCAAgC;IAChC,MAAM,MAAM,GAAG,IAAA,eAAO,EAAC,GAAG,EAAE;QAC1B,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO,cAAc,CAAC;QACxB,CAAC;QAED,2CAA2C;QAC3C,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;YACvB,SAAS,CAAC,OAAO,GAAG,IAAI,sBAAa,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC;QAED,OAAO,SAAS,CAAC,OAAO,CAAC;IAC3B,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;IAE7B,wBAAwB;IACxB,MAAM,YAAY,GAAG,IAAA,eAAO,EAC1B,GAAG,EAAE,CAAC,CAAC;QACL,MAAM;QACN,MAAM;KACP,CAAC,EACF,CAAC,MAAM,EAAE,MAAM,CAAC,CACjB,CAAC;IAEF,OAAO,uBAAC,cAAc,CAAC,QAAQ,IAAC,KAAK,EAAE,YAAY,YAAG,QAAQ,GAA2B,CAAC;AAC5F,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,iBAAiB;IAC/B,MAAM,OAAO,GAAG,IAAA,kBAAU,EAAC,cAAc,CAAC,CAAC;IAE3C,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,4DAA4D;YAC1D,iEAAiE,CACpE,CAAC;IACJ,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,gBAAgB;IAC9B,MAAM,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CAAC;IACvC,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["/**\n * EnclaveProvider\n *\n * React context provider for the EnclaveJS client.\n *\n * @packageDocumentation\n */\n\nimport React, { createContext, useContext, useMemo, useRef } from 'react';\nimport { EnclaveClient } from '@enclave-vm/client';\nimport type { EnclaveProviderProps, EnclaveContextValue } from './types.js';\n\n/**\n * React context for the Enclave client\n */\nconst EnclaveContext = createContext<EnclaveContextValue | null>(null);\n\n/**\n * EnclaveProvider component\n *\n * Provides the EnclaveClient to child components via React context.\n *\n * @example\n * ```tsx\n * function App() {\n *   return (\n *     <EnclaveProvider config={{ baseUrl: 'https://api.example.com' }}>\n *       <MyComponent />\n *     </EnclaveProvider>\n *   );\n * }\n * ```\n */\nexport function EnclaveProvider({\n  config,\n  client: providedClient,\n  children,\n}: EnclaveProviderProps): React.ReactElement {\n  // Use ref to ensure client is only created once\n  const clientRef = useRef<EnclaveClient | null>(null);\n\n  // Create or use provided client\n  const client = useMemo(() => {\n    if (providedClient) {\n      return providedClient;\n    }\n\n    // Create new client if not already created\n    if (!clientRef.current) {\n      clientRef.current = new EnclaveClient(config);\n    }\n\n    return clientRef.current;\n  }, [providedClient, config]);\n\n  // Memoize context value\n  const contextValue = useMemo<EnclaveContextValue>(\n    () => ({\n      client,\n      config,\n    }),\n    [client, config],\n  );\n\n  return <EnclaveContext.Provider value={contextValue}>{children}</EnclaveContext.Provider>;\n}\n\n/**\n * useEnclaveContext hook\n *\n * Access the Enclave context directly. Throws if used outside EnclaveProvider.\n *\n * @internal\n */\nexport function useEnclaveContext(): EnclaveContextValue {\n  const context = useContext(EnclaveContext);\n\n  if (!context) {\n    throw new Error(\n      'useEnclaveContext must be used within an EnclaveProvider. ' +\n        'Wrap your component tree with <EnclaveProvider config={{...}}>.',\n    );\n  }\n\n  return context;\n}\n\n/**\n * useEnclaveClient hook\n *\n * Get the EnclaveClient instance from context.\n *\n * @example\n * ```tsx\n * function MyComponent() {\n *   const client = useEnclaveClient();\n *\n *   const handleClick = async () => {\n *     const result = await client.execute('return 1 + 1');\n *     console.log(result.value);\n *   };\n *\n *   return <button onClick={handleClick}>Execute</button>;\n * }\n * ```\n */\nexport function useEnclaveClient(): EnclaveClient {\n  const { client } = useEnclaveContext();\n  return client;\n}\n\nexport { EnclaveContext };\n"]}

package/src/index.js

@@ -1,19 +0,0 @@
-"use strict";
-/**
- * @enclave-vm/react
- *
- * React hooks and components for the EnclaveJS streaming runtime.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useEnclaveSession = exports.useEnclaveContext = exports.useEnclaveClient = exports.EnclaveProvider = void 0;
-// Provider and context
-var EnclaveProvider_js_1 = require("./EnclaveProvider.js");
-Object.defineProperty(exports, "EnclaveProvider", { enumerable: true, get: function () { return EnclaveProvider_js_1.EnclaveProvider; } });
-Object.defineProperty(exports, "useEnclaveClient", { enumerable: true, get: function () { return EnclaveProvider_js_1.useEnclaveClient; } });
-Object.defineProperty(exports, "useEnclaveContext", { enumerable: true, get: function () { return EnclaveProvider_js_1.useEnclaveContext; } });
-// Hooks
-var useEnclaveSession_js_1 = require("./useEnclaveSession.js");
-Object.defineProperty(exports, "useEnclaveSession", { enumerable: true, get: function () { return useEnclaveSession_js_1.useEnclaveSession; } });
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;;AAEH,uBAAuB;AACvB,2DAA4F;AAAnF,qHAAA,eAAe,OAAA;AAAE,sHAAA,gBAAgB,OAAA;AAAE,uHAAA,iBAAiB,OAAA;AAE7D,QAAQ;AACR,+DAA2D;AAAlD,yHAAA,iBAAiB,OAAA","sourcesContent":["/**\n * @enclave-vm/react\n *\n * React hooks and components for the EnclaveJS streaming runtime.\n *\n * @packageDocumentation\n */\n\n// Provider and context\nexport { EnclaveProvider, useEnclaveClient, useEnclaveContext } from './EnclaveProvider.js';\n\n// Hooks\nexport { useEnclaveSession } from './useEnclaveSession.js';\n\n// Types\nexport type {\n  SessionState,\n  UseEnclaveSessionOptions,\n  UseEnclaveSessionReturn,\n  EnclaveProviderProps,\n  EnclaveContextValue,\n} from './types.js';\n\n// Re-export commonly used types from @enclave-vm/client\nexport type {\n  EnclaveClient,\n  EnclaveClientConfig,\n  SessionResult,\n  SessionHandle,\n  StreamEvent,\n  SessionId,\n} from '@enclave-vm/client';\n"]}

package/src/test-setup.js

@@ -1,7 +0,0 @@
-"use strict";
-/**
- * Test setup for React Testing Library
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-require("@testing-library/jest-dom");
-//# sourceMappingURL=test-setup.js.map

package/src/test-setup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-setup.js","sourceRoot":"","sources":["../../src/test-setup.ts"],"names":[],"mappings":";AAAA;;GAEG;;AAEH,qCAAmC","sourcesContent":["/**\n * Test setup for React Testing Library\n */\n\nimport '@testing-library/jest-dom';\n"]}

package/src/types.js

@@ -1,10 +0,0 @@
-"use strict";
-/**
- * React Types
- *
- * Types for the EnclaveJS React hooks and components.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/src/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG","sourcesContent":["/**\n * React Types\n *\n * Types for the EnclaveJS React hooks and components.\n *\n * @packageDocumentation\n */\n\nimport type { EnclaveClient, EnclaveClientConfig, SessionResult, StreamEvent, SessionId } from '@enclave-vm/client';\n\n/**\n * Session state enum\n */\nexport type SessionState = 'idle' | 'running' | 'completed' | 'error' | 'cancelled';\n\n/**\n * useEnclaveSession hook options\n */\nexport interface UseEnclaveSessionOptions {\n  /**\n   * Custom session ID (generated if not provided)\n   */\n  sessionId?: SessionId;\n\n  /**\n   * Session timeout in milliseconds\n   */\n  timeoutMs?: number;\n\n  /**\n   * Maximum number of tool calls\n   */\n  maxToolCalls?: number;\n\n  /**\n   * Heartbeat interval in milliseconds\n   */\n  heartbeatIntervalMs?: number;\n\n  /**\n   * Callback when session starts\n   */\n  onStart?: () => void;\n\n  /**\n   * Callback for stdout output\n   */\n  onStdout?: (chunk: string) => void;\n\n  /**\n   * Callback for log messages\n   */\n  onLog?: (level: string, message: string, data?: Record<string, unknown>) => void;\n\n  /**\n   * Callback for tool calls\n   */\n  onToolCall?: (callId: string, toolName: string, args: unknown) => void;\n\n  /**\n   * Callback when tool result is applied\n   */\n  onToolResultApplied?: (callId: string) => void;\n\n  /**\n   * Callback on completion\n   */\n  onComplete?: (result: SessionResult) => void;\n\n  /**\n   * Callback on error\n   */\n  onError?: (error: { code?: string; message: string }) => void;\n}\n\n/**\n * useEnclaveSession hook return type\n */\nexport interface UseEnclaveSessionReturn<T = unknown> {\n  /**\n   * Execute code in the enclave\n   */\n  execute: (code: string) => Promise<SessionResult<T>>;\n\n  /**\n   * Cancel the current session\n   */\n  cancel: (reason?: string) => Promise<void>;\n\n  /**\n   * Current session state\n   */\n  state: SessionState;\n\n  /**\n   * Whether a session is currently running\n   */\n  isRunning: boolean;\n\n  /**\n   * Current session ID (if running)\n   */\n  sessionId: SessionId | null;\n\n  /**\n   * Result of the last execution (if completed)\n   */\n  result: SessionResult<T> | null;\n\n  /**\n   * Error from the last execution (if failed)\n   */\n  error: { code?: string; message: string } | null;\n\n  /**\n   * Stdout output accumulated during execution\n   */\n  stdout: string;\n\n  /**\n   * Events received during execution\n   */\n  events: StreamEvent[];\n\n  /**\n   * Reset the hook state\n   */\n  reset: () => void;\n}\n\n/**\n * EnclaveProvider props\n */\nexport interface EnclaveProviderProps {\n  /**\n   * Client configuration\n   */\n  config: EnclaveClientConfig;\n\n  /**\n   * Pre-created client instance (alternative to config)\n   */\n  client?: EnclaveClient;\n\n  /**\n   * Children to render\n   */\n  children: React.ReactNode;\n}\n\n/**\n * Enclave context value\n */\nexport interface EnclaveContextValue {\n  /**\n   * The EnclaveClient instance\n   */\n  client: EnclaveClient;\n\n  /**\n   * Client configuration\n   */\n  config: EnclaveClientConfig;\n}\n"]}

package/src/useEnclaveSession.js

@@ -1,181 +0,0 @@
-"use strict";
-/**
- * useEnclaveSession Hook
- *
- * React hook for executing code in the EnclaveJS runtime with state management.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useEnclaveSession = useEnclaveSession;
-const react_1 = require("react");
-const EnclaveProvider_js_1 = require("./EnclaveProvider.js");
-/**
- * useEnclaveSession hook
- *
- * Provides a stateful interface for executing code in the Enclave runtime.
- *
- * @example
- * ```tsx
- * function Calculator() {
- *   const { execute, isRunning, result, stdout } = useEnclaveSession({
- *     onStdout: (chunk) => console.log(chunk),
- *   });
- *
- *   const calculate = async () => {
- *     const result = await execute('return 1 + 1');
- *     console.log('Result:', result.value);
- *   };
- *
- *   return (
- *     <div>
- *       <button onClick={calculate} disabled={isRunning}>
- *         Calculate
- *       </button>
- *       {result && <p>Result: {JSON.stringify(result.value)}</p>}
- *       <pre>{stdout}</pre>
- *     </div>
- *   );
- * }
- * ```
- */
-function useEnclaveSession(options = {}) {
-    const client = (0, EnclaveProvider_js_1.useEnclaveClient)();
-    // State
-    const [state, setState] = (0, react_1.useState)('idle');
-    const [sessionId, setSessionId] = (0, react_1.useState)(null);
-    const [result, setResult] = (0, react_1.useState)(null);
-    const [error, setError] = (0, react_1.useState)(null);
-    const [stdout, setStdout] = (0, react_1.useState)('');
-    const [events, setEvents] = (0, react_1.useState)([]);
-    // Refs for current session handle
-    const handleRef = (0, react_1.useRef)(null);
-    /**
-     * Reset the hook state
-     */
-    const reset = (0, react_1.useCallback)(() => {
-        setState('idle');
-        setSessionId(null);
-        setResult(null);
-        setError(null);
-        setStdout('');
-        setEvents([]);
-        handleRef.current = null;
-    }, []);
-    /**
-     * Execute code in the enclave
-     */
-    const execute = (0, react_1.useCallback)(async (code) => {
-        // Reset state for new execution
-        setState('running');
-        setResult(null);
-        setError(null);
-        setStdout('');
-        setEvents([]);
-        // Call onStart callback
-        options.onStart?.();
-        // Build limits from options
-        const limits = {};
-        if (options.timeoutMs !== undefined) {
-            limits.sessionTtlMs = options.timeoutMs;
-        }
-        if (options.maxToolCalls !== undefined) {
-            limits.maxToolCalls = options.maxToolCalls;
-        }
-        if (options.heartbeatIntervalMs !== undefined) {
-            limits.heartbeatIntervalMs = options.heartbeatIntervalMs;
-        }
-        // Start streaming execution
-        const handle = client.executeStream(code, {
-            sessionId: options.sessionId,
-            limits: Object.keys(limits).length > 0 ? limits : undefined,
-            onEvent: (event) => {
-                setEvents((prev) => [...prev, event]);
-            },
-            onStdout: (chunk) => {
-                setStdout((prev) => prev + chunk);
-                options.onStdout?.(chunk);
-            },
-            onLog: (level, message, data) => {
-                options.onLog?.(level, message, data);
-            },
-            onToolCall: (callId, toolName, args) => {
-                options.onToolCall?.(callId, toolName, args);
-            },
-            onToolResultApplied: (callId) => {
-                options.onToolResultApplied?.(callId);
-            },
-            onError: (code, message) => {
-                options.onError?.({ code, message });
-            },
-        });
-        handleRef.current = handle;
-        setSessionId(handle.sessionId);
-        try {
-            // Wait for completion
-            const sessionResult = (await handle.wait());
-            // Update state based on result
-            if (sessionResult.success) {
-                setState('completed');
-                setResult(sessionResult);
-            }
-            else if (sessionResult.error?.code === 'CANCELLED') {
-                setState('cancelled');
-                setResult(sessionResult);
-            }
-            else {
-                setState('error');
-                setResult(sessionResult);
-                setError(sessionResult.error ?? { message: 'Unknown error' });
-                options.onError?.(sessionResult.error ?? { message: 'Unknown error' });
-            }
-            // Call onComplete callback
-            options.onComplete?.(sessionResult);
-            return sessionResult;
-        }
-        catch (err) {
-            // Handle unexpected errors
-            const errorInfo = {
-                code: 'UNEXPECTED_ERROR',
-                message: err instanceof Error ? err.message : 'Unknown error',
-            };
-            setState('error');
-            setError(errorInfo);
-            options.onError?.(errorInfo);
-            // Return error result
-            const errorResult = {
-                success: false,
-                sessionId: handle.sessionId,
-                error: errorInfo,
-                events: handle.getEvents(),
-            };
-            setResult(errorResult);
-            options.onComplete?.(errorResult);
-            return errorResult;
-        }
-        finally {
-            handleRef.current = null;
-        }
-    }, [client, options]);
-    /**
-     * Cancel the current session
-     */
-    const cancel = (0, react_1.useCallback)(async (reason) => {
-        if (handleRef.current) {
-            await handleRef.current.cancel(reason);
-        }
-    }, []);
-    return {
-        execute,
-        cancel,
-        state,
-        isRunning: state === 'running',
-        sessionId,
-        result,
-        error,
-        stdout,
-        events,
-        reset,
-    };
-}
-//# sourceMappingURL=useEnclaveSession.js.map

package/src/useEnclaveSession.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useEnclaveSession.js","sourceRoot":"","sources":["../../src/useEnclaveSession.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * useEnclaveSession Hook\n *\n * React hook for executing code in the EnclaveJS runtime with state management.\n *\n * @packageDocumentation\n */\n\nimport { useState, useCallback, useRef } from 'react';\nimport type { SessionResult, SessionHandle, StreamEvent, SessionId } from '@enclave-vm/client';\nimport { useEnclaveClient } from './EnclaveProvider.js';\nimport type { SessionState, UseEnclaveSessionOptions, UseEnclaveSessionReturn } from './types.js';\n\n/**\n * useEnclaveSession hook\n *\n * Provides a stateful interface for executing code in the Enclave runtime.\n *\n * @example\n * ```tsx\n * function Calculator() {\n *   const { execute, isRunning, result, stdout } = useEnclaveSession({\n *     onStdout: (chunk) => console.log(chunk),\n *   });\n *\n *   const calculate = async () => {\n *     const result = await execute('return 1 + 1');\n *     console.log('Result:', result.value);\n *   };\n *\n *   return (\n *     <div>\n *       <button onClick={calculate} disabled={isRunning}>\n *         Calculate\n *       </button>\n *       {result && <p>Result: {JSON.stringify(result.value)}</p>}\n *       <pre>{stdout}</pre>\n *     </div>\n *   );\n * }\n * ```\n */\nexport function useEnclaveSession<T = unknown>(options: UseEnclaveSessionOptions = {}): UseEnclaveSessionReturn<T> {\n  const client = useEnclaveClient();\n\n  // State\n  const [state, setState] = useState<SessionState>('idle');\n  const [sessionId, setSessionId] = useState<SessionId | null>(null);\n  const [result, setResult] = useState<SessionResult<T> | null>(null);\n  const [error, setError] = useState<{ code?: string; message: string } | null>(null);\n  const [stdout, setStdout] = useState<string>('');\n  const [events, setEvents] = useState<StreamEvent[]>([]);\n\n  // Refs for current session handle\n  const handleRef = useRef<SessionHandle | null>(null);\n\n  /**\n   * Reset the hook state\n   */\n  const reset = useCallback(() => {\n    setState('idle');\n    setSessionId(null);\n    setResult(null);\n    setError(null);\n    setStdout('');\n    setEvents([]);\n    handleRef.current = null;\n  }, []);\n\n  /**\n   * Execute code in the enclave\n   */\n  const execute = useCallback(\n    async (code: string): Promise<SessionResult<T>> => {\n      // Reset state for new execution\n      setState('running');\n      setResult(null);\n      setError(null);\n      setStdout('');\n      setEvents([]);\n\n      // Call onStart callback\n      options.onStart?.();\n\n      // Build limits from options\n      const limits: Record<string, number> = {};\n      if (options.timeoutMs !== undefined) {\n        limits.sessionTtlMs = options.timeoutMs;\n      }\n      if (options.maxToolCalls !== undefined) {\n        limits.maxToolCalls = options.maxToolCalls;\n      }\n      if (options.heartbeatIntervalMs !== undefined) {\n        limits.heartbeatIntervalMs = options.heartbeatIntervalMs;\n      }\n\n      // Start streaming execution\n      const handle = client.executeStream(code, {\n        sessionId: options.sessionId,\n        limits: Object.keys(limits).length > 0 ? limits : undefined,\n        onEvent: (event) => {\n          setEvents((prev) => [...prev, event]);\n        },\n        onStdout: (chunk) => {\n          setStdout((prev) => prev + chunk);\n          options.onStdout?.(chunk);\n        },\n        onLog: (level, message, data) => {\n          options.onLog?.(level, message, data);\n        },\n        onToolCall: (callId, toolName, args) => {\n          options.onToolCall?.(callId, toolName, args);\n        },\n        onToolResultApplied: (callId) => {\n          options.onToolResultApplied?.(callId);\n        },\n        onError: (code, message) => {\n          options.onError?.({ code, message });\n        },\n      });\n\n      handleRef.current = handle;\n      setSessionId(handle.sessionId);\n\n      try {\n        // Wait for completion\n        const sessionResult = (await handle.wait()) as SessionResult<T>;\n\n        // Update state based on result\n        if (sessionResult.success) {\n          setState('completed');\n          setResult(sessionResult);\n        } else if (sessionResult.error?.code === 'CANCELLED') {\n          setState('cancelled');\n          setResult(sessionResult);\n        } else {\n          setState('error');\n          setResult(sessionResult);\n          setError(sessionResult.error ?? { message: 'Unknown error' });\n          options.onError?.(sessionResult.error ?? { message: 'Unknown error' });\n        }\n\n        // Call onComplete callback\n        options.onComplete?.(sessionResult);\n\n        return sessionResult;\n      } catch (err) {\n        // Handle unexpected errors\n        const errorInfo = {\n          code: 'UNEXPECTED_ERROR',\n          message: err instanceof Error ? err.message : 'Unknown error',\n        };\n\n        setState('error');\n        setError(errorInfo);\n        options.onError?.(errorInfo);\n\n        // Return error result\n        const errorResult: SessionResult<T> = {\n          success: false,\n          sessionId: handle.sessionId,\n          error: errorInfo,\n          events: handle.getEvents(),\n        };\n\n        setResult(errorResult);\n        options.onComplete?.(errorResult);\n\n        return errorResult;\n      } finally {\n        handleRef.current = null;\n      }\n    },\n    [client, options],\n  );\n\n  /**\n   * Cancel the current session\n   */\n  const cancel = useCallback(async (reason?: string): Promise<void> => {\n    if (handleRef.current) {\n      await handleRef.current.cancel(reason);\n    }\n  }, []);\n\n  return {\n    execute,\n    cancel,\n    state,\n    isRunning: state === 'running',\n    sessionId,\n    result,\n    error,\n    stdout,\n    events,\n    reset,\n  };\n}\n"]}