         topic: replyTo.topic.err
         data: err
 
-    timeoutId = timers.setTimeout onTimeout, timeout
+    timeoutId = timers.setTimeout onTimeout, core.config.timeout
 
     # Default callback is of signature (message, envelope).
     # Wrap so we can pass a conventional (err, result)-style callback.
     callback = (message, envelope) ->
-      # Either an error or a success response has been
-      # received, so cancel our timeout callback.
+
+      # We're done, so cancel timeouts and subscriptions.
       timers.clearTimeout timeoutId
+      errSub.unsubscribe()
+      successSub.unsubscribe()
 
       {topic} = envelope
       [condition, middle..., topicId] = topic.split('.')
+
       switch condition
         when 'err'
-          err = message
-          done err
+          done message
         when 'success'
           done null, message
+
         else
           # This should never be reached, as this callback should only
           # be invoked by a subscription to a topic of the form
           # 'err.<uuid>' or 'success.<uuid>'.
-          err = new Error "Invalid condition '#{condition}'for response with topicId '#{topicId}'"
+          err = new Error "Invalid condition '#{condition}' for response with topicId '#{topicId}'"
           done err
 
     # Subscribe to the 'err' response for topicId
     # We don't pass a callback immediately so that we can
     # refer to the subscription itself in the callback.
     errSub = bus.subscribe {
-      channel: replyTo.channel,
-      topic: replyTo.topic.err,
-    }
-    errSub.subscribe callback
+      channel: channel
+      topic: replyTo.topic.err
+      callback: callback
+    }
 
     # Subscribe to the 'success' response for topicId
     # As above, we don't pass a callback immediately so that


    # Map this 'responderId' to the responder and its metadata
    core.responders[channel] or= {}
    core.responders[channel][callback.responderId] =
      callback: callback

    # Actually subscribe as a responder

    successSub = bus.subscribe {
      channel: replyTo.channel
      topic: replyTo.topic.success
      callback: callback
    }


  delegate: (channel, data, done) ->
