life
Version:
Life.js is the first fullstack framework to build agentic web applications. It is minimal, extensible, and typesafe. Well, everything you love.
296 lines (281 loc) • 13.7 kB
JavaScript
"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
var _chunkVLUR4YNDjs = require('./chunk-VLUR4YND.js');
var _chunk22H3U7VVjs = require('./chunk-22H3U7VV.js');
var _chunk6PEHRAEPjs = require('./chunk-6PEHRAEP.js');
// transport/types.ts
var _zod = require('zod'); var _zod2 = _interopRequireDefault(_zod);
var rpcRequestSchema = _zod2.default.object({
type: _zod2.default.literal("request"),
id: _zod2.default.string(),
name: _zod2.default.string(),
input: _zod2.default.unknown().optional()
});
var rpcResponseSchema = _zod2.default.object({
type: _zod2.default.literal("response"),
id: _zod2.default.string(),
result: _chunk22H3U7VVjs.resultSchema.transform((result) => result)
});
var rpcMessageSchema = _zod2.default.discriminatedUnion("type", [rpcRequestSchema, rpcResponseSchema]);
// transport/base.ts
var TransportClientBase = (_class = class {
static {
_chunk6PEHRAEPjs.__name.call(void 0, this, "TransportClientBase");
}
#provider;
#obfuscateErrors;
#procedures = /* @__PURE__ */ new Map();
#resolveResults = /* @__PURE__ */ new Map();
#telemetry = null;
#rpcUnsubscribe;
constructor({
provider,
telemetry,
obfuscateErrors = false
}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);
this.#provider = provider;
this.#obfuscateErrors = obfuscateErrors;
this.#telemetry = _nullishCoalesce(telemetry, () => ( null));
}
async sendText(topic, text) {
try {
const [errWriter, writer] = await this.streamText(topic);
if (errWriter) return _chunk22H3U7VVjs.failure.call(void 0, errWriter);
await writer.write(text);
await writer.close();
return _chunk22H3U7VVjs.success.call(void 0, );
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
}
}
receiveText(topic, callback, onError) {
try {
const [errReceive, unsubscribe] = this.receiveStreamText(
topic,
async (iterator, participantId) => {
const [err] = await _chunk22H3U7VVjs.attempt.call(void 0, async () => {
let result = "";
for await (const chunk of iterator) result += chunk;
await callback(result, participantId);
});
if (err) _optionalChain([onError, 'optionalCall', _ => _(err)]);
},
onError
);
if (errReceive) return _chunk22H3U7VVjs.failure.call(void 0, errReceive);
return _chunk22H3U7VVjs.success.call(void 0, unsubscribe);
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
}
}
async sendObject(topic, obj) {
try {
const [errCanon, serialized] = _chunkVLUR4YNDjs.canon.stringify(obj);
if (errCanon) return _chunk22H3U7VVjs.failure.call(void 0, errCanon);
const [errSend] = await this.sendText(topic, serialized);
if (errSend) return _chunk22H3U7VVjs.failure.call(void 0, errSend);
return _chunk22H3U7VVjs.success.call(void 0, );
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
}
}
receiveObject(topic, callback, onError) {
try {
const [err, unsubscribe] = this.receiveText(
topic,
async (text, participantId) => {
try {
const [errParse, deserialized] = _chunkVLUR4YNDjs.canon.parse(text);
if (errParse) return _optionalChain([onError, 'optionalCall', _2 => _2(errParse)]);
const [errCallback] = await _chunk22H3U7VVjs.attempt.call(void 0,
async () => await callback(deserialized, participantId)
);
if (errCallback) return _optionalChain([onError, 'optionalCall', _3 => _3(errCallback)]);
} catch (error) {
_optionalChain([onError, 'optionalCall', _4 => _4(error)]);
}
},
onError
);
if (err) return _chunk22H3U7VVjs.failure.call(void 0, err);
return _chunk22H3U7VVjs.success.call(void 0, unsubscribe);
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
}
}
/**
* Register a remote procedure.
* @param procedure - The procedure to register
*/
register(procedure) {
this.#procedures.set(procedure.name, procedure);
}
/**
* Call a remote procedure.
* @param name - The name of the procedure to call
* @param inputs - The parameters to pass to the procedure
* @returns A promise that resolves to the response from the procedure
*/
async call({
name,
schema,
input,
timeoutMs = 1e4
}) {
const id = _chunk22H3U7VVjs.newId.call(void 0, "rpc");
try {
let parsedInput;
if (_optionalChain([schema, 'optionalAccess', _5 => _5.input])) {
const { error: errInput, data: parsedInput_ } = schema.input.safeParse(input);
if (errInput) return _chunk22H3U7VVjs.failure.call(void 0, { code: "Validation", cause: errInput });
parsedInput = parsedInput_;
}
const resultPromise = new Promise((resolve) => {
this.#resolveResults.set(id, (res) => {
resolve(
res
);
});
});
const timeoutPromise = new Promise((resolve) => {
setTimeout(() => {
resolve(
_chunk22H3U7VVjs.failure.call(void 0, {
code: "Timeout",
message: `RPC call to procedure '${name}' timed out after ${timeoutMs}ms.`
})
);
}, timeoutMs);
});
const [errCall] = await this.sendObject("rpc", {
type: "request",
id,
name,
...parsedInput ? { input: parsedInput } : {}
});
if (errCall) return _chunk22H3U7VVjs.failure.call(void 0, errCall);
const [err, data] = await Promise.race([resultPromise, timeoutPromise]);
if (err) return _chunk22H3U7VVjs.failure.call(void 0, err);
if (_optionalChain([schema, 'optionalAccess', _6 => _6.output])) {
const { error: errOutput, data: parsedOutput } = schema.output.safeParse(data);
if (errOutput) return _chunk22H3U7VVjs.failure.call(void 0, { code: "Validation", cause: errOutput });
return _chunk22H3U7VVjs.success.call(void 0, parsedOutput);
}
return _chunk22H3U7VVjs.success.call(void 0, );
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
} finally {
this.#resolveResults.delete(id);
}
}
// Initialize RPC
async #onRPCMessage(rawMessage) {
try {
const { data: parsedMessage, error: messageError } = rpcMessageSchema.safeParse(rawMessage);
if (messageError)
return _optionalChain([this, 'access', _7 => _7.#telemetry, 'optionalAccess', _8 => _8.log, 'access', _9 => _9.error, 'call', _10 => _10({
message: "Invalid RPC message.",
error: messageError
})]);
if (parsedMessage.type === "response") {
const resolveResult = this.#resolveResults.get(parsedMessage.id);
if (resolveResult) await resolveResult(parsedMessage.result);
return;
}
let procedure;
const requestMessage = parsedMessage;
const sendResult = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, async (result) => {
let [error, data] = result;
if (error)
_optionalChain([this, 'access', _11 => _11.#telemetry, 'optionalAccess', _12 => _12.log, 'access', _13 => _13.error, 'call', _14 => _14({
message: `Failed to respond to RPC request for handler '${requestMessage.name}'.`,
error
})]);
if (this.#obfuscateErrors && error) error = _chunk22H3U7VVjs.obfuscateLifeError.call(void 0, error);
const [errSend] = await this.sendObject("rpc", {
type: "response",
id: requestMessage.id,
result: error ? _chunk22H3U7VVjs.failure.call(void 0, error) : _chunk22H3U7VVjs.success.call(void 0, data)
});
if (errSend)
return _optionalChain([this, 'access', _15 => _15.#telemetry, 'optionalAccess', _16 => _16.log, 'access', _17 => _17.error, 'call', _18 => _18({
message: "Failed to send RPC response.",
error: errSend
})]);
}, "sendResult");
procedure = this.#procedures.get(parsedMessage.name);
if (!procedure)
return await sendResult(
_chunk22H3U7VVjs.failure.call(void 0, {
code: "NotFound",
message: `Procedure not found: '${parsedMessage.name}'.`
})
);
const { data: input, error: inputError } = _optionalChain([procedure, 'access', _19 => _19.schema, 'optionalAccess', _20 => _20.input]) ? procedure.schema.input.safeParse(parsedMessage.input) : { data: void 0, error: null };
if (inputError)
return await sendResult(
_chunk22H3U7VVjs.failure.call(void 0, {
code: "Validation",
message: `Invalid input parameters for procedure '${parsedMessage.name}'.`,
cause: inputError
})
);
const [err, rawOutput] = await procedure.execute(input);
if (err) return await sendResult(_chunk22H3U7VVjs.failure.call(void 0, err));
const { data: output, error: outputError } = _optionalChain([procedure, 'access', _21 => _21.schema, 'optionalAccess', _22 => _22.output]) ? await procedure.schema.output.safeParseAsync(rawOutput) : { data: rawOutput, error: null };
if (outputError) {
return await sendResult(
_chunk22H3U7VVjs.failure.call(void 0, {
code: "Validation",
message: `Invalid output from procedure '${parsedMessage.name}'.`,
cause: outputError
})
);
}
return await sendResult(_chunk22H3U7VVjs.success.call(void 0, output));
} catch (error) {
_optionalChain([this, 'access', _23 => _23.#telemetry, 'optionalAccess', _24 => _24.log, 'access', _25 => _25.error, 'call', _26 => _26({ message: "Unknown error while handling RPC message.", error })]);
}
}
#startRPC() {
try {
const [errReceive, unsubscribe] = this.receiveObject("rpc", this.#onRPCMessage.bind(this));
if (errReceive) return _chunk22H3U7VVjs.failure.call(void 0, errReceive);
this.#rpcUnsubscribe = unsubscribe;
return _chunk22H3U7VVjs.success.call(void 0, );
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
}
}
#stopRPC() {
try {
_optionalChain([this, 'access', _27 => _27.#rpcUnsubscribe, 'optionalCall', _28 => _28()]);
this.#resolveResults.clear();
this.#procedures.clear();
return _chunk22H3U7VVjs.success.call(void 0, );
} catch (error) {
return _chunk22H3U7VVjs.failure.call(void 0, { code: "Unknown", cause: error });
}
}
__init() {this.on = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, (...args) => this.#provider.on(...args), "on")}
__init2() {this.joinRoom = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, async (...args) => {
const [errJoin] = await this.#provider.joinRoom(...args);
if (errJoin) return _chunk22H3U7VVjs.failure.call(void 0, errJoin);
const [errStart] = this.#startRPC();
if (errStart) return _chunk22H3U7VVjs.failure.call(void 0, errStart);
return _chunk22H3U7VVjs.success.call(void 0, );
}, "joinRoom")}
__init3() {this.leaveRoom = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, async (...args) => {
const [errLeave] = await this.#provider.leaveRoom(...args);
if (errLeave) return _chunk22H3U7VVjs.failure.call(void 0, errLeave);
const [errStop] = this.#stopRPC();
if (errStop) return _chunk22H3U7VVjs.failure.call(void 0, errStop);
return _chunk22H3U7VVjs.success.call(void 0, );
}, "leaveRoom")}
__init4() {this.streamText = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, (...args) => this.#provider.streamText(...args), "streamText")}
__init5() {this.receiveStreamText = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, (...args) => this.#provider.receiveStreamText(...args), "receiveStreamText")}
__init6() {this.enableMicrophone = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, (...args) => this.#provider.enableMicrophone(...args), "enableMicrophone")}
__init7() {this.playAudio = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, (...args) => this.#provider.playAudio(...args), "playAudio")}
__init8() {this.streamAudioChunk = /* @__PURE__ */ _chunk6PEHRAEPjs.__name.call(void 0, (...args) => this.#provider.streamAudioChunk(...args), "streamAudioChunk")}
}, _class);
exports.TransportClientBase = TransportClientBase;
//# sourceMappingURL=chunk-FID44QSN.js.map