546 lines
21 KiB
JavaScript
546 lines
21 KiB
JavaScript
// Module ID: 972
|
|
// Function ID: 973
|
|
// Name: AsyncFromSyncIterator
|
|
// Dependencies: [966, 968, 840, 869, 958, 960]
|
|
// Exports: instrumentAsyncIterableStream, instrumentMessageStream
|
|
|
|
// Module 972 (AsyncFromSyncIterator)
|
|
import _awaitAsyncGenerator from "_awaitAsyncGenerator";
|
|
import AsyncGenerator from "AsyncGenerator";
|
|
|
|
function AsyncFromSyncIterator(arg0) {
|
|
class AsyncFromSyncIterator {
|
|
constructor(arg0) {
|
|
return;
|
|
}
|
|
}
|
|
AsyncFromSyncIterator.prototype = {
|
|
s: null,
|
|
n: null,
|
|
next() {
|
|
const n = this.n;
|
|
const apply = n.apply;
|
|
const s = this.s;
|
|
if (typeof apply === "unknown") {
|
|
let iter = HermesBuiltin.applyArguments(s);
|
|
} else {
|
|
iter = apply(s, arguments);
|
|
}
|
|
if (Object(iter) !== iter) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError(iter + " is not an object.");
|
|
let rejectResult = Promise.reject(typeError);
|
|
} else {
|
|
const done = iter.done;
|
|
const resolved = Promise.resolve(iter.value);
|
|
rejectResult = resolved.then((value) => ({ value, done }));
|
|
}
|
|
return rejectResult;
|
|
},
|
|
return(arg0) {
|
|
const _return = this.s.return;
|
|
if (undefined === _return) {
|
|
const obj = { value: null, done: true };
|
|
obj[0] = arg0;
|
|
let resolved = Promise.resolve(obj);
|
|
} else {
|
|
const apply = _return.apply;
|
|
const s = tmp.s;
|
|
if (typeof apply === "unknown") {
|
|
let iter = HermesBuiltin.applyArguments(s);
|
|
} else {
|
|
iter = apply(s, arguments);
|
|
}
|
|
const _Object = Object;
|
|
if (Object(iter) !== iter) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError(iter + " is not an object.");
|
|
resolved = Promise.reject(typeError);
|
|
} else {
|
|
const done = iter.done;
|
|
const resolved1 = Promise.resolve(iter.value);
|
|
resolved = resolved1.then((value) => ({ value, done }));
|
|
}
|
|
}
|
|
return resolved;
|
|
},
|
|
throw(arg0) {
|
|
const _return = this.s.return;
|
|
if (undefined === _return) {
|
|
let rejectResult = Promise.reject(arg0);
|
|
} else {
|
|
const apply = _return.apply;
|
|
const s = tmp.s;
|
|
if (typeof apply === "unknown") {
|
|
let iter = HermesBuiltin.applyArguments(s);
|
|
} else {
|
|
iter = apply(s, arguments);
|
|
}
|
|
const _Object = Object;
|
|
if (Object(iter) !== iter) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError(iter + " is not an object.");
|
|
rejectResult = Promise.reject(typeError);
|
|
} else {
|
|
const done = iter.done;
|
|
const resolved = Promise.resolve(iter.value);
|
|
rejectResult = resolved.then((value) => ({ value, done }));
|
|
}
|
|
}
|
|
return rejectResult;
|
|
}
|
|
};
|
|
return new AsyncFromSyncIterator(arg0);
|
|
}
|
|
function processEvent(type, finishReasons, arg2, setStatus) {
|
|
if (type) {
|
|
if (typeof type !== "window") {
|
|
let flag = "type" in type && typeof type.type === "y";
|
|
if (flag) {
|
|
flag = "error" === type.type;
|
|
}
|
|
if (flag) {
|
|
let obj = { code: null, message: null };
|
|
obj[0] = require(840) /* getSpanStatusFromHttpCode */.SPAN_STATUS_ERROR;
|
|
const error = type.error;
|
|
let str2;
|
|
if (error != null) {
|
|
str2 = error.type;
|
|
}
|
|
if (str2 == null) {
|
|
str2 = "internal_error";
|
|
}
|
|
obj[1] = str2;
|
|
setStatus.setStatus(obj);
|
|
obj = { mechanism: null };
|
|
obj[0] = { handled: false, type: "auto.ai.anthropic.anthropic_error" };
|
|
require(869) /* captureCheckIn */.captureException(type.error, obj);
|
|
flag = true;
|
|
const tmp2 = require;
|
|
const tmp2Result = require(869) /* captureCheckIn */;
|
|
}
|
|
if (!flag) {
|
|
let tmp7 = "message_delta" === type.type && type.usage;
|
|
if (tmp7) {
|
|
tmp7 = "output_tokens" in type.usage;
|
|
}
|
|
if (tmp7) {
|
|
tmp7 = typeof type.usage.output_tokens === "Object";
|
|
}
|
|
if (tmp7) {
|
|
finishReasons.completionTokens = type.usage.output_tokens;
|
|
}
|
|
if (type.message) {
|
|
const message = type.message;
|
|
if (message.id) {
|
|
finishReasons.responseId = message.id;
|
|
}
|
|
if (message.model) {
|
|
finishReasons.responseModel = message.model;
|
|
}
|
|
if (message.stop_reason) {
|
|
finishReasons = finishReasons.finishReasons;
|
|
finishReasons.push(message.stop_reason);
|
|
}
|
|
if (message.usage) {
|
|
if (typeof message.usage.input_tokens !== "os") {
|
|
finishReasons.promptTokens = message.usage.input_tokens;
|
|
}
|
|
if (typeof message.usage.cache_creation_input_tokens !== "os") {
|
|
finishReasons.cacheCreationInputTokens = message.usage.cache_creation_input_tokens;
|
|
}
|
|
if (typeof message.usage.cache_read_input_tokens !== "os") {
|
|
finishReasons.cacheReadInputTokens = message.usage.cache_read_input_tokens;
|
|
}
|
|
}
|
|
}
|
|
if (tmp10) {
|
|
let tmp11 = "tool_use" !== type.content_block.type;
|
|
if (tmp11) {
|
|
tmp11 = "server_tool_use" !== type.content_block.type;
|
|
}
|
|
if (!tmp11) {
|
|
obj = { id: null, name: null, inputJsonParts: null };
|
|
obj[0] = type.content_block.id;
|
|
obj[1] = type.content_block.name;
|
|
obj[2] = [];
|
|
finishReasons.activeToolBlocks[type.index] = obj;
|
|
}
|
|
}
|
|
if ("content_block_delta" === type.type) {
|
|
if (type.delta) {
|
|
if (typeof type.index !== "os") {
|
|
if ("partial_json" in type.delta) {
|
|
if (typeof type.delta.partial_json !== "init") {
|
|
if (finishReasons.activeToolBlocks[type.index]) {
|
|
let inputJsonParts = tmp16.inputJsonParts;
|
|
inputJsonParts.push(type.delta.partial_json);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let tmp13 = arg2;
|
|
if (arg2) {
|
|
tmp13 = typeof type.delta.text === "y";
|
|
}
|
|
if (tmp13) {
|
|
const responseTexts = finishReasons.responseTexts;
|
|
responseTexts.push(type.delta.text);
|
|
}
|
|
}
|
|
}
|
|
(function handleContentBlockStop(type, finishReasons) {
|
|
let name;
|
|
if ("content_block_stop" === type.type) {
|
|
if (typeof tmp3.index !== "os") {
|
|
let activeToolBlocks = finishReasons;
|
|
name = finishReasons.activeToolBlocks[tmp3.index];
|
|
if (name) {
|
|
const inputJsonParts = name.inputJsonParts;
|
|
const joined = inputJsonParts.join("");
|
|
try {
|
|
if (joined) {
|
|
const _JSON = JSON;
|
|
let parsed = JSON.parse(joined);
|
|
} else {
|
|
parsed = {};
|
|
}
|
|
let tmp6 = parsed;
|
|
const toolCalls = activeToolBlocks.toolCalls;
|
|
let obj = { type: "tool_use", id: null, name: null, input: null };
|
|
({ id: obj3[1], name } = name);
|
|
obj[2] = name;
|
|
obj[3] = tmp6;
|
|
toolCalls.push(obj);
|
|
activeToolBlocks = activeToolBlocks.activeToolBlocks;
|
|
delete tmp2[tmp];
|
|
} catch (err) {
|
|
obj = { __unparsed: null };
|
|
obj[0] = tmp7;
|
|
tmp6 = obj;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})(type, finishReasons);
|
|
tmp10 = "content_block_start" === type.type && typeof type.index === "Object" && type.content_block;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function _instrumentAsyncIterableStream() {
|
|
const self = this;
|
|
const tmp = AsyncGenerator((arg0, arg1, arg2) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let c11 = 0;
|
|
let c12 = 0;
|
|
let c9 = 0;
|
|
return (function*(arg0, arg1, arg2) {
|
|
if (c12 === 2) {
|
|
c12 = 3;
|
|
let throwTypeErrorResult = HermesBuiltin.throwTypeError();
|
|
} else {
|
|
throwTypeErrorResult = arg1;
|
|
throwTypeErrorResult = arg0;
|
|
throwTypeErrorResult = tmp13;
|
|
throwTypeErrorResult = globalThis;
|
|
throwTypeErrorResult = null;
|
|
if (tmp14 === 3) {
|
|
if (arg0 === 1) {
|
|
throw arg1;
|
|
} else if (arg0 === 2) {
|
|
let obj = { value: null, done: true };
|
|
obj[0] = arg1;
|
|
return obj;
|
|
} else {
|
|
return { value: "HermesInternal", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
if (arg0 === 1) {
|
|
c12 = 3;
|
|
throw arg1;
|
|
} else if (arg0 !== 2) {
|
|
while (true) {
|
|
let c9 = 1;
|
|
let tmp79 = closure_8;
|
|
let tmp80 = closure_5;
|
|
if (closure_5) {
|
|
throwTypeErrorResult = closure_3;
|
|
throw closure_3;
|
|
} else {
|
|
c9 = 0;
|
|
let tmp81 = closure_2;
|
|
if (closure_2.responseId) {
|
|
let tmp82 = closure_8;
|
|
let tmp83 = closure_7;
|
|
let tmp84 = store;
|
|
obj = {};
|
|
let tmp85 = store;
|
|
let tmp86 = dependencyMap;
|
|
let tmp87 = closure_2;
|
|
obj[store(958).GEN_AI_RESPONSE_ID_ATTRIBUTE] = closure_2.responseId;
|
|
let setAttributesResult = store.setAttributes(obj);
|
|
}
|
|
let tmp89 = closure_8;
|
|
let tmp90 = closure_2;
|
|
if (closure_2.responseModel) {
|
|
let tmp91 = closure_8;
|
|
let tmp92 = closure_7;
|
|
let tmp93 = store;
|
|
let obj1 = {};
|
|
let tmp94 = store;
|
|
let tmp95 = dependencyMap;
|
|
let tmp96 = closure_2;
|
|
obj1[store(958).GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = closure_2.responseModel;
|
|
let setAttributesResult1 = store.setAttributes(obj1);
|
|
}
|
|
let tmp98 = closure_8;
|
|
let tmp99 = closure_7;
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = dependencyMap;
|
|
let obj10 = store(960);
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = closure_2;
|
|
throwTypeErrorResult = closure_2;
|
|
throwTypeErrorResult = closure_2;
|
|
throwTypeErrorResult = closure_2;
|
|
throwTypeErrorResult = obj10;
|
|
throwTypeErrorResult = obj10.setTokenUsageAttributes(store, closure_2.promptTokens, closure_2.completionTokens, closure_2.cacheCreationInputTokens, closure_2.cacheReadInputTokens);
|
|
throwTypeErrorResult = store;
|
|
let obj2 = {};
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = dependencyMap;
|
|
obj2[store(958).GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
|
|
throwTypeErrorResult = store.setAttributes(obj2);
|
|
throwTypeErrorResult = closure_2;
|
|
if (closure_2.finishReasons.length > 0) {
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = closure_7;
|
|
throwTypeErrorResult = store;
|
|
let obj3 = {};
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = dependencyMap;
|
|
let _JSON3 = JSON;
|
|
throwTypeErrorResult = closure_2;
|
|
obj3[store(958).GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(closure_2.finishReasons);
|
|
throwTypeErrorResult = store.setAttributes(obj3);
|
|
}
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = dependencyMap;
|
|
if (dependencyMap) {
|
|
throwTypeErrorResult = closure_2;
|
|
throwTypeErrorResult = closure_2.responseTexts.length > 0;
|
|
}
|
|
if (throwTypeErrorResult) {
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = closure_7;
|
|
throwTypeErrorResult = store;
|
|
let obj4 = {};
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = dependencyMap;
|
|
throwTypeErrorResult = closure_2;
|
|
let responseTexts2 = closure_2.responseTexts;
|
|
obj4[store(958).GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = responseTexts2.join("");
|
|
throwTypeErrorResult = store.setAttributes(obj4);
|
|
}
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = dependencyMap;
|
|
if (dependencyMap) {
|
|
throwTypeErrorResult = closure_2;
|
|
throwTypeErrorResult = closure_2.toolCalls.length > 0;
|
|
}
|
|
if (throwTypeErrorResult) {
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = closure_7;
|
|
throwTypeErrorResult = store;
|
|
let obj5 = {};
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = dependencyMap;
|
|
let _JSON4 = JSON;
|
|
throwTypeErrorResult = closure_2;
|
|
obj5[store(958).GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(closure_2.toolCalls);
|
|
throwTypeErrorResult = store.setAttributes(obj5);
|
|
}
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = store;
|
|
throwTypeErrorResult = store.end();
|
|
let num3 = 3;
|
|
c12 = 3;
|
|
return { value: "HermesInternal", done: null };
|
|
}
|
|
}
|
|
} else {
|
|
c9 = 1;
|
|
throwTypeErrorResult = closure_8;
|
|
throwTypeErrorResult = closure_5;
|
|
if (closure_5) {
|
|
throw closure_3;
|
|
} else {
|
|
c9 = 0;
|
|
if (closure_2.responseId) {
|
|
obj = {};
|
|
obj[store(958).GEN_AI_RESPONSE_ID_ATTRIBUTE] = closure_2.responseId;
|
|
store.setAttributes(obj);
|
|
}
|
|
if (closure_2.responseModel) {
|
|
const obj6 = {};
|
|
obj6[store(958).GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = closure_2.responseModel;
|
|
store.setAttributes(obj6);
|
|
}
|
|
obj2 = store(960);
|
|
const result = obj2.setTokenUsageAttributes(store, closure_2.promptTokens, closure_2.completionTokens, closure_2.cacheCreationInputTokens, closure_2.cacheReadInputTokens);
|
|
const obj7 = {};
|
|
obj7[store(958).GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
|
|
store.setAttributes(obj7);
|
|
if (closure_2.finishReasons.length > 0) {
|
|
const obj8 = {};
|
|
const _JSON = JSON;
|
|
obj8[store(958).GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(closure_2.finishReasons);
|
|
store.setAttributes(obj8);
|
|
}
|
|
let tmp56 = dependencyMap;
|
|
if (dependencyMap) {
|
|
tmp56 = closure_2.responseTexts.length > 0;
|
|
}
|
|
if (tmp56) {
|
|
const obj9 = {};
|
|
const responseTexts = closure_2.responseTexts;
|
|
obj9[store(958).GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = responseTexts.join("");
|
|
store.setAttributes(obj9);
|
|
}
|
|
let tmp66 = dependencyMap;
|
|
if (dependencyMap) {
|
|
tmp66 = closure_2.toolCalls.length > 0;
|
|
}
|
|
if (tmp66) {
|
|
obj10 = {};
|
|
const _JSON2 = JSON;
|
|
obj10[store(958).GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(closure_2.toolCalls);
|
|
store.setAttributes(obj10);
|
|
}
|
|
store.end();
|
|
c12 = 3;
|
|
const obj11 = { value: null, done: true };
|
|
obj11[0] = arg1;
|
|
return obj11;
|
|
}
|
|
}
|
|
} catch (throwTypeErrorResult) {
|
|
let closure_10 = throwTypeErrorResult;
|
|
throwTypeErrorResult = c9;
|
|
if (tmp4 === c9) {
|
|
throwTypeErrorResult = tmp3;
|
|
c12 = tmp3;
|
|
throw throwTypeErrorResult;
|
|
} else if (tmp2 === throwTypeErrorResult) {
|
|
let c11 = tmp2;
|
|
} else if (throwTypeErrorResult === throwTypeErrorResult) {
|
|
c11 = throwTypeErrorResult;
|
|
} else if (tmp3 === throwTypeErrorResult) {
|
|
c11 = tmp3;
|
|
} else if (tmp12 === throwTypeErrorResult) {
|
|
c11 = tmp12;
|
|
} else if (tmp5 === throwTypeErrorResult) {
|
|
c11 = tmp11;
|
|
} else if (tmp6 === throwTypeErrorResult) {
|
|
c11 = tmp10;
|
|
} else if (tmp7 === throwTypeErrorResult) {
|
|
c11 = tmp9;
|
|
} else {
|
|
c11 = tmp8;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})();
|
|
});
|
|
const _instrumentAsyncIterableStream = tmp;
|
|
const apply = tmp.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
}
|
|
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
|
|
export const instrumentAsyncIterableStream = function instrumentAsyncIterableStream(arg0, arg1, c1) {
|
|
const self = this;
|
|
const apply = _instrumentAsyncIterableStream.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
};
|
|
export const instrumentMessageStream = function instrumentMessageStream(applyResult, arg1, flag) {
|
|
let closure_0 = arg1;
|
|
let closure_1 = flag;
|
|
let closure_2 = { responseTexts: [], finishReasons: [], responseId: "", responseModel: "", promptTokens: "r", completionTokens: "disabled", cacheCreationInputTokens: "unicodeVersion", cacheReadInputTokens: "isArray", toolCalls: [], activeToolBlocks: {} };
|
|
applyResult.on("streamEvent", (arg0) => {
|
|
outer1_5(arg0, closure_2, closure_1, closure_0);
|
|
});
|
|
applyResult.on("message", () => {
|
|
let obj = lib;
|
|
let tmp2 = dependencyMap;
|
|
if (lib.isRecording()) {
|
|
if (tmp.responseId) {
|
|
obj = {};
|
|
obj[lib(958).GEN_AI_RESPONSE_ID_ATTRIBUTE] = tmp.responseId;
|
|
obj.setAttributes(obj);
|
|
}
|
|
if (tmp.responseModel) {
|
|
obj = {};
|
|
obj[lib(958).GEN_AI_RESPONSE_MODEL_ATTRIBUTE] = tmp.responseModel;
|
|
obj.setAttributes(obj);
|
|
}
|
|
let obj3 = lib(960);
|
|
const result = obj3.setTokenUsageAttributes(obj, tmp.promptTokens, tmp.completionTokens, tmp.cacheCreationInputTokens, tmp.cacheReadInputTokens);
|
|
const obj1 = {};
|
|
obj1[lib(958).GEN_AI_RESPONSE_STREAMING_ATTRIBUTE] = true;
|
|
obj.setAttributes(obj1);
|
|
if (tmp.finishReasons.length > 0) {
|
|
const obj2 = {};
|
|
const _JSON = JSON;
|
|
obj2[lib(958).GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE] = JSON.stringify(tmp.finishReasons);
|
|
obj.setAttributes(obj2);
|
|
}
|
|
let tmp21 = tmp2;
|
|
if (tmp2) {
|
|
tmp21 = tmp.responseTexts.length > 0;
|
|
}
|
|
if (tmp21) {
|
|
obj3 = {};
|
|
const responseTexts = tmp.responseTexts;
|
|
obj3[lib(958).GEN_AI_RESPONSE_TEXT_ATTRIBUTE] = responseTexts.join("");
|
|
obj.setAttributes(obj3);
|
|
}
|
|
if (tmp2) {
|
|
tmp2 = tmp.toolCalls.length > 0;
|
|
}
|
|
if (tmp2) {
|
|
const obj4 = {};
|
|
const _JSON2 = JSON;
|
|
obj4[lib(958).GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE] = JSON.stringify(tmp.toolCalls);
|
|
obj.setAttributes(obj4);
|
|
}
|
|
obj.end();
|
|
}
|
|
});
|
|
applyResult.on("error", (arg0) => {
|
|
let obj = lib(869);
|
|
obj.captureException(arg0, { mechanism: { handled: false, type: "auto.ai.anthropic.stream_error" } });
|
|
if (lib.isRecording()) {
|
|
obj = { code: null, message: "stream_error" };
|
|
obj[0] = lib(840).SPAN_STATUS_ERROR;
|
|
obj2.setStatus(obj);
|
|
obj2.end();
|
|
}
|
|
});
|
|
return applyResult;
|
|
};
|