@maximem/synap-js-sdk 0.2.0 → 0.2.1

package/bridge/synap_bridge.py

@@ -709,7 +709,7 @@ async def main() -> None:
             write_response({"id": req_id, "result": result, "error": None})
         except Exception as exc:
             logger.error("Handler error for %s: %s", method, traceback.format_exc())
-            write_response({"id": req_id, "result": None, "error": str(exc)})
+            write_response({"id": req_id, "result": None, "error": str(exc), "error_type": type(exc).__name__})
 
 
 if __name__ == "__main__":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maximem/synap-js-sdk",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "JavaScript wrapper around the Synap Python SDK",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/bridge-manager.js

@@ -7,6 +7,7 @@ const {
   resolveInstanceId,
   setupPythonRuntime,
 } = require('./runtime');
+const { createSynapError } = require('./errors');
 
 class BridgeManager {
   constructor(options = {}) {
@@ -147,7 +148,7 @@ class BridgeManager {
       this.pending.delete(payload.id);
 
       if (payload.error) {
-        pending.reject(new Error(payload.error));
+        pending.reject(createSynapError(payload.error, payload.error_type));
       } else {
         pending.resolve(payload.result);
       }

package/src/errors.js

@@ -0,0 +1,187 @@
+'use strict';
+
+class SynapError extends Error {
+  constructor(message, correlationId) {
+    super(message);
+    this.name = 'SynapError';
+    this.correlationId = correlationId || null;
+  }
+}
+
+class SynapTransientError extends SynapError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'SynapTransientError';
+  }
+}
+
+class SynapPermanentError extends SynapError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'SynapPermanentError';
+  }
+}
+
+class NetworkTimeoutError extends SynapTransientError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'NetworkTimeoutError';
+  }
+}
+
+class RateLimitError extends SynapTransientError {
+  constructor(message, retryAfterSeconds, correlationId) {
+    super(message, correlationId);
+    this.name = 'RateLimitError';
+    this.retryAfterSeconds = retryAfterSeconds || null;
+  }
+}
+
+class ServiceUnavailableError extends SynapTransientError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'ServiceUnavailableError';
+  }
+}
+
+class AgentUnavailableError extends SynapTransientError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'AgentUnavailableError';
+  }
+}
+
+class InvalidInputError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'InvalidInputError';
+  }
+}
+
+class InvalidInstanceIdError extends InvalidInputError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'InvalidInstanceIdError';
+  }
+}
+
+class InvalidConversationIdError extends InvalidInputError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'InvalidConversationIdError';
+  }
+}
+
+class AuthenticationError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'AuthenticationError';
+  }
+}
+
+class CertificateExpiredError extends AuthenticationError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'CertificateExpiredError';
+  }
+}
+
+class CertificateRenewalError extends AuthenticationError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'CertificateRenewalError';
+  }
+}
+
+class BootstrapKeyInvalidError extends AuthenticationError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'BootstrapKeyInvalidError';
+  }
+}
+
+class BootstrapError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'BootstrapError';
+  }
+}
+
+class ContextNotFoundError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'ContextNotFoundError';
+  }
+}
+
+class SessionExpiredError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'SessionExpiredError';
+  }
+}
+
+class ListeningAlreadyActiveError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'ListeningAlreadyActiveError';
+  }
+}
+
+class ListeningNotActiveError extends SynapPermanentError {
+  constructor(message, correlationId) {
+    super(message, correlationId);
+    this.name = 'ListeningNotActiveError';
+  }
+}
+
+const ERROR_MAP = {
+  SynapError,
+  SynapTransientError,
+  SynapPermanentError,
+  NetworkTimeoutError,
+  RateLimitError,
+  ServiceUnavailableError,
+  AgentUnavailableError,
+  InvalidInputError,
+  InvalidInstanceIdError,
+  InvalidConversationIdError,
+  AuthenticationError,
+  CertificateExpiredError,
+  CertificateRenewalError,
+  BootstrapKeyInvalidError,
+  BootstrapError,
+  ContextNotFoundError,
+  SessionExpiredError,
+  ListeningAlreadyActiveError,
+  ListeningNotActiveError,
+};
+
+function createSynapError(message, errorType) {
+  const ErrorClass = ERROR_MAP[errorType];
+  if (ErrorClass) return new ErrorClass(message);
+  return new SynapError(message);
+}
+
+module.exports = {
+  SynapError,
+  SynapTransientError,
+  SynapPermanentError,
+  NetworkTimeoutError,
+  RateLimitError,
+  ServiceUnavailableError,
+  AgentUnavailableError,
+  InvalidInputError,
+  InvalidInstanceIdError,
+  InvalidConversationIdError,
+  AuthenticationError,
+  CertificateExpiredError,
+  CertificateRenewalError,
+  BootstrapKeyInvalidError,
+  BootstrapError,
+  ContextNotFoundError,
+  SessionExpiredError,
+  ListeningAlreadyActiveError,
+  ListeningNotActiveError,
+  createSynapError,
+};

package/src/index.js

@@ -1,6 +1,7 @@
 const { SynapClient } = require('./synap-client');
 const { setupPythonRuntime, resolveInstanceId } = require('./runtime');
 const { setupTypeScriptExtension } = require('./setup-typescript');
+const errors = require('./errors');
 
 module.exports = {
   SynapClient,
@@ -8,4 +9,5 @@ module.exports = {
   setupPythonRuntime,
   setupTypeScriptExtension,
   resolveInstanceId,
+  ...errors,
 };

package/types/index.d.ts

@@ -352,6 +352,33 @@ export interface SetupTypeScriptExtensionResult {
   wrapperCreated: boolean;
 }
 
+// Error classes
+export class SynapError extends Error {
+  correlationId: string | null;
+  constructor(message: string, correlationId?: string);
+}
+export class SynapTransientError extends SynapError {}
+export class SynapPermanentError extends SynapError {}
+export class NetworkTimeoutError extends SynapTransientError {}
+export class RateLimitError extends SynapTransientError {
+  retryAfterSeconds: number | null;
+  constructor(message: string, retryAfterSeconds?: number, correlationId?: string);
+}
+export class ServiceUnavailableError extends SynapTransientError {}
+export class AgentUnavailableError extends SynapTransientError {}
+export class InvalidInputError extends SynapPermanentError {}
+export class InvalidInstanceIdError extends InvalidInputError {}
+export class InvalidConversationIdError extends InvalidInputError {}
+export class AuthenticationError extends SynapPermanentError {}
+export class CertificateExpiredError extends AuthenticationError {}
+export class CertificateRenewalError extends AuthenticationError {}
+export class BootstrapKeyInvalidError extends AuthenticationError {}
+export class BootstrapError extends SynapPermanentError {}
+export class ContextNotFoundError extends SynapPermanentError {}
+export class SessionExpiredError extends SynapPermanentError {}
+export class ListeningAlreadyActiveError extends SynapPermanentError {}
+export class ListeningNotActiveError extends SynapPermanentError {}
+
 export function createClient(options?: SynapClientOptions): SynapClient;
 export function resolveInstanceId(explicitInstanceId?: string): string;
 export function setupPythonRuntime(