@ag-ui/proto 0.0.44 → 0.0.45

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/dist/index.d.mts +6 -3
  2. package/dist/index.d.mts.map +1 -0
  3. package/dist/index.d.ts +6 -3
  4. package/dist/index.d.ts.map +1 -0
  5. package/dist/index.js +1598 -2150
  6. package/dist/index.js.map +1 -1
  7. package/dist/index.mjs +1596 -2121
  8. package/dist/index.mjs.map +1 -1
  9. package/package.json +22 -12
package/dist/index.js CHANGED
@@ -1,2249 +1,1697 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __export = (target, all) => {
7
- for (var name in all)
8
- __defProp(target, name, { get: all[name], enumerable: true });
9
- };
10
- var __copyProps = (to, from, except, desc) => {
11
- if (from && typeof from === "object" || typeof from === "function") {
12
- for (let key of __getOwnPropNames(from))
13
- if (!__hasOwnProp.call(to, key) && key !== except)
14
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
- }
16
- return to;
17
- };
18
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
-
20
- // src/index.ts
21
- var index_exports = {};
22
- __export(index_exports, {
23
- AGUI_MEDIA_TYPE: () => AGUI_MEDIA_TYPE,
24
- decode: () => decode,
25
- encode: () => encode
26
- });
27
- module.exports = __toCommonJS(index_exports);
1
+ let _ag_ui_core = require("@ag-ui/core");
2
+ let _bufbuild_protobuf_wire = require("@bufbuild/protobuf/wire");
28
3
 
29
- // src/proto.ts
30
- var import_core = require("@ag-ui/core");
31
-
32
- // src/generated/events.ts
33
- var import_wire4 = require("@bufbuild/protobuf/wire");
34
-
35
- // src/generated/google/protobuf/struct.ts
36
- var import_wire = require("@bufbuild/protobuf/wire");
4
+ //#region src/generated/google/protobuf/struct.ts
5
+ /**
6
+ * `NullValue` is a singleton enumeration to represent the null value for the
7
+ * `Value` type union.
8
+ *
9
+ * The JSON representation for `NullValue` is JSON `null`.
10
+ */
11
+ let NullValue = /* @__PURE__ */ function(NullValue) {
12
+ /** NULL_VALUE - Null value. */
13
+ NullValue[NullValue["NULL_VALUE"] = 0] = "NULL_VALUE";
14
+ NullValue[NullValue["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
15
+ return NullValue;
16
+ }({});
37
17
  function createBaseStruct() {
38
- return { fields: {} };
18
+ return { fields: {} };
39
19
  }
40
- var Struct = {
41
- encode(message, writer = new import_wire.BinaryWriter()) {
42
- Object.entries(message.fields).forEach(([key, value]) => {
43
- if (value !== void 0) {
44
- Struct_FieldsEntry.encode({ key, value }, writer.uint32(10).fork()).join();
45
- }
46
- });
47
- return writer;
48
- },
49
- decode(input, length) {
50
- const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
51
- const end = length === void 0 ? reader.len : reader.pos + length;
52
- const message = createBaseStruct();
53
- while (reader.pos < end) {
54
- const tag = reader.uint32();
55
- switch (tag >>> 3) {
56
- case 1: {
57
- if (tag !== 10) {
58
- break;
59
- }
60
- const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
61
- if (entry1.value !== void 0) {
62
- message.fields[entry1.key] = entry1.value;
63
- }
64
- continue;
65
- }
66
- }
67
- if ((tag & 7) === 4 || tag === 0) {
68
- break;
69
- }
70
- reader.skip(tag & 7);
71
- }
72
- return message;
73
- },
74
- create(base) {
75
- return Struct.fromPartial(base != null ? base : {});
76
- },
77
- fromPartial(object) {
78
- var _a;
79
- const message = createBaseStruct();
80
- message.fields = Object.entries((_a = object.fields) != null ? _a : {}).reduce(
81
- (acc, [key, value]) => {
82
- if (value !== void 0) {
83
- acc[key] = value;
84
- }
85
- return acc;
86
- },
87
- {}
88
- );
89
- return message;
90
- },
91
- wrap(object) {
92
- const struct = createBaseStruct();
93
- if (object !== void 0) {
94
- for (const key of Object.keys(object)) {
95
- struct.fields[key] = object[key];
96
- }
97
- }
98
- return struct;
99
- },
100
- unwrap(message) {
101
- const object = {};
102
- if (message.fields) {
103
- for (const key of Object.keys(message.fields)) {
104
- object[key] = message.fields[key];
105
- }
106
- }
107
- return object;
108
- }
20
+ const Struct = {
21
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
22
+ Object.entries(message.fields).forEach(([key, value]) => {
23
+ if (value !== void 0) Struct_FieldsEntry.encode({
24
+ key,
25
+ value
26
+ }, writer.uint32(10).fork()).join();
27
+ });
28
+ return writer;
29
+ },
30
+ decode(input, length) {
31
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
32
+ const end = length === void 0 ? reader.len : reader.pos + length;
33
+ const message = createBaseStruct();
34
+ while (reader.pos < end) {
35
+ const tag = reader.uint32();
36
+ switch (tag >>> 3) {
37
+ case 1: {
38
+ if (tag !== 10) break;
39
+ const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
40
+ if (entry1.value !== void 0) message.fields[entry1.key] = entry1.value;
41
+ continue;
42
+ }
43
+ }
44
+ if ((tag & 7) === 4 || tag === 0) break;
45
+ reader.skip(tag & 7);
46
+ }
47
+ return message;
48
+ },
49
+ create(base) {
50
+ return Struct.fromPartial(base ?? {});
51
+ },
52
+ fromPartial(object) {
53
+ const message = createBaseStruct();
54
+ message.fields = Object.entries(object.fields ?? {}).reduce((acc, [key, value]) => {
55
+ if (value !== void 0) acc[key] = value;
56
+ return acc;
57
+ }, {});
58
+ return message;
59
+ },
60
+ wrap(object) {
61
+ const struct = createBaseStruct();
62
+ if (object !== void 0) for (const key of Object.keys(object)) struct.fields[key] = object[key];
63
+ return struct;
64
+ },
65
+ unwrap(message) {
66
+ const object = {};
67
+ if (message.fields) for (const key of Object.keys(message.fields)) object[key] = message.fields[key];
68
+ return object;
69
+ }
109
70
  };
110
71
  function createBaseStruct_FieldsEntry() {
111
- return { key: "", value: void 0 };
72
+ return {
73
+ key: "",
74
+ value: void 0
75
+ };
112
76
  }
113
- var Struct_FieldsEntry = {
114
- encode(message, writer = new import_wire.BinaryWriter()) {
115
- if (message.key !== "") {
116
- writer.uint32(10).string(message.key);
117
- }
118
- if (message.value !== void 0) {
119
- Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join();
120
- }
121
- return writer;
122
- },
123
- decode(input, length) {
124
- const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
125
- const end = length === void 0 ? reader.len : reader.pos + length;
126
- const message = createBaseStruct_FieldsEntry();
127
- while (reader.pos < end) {
128
- const tag = reader.uint32();
129
- switch (tag >>> 3) {
130
- case 1: {
131
- if (tag !== 10) {
132
- break;
133
- }
134
- message.key = reader.string();
135
- continue;
136
- }
137
- case 2: {
138
- if (tag !== 18) {
139
- break;
140
- }
141
- message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
142
- continue;
143
- }
144
- }
145
- if ((tag & 7) === 4 || tag === 0) {
146
- break;
147
- }
148
- reader.skip(tag & 7);
149
- }
150
- return message;
151
- },
152
- create(base) {
153
- return Struct_FieldsEntry.fromPartial(base != null ? base : {});
154
- },
155
- fromPartial(object) {
156
- var _a, _b;
157
- const message = createBaseStruct_FieldsEntry();
158
- message.key = (_a = object.key) != null ? _a : "";
159
- message.value = (_b = object.value) != null ? _b : void 0;
160
- return message;
161
- }
77
+ const Struct_FieldsEntry = {
78
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
79
+ if (message.key !== "") writer.uint32(10).string(message.key);
80
+ if (message.value !== void 0) Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join();
81
+ return writer;
82
+ },
83
+ decode(input, length) {
84
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
85
+ const end = length === void 0 ? reader.len : reader.pos + length;
86
+ const message = createBaseStruct_FieldsEntry();
87
+ while (reader.pos < end) {
88
+ const tag = reader.uint32();
89
+ switch (tag >>> 3) {
90
+ case 1:
91
+ if (tag !== 10) break;
92
+ message.key = reader.string();
93
+ continue;
94
+ case 2:
95
+ if (tag !== 18) break;
96
+ message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
97
+ continue;
98
+ }
99
+ if ((tag & 7) === 4 || tag === 0) break;
100
+ reader.skip(tag & 7);
101
+ }
102
+ return message;
103
+ },
104
+ create(base) {
105
+ return Struct_FieldsEntry.fromPartial(base ?? {});
106
+ },
107
+ fromPartial(object) {
108
+ const message = createBaseStruct_FieldsEntry();
109
+ message.key = object.key ?? "";
110
+ message.value = object.value ?? void 0;
111
+ return message;
112
+ }
162
113
  };
163
114
  function createBaseValue() {
164
- return {
165
- nullValue: void 0,
166
- numberValue: void 0,
167
- stringValue: void 0,
168
- boolValue: void 0,
169
- structValue: void 0,
170
- listValue: void 0
171
- };
115
+ return {
116
+ nullValue: void 0,
117
+ numberValue: void 0,
118
+ stringValue: void 0,
119
+ boolValue: void 0,
120
+ structValue: void 0,
121
+ listValue: void 0
122
+ };
172
123
  }
173
- var Value = {
174
- encode(message, writer = new import_wire.BinaryWriter()) {
175
- if (message.nullValue !== void 0) {
176
- writer.uint32(8).int32(message.nullValue);
177
- }
178
- if (message.numberValue !== void 0) {
179
- writer.uint32(17).double(message.numberValue);
180
- }
181
- if (message.stringValue !== void 0) {
182
- writer.uint32(26).string(message.stringValue);
183
- }
184
- if (message.boolValue !== void 0) {
185
- writer.uint32(32).bool(message.boolValue);
186
- }
187
- if (message.structValue !== void 0) {
188
- Struct.encode(Struct.wrap(message.structValue), writer.uint32(42).fork()).join();
189
- }
190
- if (message.listValue !== void 0) {
191
- ListValue.encode(ListValue.wrap(message.listValue), writer.uint32(50).fork()).join();
192
- }
193
- return writer;
194
- },
195
- decode(input, length) {
196
- const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
197
- const end = length === void 0 ? reader.len : reader.pos + length;
198
- const message = createBaseValue();
199
- while (reader.pos < end) {
200
- const tag = reader.uint32();
201
- switch (tag >>> 3) {
202
- case 1: {
203
- if (tag !== 8) {
204
- break;
205
- }
206
- message.nullValue = reader.int32();
207
- continue;
208
- }
209
- case 2: {
210
- if (tag !== 17) {
211
- break;
212
- }
213
- message.numberValue = reader.double();
214
- continue;
215
- }
216
- case 3: {
217
- if (tag !== 26) {
218
- break;
219
- }
220
- message.stringValue = reader.string();
221
- continue;
222
- }
223
- case 4: {
224
- if (tag !== 32) {
225
- break;
226
- }
227
- message.boolValue = reader.bool();
228
- continue;
229
- }
230
- case 5: {
231
- if (tag !== 42) {
232
- break;
233
- }
234
- message.structValue = Struct.unwrap(Struct.decode(reader, reader.uint32()));
235
- continue;
236
- }
237
- case 6: {
238
- if (tag !== 50) {
239
- break;
240
- }
241
- message.listValue = ListValue.unwrap(ListValue.decode(reader, reader.uint32()));
242
- continue;
243
- }
244
- }
245
- if ((tag & 7) === 4 || tag === 0) {
246
- break;
247
- }
248
- reader.skip(tag & 7);
249
- }
250
- return message;
251
- },
252
- create(base) {
253
- return Value.fromPartial(base != null ? base : {});
254
- },
255
- fromPartial(object) {
256
- var _a, _b, _c, _d, _e, _f;
257
- const message = createBaseValue();
258
- message.nullValue = (_a = object.nullValue) != null ? _a : void 0;
259
- message.numberValue = (_b = object.numberValue) != null ? _b : void 0;
260
- message.stringValue = (_c = object.stringValue) != null ? _c : void 0;
261
- message.boolValue = (_d = object.boolValue) != null ? _d : void 0;
262
- message.structValue = (_e = object.structValue) != null ? _e : void 0;
263
- message.listValue = (_f = object.listValue) != null ? _f : void 0;
264
- return message;
265
- },
266
- wrap(value) {
267
- const result = createBaseValue();
268
- if (value === null) {
269
- result.nullValue = 0 /* NULL_VALUE */;
270
- } else if (typeof value === "boolean") {
271
- result.boolValue = value;
272
- } else if (typeof value === "number") {
273
- result.numberValue = value;
274
- } else if (typeof value === "string") {
275
- result.stringValue = value;
276
- } else if (globalThis.Array.isArray(value)) {
277
- result.listValue = value;
278
- } else if (typeof value === "object") {
279
- result.structValue = value;
280
- } else if (typeof value !== "undefined") {
281
- throw new globalThis.Error("Unsupported any value type: " + typeof value);
282
- }
283
- return result;
284
- },
285
- unwrap(message) {
286
- if (message.stringValue !== void 0) {
287
- return message.stringValue;
288
- } else if ((message == null ? void 0 : message.numberValue) !== void 0) {
289
- return message.numberValue;
290
- } else if ((message == null ? void 0 : message.boolValue) !== void 0) {
291
- return message.boolValue;
292
- } else if ((message == null ? void 0 : message.structValue) !== void 0) {
293
- return message.structValue;
294
- } else if ((message == null ? void 0 : message.listValue) !== void 0) {
295
- return message.listValue;
296
- } else if ((message == null ? void 0 : message.nullValue) !== void 0) {
297
- return null;
298
- }
299
- return void 0;
300
- }
124
+ const Value = {
125
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
126
+ if (message.nullValue !== void 0) writer.uint32(8).int32(message.nullValue);
127
+ if (message.numberValue !== void 0) writer.uint32(17).double(message.numberValue);
128
+ if (message.stringValue !== void 0) writer.uint32(26).string(message.stringValue);
129
+ if (message.boolValue !== void 0) writer.uint32(32).bool(message.boolValue);
130
+ if (message.structValue !== void 0) Struct.encode(Struct.wrap(message.structValue), writer.uint32(42).fork()).join();
131
+ if (message.listValue !== void 0) ListValue.encode(ListValue.wrap(message.listValue), writer.uint32(50).fork()).join();
132
+ return writer;
133
+ },
134
+ decode(input, length) {
135
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
136
+ const end = length === void 0 ? reader.len : reader.pos + length;
137
+ const message = createBaseValue();
138
+ while (reader.pos < end) {
139
+ const tag = reader.uint32();
140
+ switch (tag >>> 3) {
141
+ case 1:
142
+ if (tag !== 8) break;
143
+ message.nullValue = reader.int32();
144
+ continue;
145
+ case 2:
146
+ if (tag !== 17) break;
147
+ message.numberValue = reader.double();
148
+ continue;
149
+ case 3:
150
+ if (tag !== 26) break;
151
+ message.stringValue = reader.string();
152
+ continue;
153
+ case 4:
154
+ if (tag !== 32) break;
155
+ message.boolValue = reader.bool();
156
+ continue;
157
+ case 5:
158
+ if (tag !== 42) break;
159
+ message.structValue = Struct.unwrap(Struct.decode(reader, reader.uint32()));
160
+ continue;
161
+ case 6:
162
+ if (tag !== 50) break;
163
+ message.listValue = ListValue.unwrap(ListValue.decode(reader, reader.uint32()));
164
+ continue;
165
+ }
166
+ if ((tag & 7) === 4 || tag === 0) break;
167
+ reader.skip(tag & 7);
168
+ }
169
+ return message;
170
+ },
171
+ create(base) {
172
+ return Value.fromPartial(base ?? {});
173
+ },
174
+ fromPartial(object) {
175
+ const message = createBaseValue();
176
+ message.nullValue = object.nullValue ?? void 0;
177
+ message.numberValue = object.numberValue ?? void 0;
178
+ message.stringValue = object.stringValue ?? void 0;
179
+ message.boolValue = object.boolValue ?? void 0;
180
+ message.structValue = object.structValue ?? void 0;
181
+ message.listValue = object.listValue ?? void 0;
182
+ return message;
183
+ },
184
+ wrap(value) {
185
+ const result = createBaseValue();
186
+ if (value === null) result.nullValue = NullValue.NULL_VALUE;
187
+ else if (typeof value === "boolean") result.boolValue = value;
188
+ else if (typeof value === "number") result.numberValue = value;
189
+ else if (typeof value === "string") result.stringValue = value;
190
+ else if (globalThis.Array.isArray(value)) result.listValue = value;
191
+ else if (typeof value === "object") result.structValue = value;
192
+ else if (typeof value !== "undefined") throw new globalThis.Error("Unsupported any value type: " + typeof value);
193
+ return result;
194
+ },
195
+ unwrap(message) {
196
+ if (message.stringValue !== void 0) return message.stringValue;
197
+ else if (message?.numberValue !== void 0) return message.numberValue;
198
+ else if (message?.boolValue !== void 0) return message.boolValue;
199
+ else if (message?.structValue !== void 0) return message.structValue;
200
+ else if (message?.listValue !== void 0) return message.listValue;
201
+ else if (message?.nullValue !== void 0) return null;
202
+ }
301
203
  };
302
204
  function createBaseListValue() {
303
- return { values: [] };
205
+ return { values: [] };
304
206
  }
305
- var ListValue = {
306
- encode(message, writer = new import_wire.BinaryWriter()) {
307
- for (const v of message.values) {
308
- Value.encode(Value.wrap(v), writer.uint32(10).fork()).join();
309
- }
310
- return writer;
311
- },
312
- decode(input, length) {
313
- const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
314
- const end = length === void 0 ? reader.len : reader.pos + length;
315
- const message = createBaseListValue();
316
- while (reader.pos < end) {
317
- const tag = reader.uint32();
318
- switch (tag >>> 3) {
319
- case 1: {
320
- if (tag !== 10) {
321
- break;
322
- }
323
- message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
324
- continue;
325
- }
326
- }
327
- if ((tag & 7) === 4 || tag === 0) {
328
- break;
329
- }
330
- reader.skip(tag & 7);
331
- }
332
- return message;
333
- },
334
- create(base) {
335
- return ListValue.fromPartial(base != null ? base : {});
336
- },
337
- fromPartial(object) {
338
- var _a;
339
- const message = createBaseListValue();
340
- message.values = ((_a = object.values) == null ? void 0 : _a.map((e) => e)) || [];
341
- return message;
342
- },
343
- wrap(array) {
344
- const result = createBaseListValue();
345
- result.values = array != null ? array : [];
346
- return result;
347
- },
348
- unwrap(message) {
349
- if ((message == null ? void 0 : message.hasOwnProperty("values")) && globalThis.Array.isArray(message.values)) {
350
- return message.values;
351
- } else {
352
- return message;
353
- }
354
- }
207
+ const ListValue = {
208
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
209
+ for (const v of message.values) Value.encode(Value.wrap(v), writer.uint32(10).fork()).join();
210
+ return writer;
211
+ },
212
+ decode(input, length) {
213
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
214
+ const end = length === void 0 ? reader.len : reader.pos + length;
215
+ const message = createBaseListValue();
216
+ while (reader.pos < end) {
217
+ const tag = reader.uint32();
218
+ switch (tag >>> 3) {
219
+ case 1:
220
+ if (tag !== 10) break;
221
+ message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
222
+ continue;
223
+ }
224
+ if ((tag & 7) === 4 || tag === 0) break;
225
+ reader.skip(tag & 7);
226
+ }
227
+ return message;
228
+ },
229
+ create(base) {
230
+ return ListValue.fromPartial(base ?? {});
231
+ },
232
+ fromPartial(object) {
233
+ const message = createBaseListValue();
234
+ message.values = object.values?.map((e) => e) || [];
235
+ return message;
236
+ },
237
+ wrap(array) {
238
+ const result = createBaseListValue();
239
+ result.values = array ?? [];
240
+ return result;
241
+ },
242
+ unwrap(message) {
243
+ if (message?.hasOwnProperty("values") && globalThis.Array.isArray(message.values)) return message.values;
244
+ else return message;
245
+ }
355
246
  };
356
247
 
357
- // src/generated/patch.ts
358
- var import_wire2 = require("@bufbuild/protobuf/wire");
359
- var JsonPatchOperationType = /* @__PURE__ */ ((JsonPatchOperationType2) => {
360
- JsonPatchOperationType2[JsonPatchOperationType2["ADD"] = 0] = "ADD";
361
- JsonPatchOperationType2[JsonPatchOperationType2["REMOVE"] = 1] = "REMOVE";
362
- JsonPatchOperationType2[JsonPatchOperationType2["REPLACE"] = 2] = "REPLACE";
363
- JsonPatchOperationType2[JsonPatchOperationType2["MOVE"] = 3] = "MOVE";
364
- JsonPatchOperationType2[JsonPatchOperationType2["COPY"] = 4] = "COPY";
365
- JsonPatchOperationType2[JsonPatchOperationType2["TEST"] = 5] = "TEST";
366
- JsonPatchOperationType2[JsonPatchOperationType2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
367
- return JsonPatchOperationType2;
368
- })(JsonPatchOperationType || {});
248
+ //#endregion
249
+ //#region src/generated/patch.ts
250
+ let JsonPatchOperationType = /* @__PURE__ */ function(JsonPatchOperationType) {
251
+ JsonPatchOperationType[JsonPatchOperationType["ADD"] = 0] = "ADD";
252
+ JsonPatchOperationType[JsonPatchOperationType["REMOVE"] = 1] = "REMOVE";
253
+ JsonPatchOperationType[JsonPatchOperationType["REPLACE"] = 2] = "REPLACE";
254
+ JsonPatchOperationType[JsonPatchOperationType["MOVE"] = 3] = "MOVE";
255
+ JsonPatchOperationType[JsonPatchOperationType["COPY"] = 4] = "COPY";
256
+ JsonPatchOperationType[JsonPatchOperationType["TEST"] = 5] = "TEST";
257
+ JsonPatchOperationType[JsonPatchOperationType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
258
+ return JsonPatchOperationType;
259
+ }({});
369
260
  function createBaseJsonPatchOperation() {
370
- return { op: 0, path: "", from: void 0, value: void 0 };
261
+ return {
262
+ op: 0,
263
+ path: "",
264
+ from: void 0,
265
+ value: void 0
266
+ };
371
267
  }
372
- var JsonPatchOperation = {
373
- encode(message, writer = new import_wire2.BinaryWriter()) {
374
- if (message.op !== 0) {
375
- writer.uint32(8).int32(message.op);
376
- }
377
- if (message.path !== "") {
378
- writer.uint32(18).string(message.path);
379
- }
380
- if (message.from !== void 0) {
381
- writer.uint32(26).string(message.from);
382
- }
383
- if (message.value !== void 0) {
384
- Value.encode(Value.wrap(message.value), writer.uint32(34).fork()).join();
385
- }
386
- return writer;
387
- },
388
- decode(input, length) {
389
- const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
390
- const end = length === void 0 ? reader.len : reader.pos + length;
391
- const message = createBaseJsonPatchOperation();
392
- while (reader.pos < end) {
393
- const tag = reader.uint32();
394
- switch (tag >>> 3) {
395
- case 1: {
396
- if (tag !== 8) {
397
- break;
398
- }
399
- message.op = reader.int32();
400
- continue;
401
- }
402
- case 2: {
403
- if (tag !== 18) {
404
- break;
405
- }
406
- message.path = reader.string();
407
- continue;
408
- }
409
- case 3: {
410
- if (tag !== 26) {
411
- break;
412
- }
413
- message.from = reader.string();
414
- continue;
415
- }
416
- case 4: {
417
- if (tag !== 34) {
418
- break;
419
- }
420
- message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
421
- continue;
422
- }
423
- }
424
- if ((tag & 7) === 4 || tag === 0) {
425
- break;
426
- }
427
- reader.skip(tag & 7);
428
- }
429
- return message;
430
- },
431
- create(base) {
432
- return JsonPatchOperation.fromPartial(base != null ? base : {});
433
- },
434
- fromPartial(object) {
435
- var _a, _b, _c, _d;
436
- const message = createBaseJsonPatchOperation();
437
- message.op = (_a = object.op) != null ? _a : 0;
438
- message.path = (_b = object.path) != null ? _b : "";
439
- message.from = (_c = object.from) != null ? _c : void 0;
440
- message.value = (_d = object.value) != null ? _d : void 0;
441
- return message;
442
- }
268
+ const JsonPatchOperation = {
269
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
270
+ if (message.op !== 0) writer.uint32(8).int32(message.op);
271
+ if (message.path !== "") writer.uint32(18).string(message.path);
272
+ if (message.from !== void 0) writer.uint32(26).string(message.from);
273
+ if (message.value !== void 0) Value.encode(Value.wrap(message.value), writer.uint32(34).fork()).join();
274
+ return writer;
275
+ },
276
+ decode(input, length) {
277
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
278
+ const end = length === void 0 ? reader.len : reader.pos + length;
279
+ const message = createBaseJsonPatchOperation();
280
+ while (reader.pos < end) {
281
+ const tag = reader.uint32();
282
+ switch (tag >>> 3) {
283
+ case 1:
284
+ if (tag !== 8) break;
285
+ message.op = reader.int32();
286
+ continue;
287
+ case 2:
288
+ if (tag !== 18) break;
289
+ message.path = reader.string();
290
+ continue;
291
+ case 3:
292
+ if (tag !== 26) break;
293
+ message.from = reader.string();
294
+ continue;
295
+ case 4:
296
+ if (tag !== 34) break;
297
+ message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
298
+ continue;
299
+ }
300
+ if ((tag & 7) === 4 || tag === 0) break;
301
+ reader.skip(tag & 7);
302
+ }
303
+ return message;
304
+ },
305
+ create(base) {
306
+ return JsonPatchOperation.fromPartial(base ?? {});
307
+ },
308
+ fromPartial(object) {
309
+ const message = createBaseJsonPatchOperation();
310
+ message.op = object.op ?? 0;
311
+ message.path = object.path ?? "";
312
+ message.from = object.from ?? void 0;
313
+ message.value = object.value ?? void 0;
314
+ return message;
315
+ }
443
316
  };
444
317
 
445
- // src/generated/types.ts
446
- var import_wire3 = require("@bufbuild/protobuf/wire");
318
+ //#endregion
319
+ //#region src/generated/types.ts
447
320
  function createBaseToolCall() {
448
- return { id: "", type: "", function: void 0 };
321
+ return {
322
+ id: "",
323
+ type: "",
324
+ function: void 0
325
+ };
449
326
  }
450
- var ToolCall = {
451
- encode(message, writer = new import_wire3.BinaryWriter()) {
452
- if (message.id !== "") {
453
- writer.uint32(10).string(message.id);
454
- }
455
- if (message.type !== "") {
456
- writer.uint32(18).string(message.type);
457
- }
458
- if (message.function !== void 0) {
459
- ToolCall_Function.encode(message.function, writer.uint32(26).fork()).join();
460
- }
461
- return writer;
462
- },
463
- decode(input, length) {
464
- const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
465
- const end = length === void 0 ? reader.len : reader.pos + length;
466
- const message = createBaseToolCall();
467
- while (reader.pos < end) {
468
- const tag = reader.uint32();
469
- switch (tag >>> 3) {
470
- case 1: {
471
- if (tag !== 10) {
472
- break;
473
- }
474
- message.id = reader.string();
475
- continue;
476
- }
477
- case 2: {
478
- if (tag !== 18) {
479
- break;
480
- }
481
- message.type = reader.string();
482
- continue;
483
- }
484
- case 3: {
485
- if (tag !== 26) {
486
- break;
487
- }
488
- message.function = ToolCall_Function.decode(reader, reader.uint32());
489
- continue;
490
- }
491
- }
492
- if ((tag & 7) === 4 || tag === 0) {
493
- break;
494
- }
495
- reader.skip(tag & 7);
496
- }
497
- return message;
498
- },
499
- create(base) {
500
- return ToolCall.fromPartial(base != null ? base : {});
501
- },
502
- fromPartial(object) {
503
- var _a, _b;
504
- const message = createBaseToolCall();
505
- message.id = (_a = object.id) != null ? _a : "";
506
- message.type = (_b = object.type) != null ? _b : "";
507
- message.function = object.function !== void 0 && object.function !== null ? ToolCall_Function.fromPartial(object.function) : void 0;
508
- return message;
509
- }
327
+ const ToolCall = {
328
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
329
+ if (message.id !== "") writer.uint32(10).string(message.id);
330
+ if (message.type !== "") writer.uint32(18).string(message.type);
331
+ if (message.function !== void 0) ToolCall_Function.encode(message.function, writer.uint32(26).fork()).join();
332
+ return writer;
333
+ },
334
+ decode(input, length) {
335
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
336
+ const end = length === void 0 ? reader.len : reader.pos + length;
337
+ const message = createBaseToolCall();
338
+ while (reader.pos < end) {
339
+ const tag = reader.uint32();
340
+ switch (tag >>> 3) {
341
+ case 1:
342
+ if (tag !== 10) break;
343
+ message.id = reader.string();
344
+ continue;
345
+ case 2:
346
+ if (tag !== 18) break;
347
+ message.type = reader.string();
348
+ continue;
349
+ case 3:
350
+ if (tag !== 26) break;
351
+ message.function = ToolCall_Function.decode(reader, reader.uint32());
352
+ continue;
353
+ }
354
+ if ((tag & 7) === 4 || tag === 0) break;
355
+ reader.skip(tag & 7);
356
+ }
357
+ return message;
358
+ },
359
+ create(base) {
360
+ return ToolCall.fromPartial(base ?? {});
361
+ },
362
+ fromPartial(object) {
363
+ const message = createBaseToolCall();
364
+ message.id = object.id ?? "";
365
+ message.type = object.type ?? "";
366
+ message.function = object.function !== void 0 && object.function !== null ? ToolCall_Function.fromPartial(object.function) : void 0;
367
+ return message;
368
+ }
510
369
  };
511
370
  function createBaseToolCall_Function() {
512
- return { name: "", arguments: "" };
371
+ return {
372
+ name: "",
373
+ arguments: ""
374
+ };
513
375
  }
514
- var ToolCall_Function = {
515
- encode(message, writer = new import_wire3.BinaryWriter()) {
516
- if (message.name !== "") {
517
- writer.uint32(10).string(message.name);
518
- }
519
- if (message.arguments !== "") {
520
- writer.uint32(18).string(message.arguments);
521
- }
522
- return writer;
523
- },
524
- decode(input, length) {
525
- const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
526
- const end = length === void 0 ? reader.len : reader.pos + length;
527
- const message = createBaseToolCall_Function();
528
- while (reader.pos < end) {
529
- const tag = reader.uint32();
530
- switch (tag >>> 3) {
531
- case 1: {
532
- if (tag !== 10) {
533
- break;
534
- }
535
- message.name = reader.string();
536
- continue;
537
- }
538
- case 2: {
539
- if (tag !== 18) {
540
- break;
541
- }
542
- message.arguments = reader.string();
543
- continue;
544
- }
545
- }
546
- if ((tag & 7) === 4 || tag === 0) {
547
- break;
548
- }
549
- reader.skip(tag & 7);
550
- }
551
- return message;
552
- },
553
- create(base) {
554
- return ToolCall_Function.fromPartial(base != null ? base : {});
555
- },
556
- fromPartial(object) {
557
- var _a, _b;
558
- const message = createBaseToolCall_Function();
559
- message.name = (_a = object.name) != null ? _a : "";
560
- message.arguments = (_b = object.arguments) != null ? _b : "";
561
- return message;
562
- }
376
+ const ToolCall_Function = {
377
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
378
+ if (message.name !== "") writer.uint32(10).string(message.name);
379
+ if (message.arguments !== "") writer.uint32(18).string(message.arguments);
380
+ return writer;
381
+ },
382
+ decode(input, length) {
383
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
384
+ const end = length === void 0 ? reader.len : reader.pos + length;
385
+ const message = createBaseToolCall_Function();
386
+ while (reader.pos < end) {
387
+ const tag = reader.uint32();
388
+ switch (tag >>> 3) {
389
+ case 1:
390
+ if (tag !== 10) break;
391
+ message.name = reader.string();
392
+ continue;
393
+ case 2:
394
+ if (tag !== 18) break;
395
+ message.arguments = reader.string();
396
+ continue;
397
+ }
398
+ if ((tag & 7) === 4 || tag === 0) break;
399
+ reader.skip(tag & 7);
400
+ }
401
+ return message;
402
+ },
403
+ create(base) {
404
+ return ToolCall_Function.fromPartial(base ?? {});
405
+ },
406
+ fromPartial(object) {
407
+ const message = createBaseToolCall_Function();
408
+ message.name = object.name ?? "";
409
+ message.arguments = object.arguments ?? "";
410
+ return message;
411
+ }
563
412
  };
564
413
  function createBaseMessage() {
565
- return {
566
- id: "",
567
- role: "",
568
- content: void 0,
569
- name: void 0,
570
- toolCalls: [],
571
- toolCallId: void 0,
572
- error: void 0
573
- };
414
+ return {
415
+ id: "",
416
+ role: "",
417
+ content: void 0,
418
+ name: void 0,
419
+ toolCalls: [],
420
+ toolCallId: void 0,
421
+ error: void 0
422
+ };
574
423
  }
575
- var Message = {
576
- encode(message, writer = new import_wire3.BinaryWriter()) {
577
- if (message.id !== "") {
578
- writer.uint32(10).string(message.id);
579
- }
580
- if (message.role !== "") {
581
- writer.uint32(18).string(message.role);
582
- }
583
- if (message.content !== void 0) {
584
- writer.uint32(26).string(message.content);
585
- }
586
- if (message.name !== void 0) {
587
- writer.uint32(34).string(message.name);
588
- }
589
- for (const v of message.toolCalls) {
590
- ToolCall.encode(v, writer.uint32(42).fork()).join();
591
- }
592
- if (message.toolCallId !== void 0) {
593
- writer.uint32(50).string(message.toolCallId);
594
- }
595
- if (message.error !== void 0) {
596
- writer.uint32(58).string(message.error);
597
- }
598
- return writer;
599
- },
600
- decode(input, length) {
601
- const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
602
- const end = length === void 0 ? reader.len : reader.pos + length;
603
- const message = createBaseMessage();
604
- while (reader.pos < end) {
605
- const tag = reader.uint32();
606
- switch (tag >>> 3) {
607
- case 1: {
608
- if (tag !== 10) {
609
- break;
610
- }
611
- message.id = reader.string();
612
- continue;
613
- }
614
- case 2: {
615
- if (tag !== 18) {
616
- break;
617
- }
618
- message.role = reader.string();
619
- continue;
620
- }
621
- case 3: {
622
- if (tag !== 26) {
623
- break;
624
- }
625
- message.content = reader.string();
626
- continue;
627
- }
628
- case 4: {
629
- if (tag !== 34) {
630
- break;
631
- }
632
- message.name = reader.string();
633
- continue;
634
- }
635
- case 5: {
636
- if (tag !== 42) {
637
- break;
638
- }
639
- message.toolCalls.push(ToolCall.decode(reader, reader.uint32()));
640
- continue;
641
- }
642
- case 6: {
643
- if (tag !== 50) {
644
- break;
645
- }
646
- message.toolCallId = reader.string();
647
- continue;
648
- }
649
- case 7: {
650
- if (tag !== 58) {
651
- break;
652
- }
653
- message.error = reader.string();
654
- continue;
655
- }
656
- }
657
- if ((tag & 7) === 4 || tag === 0) {
658
- break;
659
- }
660
- reader.skip(tag & 7);
661
- }
662
- return message;
663
- },
664
- create(base) {
665
- return Message.fromPartial(base != null ? base : {});
666
- },
667
- fromPartial(object) {
668
- var _a, _b, _c, _d, _e, _f, _g;
669
- const message = createBaseMessage();
670
- message.id = (_a = object.id) != null ? _a : "";
671
- message.role = (_b = object.role) != null ? _b : "";
672
- message.content = (_c = object.content) != null ? _c : void 0;
673
- message.name = (_d = object.name) != null ? _d : void 0;
674
- message.toolCalls = ((_e = object.toolCalls) == null ? void 0 : _e.map((e) => ToolCall.fromPartial(e))) || [];
675
- message.toolCallId = (_f = object.toolCallId) != null ? _f : void 0;
676
- message.error = (_g = object.error) != null ? _g : void 0;
677
- return message;
678
- }
424
+ const Message = {
425
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
426
+ if (message.id !== "") writer.uint32(10).string(message.id);
427
+ if (message.role !== "") writer.uint32(18).string(message.role);
428
+ if (message.content !== void 0) writer.uint32(26).string(message.content);
429
+ if (message.name !== void 0) writer.uint32(34).string(message.name);
430
+ for (const v of message.toolCalls) ToolCall.encode(v, writer.uint32(42).fork()).join();
431
+ if (message.toolCallId !== void 0) writer.uint32(50).string(message.toolCallId);
432
+ if (message.error !== void 0) writer.uint32(58).string(message.error);
433
+ return writer;
434
+ },
435
+ decode(input, length) {
436
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
437
+ const end = length === void 0 ? reader.len : reader.pos + length;
438
+ const message = createBaseMessage();
439
+ while (reader.pos < end) {
440
+ const tag = reader.uint32();
441
+ switch (tag >>> 3) {
442
+ case 1:
443
+ if (tag !== 10) break;
444
+ message.id = reader.string();
445
+ continue;
446
+ case 2:
447
+ if (tag !== 18) break;
448
+ message.role = reader.string();
449
+ continue;
450
+ case 3:
451
+ if (tag !== 26) break;
452
+ message.content = reader.string();
453
+ continue;
454
+ case 4:
455
+ if (tag !== 34) break;
456
+ message.name = reader.string();
457
+ continue;
458
+ case 5:
459
+ if (tag !== 42) break;
460
+ message.toolCalls.push(ToolCall.decode(reader, reader.uint32()));
461
+ continue;
462
+ case 6:
463
+ if (tag !== 50) break;
464
+ message.toolCallId = reader.string();
465
+ continue;
466
+ case 7:
467
+ if (tag !== 58) break;
468
+ message.error = reader.string();
469
+ continue;
470
+ }
471
+ if ((tag & 7) === 4 || tag === 0) break;
472
+ reader.skip(tag & 7);
473
+ }
474
+ return message;
475
+ },
476
+ create(base) {
477
+ return Message.fromPartial(base ?? {});
478
+ },
479
+ fromPartial(object) {
480
+ const message = createBaseMessage();
481
+ message.id = object.id ?? "";
482
+ message.role = object.role ?? "";
483
+ message.content = object.content ?? void 0;
484
+ message.name = object.name ?? void 0;
485
+ message.toolCalls = object.toolCalls?.map((e) => ToolCall.fromPartial(e)) || [];
486
+ message.toolCallId = object.toolCallId ?? void 0;
487
+ message.error = object.error ?? void 0;
488
+ return message;
489
+ }
679
490
  };
680
491
 
681
- // src/generated/events.ts
682
- var EventType = /* @__PURE__ */ ((EventType3) => {
683
- EventType3[EventType3["TEXT_MESSAGE_START"] = 0] = "TEXT_MESSAGE_START";
684
- EventType3[EventType3["TEXT_MESSAGE_CONTENT"] = 1] = "TEXT_MESSAGE_CONTENT";
685
- EventType3[EventType3["TEXT_MESSAGE_END"] = 2] = "TEXT_MESSAGE_END";
686
- EventType3[EventType3["TOOL_CALL_START"] = 3] = "TOOL_CALL_START";
687
- EventType3[EventType3["TOOL_CALL_ARGS"] = 4] = "TOOL_CALL_ARGS";
688
- EventType3[EventType3["TOOL_CALL_END"] = 5] = "TOOL_CALL_END";
689
- EventType3[EventType3["STATE_SNAPSHOT"] = 6] = "STATE_SNAPSHOT";
690
- EventType3[EventType3["STATE_DELTA"] = 7] = "STATE_DELTA";
691
- EventType3[EventType3["MESSAGES_SNAPSHOT"] = 8] = "MESSAGES_SNAPSHOT";
692
- EventType3[EventType3["RAW"] = 9] = "RAW";
693
- EventType3[EventType3["CUSTOM"] = 10] = "CUSTOM";
694
- EventType3[EventType3["RUN_STARTED"] = 11] = "RUN_STARTED";
695
- EventType3[EventType3["RUN_FINISHED"] = 12] = "RUN_FINISHED";
696
- EventType3[EventType3["RUN_ERROR"] = 13] = "RUN_ERROR";
697
- EventType3[EventType3["STEP_STARTED"] = 14] = "STEP_STARTED";
698
- EventType3[EventType3["STEP_FINISHED"] = 15] = "STEP_FINISHED";
699
- EventType3[EventType3["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
700
- return EventType3;
701
- })(EventType || {});
492
+ //#endregion
493
+ //#region src/generated/events.ts
494
+ let EventType$1 = /* @__PURE__ */ function(EventType) {
495
+ EventType[EventType["TEXT_MESSAGE_START"] = 0] = "TEXT_MESSAGE_START";
496
+ EventType[EventType["TEXT_MESSAGE_CONTENT"] = 1] = "TEXT_MESSAGE_CONTENT";
497
+ EventType[EventType["TEXT_MESSAGE_END"] = 2] = "TEXT_MESSAGE_END";
498
+ EventType[EventType["TOOL_CALL_START"] = 3] = "TOOL_CALL_START";
499
+ EventType[EventType["TOOL_CALL_ARGS"] = 4] = "TOOL_CALL_ARGS";
500
+ EventType[EventType["TOOL_CALL_END"] = 5] = "TOOL_CALL_END";
501
+ EventType[EventType["STATE_SNAPSHOT"] = 6] = "STATE_SNAPSHOT";
502
+ EventType[EventType["STATE_DELTA"] = 7] = "STATE_DELTA";
503
+ EventType[EventType["MESSAGES_SNAPSHOT"] = 8] = "MESSAGES_SNAPSHOT";
504
+ EventType[EventType["RAW"] = 9] = "RAW";
505
+ EventType[EventType["CUSTOM"] = 10] = "CUSTOM";
506
+ EventType[EventType["RUN_STARTED"] = 11] = "RUN_STARTED";
507
+ EventType[EventType["RUN_FINISHED"] = 12] = "RUN_FINISHED";
508
+ EventType[EventType["RUN_ERROR"] = 13] = "RUN_ERROR";
509
+ EventType[EventType["STEP_STARTED"] = 14] = "STEP_STARTED";
510
+ EventType[EventType["STEP_FINISHED"] = 15] = "STEP_FINISHED";
511
+ EventType[EventType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
512
+ return EventType;
513
+ }({});
702
514
  function createBaseBaseEvent() {
703
- return { type: 0, timestamp: void 0, rawEvent: void 0 };
515
+ return {
516
+ type: 0,
517
+ timestamp: void 0,
518
+ rawEvent: void 0
519
+ };
704
520
  }
705
- var BaseEvent = {
706
- encode(message, writer = new import_wire4.BinaryWriter()) {
707
- if (message.type !== 0) {
708
- writer.uint32(8).int32(message.type);
709
- }
710
- if (message.timestamp !== void 0) {
711
- writer.uint32(16).int64(message.timestamp);
712
- }
713
- if (message.rawEvent !== void 0) {
714
- Value.encode(Value.wrap(message.rawEvent), writer.uint32(26).fork()).join();
715
- }
716
- return writer;
717
- },
718
- decode(input, length) {
719
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
720
- const end = length === void 0 ? reader.len : reader.pos + length;
721
- const message = createBaseBaseEvent();
722
- while (reader.pos < end) {
723
- const tag = reader.uint32();
724
- switch (tag >>> 3) {
725
- case 1: {
726
- if (tag !== 8) {
727
- break;
728
- }
729
- message.type = reader.int32();
730
- continue;
731
- }
732
- case 2: {
733
- if (tag !== 16) {
734
- break;
735
- }
736
- message.timestamp = longToNumber(reader.int64());
737
- continue;
738
- }
739
- case 3: {
740
- if (tag !== 26) {
741
- break;
742
- }
743
- message.rawEvent = Value.unwrap(Value.decode(reader, reader.uint32()));
744
- continue;
745
- }
746
- }
747
- if ((tag & 7) === 4 || tag === 0) {
748
- break;
749
- }
750
- reader.skip(tag & 7);
751
- }
752
- return message;
753
- },
754
- create(base) {
755
- return BaseEvent.fromPartial(base != null ? base : {});
756
- },
757
- fromPartial(object) {
758
- var _a, _b, _c;
759
- const message = createBaseBaseEvent();
760
- message.type = (_a = object.type) != null ? _a : 0;
761
- message.timestamp = (_b = object.timestamp) != null ? _b : void 0;
762
- message.rawEvent = (_c = object.rawEvent) != null ? _c : void 0;
763
- return message;
764
- }
521
+ const BaseEvent = {
522
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
523
+ if (message.type !== 0) writer.uint32(8).int32(message.type);
524
+ if (message.timestamp !== void 0) writer.uint32(16).int64(message.timestamp);
525
+ if (message.rawEvent !== void 0) Value.encode(Value.wrap(message.rawEvent), writer.uint32(26).fork()).join();
526
+ return writer;
527
+ },
528
+ decode(input, length) {
529
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
530
+ const end = length === void 0 ? reader.len : reader.pos + length;
531
+ const message = createBaseBaseEvent();
532
+ while (reader.pos < end) {
533
+ const tag = reader.uint32();
534
+ switch (tag >>> 3) {
535
+ case 1:
536
+ if (tag !== 8) break;
537
+ message.type = reader.int32();
538
+ continue;
539
+ case 2:
540
+ if (tag !== 16) break;
541
+ message.timestamp = longToNumber(reader.int64());
542
+ continue;
543
+ case 3:
544
+ if (tag !== 26) break;
545
+ message.rawEvent = Value.unwrap(Value.decode(reader, reader.uint32()));
546
+ continue;
547
+ }
548
+ if ((tag & 7) === 4 || tag === 0) break;
549
+ reader.skip(tag & 7);
550
+ }
551
+ return message;
552
+ },
553
+ create(base) {
554
+ return BaseEvent.fromPartial(base ?? {});
555
+ },
556
+ fromPartial(object) {
557
+ const message = createBaseBaseEvent();
558
+ message.type = object.type ?? 0;
559
+ message.timestamp = object.timestamp ?? void 0;
560
+ message.rawEvent = object.rawEvent ?? void 0;
561
+ return message;
562
+ }
765
563
  };
766
564
  function createBaseTextMessageStartEvent() {
767
- return { baseEvent: void 0, messageId: "", role: void 0 };
565
+ return {
566
+ baseEvent: void 0,
567
+ messageId: "",
568
+ role: void 0
569
+ };
768
570
  }
769
- var TextMessageStartEvent = {
770
- encode(message, writer = new import_wire4.BinaryWriter()) {
771
- if (message.baseEvent !== void 0) {
772
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
773
- }
774
- if (message.messageId !== "") {
775
- writer.uint32(18).string(message.messageId);
776
- }
777
- if (message.role !== void 0) {
778
- writer.uint32(26).string(message.role);
779
- }
780
- return writer;
781
- },
782
- decode(input, length) {
783
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
784
- const end = length === void 0 ? reader.len : reader.pos + length;
785
- const message = createBaseTextMessageStartEvent();
786
- while (reader.pos < end) {
787
- const tag = reader.uint32();
788
- switch (tag >>> 3) {
789
- case 1: {
790
- if (tag !== 10) {
791
- break;
792
- }
793
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
794
- continue;
795
- }
796
- case 2: {
797
- if (tag !== 18) {
798
- break;
799
- }
800
- message.messageId = reader.string();
801
- continue;
802
- }
803
- case 3: {
804
- if (tag !== 26) {
805
- break;
806
- }
807
- message.role = reader.string();
808
- continue;
809
- }
810
- }
811
- if ((tag & 7) === 4 || tag === 0) {
812
- break;
813
- }
814
- reader.skip(tag & 7);
815
- }
816
- return message;
817
- },
818
- create(base) {
819
- return TextMessageStartEvent.fromPartial(base != null ? base : {});
820
- },
821
- fromPartial(object) {
822
- var _a, _b;
823
- const message = createBaseTextMessageStartEvent();
824
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
825
- message.messageId = (_a = object.messageId) != null ? _a : "";
826
- message.role = (_b = object.role) != null ? _b : void 0;
827
- return message;
828
- }
571
+ const TextMessageStartEvent = {
572
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
573
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
574
+ if (message.messageId !== "") writer.uint32(18).string(message.messageId);
575
+ if (message.role !== void 0) writer.uint32(26).string(message.role);
576
+ return writer;
577
+ },
578
+ decode(input, length) {
579
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
580
+ const end = length === void 0 ? reader.len : reader.pos + length;
581
+ const message = createBaseTextMessageStartEvent();
582
+ while (reader.pos < end) {
583
+ const tag = reader.uint32();
584
+ switch (tag >>> 3) {
585
+ case 1:
586
+ if (tag !== 10) break;
587
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
588
+ continue;
589
+ case 2:
590
+ if (tag !== 18) break;
591
+ message.messageId = reader.string();
592
+ continue;
593
+ case 3:
594
+ if (tag !== 26) break;
595
+ message.role = reader.string();
596
+ continue;
597
+ }
598
+ if ((tag & 7) === 4 || tag === 0) break;
599
+ reader.skip(tag & 7);
600
+ }
601
+ return message;
602
+ },
603
+ create(base) {
604
+ return TextMessageStartEvent.fromPartial(base ?? {});
605
+ },
606
+ fromPartial(object) {
607
+ const message = createBaseTextMessageStartEvent();
608
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
609
+ message.messageId = object.messageId ?? "";
610
+ message.role = object.role ?? void 0;
611
+ return message;
612
+ }
829
613
  };
830
614
  function createBaseTextMessageContentEvent() {
831
- return { baseEvent: void 0, messageId: "", delta: "" };
615
+ return {
616
+ baseEvent: void 0,
617
+ messageId: "",
618
+ delta: ""
619
+ };
832
620
  }
833
- var TextMessageContentEvent = {
834
- encode(message, writer = new import_wire4.BinaryWriter()) {
835
- if (message.baseEvent !== void 0) {
836
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
837
- }
838
- if (message.messageId !== "") {
839
- writer.uint32(18).string(message.messageId);
840
- }
841
- if (message.delta !== "") {
842
- writer.uint32(26).string(message.delta);
843
- }
844
- return writer;
845
- },
846
- decode(input, length) {
847
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
848
- const end = length === void 0 ? reader.len : reader.pos + length;
849
- const message = createBaseTextMessageContentEvent();
850
- while (reader.pos < end) {
851
- const tag = reader.uint32();
852
- switch (tag >>> 3) {
853
- case 1: {
854
- if (tag !== 10) {
855
- break;
856
- }
857
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
858
- continue;
859
- }
860
- case 2: {
861
- if (tag !== 18) {
862
- break;
863
- }
864
- message.messageId = reader.string();
865
- continue;
866
- }
867
- case 3: {
868
- if (tag !== 26) {
869
- break;
870
- }
871
- message.delta = reader.string();
872
- continue;
873
- }
874
- }
875
- if ((tag & 7) === 4 || tag === 0) {
876
- break;
877
- }
878
- reader.skip(tag & 7);
879
- }
880
- return message;
881
- },
882
- create(base) {
883
- return TextMessageContentEvent.fromPartial(base != null ? base : {});
884
- },
885
- fromPartial(object) {
886
- var _a, _b;
887
- const message = createBaseTextMessageContentEvent();
888
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
889
- message.messageId = (_a = object.messageId) != null ? _a : "";
890
- message.delta = (_b = object.delta) != null ? _b : "";
891
- return message;
892
- }
621
+ const TextMessageContentEvent = {
622
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
623
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
624
+ if (message.messageId !== "") writer.uint32(18).string(message.messageId);
625
+ if (message.delta !== "") writer.uint32(26).string(message.delta);
626
+ return writer;
627
+ },
628
+ decode(input, length) {
629
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
630
+ const end = length === void 0 ? reader.len : reader.pos + length;
631
+ const message = createBaseTextMessageContentEvent();
632
+ while (reader.pos < end) {
633
+ const tag = reader.uint32();
634
+ switch (tag >>> 3) {
635
+ case 1:
636
+ if (tag !== 10) break;
637
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
638
+ continue;
639
+ case 2:
640
+ if (tag !== 18) break;
641
+ message.messageId = reader.string();
642
+ continue;
643
+ case 3:
644
+ if (tag !== 26) break;
645
+ message.delta = reader.string();
646
+ continue;
647
+ }
648
+ if ((tag & 7) === 4 || tag === 0) break;
649
+ reader.skip(tag & 7);
650
+ }
651
+ return message;
652
+ },
653
+ create(base) {
654
+ return TextMessageContentEvent.fromPartial(base ?? {});
655
+ },
656
+ fromPartial(object) {
657
+ const message = createBaseTextMessageContentEvent();
658
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
659
+ message.messageId = object.messageId ?? "";
660
+ message.delta = object.delta ?? "";
661
+ return message;
662
+ }
893
663
  };
894
664
  function createBaseTextMessageEndEvent() {
895
- return { baseEvent: void 0, messageId: "" };
665
+ return {
666
+ baseEvent: void 0,
667
+ messageId: ""
668
+ };
896
669
  }
897
- var TextMessageEndEvent = {
898
- encode(message, writer = new import_wire4.BinaryWriter()) {
899
- if (message.baseEvent !== void 0) {
900
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
901
- }
902
- if (message.messageId !== "") {
903
- writer.uint32(18).string(message.messageId);
904
- }
905
- return writer;
906
- },
907
- decode(input, length) {
908
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
909
- const end = length === void 0 ? reader.len : reader.pos + length;
910
- const message = createBaseTextMessageEndEvent();
911
- while (reader.pos < end) {
912
- const tag = reader.uint32();
913
- switch (tag >>> 3) {
914
- case 1: {
915
- if (tag !== 10) {
916
- break;
917
- }
918
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
919
- continue;
920
- }
921
- case 2: {
922
- if (tag !== 18) {
923
- break;
924
- }
925
- message.messageId = reader.string();
926
- continue;
927
- }
928
- }
929
- if ((tag & 7) === 4 || tag === 0) {
930
- break;
931
- }
932
- reader.skip(tag & 7);
933
- }
934
- return message;
935
- },
936
- create(base) {
937
- return TextMessageEndEvent.fromPartial(base != null ? base : {});
938
- },
939
- fromPartial(object) {
940
- var _a;
941
- const message = createBaseTextMessageEndEvent();
942
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
943
- message.messageId = (_a = object.messageId) != null ? _a : "";
944
- return message;
945
- }
670
+ const TextMessageEndEvent = {
671
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
672
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
673
+ if (message.messageId !== "") writer.uint32(18).string(message.messageId);
674
+ return writer;
675
+ },
676
+ decode(input, length) {
677
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
678
+ const end = length === void 0 ? reader.len : reader.pos + length;
679
+ const message = createBaseTextMessageEndEvent();
680
+ while (reader.pos < end) {
681
+ const tag = reader.uint32();
682
+ switch (tag >>> 3) {
683
+ case 1:
684
+ if (tag !== 10) break;
685
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
686
+ continue;
687
+ case 2:
688
+ if (tag !== 18) break;
689
+ message.messageId = reader.string();
690
+ continue;
691
+ }
692
+ if ((tag & 7) === 4 || tag === 0) break;
693
+ reader.skip(tag & 7);
694
+ }
695
+ return message;
696
+ },
697
+ create(base) {
698
+ return TextMessageEndEvent.fromPartial(base ?? {});
699
+ },
700
+ fromPartial(object) {
701
+ const message = createBaseTextMessageEndEvent();
702
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
703
+ message.messageId = object.messageId ?? "";
704
+ return message;
705
+ }
946
706
  };
947
707
  function createBaseToolCallStartEvent() {
948
- return { baseEvent: void 0, toolCallId: "", toolCallName: "", parentMessageId: void 0 };
708
+ return {
709
+ baseEvent: void 0,
710
+ toolCallId: "",
711
+ toolCallName: "",
712
+ parentMessageId: void 0
713
+ };
949
714
  }
950
- var ToolCallStartEvent = {
951
- encode(message, writer = new import_wire4.BinaryWriter()) {
952
- if (message.baseEvent !== void 0) {
953
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
954
- }
955
- if (message.toolCallId !== "") {
956
- writer.uint32(18).string(message.toolCallId);
957
- }
958
- if (message.toolCallName !== "") {
959
- writer.uint32(26).string(message.toolCallName);
960
- }
961
- if (message.parentMessageId !== void 0) {
962
- writer.uint32(34).string(message.parentMessageId);
963
- }
964
- return writer;
965
- },
966
- decode(input, length) {
967
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
968
- const end = length === void 0 ? reader.len : reader.pos + length;
969
- const message = createBaseToolCallStartEvent();
970
- while (reader.pos < end) {
971
- const tag = reader.uint32();
972
- switch (tag >>> 3) {
973
- case 1: {
974
- if (tag !== 10) {
975
- break;
976
- }
977
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
978
- continue;
979
- }
980
- case 2: {
981
- if (tag !== 18) {
982
- break;
983
- }
984
- message.toolCallId = reader.string();
985
- continue;
986
- }
987
- case 3: {
988
- if (tag !== 26) {
989
- break;
990
- }
991
- message.toolCallName = reader.string();
992
- continue;
993
- }
994
- case 4: {
995
- if (tag !== 34) {
996
- break;
997
- }
998
- message.parentMessageId = reader.string();
999
- continue;
1000
- }
1001
- }
1002
- if ((tag & 7) === 4 || tag === 0) {
1003
- break;
1004
- }
1005
- reader.skip(tag & 7);
1006
- }
1007
- return message;
1008
- },
1009
- create(base) {
1010
- return ToolCallStartEvent.fromPartial(base != null ? base : {});
1011
- },
1012
- fromPartial(object) {
1013
- var _a, _b, _c;
1014
- const message = createBaseToolCallStartEvent();
1015
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1016
- message.toolCallId = (_a = object.toolCallId) != null ? _a : "";
1017
- message.toolCallName = (_b = object.toolCallName) != null ? _b : "";
1018
- message.parentMessageId = (_c = object.parentMessageId) != null ? _c : void 0;
1019
- return message;
1020
- }
715
+ const ToolCallStartEvent = {
716
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
717
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
718
+ if (message.toolCallId !== "") writer.uint32(18).string(message.toolCallId);
719
+ if (message.toolCallName !== "") writer.uint32(26).string(message.toolCallName);
720
+ if (message.parentMessageId !== void 0) writer.uint32(34).string(message.parentMessageId);
721
+ return writer;
722
+ },
723
+ decode(input, length) {
724
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
725
+ const end = length === void 0 ? reader.len : reader.pos + length;
726
+ const message = createBaseToolCallStartEvent();
727
+ while (reader.pos < end) {
728
+ const tag = reader.uint32();
729
+ switch (tag >>> 3) {
730
+ case 1:
731
+ if (tag !== 10) break;
732
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
733
+ continue;
734
+ case 2:
735
+ if (tag !== 18) break;
736
+ message.toolCallId = reader.string();
737
+ continue;
738
+ case 3:
739
+ if (tag !== 26) break;
740
+ message.toolCallName = reader.string();
741
+ continue;
742
+ case 4:
743
+ if (tag !== 34) break;
744
+ message.parentMessageId = reader.string();
745
+ continue;
746
+ }
747
+ if ((tag & 7) === 4 || tag === 0) break;
748
+ reader.skip(tag & 7);
749
+ }
750
+ return message;
751
+ },
752
+ create(base) {
753
+ return ToolCallStartEvent.fromPartial(base ?? {});
754
+ },
755
+ fromPartial(object) {
756
+ const message = createBaseToolCallStartEvent();
757
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
758
+ message.toolCallId = object.toolCallId ?? "";
759
+ message.toolCallName = object.toolCallName ?? "";
760
+ message.parentMessageId = object.parentMessageId ?? void 0;
761
+ return message;
762
+ }
1021
763
  };
1022
764
  function createBaseToolCallArgsEvent() {
1023
- return { baseEvent: void 0, toolCallId: "", delta: "" };
765
+ return {
766
+ baseEvent: void 0,
767
+ toolCallId: "",
768
+ delta: ""
769
+ };
1024
770
  }
1025
- var ToolCallArgsEvent = {
1026
- encode(message, writer = new import_wire4.BinaryWriter()) {
1027
- if (message.baseEvent !== void 0) {
1028
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1029
- }
1030
- if (message.toolCallId !== "") {
1031
- writer.uint32(18).string(message.toolCallId);
1032
- }
1033
- if (message.delta !== "") {
1034
- writer.uint32(26).string(message.delta);
1035
- }
1036
- return writer;
1037
- },
1038
- decode(input, length) {
1039
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1040
- const end = length === void 0 ? reader.len : reader.pos + length;
1041
- const message = createBaseToolCallArgsEvent();
1042
- while (reader.pos < end) {
1043
- const tag = reader.uint32();
1044
- switch (tag >>> 3) {
1045
- case 1: {
1046
- if (tag !== 10) {
1047
- break;
1048
- }
1049
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1050
- continue;
1051
- }
1052
- case 2: {
1053
- if (tag !== 18) {
1054
- break;
1055
- }
1056
- message.toolCallId = reader.string();
1057
- continue;
1058
- }
1059
- case 3: {
1060
- if (tag !== 26) {
1061
- break;
1062
- }
1063
- message.delta = reader.string();
1064
- continue;
1065
- }
1066
- }
1067
- if ((tag & 7) === 4 || tag === 0) {
1068
- break;
1069
- }
1070
- reader.skip(tag & 7);
1071
- }
1072
- return message;
1073
- },
1074
- create(base) {
1075
- return ToolCallArgsEvent.fromPartial(base != null ? base : {});
1076
- },
1077
- fromPartial(object) {
1078
- var _a, _b;
1079
- const message = createBaseToolCallArgsEvent();
1080
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1081
- message.toolCallId = (_a = object.toolCallId) != null ? _a : "";
1082
- message.delta = (_b = object.delta) != null ? _b : "";
1083
- return message;
1084
- }
771
+ const ToolCallArgsEvent = {
772
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
773
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
774
+ if (message.toolCallId !== "") writer.uint32(18).string(message.toolCallId);
775
+ if (message.delta !== "") writer.uint32(26).string(message.delta);
776
+ return writer;
777
+ },
778
+ decode(input, length) {
779
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
780
+ const end = length === void 0 ? reader.len : reader.pos + length;
781
+ const message = createBaseToolCallArgsEvent();
782
+ while (reader.pos < end) {
783
+ const tag = reader.uint32();
784
+ switch (tag >>> 3) {
785
+ case 1:
786
+ if (tag !== 10) break;
787
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
788
+ continue;
789
+ case 2:
790
+ if (tag !== 18) break;
791
+ message.toolCallId = reader.string();
792
+ continue;
793
+ case 3:
794
+ if (tag !== 26) break;
795
+ message.delta = reader.string();
796
+ continue;
797
+ }
798
+ if ((tag & 7) === 4 || tag === 0) break;
799
+ reader.skip(tag & 7);
800
+ }
801
+ return message;
802
+ },
803
+ create(base) {
804
+ return ToolCallArgsEvent.fromPartial(base ?? {});
805
+ },
806
+ fromPartial(object) {
807
+ const message = createBaseToolCallArgsEvent();
808
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
809
+ message.toolCallId = object.toolCallId ?? "";
810
+ message.delta = object.delta ?? "";
811
+ return message;
812
+ }
1085
813
  };
1086
814
  function createBaseToolCallEndEvent() {
1087
- return { baseEvent: void 0, toolCallId: "" };
815
+ return {
816
+ baseEvent: void 0,
817
+ toolCallId: ""
818
+ };
1088
819
  }
1089
- var ToolCallEndEvent = {
1090
- encode(message, writer = new import_wire4.BinaryWriter()) {
1091
- if (message.baseEvent !== void 0) {
1092
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1093
- }
1094
- if (message.toolCallId !== "") {
1095
- writer.uint32(18).string(message.toolCallId);
1096
- }
1097
- return writer;
1098
- },
1099
- decode(input, length) {
1100
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1101
- const end = length === void 0 ? reader.len : reader.pos + length;
1102
- const message = createBaseToolCallEndEvent();
1103
- while (reader.pos < end) {
1104
- const tag = reader.uint32();
1105
- switch (tag >>> 3) {
1106
- case 1: {
1107
- if (tag !== 10) {
1108
- break;
1109
- }
1110
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1111
- continue;
1112
- }
1113
- case 2: {
1114
- if (tag !== 18) {
1115
- break;
1116
- }
1117
- message.toolCallId = reader.string();
1118
- continue;
1119
- }
1120
- }
1121
- if ((tag & 7) === 4 || tag === 0) {
1122
- break;
1123
- }
1124
- reader.skip(tag & 7);
1125
- }
1126
- return message;
1127
- },
1128
- create(base) {
1129
- return ToolCallEndEvent.fromPartial(base != null ? base : {});
1130
- },
1131
- fromPartial(object) {
1132
- var _a;
1133
- const message = createBaseToolCallEndEvent();
1134
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1135
- message.toolCallId = (_a = object.toolCallId) != null ? _a : "";
1136
- return message;
1137
- }
820
+ const ToolCallEndEvent = {
821
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
822
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
823
+ if (message.toolCallId !== "") writer.uint32(18).string(message.toolCallId);
824
+ return writer;
825
+ },
826
+ decode(input, length) {
827
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
828
+ const end = length === void 0 ? reader.len : reader.pos + length;
829
+ const message = createBaseToolCallEndEvent();
830
+ while (reader.pos < end) {
831
+ const tag = reader.uint32();
832
+ switch (tag >>> 3) {
833
+ case 1:
834
+ if (tag !== 10) break;
835
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
836
+ continue;
837
+ case 2:
838
+ if (tag !== 18) break;
839
+ message.toolCallId = reader.string();
840
+ continue;
841
+ }
842
+ if ((tag & 7) === 4 || tag === 0) break;
843
+ reader.skip(tag & 7);
844
+ }
845
+ return message;
846
+ },
847
+ create(base) {
848
+ return ToolCallEndEvent.fromPartial(base ?? {});
849
+ },
850
+ fromPartial(object) {
851
+ const message = createBaseToolCallEndEvent();
852
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
853
+ message.toolCallId = object.toolCallId ?? "";
854
+ return message;
855
+ }
1138
856
  };
1139
857
  function createBaseStateSnapshotEvent() {
1140
- return { baseEvent: void 0, snapshot: void 0 };
858
+ return {
859
+ baseEvent: void 0,
860
+ snapshot: void 0
861
+ };
1141
862
  }
1142
- var StateSnapshotEvent = {
1143
- encode(message, writer = new import_wire4.BinaryWriter()) {
1144
- if (message.baseEvent !== void 0) {
1145
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1146
- }
1147
- if (message.snapshot !== void 0) {
1148
- Value.encode(Value.wrap(message.snapshot), writer.uint32(18).fork()).join();
1149
- }
1150
- return writer;
1151
- },
1152
- decode(input, length) {
1153
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1154
- const end = length === void 0 ? reader.len : reader.pos + length;
1155
- const message = createBaseStateSnapshotEvent();
1156
- while (reader.pos < end) {
1157
- const tag = reader.uint32();
1158
- switch (tag >>> 3) {
1159
- case 1: {
1160
- if (tag !== 10) {
1161
- break;
1162
- }
1163
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1164
- continue;
1165
- }
1166
- case 2: {
1167
- if (tag !== 18) {
1168
- break;
1169
- }
1170
- message.snapshot = Value.unwrap(Value.decode(reader, reader.uint32()));
1171
- continue;
1172
- }
1173
- }
1174
- if ((tag & 7) === 4 || tag === 0) {
1175
- break;
1176
- }
1177
- reader.skip(tag & 7);
1178
- }
1179
- return message;
1180
- },
1181
- create(base) {
1182
- return StateSnapshotEvent.fromPartial(base != null ? base : {});
1183
- },
1184
- fromPartial(object) {
1185
- var _a;
1186
- const message = createBaseStateSnapshotEvent();
1187
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1188
- message.snapshot = (_a = object.snapshot) != null ? _a : void 0;
1189
- return message;
1190
- }
863
+ const StateSnapshotEvent = {
864
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
865
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
866
+ if (message.snapshot !== void 0) Value.encode(Value.wrap(message.snapshot), writer.uint32(18).fork()).join();
867
+ return writer;
868
+ },
869
+ decode(input, length) {
870
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
871
+ const end = length === void 0 ? reader.len : reader.pos + length;
872
+ const message = createBaseStateSnapshotEvent();
873
+ while (reader.pos < end) {
874
+ const tag = reader.uint32();
875
+ switch (tag >>> 3) {
876
+ case 1:
877
+ if (tag !== 10) break;
878
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
879
+ continue;
880
+ case 2:
881
+ if (tag !== 18) break;
882
+ message.snapshot = Value.unwrap(Value.decode(reader, reader.uint32()));
883
+ continue;
884
+ }
885
+ if ((tag & 7) === 4 || tag === 0) break;
886
+ reader.skip(tag & 7);
887
+ }
888
+ return message;
889
+ },
890
+ create(base) {
891
+ return StateSnapshotEvent.fromPartial(base ?? {});
892
+ },
893
+ fromPartial(object) {
894
+ const message = createBaseStateSnapshotEvent();
895
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
896
+ message.snapshot = object.snapshot ?? void 0;
897
+ return message;
898
+ }
1191
899
  };
1192
900
  function createBaseStateDeltaEvent() {
1193
- return { baseEvent: void 0, delta: [] };
901
+ return {
902
+ baseEvent: void 0,
903
+ delta: []
904
+ };
1194
905
  }
1195
- var StateDeltaEvent = {
1196
- encode(message, writer = new import_wire4.BinaryWriter()) {
1197
- if (message.baseEvent !== void 0) {
1198
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1199
- }
1200
- for (const v of message.delta) {
1201
- JsonPatchOperation.encode(v, writer.uint32(18).fork()).join();
1202
- }
1203
- return writer;
1204
- },
1205
- decode(input, length) {
1206
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1207
- const end = length === void 0 ? reader.len : reader.pos + length;
1208
- const message = createBaseStateDeltaEvent();
1209
- while (reader.pos < end) {
1210
- const tag = reader.uint32();
1211
- switch (tag >>> 3) {
1212
- case 1: {
1213
- if (tag !== 10) {
1214
- break;
1215
- }
1216
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1217
- continue;
1218
- }
1219
- case 2: {
1220
- if (tag !== 18) {
1221
- break;
1222
- }
1223
- message.delta.push(JsonPatchOperation.decode(reader, reader.uint32()));
1224
- continue;
1225
- }
1226
- }
1227
- if ((tag & 7) === 4 || tag === 0) {
1228
- break;
1229
- }
1230
- reader.skip(tag & 7);
1231
- }
1232
- return message;
1233
- },
1234
- create(base) {
1235
- return StateDeltaEvent.fromPartial(base != null ? base : {});
1236
- },
1237
- fromPartial(object) {
1238
- var _a;
1239
- const message = createBaseStateDeltaEvent();
1240
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1241
- message.delta = ((_a = object.delta) == null ? void 0 : _a.map((e) => JsonPatchOperation.fromPartial(e))) || [];
1242
- return message;
1243
- }
906
+ const StateDeltaEvent = {
907
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
908
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
909
+ for (const v of message.delta) JsonPatchOperation.encode(v, writer.uint32(18).fork()).join();
910
+ return writer;
911
+ },
912
+ decode(input, length) {
913
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
914
+ const end = length === void 0 ? reader.len : reader.pos + length;
915
+ const message = createBaseStateDeltaEvent();
916
+ while (reader.pos < end) {
917
+ const tag = reader.uint32();
918
+ switch (tag >>> 3) {
919
+ case 1:
920
+ if (tag !== 10) break;
921
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
922
+ continue;
923
+ case 2:
924
+ if (tag !== 18) break;
925
+ message.delta.push(JsonPatchOperation.decode(reader, reader.uint32()));
926
+ continue;
927
+ }
928
+ if ((tag & 7) === 4 || tag === 0) break;
929
+ reader.skip(tag & 7);
930
+ }
931
+ return message;
932
+ },
933
+ create(base) {
934
+ return StateDeltaEvent.fromPartial(base ?? {});
935
+ },
936
+ fromPartial(object) {
937
+ const message = createBaseStateDeltaEvent();
938
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
939
+ message.delta = object.delta?.map((e) => JsonPatchOperation.fromPartial(e)) || [];
940
+ return message;
941
+ }
1244
942
  };
1245
943
  function createBaseMessagesSnapshotEvent() {
1246
- return { baseEvent: void 0, messages: [] };
944
+ return {
945
+ baseEvent: void 0,
946
+ messages: []
947
+ };
1247
948
  }
1248
- var MessagesSnapshotEvent = {
1249
- encode(message, writer = new import_wire4.BinaryWriter()) {
1250
- if (message.baseEvent !== void 0) {
1251
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1252
- }
1253
- for (const v of message.messages) {
1254
- Message.encode(v, writer.uint32(18).fork()).join();
1255
- }
1256
- return writer;
1257
- },
1258
- decode(input, length) {
1259
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1260
- const end = length === void 0 ? reader.len : reader.pos + length;
1261
- const message = createBaseMessagesSnapshotEvent();
1262
- while (reader.pos < end) {
1263
- const tag = reader.uint32();
1264
- switch (tag >>> 3) {
1265
- case 1: {
1266
- if (tag !== 10) {
1267
- break;
1268
- }
1269
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1270
- continue;
1271
- }
1272
- case 2: {
1273
- if (tag !== 18) {
1274
- break;
1275
- }
1276
- message.messages.push(Message.decode(reader, reader.uint32()));
1277
- continue;
1278
- }
1279
- }
1280
- if ((tag & 7) === 4 || tag === 0) {
1281
- break;
1282
- }
1283
- reader.skip(tag & 7);
1284
- }
1285
- return message;
1286
- },
1287
- create(base) {
1288
- return MessagesSnapshotEvent.fromPartial(base != null ? base : {});
1289
- },
1290
- fromPartial(object) {
1291
- var _a;
1292
- const message = createBaseMessagesSnapshotEvent();
1293
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1294
- message.messages = ((_a = object.messages) == null ? void 0 : _a.map((e) => Message.fromPartial(e))) || [];
1295
- return message;
1296
- }
949
+ const MessagesSnapshotEvent = {
950
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
951
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
952
+ for (const v of message.messages) Message.encode(v, writer.uint32(18).fork()).join();
953
+ return writer;
954
+ },
955
+ decode(input, length) {
956
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
957
+ const end = length === void 0 ? reader.len : reader.pos + length;
958
+ const message = createBaseMessagesSnapshotEvent();
959
+ while (reader.pos < end) {
960
+ const tag = reader.uint32();
961
+ switch (tag >>> 3) {
962
+ case 1:
963
+ if (tag !== 10) break;
964
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
965
+ continue;
966
+ case 2:
967
+ if (tag !== 18) break;
968
+ message.messages.push(Message.decode(reader, reader.uint32()));
969
+ continue;
970
+ }
971
+ if ((tag & 7) === 4 || tag === 0) break;
972
+ reader.skip(tag & 7);
973
+ }
974
+ return message;
975
+ },
976
+ create(base) {
977
+ return MessagesSnapshotEvent.fromPartial(base ?? {});
978
+ },
979
+ fromPartial(object) {
980
+ const message = createBaseMessagesSnapshotEvent();
981
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
982
+ message.messages = object.messages?.map((e) => Message.fromPartial(e)) || [];
983
+ return message;
984
+ }
1297
985
  };
1298
986
  function createBaseRawEvent() {
1299
- return { baseEvent: void 0, event: void 0, source: void 0 };
987
+ return {
988
+ baseEvent: void 0,
989
+ event: void 0,
990
+ source: void 0
991
+ };
1300
992
  }
1301
- var RawEvent = {
1302
- encode(message, writer = new import_wire4.BinaryWriter()) {
1303
- if (message.baseEvent !== void 0) {
1304
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1305
- }
1306
- if (message.event !== void 0) {
1307
- Value.encode(Value.wrap(message.event), writer.uint32(18).fork()).join();
1308
- }
1309
- if (message.source !== void 0) {
1310
- writer.uint32(26).string(message.source);
1311
- }
1312
- return writer;
1313
- },
1314
- decode(input, length) {
1315
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1316
- const end = length === void 0 ? reader.len : reader.pos + length;
1317
- const message = createBaseRawEvent();
1318
- while (reader.pos < end) {
1319
- const tag = reader.uint32();
1320
- switch (tag >>> 3) {
1321
- case 1: {
1322
- if (tag !== 10) {
1323
- break;
1324
- }
1325
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1326
- continue;
1327
- }
1328
- case 2: {
1329
- if (tag !== 18) {
1330
- break;
1331
- }
1332
- message.event = Value.unwrap(Value.decode(reader, reader.uint32()));
1333
- continue;
1334
- }
1335
- case 3: {
1336
- if (tag !== 26) {
1337
- break;
1338
- }
1339
- message.source = reader.string();
1340
- continue;
1341
- }
1342
- }
1343
- if ((tag & 7) === 4 || tag === 0) {
1344
- break;
1345
- }
1346
- reader.skip(tag & 7);
1347
- }
1348
- return message;
1349
- },
1350
- create(base) {
1351
- return RawEvent.fromPartial(base != null ? base : {});
1352
- },
1353
- fromPartial(object) {
1354
- var _a, _b;
1355
- const message = createBaseRawEvent();
1356
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1357
- message.event = (_a = object.event) != null ? _a : void 0;
1358
- message.source = (_b = object.source) != null ? _b : void 0;
1359
- return message;
1360
- }
993
+ const RawEvent = {
994
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
995
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
996
+ if (message.event !== void 0) Value.encode(Value.wrap(message.event), writer.uint32(18).fork()).join();
997
+ if (message.source !== void 0) writer.uint32(26).string(message.source);
998
+ return writer;
999
+ },
1000
+ decode(input, length) {
1001
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1002
+ const end = length === void 0 ? reader.len : reader.pos + length;
1003
+ const message = createBaseRawEvent();
1004
+ while (reader.pos < end) {
1005
+ const tag = reader.uint32();
1006
+ switch (tag >>> 3) {
1007
+ case 1:
1008
+ if (tag !== 10) break;
1009
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1010
+ continue;
1011
+ case 2:
1012
+ if (tag !== 18) break;
1013
+ message.event = Value.unwrap(Value.decode(reader, reader.uint32()));
1014
+ continue;
1015
+ case 3:
1016
+ if (tag !== 26) break;
1017
+ message.source = reader.string();
1018
+ continue;
1019
+ }
1020
+ if ((tag & 7) === 4 || tag === 0) break;
1021
+ reader.skip(tag & 7);
1022
+ }
1023
+ return message;
1024
+ },
1025
+ create(base) {
1026
+ return RawEvent.fromPartial(base ?? {});
1027
+ },
1028
+ fromPartial(object) {
1029
+ const message = createBaseRawEvent();
1030
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1031
+ message.event = object.event ?? void 0;
1032
+ message.source = object.source ?? void 0;
1033
+ return message;
1034
+ }
1361
1035
  };
1362
1036
  function createBaseCustomEvent() {
1363
- return { baseEvent: void 0, name: "", value: void 0 };
1037
+ return {
1038
+ baseEvent: void 0,
1039
+ name: "",
1040
+ value: void 0
1041
+ };
1364
1042
  }
1365
- var CustomEvent = {
1366
- encode(message, writer = new import_wire4.BinaryWriter()) {
1367
- if (message.baseEvent !== void 0) {
1368
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1369
- }
1370
- if (message.name !== "") {
1371
- writer.uint32(18).string(message.name);
1372
- }
1373
- if (message.value !== void 0) {
1374
- Value.encode(Value.wrap(message.value), writer.uint32(26).fork()).join();
1375
- }
1376
- return writer;
1377
- },
1378
- decode(input, length) {
1379
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1380
- const end = length === void 0 ? reader.len : reader.pos + length;
1381
- const message = createBaseCustomEvent();
1382
- while (reader.pos < end) {
1383
- const tag = reader.uint32();
1384
- switch (tag >>> 3) {
1385
- case 1: {
1386
- if (tag !== 10) {
1387
- break;
1388
- }
1389
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1390
- continue;
1391
- }
1392
- case 2: {
1393
- if (tag !== 18) {
1394
- break;
1395
- }
1396
- message.name = reader.string();
1397
- continue;
1398
- }
1399
- case 3: {
1400
- if (tag !== 26) {
1401
- break;
1402
- }
1403
- message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
1404
- continue;
1405
- }
1406
- }
1407
- if ((tag & 7) === 4 || tag === 0) {
1408
- break;
1409
- }
1410
- reader.skip(tag & 7);
1411
- }
1412
- return message;
1413
- },
1414
- create(base) {
1415
- return CustomEvent.fromPartial(base != null ? base : {});
1416
- },
1417
- fromPartial(object) {
1418
- var _a, _b;
1419
- const message = createBaseCustomEvent();
1420
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1421
- message.name = (_a = object.name) != null ? _a : "";
1422
- message.value = (_b = object.value) != null ? _b : void 0;
1423
- return message;
1424
- }
1043
+ const CustomEvent = {
1044
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1045
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1046
+ if (message.name !== "") writer.uint32(18).string(message.name);
1047
+ if (message.value !== void 0) Value.encode(Value.wrap(message.value), writer.uint32(26).fork()).join();
1048
+ return writer;
1049
+ },
1050
+ decode(input, length) {
1051
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1052
+ const end = length === void 0 ? reader.len : reader.pos + length;
1053
+ const message = createBaseCustomEvent();
1054
+ while (reader.pos < end) {
1055
+ const tag = reader.uint32();
1056
+ switch (tag >>> 3) {
1057
+ case 1:
1058
+ if (tag !== 10) break;
1059
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1060
+ continue;
1061
+ case 2:
1062
+ if (tag !== 18) break;
1063
+ message.name = reader.string();
1064
+ continue;
1065
+ case 3:
1066
+ if (tag !== 26) break;
1067
+ message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
1068
+ continue;
1069
+ }
1070
+ if ((tag & 7) === 4 || tag === 0) break;
1071
+ reader.skip(tag & 7);
1072
+ }
1073
+ return message;
1074
+ },
1075
+ create(base) {
1076
+ return CustomEvent.fromPartial(base ?? {});
1077
+ },
1078
+ fromPartial(object) {
1079
+ const message = createBaseCustomEvent();
1080
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1081
+ message.name = object.name ?? "";
1082
+ message.value = object.value ?? void 0;
1083
+ return message;
1084
+ }
1425
1085
  };
1426
1086
  function createBaseRunStartedEvent() {
1427
- return { baseEvent: void 0, threadId: "", runId: "" };
1087
+ return {
1088
+ baseEvent: void 0,
1089
+ threadId: "",
1090
+ runId: ""
1091
+ };
1428
1092
  }
1429
- var RunStartedEvent = {
1430
- encode(message, writer = new import_wire4.BinaryWriter()) {
1431
- if (message.baseEvent !== void 0) {
1432
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1433
- }
1434
- if (message.threadId !== "") {
1435
- writer.uint32(18).string(message.threadId);
1436
- }
1437
- if (message.runId !== "") {
1438
- writer.uint32(26).string(message.runId);
1439
- }
1440
- return writer;
1441
- },
1442
- decode(input, length) {
1443
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1444
- const end = length === void 0 ? reader.len : reader.pos + length;
1445
- const message = createBaseRunStartedEvent();
1446
- while (reader.pos < end) {
1447
- const tag = reader.uint32();
1448
- switch (tag >>> 3) {
1449
- case 1: {
1450
- if (tag !== 10) {
1451
- break;
1452
- }
1453
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1454
- continue;
1455
- }
1456
- case 2: {
1457
- if (tag !== 18) {
1458
- break;
1459
- }
1460
- message.threadId = reader.string();
1461
- continue;
1462
- }
1463
- case 3: {
1464
- if (tag !== 26) {
1465
- break;
1466
- }
1467
- message.runId = reader.string();
1468
- continue;
1469
- }
1470
- }
1471
- if ((tag & 7) === 4 || tag === 0) {
1472
- break;
1473
- }
1474
- reader.skip(tag & 7);
1475
- }
1476
- return message;
1477
- },
1478
- create(base) {
1479
- return RunStartedEvent.fromPartial(base != null ? base : {});
1480
- },
1481
- fromPartial(object) {
1482
- var _a, _b;
1483
- const message = createBaseRunStartedEvent();
1484
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1485
- message.threadId = (_a = object.threadId) != null ? _a : "";
1486
- message.runId = (_b = object.runId) != null ? _b : "";
1487
- return message;
1488
- }
1093
+ const RunStartedEvent = {
1094
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1095
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1096
+ if (message.threadId !== "") writer.uint32(18).string(message.threadId);
1097
+ if (message.runId !== "") writer.uint32(26).string(message.runId);
1098
+ return writer;
1099
+ },
1100
+ decode(input, length) {
1101
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1102
+ const end = length === void 0 ? reader.len : reader.pos + length;
1103
+ const message = createBaseRunStartedEvent();
1104
+ while (reader.pos < end) {
1105
+ const tag = reader.uint32();
1106
+ switch (tag >>> 3) {
1107
+ case 1:
1108
+ if (tag !== 10) break;
1109
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1110
+ continue;
1111
+ case 2:
1112
+ if (tag !== 18) break;
1113
+ message.threadId = reader.string();
1114
+ continue;
1115
+ case 3:
1116
+ if (tag !== 26) break;
1117
+ message.runId = reader.string();
1118
+ continue;
1119
+ }
1120
+ if ((tag & 7) === 4 || tag === 0) break;
1121
+ reader.skip(tag & 7);
1122
+ }
1123
+ return message;
1124
+ },
1125
+ create(base) {
1126
+ return RunStartedEvent.fromPartial(base ?? {});
1127
+ },
1128
+ fromPartial(object) {
1129
+ const message = createBaseRunStartedEvent();
1130
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1131
+ message.threadId = object.threadId ?? "";
1132
+ message.runId = object.runId ?? "";
1133
+ return message;
1134
+ }
1489
1135
  };
1490
1136
  function createBaseRunFinishedEvent() {
1491
- return { baseEvent: void 0, threadId: "", runId: "", result: void 0 };
1137
+ return {
1138
+ baseEvent: void 0,
1139
+ threadId: "",
1140
+ runId: "",
1141
+ result: void 0
1142
+ };
1492
1143
  }
1493
- var RunFinishedEvent = {
1494
- encode(message, writer = new import_wire4.BinaryWriter()) {
1495
- if (message.baseEvent !== void 0) {
1496
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1497
- }
1498
- if (message.threadId !== "") {
1499
- writer.uint32(18).string(message.threadId);
1500
- }
1501
- if (message.runId !== "") {
1502
- writer.uint32(26).string(message.runId);
1503
- }
1504
- if (message.result !== void 0) {
1505
- Value.encode(Value.wrap(message.result), writer.uint32(34).fork()).join();
1506
- }
1507
- return writer;
1508
- },
1509
- decode(input, length) {
1510
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1511
- const end = length === void 0 ? reader.len : reader.pos + length;
1512
- const message = createBaseRunFinishedEvent();
1513
- while (reader.pos < end) {
1514
- const tag = reader.uint32();
1515
- switch (tag >>> 3) {
1516
- case 1: {
1517
- if (tag !== 10) {
1518
- break;
1519
- }
1520
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1521
- continue;
1522
- }
1523
- case 2: {
1524
- if (tag !== 18) {
1525
- break;
1526
- }
1527
- message.threadId = reader.string();
1528
- continue;
1529
- }
1530
- case 3: {
1531
- if (tag !== 26) {
1532
- break;
1533
- }
1534
- message.runId = reader.string();
1535
- continue;
1536
- }
1537
- case 4: {
1538
- if (tag !== 34) {
1539
- break;
1540
- }
1541
- message.result = Value.unwrap(Value.decode(reader, reader.uint32()));
1542
- continue;
1543
- }
1544
- }
1545
- if ((tag & 7) === 4 || tag === 0) {
1546
- break;
1547
- }
1548
- reader.skip(tag & 7);
1549
- }
1550
- return message;
1551
- },
1552
- create(base) {
1553
- return RunFinishedEvent.fromPartial(base != null ? base : {});
1554
- },
1555
- fromPartial(object) {
1556
- var _a, _b, _c;
1557
- const message = createBaseRunFinishedEvent();
1558
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1559
- message.threadId = (_a = object.threadId) != null ? _a : "";
1560
- message.runId = (_b = object.runId) != null ? _b : "";
1561
- message.result = (_c = object.result) != null ? _c : void 0;
1562
- return message;
1563
- }
1144
+ const RunFinishedEvent = {
1145
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1146
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1147
+ if (message.threadId !== "") writer.uint32(18).string(message.threadId);
1148
+ if (message.runId !== "") writer.uint32(26).string(message.runId);
1149
+ if (message.result !== void 0) Value.encode(Value.wrap(message.result), writer.uint32(34).fork()).join();
1150
+ return writer;
1151
+ },
1152
+ decode(input, length) {
1153
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1154
+ const end = length === void 0 ? reader.len : reader.pos + length;
1155
+ const message = createBaseRunFinishedEvent();
1156
+ while (reader.pos < end) {
1157
+ const tag = reader.uint32();
1158
+ switch (tag >>> 3) {
1159
+ case 1:
1160
+ if (tag !== 10) break;
1161
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1162
+ continue;
1163
+ case 2:
1164
+ if (tag !== 18) break;
1165
+ message.threadId = reader.string();
1166
+ continue;
1167
+ case 3:
1168
+ if (tag !== 26) break;
1169
+ message.runId = reader.string();
1170
+ continue;
1171
+ case 4:
1172
+ if (tag !== 34) break;
1173
+ message.result = Value.unwrap(Value.decode(reader, reader.uint32()));
1174
+ continue;
1175
+ }
1176
+ if ((tag & 7) === 4 || tag === 0) break;
1177
+ reader.skip(tag & 7);
1178
+ }
1179
+ return message;
1180
+ },
1181
+ create(base) {
1182
+ return RunFinishedEvent.fromPartial(base ?? {});
1183
+ },
1184
+ fromPartial(object) {
1185
+ const message = createBaseRunFinishedEvent();
1186
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1187
+ message.threadId = object.threadId ?? "";
1188
+ message.runId = object.runId ?? "";
1189
+ message.result = object.result ?? void 0;
1190
+ return message;
1191
+ }
1564
1192
  };
1565
1193
  function createBaseRunErrorEvent() {
1566
- return { baseEvent: void 0, code: void 0, message: "" };
1194
+ return {
1195
+ baseEvent: void 0,
1196
+ code: void 0,
1197
+ message: ""
1198
+ };
1567
1199
  }
1568
- var RunErrorEvent = {
1569
- encode(message, writer = new import_wire4.BinaryWriter()) {
1570
- if (message.baseEvent !== void 0) {
1571
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1572
- }
1573
- if (message.code !== void 0) {
1574
- writer.uint32(18).string(message.code);
1575
- }
1576
- if (message.message !== "") {
1577
- writer.uint32(26).string(message.message);
1578
- }
1579
- return writer;
1580
- },
1581
- decode(input, length) {
1582
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1583
- const end = length === void 0 ? reader.len : reader.pos + length;
1584
- const message = createBaseRunErrorEvent();
1585
- while (reader.pos < end) {
1586
- const tag = reader.uint32();
1587
- switch (tag >>> 3) {
1588
- case 1: {
1589
- if (tag !== 10) {
1590
- break;
1591
- }
1592
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1593
- continue;
1594
- }
1595
- case 2: {
1596
- if (tag !== 18) {
1597
- break;
1598
- }
1599
- message.code = reader.string();
1600
- continue;
1601
- }
1602
- case 3: {
1603
- if (tag !== 26) {
1604
- break;
1605
- }
1606
- message.message = reader.string();
1607
- continue;
1608
- }
1609
- }
1610
- if ((tag & 7) === 4 || tag === 0) {
1611
- break;
1612
- }
1613
- reader.skip(tag & 7);
1614
- }
1615
- return message;
1616
- },
1617
- create(base) {
1618
- return RunErrorEvent.fromPartial(base != null ? base : {});
1619
- },
1620
- fromPartial(object) {
1621
- var _a, _b;
1622
- const message = createBaseRunErrorEvent();
1623
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1624
- message.code = (_a = object.code) != null ? _a : void 0;
1625
- message.message = (_b = object.message) != null ? _b : "";
1626
- return message;
1627
- }
1200
+ const RunErrorEvent = {
1201
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1202
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1203
+ if (message.code !== void 0) writer.uint32(18).string(message.code);
1204
+ if (message.message !== "") writer.uint32(26).string(message.message);
1205
+ return writer;
1206
+ },
1207
+ decode(input, length) {
1208
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1209
+ const end = length === void 0 ? reader.len : reader.pos + length;
1210
+ const message = createBaseRunErrorEvent();
1211
+ while (reader.pos < end) {
1212
+ const tag = reader.uint32();
1213
+ switch (tag >>> 3) {
1214
+ case 1:
1215
+ if (tag !== 10) break;
1216
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1217
+ continue;
1218
+ case 2:
1219
+ if (tag !== 18) break;
1220
+ message.code = reader.string();
1221
+ continue;
1222
+ case 3:
1223
+ if (tag !== 26) break;
1224
+ message.message = reader.string();
1225
+ continue;
1226
+ }
1227
+ if ((tag & 7) === 4 || tag === 0) break;
1228
+ reader.skip(tag & 7);
1229
+ }
1230
+ return message;
1231
+ },
1232
+ create(base) {
1233
+ return RunErrorEvent.fromPartial(base ?? {});
1234
+ },
1235
+ fromPartial(object) {
1236
+ const message = createBaseRunErrorEvent();
1237
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1238
+ message.code = object.code ?? void 0;
1239
+ message.message = object.message ?? "";
1240
+ return message;
1241
+ }
1628
1242
  };
1629
1243
  function createBaseStepStartedEvent() {
1630
- return { baseEvent: void 0, stepName: "" };
1244
+ return {
1245
+ baseEvent: void 0,
1246
+ stepName: ""
1247
+ };
1631
1248
  }
1632
- var StepStartedEvent = {
1633
- encode(message, writer = new import_wire4.BinaryWriter()) {
1634
- if (message.baseEvent !== void 0) {
1635
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1636
- }
1637
- if (message.stepName !== "") {
1638
- writer.uint32(18).string(message.stepName);
1639
- }
1640
- return writer;
1641
- },
1642
- decode(input, length) {
1643
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1644
- const end = length === void 0 ? reader.len : reader.pos + length;
1645
- const message = createBaseStepStartedEvent();
1646
- while (reader.pos < end) {
1647
- const tag = reader.uint32();
1648
- switch (tag >>> 3) {
1649
- case 1: {
1650
- if (tag !== 10) {
1651
- break;
1652
- }
1653
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1654
- continue;
1655
- }
1656
- case 2: {
1657
- if (tag !== 18) {
1658
- break;
1659
- }
1660
- message.stepName = reader.string();
1661
- continue;
1662
- }
1663
- }
1664
- if ((tag & 7) === 4 || tag === 0) {
1665
- break;
1666
- }
1667
- reader.skip(tag & 7);
1668
- }
1669
- return message;
1670
- },
1671
- create(base) {
1672
- return StepStartedEvent.fromPartial(base != null ? base : {});
1673
- },
1674
- fromPartial(object) {
1675
- var _a;
1676
- const message = createBaseStepStartedEvent();
1677
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1678
- message.stepName = (_a = object.stepName) != null ? _a : "";
1679
- return message;
1680
- }
1249
+ const StepStartedEvent = {
1250
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1251
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1252
+ if (message.stepName !== "") writer.uint32(18).string(message.stepName);
1253
+ return writer;
1254
+ },
1255
+ decode(input, length) {
1256
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1257
+ const end = length === void 0 ? reader.len : reader.pos + length;
1258
+ const message = createBaseStepStartedEvent();
1259
+ while (reader.pos < end) {
1260
+ const tag = reader.uint32();
1261
+ switch (tag >>> 3) {
1262
+ case 1:
1263
+ if (tag !== 10) break;
1264
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1265
+ continue;
1266
+ case 2:
1267
+ if (tag !== 18) break;
1268
+ message.stepName = reader.string();
1269
+ continue;
1270
+ }
1271
+ if ((tag & 7) === 4 || tag === 0) break;
1272
+ reader.skip(tag & 7);
1273
+ }
1274
+ return message;
1275
+ },
1276
+ create(base) {
1277
+ return StepStartedEvent.fromPartial(base ?? {});
1278
+ },
1279
+ fromPartial(object) {
1280
+ const message = createBaseStepStartedEvent();
1281
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1282
+ message.stepName = object.stepName ?? "";
1283
+ return message;
1284
+ }
1681
1285
  };
1682
1286
  function createBaseStepFinishedEvent() {
1683
- return { baseEvent: void 0, stepName: "" };
1287
+ return {
1288
+ baseEvent: void 0,
1289
+ stepName: ""
1290
+ };
1684
1291
  }
1685
- var StepFinishedEvent = {
1686
- encode(message, writer = new import_wire4.BinaryWriter()) {
1687
- if (message.baseEvent !== void 0) {
1688
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1689
- }
1690
- if (message.stepName !== "") {
1691
- writer.uint32(18).string(message.stepName);
1692
- }
1693
- return writer;
1694
- },
1695
- decode(input, length) {
1696
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1697
- const end = length === void 0 ? reader.len : reader.pos + length;
1698
- const message = createBaseStepFinishedEvent();
1699
- while (reader.pos < end) {
1700
- const tag = reader.uint32();
1701
- switch (tag >>> 3) {
1702
- case 1: {
1703
- if (tag !== 10) {
1704
- break;
1705
- }
1706
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1707
- continue;
1708
- }
1709
- case 2: {
1710
- if (tag !== 18) {
1711
- break;
1712
- }
1713
- message.stepName = reader.string();
1714
- continue;
1715
- }
1716
- }
1717
- if ((tag & 7) === 4 || tag === 0) {
1718
- break;
1719
- }
1720
- reader.skip(tag & 7);
1721
- }
1722
- return message;
1723
- },
1724
- create(base) {
1725
- return StepFinishedEvent.fromPartial(base != null ? base : {});
1726
- },
1727
- fromPartial(object) {
1728
- var _a;
1729
- const message = createBaseStepFinishedEvent();
1730
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1731
- message.stepName = (_a = object.stepName) != null ? _a : "";
1732
- return message;
1733
- }
1292
+ const StepFinishedEvent = {
1293
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1294
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1295
+ if (message.stepName !== "") writer.uint32(18).string(message.stepName);
1296
+ return writer;
1297
+ },
1298
+ decode(input, length) {
1299
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1300
+ const end = length === void 0 ? reader.len : reader.pos + length;
1301
+ const message = createBaseStepFinishedEvent();
1302
+ while (reader.pos < end) {
1303
+ const tag = reader.uint32();
1304
+ switch (tag >>> 3) {
1305
+ case 1:
1306
+ if (tag !== 10) break;
1307
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1308
+ continue;
1309
+ case 2:
1310
+ if (tag !== 18) break;
1311
+ message.stepName = reader.string();
1312
+ continue;
1313
+ }
1314
+ if ((tag & 7) === 4 || tag === 0) break;
1315
+ reader.skip(tag & 7);
1316
+ }
1317
+ return message;
1318
+ },
1319
+ create(base) {
1320
+ return StepFinishedEvent.fromPartial(base ?? {});
1321
+ },
1322
+ fromPartial(object) {
1323
+ const message = createBaseStepFinishedEvent();
1324
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1325
+ message.stepName = object.stepName ?? "";
1326
+ return message;
1327
+ }
1734
1328
  };
1735
1329
  function createBaseTextMessageChunkEvent() {
1736
- return { baseEvent: void 0, messageId: void 0, role: void 0, delta: void 0 };
1330
+ return {
1331
+ baseEvent: void 0,
1332
+ messageId: void 0,
1333
+ role: void 0,
1334
+ delta: void 0
1335
+ };
1737
1336
  }
1738
- var TextMessageChunkEvent = {
1739
- encode(message, writer = new import_wire4.BinaryWriter()) {
1740
- if (message.baseEvent !== void 0) {
1741
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1742
- }
1743
- if (message.messageId !== void 0) {
1744
- writer.uint32(18).string(message.messageId);
1745
- }
1746
- if (message.role !== void 0) {
1747
- writer.uint32(26).string(message.role);
1748
- }
1749
- if (message.delta !== void 0) {
1750
- writer.uint32(34).string(message.delta);
1751
- }
1752
- return writer;
1753
- },
1754
- decode(input, length) {
1755
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1756
- const end = length === void 0 ? reader.len : reader.pos + length;
1757
- const message = createBaseTextMessageChunkEvent();
1758
- while (reader.pos < end) {
1759
- const tag = reader.uint32();
1760
- switch (tag >>> 3) {
1761
- case 1: {
1762
- if (tag !== 10) {
1763
- break;
1764
- }
1765
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1766
- continue;
1767
- }
1768
- case 2: {
1769
- if (tag !== 18) {
1770
- break;
1771
- }
1772
- message.messageId = reader.string();
1773
- continue;
1774
- }
1775
- case 3: {
1776
- if (tag !== 26) {
1777
- break;
1778
- }
1779
- message.role = reader.string();
1780
- continue;
1781
- }
1782
- case 4: {
1783
- if (tag !== 34) {
1784
- break;
1785
- }
1786
- message.delta = reader.string();
1787
- continue;
1788
- }
1789
- }
1790
- if ((tag & 7) === 4 || tag === 0) {
1791
- break;
1792
- }
1793
- reader.skip(tag & 7);
1794
- }
1795
- return message;
1796
- },
1797
- create(base) {
1798
- return TextMessageChunkEvent.fromPartial(base != null ? base : {});
1799
- },
1800
- fromPartial(object) {
1801
- var _a, _b, _c;
1802
- const message = createBaseTextMessageChunkEvent();
1803
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1804
- message.messageId = (_a = object.messageId) != null ? _a : void 0;
1805
- message.role = (_b = object.role) != null ? _b : void 0;
1806
- message.delta = (_c = object.delta) != null ? _c : void 0;
1807
- return message;
1808
- }
1337
+ const TextMessageChunkEvent = {
1338
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1339
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1340
+ if (message.messageId !== void 0) writer.uint32(18).string(message.messageId);
1341
+ if (message.role !== void 0) writer.uint32(26).string(message.role);
1342
+ if (message.delta !== void 0) writer.uint32(34).string(message.delta);
1343
+ return writer;
1344
+ },
1345
+ decode(input, length) {
1346
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1347
+ const end = length === void 0 ? reader.len : reader.pos + length;
1348
+ const message = createBaseTextMessageChunkEvent();
1349
+ while (reader.pos < end) {
1350
+ const tag = reader.uint32();
1351
+ switch (tag >>> 3) {
1352
+ case 1:
1353
+ if (tag !== 10) break;
1354
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1355
+ continue;
1356
+ case 2:
1357
+ if (tag !== 18) break;
1358
+ message.messageId = reader.string();
1359
+ continue;
1360
+ case 3:
1361
+ if (tag !== 26) break;
1362
+ message.role = reader.string();
1363
+ continue;
1364
+ case 4:
1365
+ if (tag !== 34) break;
1366
+ message.delta = reader.string();
1367
+ continue;
1368
+ }
1369
+ if ((tag & 7) === 4 || tag === 0) break;
1370
+ reader.skip(tag & 7);
1371
+ }
1372
+ return message;
1373
+ },
1374
+ create(base) {
1375
+ return TextMessageChunkEvent.fromPartial(base ?? {});
1376
+ },
1377
+ fromPartial(object) {
1378
+ const message = createBaseTextMessageChunkEvent();
1379
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1380
+ message.messageId = object.messageId ?? void 0;
1381
+ message.role = object.role ?? void 0;
1382
+ message.delta = object.delta ?? void 0;
1383
+ return message;
1384
+ }
1809
1385
  };
1810
1386
  function createBaseToolCallChunkEvent() {
1811
- return {
1812
- baseEvent: void 0,
1813
- toolCallId: void 0,
1814
- toolCallName: void 0,
1815
- parentMessageId: void 0,
1816
- delta: void 0
1817
- };
1387
+ return {
1388
+ baseEvent: void 0,
1389
+ toolCallId: void 0,
1390
+ toolCallName: void 0,
1391
+ parentMessageId: void 0,
1392
+ delta: void 0
1393
+ };
1818
1394
  }
1819
- var ToolCallChunkEvent = {
1820
- encode(message, writer = new import_wire4.BinaryWriter()) {
1821
- if (message.baseEvent !== void 0) {
1822
- BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1823
- }
1824
- if (message.toolCallId !== void 0) {
1825
- writer.uint32(18).string(message.toolCallId);
1826
- }
1827
- if (message.toolCallName !== void 0) {
1828
- writer.uint32(26).string(message.toolCallName);
1829
- }
1830
- if (message.parentMessageId !== void 0) {
1831
- writer.uint32(34).string(message.parentMessageId);
1832
- }
1833
- if (message.delta !== void 0) {
1834
- writer.uint32(42).string(message.delta);
1835
- }
1836
- return writer;
1837
- },
1838
- decode(input, length) {
1839
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1840
- const end = length === void 0 ? reader.len : reader.pos + length;
1841
- const message = createBaseToolCallChunkEvent();
1842
- while (reader.pos < end) {
1843
- const tag = reader.uint32();
1844
- switch (tag >>> 3) {
1845
- case 1: {
1846
- if (tag !== 10) {
1847
- break;
1848
- }
1849
- message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1850
- continue;
1851
- }
1852
- case 2: {
1853
- if (tag !== 18) {
1854
- break;
1855
- }
1856
- message.toolCallId = reader.string();
1857
- continue;
1858
- }
1859
- case 3: {
1860
- if (tag !== 26) {
1861
- break;
1862
- }
1863
- message.toolCallName = reader.string();
1864
- continue;
1865
- }
1866
- case 4: {
1867
- if (tag !== 34) {
1868
- break;
1869
- }
1870
- message.parentMessageId = reader.string();
1871
- continue;
1872
- }
1873
- case 5: {
1874
- if (tag !== 42) {
1875
- break;
1876
- }
1877
- message.delta = reader.string();
1878
- continue;
1879
- }
1880
- }
1881
- if ((tag & 7) === 4 || tag === 0) {
1882
- break;
1883
- }
1884
- reader.skip(tag & 7);
1885
- }
1886
- return message;
1887
- },
1888
- create(base) {
1889
- return ToolCallChunkEvent.fromPartial(base != null ? base : {});
1890
- },
1891
- fromPartial(object) {
1892
- var _a, _b, _c, _d;
1893
- const message = createBaseToolCallChunkEvent();
1894
- message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1895
- message.toolCallId = (_a = object.toolCallId) != null ? _a : void 0;
1896
- message.toolCallName = (_b = object.toolCallName) != null ? _b : void 0;
1897
- message.parentMessageId = (_c = object.parentMessageId) != null ? _c : void 0;
1898
- message.delta = (_d = object.delta) != null ? _d : void 0;
1899
- return message;
1900
- }
1395
+ const ToolCallChunkEvent = {
1396
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1397
+ if (message.baseEvent !== void 0) BaseEvent.encode(message.baseEvent, writer.uint32(10).fork()).join();
1398
+ if (message.toolCallId !== void 0) writer.uint32(18).string(message.toolCallId);
1399
+ if (message.toolCallName !== void 0) writer.uint32(26).string(message.toolCallName);
1400
+ if (message.parentMessageId !== void 0) writer.uint32(34).string(message.parentMessageId);
1401
+ if (message.delta !== void 0) writer.uint32(42).string(message.delta);
1402
+ return writer;
1403
+ },
1404
+ decode(input, length) {
1405
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1406
+ const end = length === void 0 ? reader.len : reader.pos + length;
1407
+ const message = createBaseToolCallChunkEvent();
1408
+ while (reader.pos < end) {
1409
+ const tag = reader.uint32();
1410
+ switch (tag >>> 3) {
1411
+ case 1:
1412
+ if (tag !== 10) break;
1413
+ message.baseEvent = BaseEvent.decode(reader, reader.uint32());
1414
+ continue;
1415
+ case 2:
1416
+ if (tag !== 18) break;
1417
+ message.toolCallId = reader.string();
1418
+ continue;
1419
+ case 3:
1420
+ if (tag !== 26) break;
1421
+ message.toolCallName = reader.string();
1422
+ continue;
1423
+ case 4:
1424
+ if (tag !== 34) break;
1425
+ message.parentMessageId = reader.string();
1426
+ continue;
1427
+ case 5:
1428
+ if (tag !== 42) break;
1429
+ message.delta = reader.string();
1430
+ continue;
1431
+ }
1432
+ if ((tag & 7) === 4 || tag === 0) break;
1433
+ reader.skip(tag & 7);
1434
+ }
1435
+ return message;
1436
+ },
1437
+ create(base) {
1438
+ return ToolCallChunkEvent.fromPartial(base ?? {});
1439
+ },
1440
+ fromPartial(object) {
1441
+ const message = createBaseToolCallChunkEvent();
1442
+ message.baseEvent = object.baseEvent !== void 0 && object.baseEvent !== null ? BaseEvent.fromPartial(object.baseEvent) : void 0;
1443
+ message.toolCallId = object.toolCallId ?? void 0;
1444
+ message.toolCallName = object.toolCallName ?? void 0;
1445
+ message.parentMessageId = object.parentMessageId ?? void 0;
1446
+ message.delta = object.delta ?? void 0;
1447
+ return message;
1448
+ }
1901
1449
  };
1902
1450
  function createBaseEvent() {
1903
- return {
1904
- textMessageStart: void 0,
1905
- textMessageContent: void 0,
1906
- textMessageEnd: void 0,
1907
- toolCallStart: void 0,
1908
- toolCallArgs: void 0,
1909
- toolCallEnd: void 0,
1910
- stateSnapshot: void 0,
1911
- stateDelta: void 0,
1912
- messagesSnapshot: void 0,
1913
- raw: void 0,
1914
- custom: void 0,
1915
- runStarted: void 0,
1916
- runFinished: void 0,
1917
- runError: void 0,
1918
- stepStarted: void 0,
1919
- stepFinished: void 0,
1920
- textMessageChunk: void 0,
1921
- toolCallChunk: void 0
1922
- };
1451
+ return {
1452
+ textMessageStart: void 0,
1453
+ textMessageContent: void 0,
1454
+ textMessageEnd: void 0,
1455
+ toolCallStart: void 0,
1456
+ toolCallArgs: void 0,
1457
+ toolCallEnd: void 0,
1458
+ stateSnapshot: void 0,
1459
+ stateDelta: void 0,
1460
+ messagesSnapshot: void 0,
1461
+ raw: void 0,
1462
+ custom: void 0,
1463
+ runStarted: void 0,
1464
+ runFinished: void 0,
1465
+ runError: void 0,
1466
+ stepStarted: void 0,
1467
+ stepFinished: void 0,
1468
+ textMessageChunk: void 0,
1469
+ toolCallChunk: void 0
1470
+ };
1923
1471
  }
1924
- var Event = {
1925
- encode(message, writer = new import_wire4.BinaryWriter()) {
1926
- if (message.textMessageStart !== void 0) {
1927
- TextMessageStartEvent.encode(message.textMessageStart, writer.uint32(10).fork()).join();
1928
- }
1929
- if (message.textMessageContent !== void 0) {
1930
- TextMessageContentEvent.encode(message.textMessageContent, writer.uint32(18).fork()).join();
1931
- }
1932
- if (message.textMessageEnd !== void 0) {
1933
- TextMessageEndEvent.encode(message.textMessageEnd, writer.uint32(26).fork()).join();
1934
- }
1935
- if (message.toolCallStart !== void 0) {
1936
- ToolCallStartEvent.encode(message.toolCallStart, writer.uint32(34).fork()).join();
1937
- }
1938
- if (message.toolCallArgs !== void 0) {
1939
- ToolCallArgsEvent.encode(message.toolCallArgs, writer.uint32(42).fork()).join();
1940
- }
1941
- if (message.toolCallEnd !== void 0) {
1942
- ToolCallEndEvent.encode(message.toolCallEnd, writer.uint32(50).fork()).join();
1943
- }
1944
- if (message.stateSnapshot !== void 0) {
1945
- StateSnapshotEvent.encode(message.stateSnapshot, writer.uint32(58).fork()).join();
1946
- }
1947
- if (message.stateDelta !== void 0) {
1948
- StateDeltaEvent.encode(message.stateDelta, writer.uint32(66).fork()).join();
1949
- }
1950
- if (message.messagesSnapshot !== void 0) {
1951
- MessagesSnapshotEvent.encode(message.messagesSnapshot, writer.uint32(74).fork()).join();
1952
- }
1953
- if (message.raw !== void 0) {
1954
- RawEvent.encode(message.raw, writer.uint32(82).fork()).join();
1955
- }
1956
- if (message.custom !== void 0) {
1957
- CustomEvent.encode(message.custom, writer.uint32(90).fork()).join();
1958
- }
1959
- if (message.runStarted !== void 0) {
1960
- RunStartedEvent.encode(message.runStarted, writer.uint32(98).fork()).join();
1961
- }
1962
- if (message.runFinished !== void 0) {
1963
- RunFinishedEvent.encode(message.runFinished, writer.uint32(106).fork()).join();
1964
- }
1965
- if (message.runError !== void 0) {
1966
- RunErrorEvent.encode(message.runError, writer.uint32(114).fork()).join();
1967
- }
1968
- if (message.stepStarted !== void 0) {
1969
- StepStartedEvent.encode(message.stepStarted, writer.uint32(122).fork()).join();
1970
- }
1971
- if (message.stepFinished !== void 0) {
1972
- StepFinishedEvent.encode(message.stepFinished, writer.uint32(130).fork()).join();
1973
- }
1974
- if (message.textMessageChunk !== void 0) {
1975
- TextMessageChunkEvent.encode(message.textMessageChunk, writer.uint32(138).fork()).join();
1976
- }
1977
- if (message.toolCallChunk !== void 0) {
1978
- ToolCallChunkEvent.encode(message.toolCallChunk, writer.uint32(146).fork()).join();
1979
- }
1980
- return writer;
1981
- },
1982
- decode(input, length) {
1983
- const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
1984
- const end = length === void 0 ? reader.len : reader.pos + length;
1985
- const message = createBaseEvent();
1986
- while (reader.pos < end) {
1987
- const tag = reader.uint32();
1988
- switch (tag >>> 3) {
1989
- case 1: {
1990
- if (tag !== 10) {
1991
- break;
1992
- }
1993
- message.textMessageStart = TextMessageStartEvent.decode(reader, reader.uint32());
1994
- continue;
1995
- }
1996
- case 2: {
1997
- if (tag !== 18) {
1998
- break;
1999
- }
2000
- message.textMessageContent = TextMessageContentEvent.decode(reader, reader.uint32());
2001
- continue;
2002
- }
2003
- case 3: {
2004
- if (tag !== 26) {
2005
- break;
2006
- }
2007
- message.textMessageEnd = TextMessageEndEvent.decode(reader, reader.uint32());
2008
- continue;
2009
- }
2010
- case 4: {
2011
- if (tag !== 34) {
2012
- break;
2013
- }
2014
- message.toolCallStart = ToolCallStartEvent.decode(reader, reader.uint32());
2015
- continue;
2016
- }
2017
- case 5: {
2018
- if (tag !== 42) {
2019
- break;
2020
- }
2021
- message.toolCallArgs = ToolCallArgsEvent.decode(reader, reader.uint32());
2022
- continue;
2023
- }
2024
- case 6: {
2025
- if (tag !== 50) {
2026
- break;
2027
- }
2028
- message.toolCallEnd = ToolCallEndEvent.decode(reader, reader.uint32());
2029
- continue;
2030
- }
2031
- case 7: {
2032
- if (tag !== 58) {
2033
- break;
2034
- }
2035
- message.stateSnapshot = StateSnapshotEvent.decode(reader, reader.uint32());
2036
- continue;
2037
- }
2038
- case 8: {
2039
- if (tag !== 66) {
2040
- break;
2041
- }
2042
- message.stateDelta = StateDeltaEvent.decode(reader, reader.uint32());
2043
- continue;
2044
- }
2045
- case 9: {
2046
- if (tag !== 74) {
2047
- break;
2048
- }
2049
- message.messagesSnapshot = MessagesSnapshotEvent.decode(reader, reader.uint32());
2050
- continue;
2051
- }
2052
- case 10: {
2053
- if (tag !== 82) {
2054
- break;
2055
- }
2056
- message.raw = RawEvent.decode(reader, reader.uint32());
2057
- continue;
2058
- }
2059
- case 11: {
2060
- if (tag !== 90) {
2061
- break;
2062
- }
2063
- message.custom = CustomEvent.decode(reader, reader.uint32());
2064
- continue;
2065
- }
2066
- case 12: {
2067
- if (tag !== 98) {
2068
- break;
2069
- }
2070
- message.runStarted = RunStartedEvent.decode(reader, reader.uint32());
2071
- continue;
2072
- }
2073
- case 13: {
2074
- if (tag !== 106) {
2075
- break;
2076
- }
2077
- message.runFinished = RunFinishedEvent.decode(reader, reader.uint32());
2078
- continue;
2079
- }
2080
- case 14: {
2081
- if (tag !== 114) {
2082
- break;
2083
- }
2084
- message.runError = RunErrorEvent.decode(reader, reader.uint32());
2085
- continue;
2086
- }
2087
- case 15: {
2088
- if (tag !== 122) {
2089
- break;
2090
- }
2091
- message.stepStarted = StepStartedEvent.decode(reader, reader.uint32());
2092
- continue;
2093
- }
2094
- case 16: {
2095
- if (tag !== 130) {
2096
- break;
2097
- }
2098
- message.stepFinished = StepFinishedEvent.decode(reader, reader.uint32());
2099
- continue;
2100
- }
2101
- case 17: {
2102
- if (tag !== 138) {
2103
- break;
2104
- }
2105
- message.textMessageChunk = TextMessageChunkEvent.decode(reader, reader.uint32());
2106
- continue;
2107
- }
2108
- case 18: {
2109
- if (tag !== 146) {
2110
- break;
2111
- }
2112
- message.toolCallChunk = ToolCallChunkEvent.decode(reader, reader.uint32());
2113
- continue;
2114
- }
2115
- }
2116
- if ((tag & 7) === 4 || tag === 0) {
2117
- break;
2118
- }
2119
- reader.skip(tag & 7);
2120
- }
2121
- return message;
2122
- },
2123
- create(base) {
2124
- return Event.fromPartial(base != null ? base : {});
2125
- },
2126
- fromPartial(object) {
2127
- const message = createBaseEvent();
2128
- message.textMessageStart = object.textMessageStart !== void 0 && object.textMessageStart !== null ? TextMessageStartEvent.fromPartial(object.textMessageStart) : void 0;
2129
- message.textMessageContent = object.textMessageContent !== void 0 && object.textMessageContent !== null ? TextMessageContentEvent.fromPartial(object.textMessageContent) : void 0;
2130
- message.textMessageEnd = object.textMessageEnd !== void 0 && object.textMessageEnd !== null ? TextMessageEndEvent.fromPartial(object.textMessageEnd) : void 0;
2131
- message.toolCallStart = object.toolCallStart !== void 0 && object.toolCallStart !== null ? ToolCallStartEvent.fromPartial(object.toolCallStart) : void 0;
2132
- message.toolCallArgs = object.toolCallArgs !== void 0 && object.toolCallArgs !== null ? ToolCallArgsEvent.fromPartial(object.toolCallArgs) : void 0;
2133
- message.toolCallEnd = object.toolCallEnd !== void 0 && object.toolCallEnd !== null ? ToolCallEndEvent.fromPartial(object.toolCallEnd) : void 0;
2134
- message.stateSnapshot = object.stateSnapshot !== void 0 && object.stateSnapshot !== null ? StateSnapshotEvent.fromPartial(object.stateSnapshot) : void 0;
2135
- message.stateDelta = object.stateDelta !== void 0 && object.stateDelta !== null ? StateDeltaEvent.fromPartial(object.stateDelta) : void 0;
2136
- message.messagesSnapshot = object.messagesSnapshot !== void 0 && object.messagesSnapshot !== null ? MessagesSnapshotEvent.fromPartial(object.messagesSnapshot) : void 0;
2137
- message.raw = object.raw !== void 0 && object.raw !== null ? RawEvent.fromPartial(object.raw) : void 0;
2138
- message.custom = object.custom !== void 0 && object.custom !== null ? CustomEvent.fromPartial(object.custom) : void 0;
2139
- message.runStarted = object.runStarted !== void 0 && object.runStarted !== null ? RunStartedEvent.fromPartial(object.runStarted) : void 0;
2140
- message.runFinished = object.runFinished !== void 0 && object.runFinished !== null ? RunFinishedEvent.fromPartial(object.runFinished) : void 0;
2141
- message.runError = object.runError !== void 0 && object.runError !== null ? RunErrorEvent.fromPartial(object.runError) : void 0;
2142
- message.stepStarted = object.stepStarted !== void 0 && object.stepStarted !== null ? StepStartedEvent.fromPartial(object.stepStarted) : void 0;
2143
- message.stepFinished = object.stepFinished !== void 0 && object.stepFinished !== null ? StepFinishedEvent.fromPartial(object.stepFinished) : void 0;
2144
- message.textMessageChunk = object.textMessageChunk !== void 0 && object.textMessageChunk !== null ? TextMessageChunkEvent.fromPartial(object.textMessageChunk) : void 0;
2145
- message.toolCallChunk = object.toolCallChunk !== void 0 && object.toolCallChunk !== null ? ToolCallChunkEvent.fromPartial(object.toolCallChunk) : void 0;
2146
- return message;
2147
- }
1472
+ const Event = {
1473
+ encode(message, writer = new _bufbuild_protobuf_wire.BinaryWriter()) {
1474
+ if (message.textMessageStart !== void 0) TextMessageStartEvent.encode(message.textMessageStart, writer.uint32(10).fork()).join();
1475
+ if (message.textMessageContent !== void 0) TextMessageContentEvent.encode(message.textMessageContent, writer.uint32(18).fork()).join();
1476
+ if (message.textMessageEnd !== void 0) TextMessageEndEvent.encode(message.textMessageEnd, writer.uint32(26).fork()).join();
1477
+ if (message.toolCallStart !== void 0) ToolCallStartEvent.encode(message.toolCallStart, writer.uint32(34).fork()).join();
1478
+ if (message.toolCallArgs !== void 0) ToolCallArgsEvent.encode(message.toolCallArgs, writer.uint32(42).fork()).join();
1479
+ if (message.toolCallEnd !== void 0) ToolCallEndEvent.encode(message.toolCallEnd, writer.uint32(50).fork()).join();
1480
+ if (message.stateSnapshot !== void 0) StateSnapshotEvent.encode(message.stateSnapshot, writer.uint32(58).fork()).join();
1481
+ if (message.stateDelta !== void 0) StateDeltaEvent.encode(message.stateDelta, writer.uint32(66).fork()).join();
1482
+ if (message.messagesSnapshot !== void 0) MessagesSnapshotEvent.encode(message.messagesSnapshot, writer.uint32(74).fork()).join();
1483
+ if (message.raw !== void 0) RawEvent.encode(message.raw, writer.uint32(82).fork()).join();
1484
+ if (message.custom !== void 0) CustomEvent.encode(message.custom, writer.uint32(90).fork()).join();
1485
+ if (message.runStarted !== void 0) RunStartedEvent.encode(message.runStarted, writer.uint32(98).fork()).join();
1486
+ if (message.runFinished !== void 0) RunFinishedEvent.encode(message.runFinished, writer.uint32(106).fork()).join();
1487
+ if (message.runError !== void 0) RunErrorEvent.encode(message.runError, writer.uint32(114).fork()).join();
1488
+ if (message.stepStarted !== void 0) StepStartedEvent.encode(message.stepStarted, writer.uint32(122).fork()).join();
1489
+ if (message.stepFinished !== void 0) StepFinishedEvent.encode(message.stepFinished, writer.uint32(130).fork()).join();
1490
+ if (message.textMessageChunk !== void 0) TextMessageChunkEvent.encode(message.textMessageChunk, writer.uint32(138).fork()).join();
1491
+ if (message.toolCallChunk !== void 0) ToolCallChunkEvent.encode(message.toolCallChunk, writer.uint32(146).fork()).join();
1492
+ return writer;
1493
+ },
1494
+ decode(input, length) {
1495
+ const reader = input instanceof _bufbuild_protobuf_wire.BinaryReader ? input : new _bufbuild_protobuf_wire.BinaryReader(input);
1496
+ const end = length === void 0 ? reader.len : reader.pos + length;
1497
+ const message = createBaseEvent();
1498
+ while (reader.pos < end) {
1499
+ const tag = reader.uint32();
1500
+ switch (tag >>> 3) {
1501
+ case 1:
1502
+ if (tag !== 10) break;
1503
+ message.textMessageStart = TextMessageStartEvent.decode(reader, reader.uint32());
1504
+ continue;
1505
+ case 2:
1506
+ if (tag !== 18) break;
1507
+ message.textMessageContent = TextMessageContentEvent.decode(reader, reader.uint32());
1508
+ continue;
1509
+ case 3:
1510
+ if (tag !== 26) break;
1511
+ message.textMessageEnd = TextMessageEndEvent.decode(reader, reader.uint32());
1512
+ continue;
1513
+ case 4:
1514
+ if (tag !== 34) break;
1515
+ message.toolCallStart = ToolCallStartEvent.decode(reader, reader.uint32());
1516
+ continue;
1517
+ case 5:
1518
+ if (tag !== 42) break;
1519
+ message.toolCallArgs = ToolCallArgsEvent.decode(reader, reader.uint32());
1520
+ continue;
1521
+ case 6:
1522
+ if (tag !== 50) break;
1523
+ message.toolCallEnd = ToolCallEndEvent.decode(reader, reader.uint32());
1524
+ continue;
1525
+ case 7:
1526
+ if (tag !== 58) break;
1527
+ message.stateSnapshot = StateSnapshotEvent.decode(reader, reader.uint32());
1528
+ continue;
1529
+ case 8:
1530
+ if (tag !== 66) break;
1531
+ message.stateDelta = StateDeltaEvent.decode(reader, reader.uint32());
1532
+ continue;
1533
+ case 9:
1534
+ if (tag !== 74) break;
1535
+ message.messagesSnapshot = MessagesSnapshotEvent.decode(reader, reader.uint32());
1536
+ continue;
1537
+ case 10:
1538
+ if (tag !== 82) break;
1539
+ message.raw = RawEvent.decode(reader, reader.uint32());
1540
+ continue;
1541
+ case 11:
1542
+ if (tag !== 90) break;
1543
+ message.custom = CustomEvent.decode(reader, reader.uint32());
1544
+ continue;
1545
+ case 12:
1546
+ if (tag !== 98) break;
1547
+ message.runStarted = RunStartedEvent.decode(reader, reader.uint32());
1548
+ continue;
1549
+ case 13:
1550
+ if (tag !== 106) break;
1551
+ message.runFinished = RunFinishedEvent.decode(reader, reader.uint32());
1552
+ continue;
1553
+ case 14:
1554
+ if (tag !== 114) break;
1555
+ message.runError = RunErrorEvent.decode(reader, reader.uint32());
1556
+ continue;
1557
+ case 15:
1558
+ if (tag !== 122) break;
1559
+ message.stepStarted = StepStartedEvent.decode(reader, reader.uint32());
1560
+ continue;
1561
+ case 16:
1562
+ if (tag !== 130) break;
1563
+ message.stepFinished = StepFinishedEvent.decode(reader, reader.uint32());
1564
+ continue;
1565
+ case 17:
1566
+ if (tag !== 138) break;
1567
+ message.textMessageChunk = TextMessageChunkEvent.decode(reader, reader.uint32());
1568
+ continue;
1569
+ case 18:
1570
+ if (tag !== 146) break;
1571
+ message.toolCallChunk = ToolCallChunkEvent.decode(reader, reader.uint32());
1572
+ continue;
1573
+ }
1574
+ if ((tag & 7) === 4 || tag === 0) break;
1575
+ reader.skip(tag & 7);
1576
+ }
1577
+ return message;
1578
+ },
1579
+ create(base) {
1580
+ return Event.fromPartial(base ?? {});
1581
+ },
1582
+ fromPartial(object) {
1583
+ const message = createBaseEvent();
1584
+ message.textMessageStart = object.textMessageStart !== void 0 && object.textMessageStart !== null ? TextMessageStartEvent.fromPartial(object.textMessageStart) : void 0;
1585
+ message.textMessageContent = object.textMessageContent !== void 0 && object.textMessageContent !== null ? TextMessageContentEvent.fromPartial(object.textMessageContent) : void 0;
1586
+ message.textMessageEnd = object.textMessageEnd !== void 0 && object.textMessageEnd !== null ? TextMessageEndEvent.fromPartial(object.textMessageEnd) : void 0;
1587
+ message.toolCallStart = object.toolCallStart !== void 0 && object.toolCallStart !== null ? ToolCallStartEvent.fromPartial(object.toolCallStart) : void 0;
1588
+ message.toolCallArgs = object.toolCallArgs !== void 0 && object.toolCallArgs !== null ? ToolCallArgsEvent.fromPartial(object.toolCallArgs) : void 0;
1589
+ message.toolCallEnd = object.toolCallEnd !== void 0 && object.toolCallEnd !== null ? ToolCallEndEvent.fromPartial(object.toolCallEnd) : void 0;
1590
+ message.stateSnapshot = object.stateSnapshot !== void 0 && object.stateSnapshot !== null ? StateSnapshotEvent.fromPartial(object.stateSnapshot) : void 0;
1591
+ message.stateDelta = object.stateDelta !== void 0 && object.stateDelta !== null ? StateDeltaEvent.fromPartial(object.stateDelta) : void 0;
1592
+ message.messagesSnapshot = object.messagesSnapshot !== void 0 && object.messagesSnapshot !== null ? MessagesSnapshotEvent.fromPartial(object.messagesSnapshot) : void 0;
1593
+ message.raw = object.raw !== void 0 && object.raw !== null ? RawEvent.fromPartial(object.raw) : void 0;
1594
+ message.custom = object.custom !== void 0 && object.custom !== null ? CustomEvent.fromPartial(object.custom) : void 0;
1595
+ message.runStarted = object.runStarted !== void 0 && object.runStarted !== null ? RunStartedEvent.fromPartial(object.runStarted) : void 0;
1596
+ message.runFinished = object.runFinished !== void 0 && object.runFinished !== null ? RunFinishedEvent.fromPartial(object.runFinished) : void 0;
1597
+ message.runError = object.runError !== void 0 && object.runError !== null ? RunErrorEvent.fromPartial(object.runError) : void 0;
1598
+ message.stepStarted = object.stepStarted !== void 0 && object.stepStarted !== null ? StepStartedEvent.fromPartial(object.stepStarted) : void 0;
1599
+ message.stepFinished = object.stepFinished !== void 0 && object.stepFinished !== null ? StepFinishedEvent.fromPartial(object.stepFinished) : void 0;
1600
+ message.textMessageChunk = object.textMessageChunk !== void 0 && object.textMessageChunk !== null ? TextMessageChunkEvent.fromPartial(object.textMessageChunk) : void 0;
1601
+ message.toolCallChunk = object.toolCallChunk !== void 0 && object.toolCallChunk !== null ? ToolCallChunkEvent.fromPartial(object.toolCallChunk) : void 0;
1602
+ return message;
1603
+ }
2148
1604
  };
2149
1605
  function longToNumber(int64) {
2150
- const num = globalThis.Number(int64.toString());
2151
- if (num > globalThis.Number.MAX_SAFE_INTEGER) {
2152
- throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
2153
- }
2154
- if (num < globalThis.Number.MIN_SAFE_INTEGER) {
2155
- throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
2156
- }
2157
- return num;
1606
+ const num = globalThis.Number(int64.toString());
1607
+ if (num > globalThis.Number.MAX_SAFE_INTEGER) throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
1608
+ if (num < globalThis.Number.MIN_SAFE_INTEGER) throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
1609
+ return num;
2158
1610
  }
2159
1611
 
2160
- // src/proto.ts
1612
+ //#endregion
1613
+ //#region src/proto.ts
2161
1614
  function toCamelCase(str) {
2162
- return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
1615
+ return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
2163
1616
  }
1617
+ /**
1618
+ * Encodes an event message to a protocol buffer binary format.
1619
+ */
2164
1620
  function encode(event) {
2165
- let validatedEvent;
2166
- try {
2167
- validatedEvent = import_core.EventSchemas.parse(event);
2168
- } catch (err) {
2169
- console.warn(
2170
- "[ag-ui][proto.encode] Malformed devent detected, falling back to unvalidated event",
2171
- err,
2172
- event
2173
- );
2174
- validatedEvent = event;
2175
- }
2176
- const oneofField = toCamelCase(validatedEvent.type);
2177
- const { type, timestamp, rawEvent, ...rest } = validatedEvent;
2178
- if (type === import_core.EventType.MESSAGES_SNAPSHOT && Array.isArray(rest.messages)) {
2179
- rest.messages = rest.messages.map((message) => {
2180
- const untypedMessage = message;
2181
- if (untypedMessage.toolCalls === void 0) {
2182
- return { ...message, toolCalls: [] };
2183
- }
2184
- return message;
2185
- });
2186
- }
2187
- if (type === import_core.EventType.STATE_DELTA && Array.isArray(rest.delta)) {
2188
- rest.delta = rest.delta.map((operation) => ({
2189
- ...operation,
2190
- op: JsonPatchOperationType[operation.op.toUpperCase()]
2191
- }));
2192
- }
2193
- const eventMessage = {
2194
- [oneofField]: {
2195
- baseEvent: {
2196
- type: EventType[event.type],
2197
- timestamp,
2198
- rawEvent
2199
- },
2200
- ...rest
2201
- }
2202
- };
2203
- return Event.encode(eventMessage).finish();
1621
+ /**
1622
+ * In previous versions of AG-UI, we didn't really validate the events
1623
+ * against a schema. With stronger types for events and Zod schemas, we
1624
+ * can now validate.
1625
+ *
1626
+ * However, I don't want to break compatibility with existing clients
1627
+ * even if they are encoding invalid events. This surfaces a warning
1628
+ * to them in those situations.
1629
+ *
1630
+ * @author mikeryandev
1631
+ */
1632
+ let validatedEvent;
1633
+ try {
1634
+ validatedEvent = _ag_ui_core.EventSchemas.parse(event);
1635
+ } catch (err) {
1636
+ console.warn("[ag-ui][proto.encode] Malformed devent detected, falling back to unvalidated event", err, event);
1637
+ validatedEvent = event;
1638
+ }
1639
+ const oneofField = toCamelCase(validatedEvent.type);
1640
+ const { type, timestamp, rawEvent, ...rest } = validatedEvent;
1641
+ if (type === _ag_ui_core.EventType.MESSAGES_SNAPSHOT && Array.isArray(rest.messages)) rest.messages = rest.messages.map((message) => {
1642
+ if (message.toolCalls === void 0) return {
1643
+ ...message,
1644
+ toolCalls: []
1645
+ };
1646
+ return message;
1647
+ });
1648
+ if (type === _ag_ui_core.EventType.STATE_DELTA && Array.isArray(rest.delta)) rest.delta = rest.delta.map((operation) => ({
1649
+ ...operation,
1650
+ op: JsonPatchOperationType[operation.op.toUpperCase()]
1651
+ }));
1652
+ const eventMessage = { [oneofField]: {
1653
+ baseEvent: {
1654
+ type: EventType$1[event.type],
1655
+ timestamp,
1656
+ rawEvent
1657
+ },
1658
+ ...rest
1659
+ } };
1660
+ return Event.encode(eventMessage).finish();
2204
1661
  }
1662
+ /**
1663
+ * Decodes a protocol buffer binary format to an event message.
1664
+ * The format includes a 4-byte length prefix followed by the message.
1665
+ */
2205
1666
  function decode(data) {
2206
- var _a;
2207
- const event = Event.decode(data);
2208
- const decoded = Object.values(event).find((value) => value !== void 0);
2209
- if (!decoded) {
2210
- throw new Error("Invalid event");
2211
- }
2212
- decoded.type = EventType[decoded.baseEvent.type];
2213
- decoded.timestamp = decoded.baseEvent.timestamp;
2214
- decoded.rawEvent = decoded.baseEvent.rawEvent;
2215
- if (decoded.type === import_core.EventType.MESSAGES_SNAPSHOT) {
2216
- for (const message of decoded.messages) {
2217
- const untypedMessage = message;
2218
- if (((_a = untypedMessage.toolCalls) == null ? void 0 : _a.length) === 0) {
2219
- untypedMessage.toolCalls = void 0;
2220
- }
2221
- }
2222
- }
2223
- if (decoded.type === import_core.EventType.STATE_DELTA) {
2224
- for (const operation of decoded.delta) {
2225
- operation.op = JsonPatchOperationType[operation.op].toLowerCase();
2226
- Object.keys(operation).forEach((key) => {
2227
- if (operation[key] === void 0) {
2228
- delete operation[key];
2229
- }
2230
- });
2231
- }
2232
- }
2233
- Object.keys(decoded).forEach((key) => {
2234
- if (decoded[key] === void 0) {
2235
- delete decoded[key];
2236
- }
2237
- });
2238
- return import_core.EventSchemas.parse(decoded);
1667
+ const event = Event.decode(data);
1668
+ const decoded = Object.values(event).find((value) => value !== void 0);
1669
+ if (!decoded) throw new Error("Invalid event");
1670
+ decoded.type = EventType$1[decoded.baseEvent.type];
1671
+ decoded.timestamp = decoded.baseEvent.timestamp;
1672
+ decoded.rawEvent = decoded.baseEvent.rawEvent;
1673
+ if (decoded.type === _ag_ui_core.EventType.MESSAGES_SNAPSHOT) for (const message of decoded.messages) {
1674
+ const untypedMessage = message;
1675
+ if (untypedMessage.toolCalls?.length === 0) untypedMessage.toolCalls = void 0;
1676
+ }
1677
+ if (decoded.type === _ag_ui_core.EventType.STATE_DELTA) for (const operation of decoded.delta) {
1678
+ operation.op = JsonPatchOperationType[operation.op].toLowerCase();
1679
+ Object.keys(operation).forEach((key) => {
1680
+ if (operation[key] === void 0) delete operation[key];
1681
+ });
1682
+ }
1683
+ Object.keys(decoded).forEach((key) => {
1684
+ if (decoded[key] === void 0) delete decoded[key];
1685
+ });
1686
+ return _ag_ui_core.EventSchemas.parse(decoded);
2239
1687
  }
2240
1688
 
2241
- // src/index.ts
2242
- var AGUI_MEDIA_TYPE = "application/vnd.ag-ui.event+proto";
2243
- // Annotate the CommonJS export names for ESM import in node:
2244
- 0 && (module.exports = {
2245
- AGUI_MEDIA_TYPE,
2246
- decode,
2247
- encode
2248
- });
1689
+ //#endregion
1690
+ //#region src/index.ts
1691
+ const AGUI_MEDIA_TYPE = "application/vnd.ag-ui.event+proto";
1692
+
1693
+ //#endregion
1694
+ exports.AGUI_MEDIA_TYPE = AGUI_MEDIA_TYPE;
1695
+ exports.decode = decode;
1696
+ exports.encode = encode;
2249
1697
  //# sourceMappingURL=index.js.map