1package fantasy
2
3import (
4 "encoding/json"
5 "errors"
6 "fmt"
7)
8
9// contentJSON is a helper type for JSON serialization of Content in Response.
10type contentJSON struct {
11 Type string `json:"type"`
12 Data json.RawMessage `json:"data"`
13}
14
15// messagePartJSON is a helper type for JSON serialization of MessagePart.
16type messagePartJSON struct {
17 Type string `json:"type"`
18 Data json.RawMessage `json:"data"`
19}
20
21// toolResultOutputJSON is a helper type for JSON serialization of ToolResultOutputContent.
22type toolResultOutputJSON struct {
23 Type string `json:"type"`
24 Data json.RawMessage `json:"data"`
25}
26
27// toolJSON is a helper type for JSON serialization of Tool.
28type toolJSON struct {
29 Type string `json:"type"`
30 Data json.RawMessage `json:"data"`
31}
32
33func (t TextContent) MarshalJSON() ([]byte, error) {
34 dataBytes, err := json.Marshal(struct {
35 Text string `json:"text"`
36 ProviderMetadata ProviderMetadata `json:"provider_metadata,omitempty"`
37 }{
38 Text: t.Text,
39 ProviderMetadata: t.ProviderMetadata,
40 })
41 if err != nil {
42 return nil, err
43 }
44
45 return json.Marshal(contentJSON{
46 Type: string(ContentTypeText),
47 Data: json.RawMessage(dataBytes),
48 })
49}
50
51func (t *TextContent) UnmarshalJSON(data []byte) error {
52 var cj contentJSON
53 if err := json.Unmarshal(data, &cj); err != nil {
54 return err
55 }
56
57 var aux struct {
58 Text string `json:"text"`
59 ProviderMetadata map[string]json.RawMessage `json:"provider_metadata,omitempty"`
60 }
61
62 if err := json.Unmarshal(cj.Data, &aux); err != nil {
63 return err
64 }
65
66 t.Text = aux.Text
67
68 if len(aux.ProviderMetadata) > 0 {
69 metadata, err := UnmarshalProviderMetadata(aux.ProviderMetadata)
70 if err != nil {
71 return err
72 }
73 t.ProviderMetadata = metadata
74 }
75
76 return nil
77}
78
79func (r ReasoningContent) MarshalJSON() ([]byte, error) {
80 dataBytes, err := json.Marshal(struct {
81 Text string `json:"text"`
82 ProviderMetadata ProviderMetadata `json:"provider_metadata,omitempty"`
83 }{
84 Text: r.Text,
85 ProviderMetadata: r.ProviderMetadata,
86 })
87 if err != nil {
88 return nil, err
89 }
90
91 return json.Marshal(contentJSON{
92 Type: string(ContentTypeReasoning),
93 Data: json.RawMessage(dataBytes),
94 })
95}
96
97func (r *ReasoningContent) UnmarshalJSON(data []byte) error {
98 var cj contentJSON
99 if err := json.Unmarshal(data, &cj); err != nil {
100 return err
101 }
102
103 var aux struct {
104 Text string `json:"text"`
105 ProviderMetadata map[string]json.RawMessage `json:"provider_metadata,omitempty"`
106 }
107
108 if err := json.Unmarshal(cj.Data, &aux); err != nil {
109 return err
110 }
111
112 r.Text = aux.Text
113
114 if len(aux.ProviderMetadata) > 0 {
115 metadata, err := UnmarshalProviderMetadata(aux.ProviderMetadata)
116 if err != nil {
117 return err
118 }
119 r.ProviderMetadata = metadata
120 }
121
122 return nil
123}
124
125func (f FileContent) MarshalJSON() ([]byte, error) {
126 dataBytes, err := json.Marshal(struct {
127 MediaType string `json:"media_type"`
128 Data []byte `json:"data"`
129 ProviderMetadata ProviderMetadata `json:"provider_metadata,omitempty"`
130 }{
131 MediaType: f.MediaType,
132 Data: f.Data,
133 ProviderMetadata: f.ProviderMetadata,
134 })
135 if err != nil {
136 return nil, err
137 }
138
139 return json.Marshal(contentJSON{
140 Type: string(ContentTypeFile),
141 Data: json.RawMessage(dataBytes),
142 })
143}
144
145func (f *FileContent) UnmarshalJSON(data []byte) error {
146 var cj contentJSON
147 if err := json.Unmarshal(data, &cj); err != nil {
148 return err
149 }
150
151 var aux struct {
152 MediaType string `json:"media_type"`
153 Data []byte `json:"data"`
154 ProviderMetadata map[string]json.RawMessage `json:"provider_metadata,omitempty"`
155 }
156
157 if err := json.Unmarshal(cj.Data, &aux); err != nil {
158 return err
159 }
160
161 f.MediaType = aux.MediaType
162 f.Data = aux.Data
163
164 if len(aux.ProviderMetadata) > 0 {
165 metadata, err := UnmarshalProviderMetadata(aux.ProviderMetadata)
166 if err != nil {
167 return err
168 }
169 f.ProviderMetadata = metadata
170 }
171
172 return nil
173}
174
175func (s SourceContent) MarshalJSON() ([]byte, error) {
176 dataBytes, err := json.Marshal(struct {
177 SourceType SourceType `json:"source_type"`
178 ID string `json:"id"`
179 URL string `json:"url,omitempty"`
180 Title string `json:"title,omitempty"`
181 MediaType string `json:"media_type,omitempty"`
182 Filename string `json:"filename,omitempty"`
183 ProviderMetadata ProviderMetadata `json:"provider_metadata,omitempty"`
184 }{
185 SourceType: s.SourceType,
186 ID: s.ID,
187 URL: s.URL,
188 Title: s.Title,
189 MediaType: s.MediaType,
190 Filename: s.Filename,
191 ProviderMetadata: s.ProviderMetadata,
192 })
193 if err != nil {
194 return nil, err
195 }
196
197 return json.Marshal(contentJSON{
198 Type: string(ContentTypeSource),
199 Data: json.RawMessage(dataBytes),
200 })
201}
202
203func (s *SourceContent) UnmarshalJSON(data []byte) error {
204 var cj contentJSON
205 if err := json.Unmarshal(data, &cj); err != nil {
206 return err
207 }
208
209 var aux struct {
210 SourceType SourceType `json:"source_type"`
211 ID string `json:"id"`
212 URL string `json:"url,omitempty"`
213 Title string `json:"title,omitempty"`
214 MediaType string `json:"media_type,omitempty"`
215 Filename string `json:"filename,omitempty"`
216 ProviderMetadata map[string]json.RawMessage `json:"provider_metadata,omitempty"`
217 }
218
219 if err := json.Unmarshal(cj.Data, &aux); err != nil {
220 return err
221 }
222
223 s.SourceType = aux.SourceType
224 s.ID = aux.ID
225 s.URL = aux.URL
226 s.Title = aux.Title
227 s.MediaType = aux.MediaType
228 s.Filename = aux.Filename
229
230 if len(aux.ProviderMetadata) > 0 {
231 metadata, err := UnmarshalProviderMetadata(aux.ProviderMetadata)
232 if err != nil {
233 return err
234 }
235 s.ProviderMetadata = metadata
236 }
237
238 return nil
239}
240
241func (t ToolCallContent) MarshalJSON() ([]byte, error) {
242 dataBytes, err := json.Marshal(struct {
243 ToolCallID string `json:"tool_call_id"`
244 ToolName string `json:"tool_name"`
245 Input string `json:"input"`
246 ProviderExecuted bool `json:"provider_executed"`
247 ProviderMetadata ProviderMetadata `json:"provider_metadata,omitempty"`
248 Invalid bool `json:"invalid,omitempty"`
249 ValidationError error `json:"validation_error,omitempty"`
250 }{
251 ToolCallID: t.ToolCallID,
252 ToolName: t.ToolName,
253 Input: t.Input,
254 ProviderExecuted: t.ProviderExecuted,
255 ProviderMetadata: t.ProviderMetadata,
256 Invalid: t.Invalid,
257 ValidationError: t.ValidationError,
258 })
259 if err != nil {
260 return nil, err
261 }
262
263 return json.Marshal(contentJSON{
264 Type: string(ContentTypeToolCall),
265 Data: json.RawMessage(dataBytes),
266 })
267}
268
269func (t *ToolCallContent) UnmarshalJSON(data []byte) error {
270 var cj contentJSON
271 if err := json.Unmarshal(data, &cj); err != nil {
272 return err
273 }
274
275 var aux struct {
276 ToolCallID string `json:"tool_call_id"`
277 ToolName string `json:"tool_name"`
278 Input string `json:"input"`
279 ProviderExecuted bool `json:"provider_executed"`
280 ProviderMetadata map[string]json.RawMessage `json:"provider_metadata,omitempty"`
281 Invalid bool `json:"invalid,omitempty"`
282 ValidationError error `json:"validation_error,omitempty"`
283 }
284
285 if err := json.Unmarshal(cj.Data, &aux); err != nil {
286 return err
287 }
288
289 t.ToolCallID = aux.ToolCallID
290 t.ToolName = aux.ToolName
291 t.Input = aux.Input
292 t.ProviderExecuted = aux.ProviderExecuted
293 t.Invalid = aux.Invalid
294 t.ValidationError = aux.ValidationError
295
296 if len(aux.ProviderMetadata) > 0 {
297 metadata, err := UnmarshalProviderMetadata(aux.ProviderMetadata)
298 if err != nil {
299 return err
300 }
301 t.ProviderMetadata = metadata
302 }
303
304 return nil
305}
306
307func (t ToolResultContent) MarshalJSON() ([]byte, error) {
308 dataBytes, err := json.Marshal(struct {
309 ToolCallID string `json:"tool_call_id"`
310 ToolName string `json:"tool_name"`
311 Result ToolResultOutputContent `json:"result"`
312 ClientMetadata string `json:"client_metadata,omitempty"`
313 ProviderExecuted bool `json:"provider_executed"`
314 ProviderMetadata ProviderMetadata `json:"provider_metadata,omitempty"`
315 }{
316 ToolCallID: t.ToolCallID,
317 ToolName: t.ToolName,
318 Result: t.Result,
319 ClientMetadata: t.ClientMetadata,
320 ProviderExecuted: t.ProviderExecuted,
321 ProviderMetadata: t.ProviderMetadata,
322 })
323 if err != nil {
324 return nil, err
325 }
326
327 return json.Marshal(contentJSON{
328 Type: string(ContentTypeToolResult),
329 Data: json.RawMessage(dataBytes),
330 })
331}
332
333func (t *ToolResultContent) UnmarshalJSON(data []byte) error {
334 var cj contentJSON
335 if err := json.Unmarshal(data, &cj); err != nil {
336 return err
337 }
338
339 var aux struct {
340 ToolCallID string `json:"tool_call_id"`
341 ToolName string `json:"tool_name"`
342 Result json.RawMessage `json:"result"`
343 ClientMetadata string `json:"client_metadata,omitempty"`
344 ProviderExecuted bool `json:"provider_executed"`
345 ProviderMetadata map[string]json.RawMessage `json:"provider_metadata,omitempty"`
346 }
347
348 if err := json.Unmarshal(cj.Data, &aux); err != nil {
349 return err
350 }
351
352 t.ToolCallID = aux.ToolCallID
353 t.ToolName = aux.ToolName
354 t.ClientMetadata = aux.ClientMetadata
355 t.ProviderExecuted = aux.ProviderExecuted
356
357 // Unmarshal the Result field
358 result, err := UnmarshalToolResultOutputContent(aux.Result)
359 if err != nil {
360 return fmt.Errorf("failed to unmarshal tool result output: %w", err)
361 }
362 t.Result = result
363
364 if len(aux.ProviderMetadata) > 0 {
365 metadata, err := UnmarshalProviderMetadata(aux.ProviderMetadata)
366 if err != nil {
367 return err
368 }
369 t.ProviderMetadata = metadata
370 }
371
372 return nil
373}
374
375func (t ToolResultOutputContentText) MarshalJSON() ([]byte, error) {
376 dataBytes, err := json.Marshal(struct {
377 Text string `json:"text"`
378 }{
379 Text: t.Text,
380 })
381 if err != nil {
382 return nil, err
383 }
384
385 return json.Marshal(toolResultOutputJSON{
386 Type: string(ToolResultContentTypeText),
387 Data: json.RawMessage(dataBytes),
388 })
389}
390
391func (t *ToolResultOutputContentText) UnmarshalJSON(data []byte) error {
392 var tr toolResultOutputJSON
393 if err := json.Unmarshal(data, &tr); err != nil {
394 return err
395 }
396
397 var temp struct {
398 Text string `json:"text"`
399 }
400
401 if err := json.Unmarshal(tr.Data, &temp); err != nil {
402 return err
403 }
404
405 t.Text = temp.Text
406 return nil
407}
408
409func (t ToolResultOutputContentError) MarshalJSON() ([]byte, error) {
410 errMsg := ""
411 if t.Error != nil {
412 errMsg = t.Error.Error()
413 }
414 dataBytes, err := json.Marshal(struct {
415 Error string `json:"error"`
416 }{
417 Error: errMsg,
418 })
419 if err != nil {
420 return nil, err
421 }
422
423 return json.Marshal(toolResultOutputJSON{
424 Type: string(ToolResultContentTypeError),
425 Data: json.RawMessage(dataBytes),
426 })
427}
428
429func (t *ToolResultOutputContentError) UnmarshalJSON(data []byte) error {
430 var tr toolResultOutputJSON
431 if err := json.Unmarshal(data, &tr); err != nil {
432 return err
433 }
434
435 var temp struct {
436 Error string `json:"error"`
437 }
438
439 if err := json.Unmarshal(tr.Data, &temp); err != nil {
440 return err
441 }
442 if temp.Error != "" {
443 t.Error = errors.New(temp.Error)
444 }
445 return nil
446}
447
448func (t ToolResultOutputContentMedia) MarshalJSON() ([]byte, error) {
449 dataBytes, err := json.Marshal(struct {
450 Data string `json:"data"`
451 MediaType string `json:"media_type"`
452 }{
453 Data: t.Data,
454 MediaType: t.MediaType,
455 })
456 if err != nil {
457 return nil, err
458 }
459
460 return json.Marshal(toolResultOutputJSON{
461 Type: string(ToolResultContentTypeMedia),
462 Data: json.RawMessage(dataBytes),
463 })
464}
465
466func (t *ToolResultOutputContentMedia) UnmarshalJSON(data []byte) error {
467 var tr toolResultOutputJSON
468 if err := json.Unmarshal(data, &tr); err != nil {
469 return err
470 }
471
472 var temp struct {
473 Data string `json:"data"`
474 MediaType string `json:"media_type"`
475 }
476
477 if err := json.Unmarshal(tr.Data, &temp); err != nil {
478 return err
479 }
480
481 t.Data = temp.Data
482 t.MediaType = temp.MediaType
483 return nil
484}
485
486func (t TextPart) MarshalJSON() ([]byte, error) {
487 dataBytes, err := json.Marshal(struct {
488 Text string `json:"text"`
489 ProviderOptions ProviderOptions `json:"provider_options,omitempty"`
490 }{
491 Text: t.Text,
492 ProviderOptions: t.ProviderOptions,
493 })
494 if err != nil {
495 return nil, err
496 }
497
498 return json.Marshal(messagePartJSON{
499 Type: string(ContentTypeText),
500 Data: json.RawMessage(dataBytes),
501 })
502}
503
504func (t *TextPart) UnmarshalJSON(data []byte) error {
505 var mpj messagePartJSON
506 if err := json.Unmarshal(data, &mpj); err != nil {
507 return err
508 }
509
510 var aux struct {
511 Text string `json:"text"`
512 ProviderOptions map[string]json.RawMessage `json:"provider_options,omitempty"`
513 }
514
515 if err := json.Unmarshal(mpj.Data, &aux); err != nil {
516 return err
517 }
518
519 t.Text = aux.Text
520
521 if len(aux.ProviderOptions) > 0 {
522 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
523 if err != nil {
524 return err
525 }
526 t.ProviderOptions = options
527 }
528
529 return nil
530}
531
532func (r ReasoningPart) MarshalJSON() ([]byte, error) {
533 dataBytes, err := json.Marshal(struct {
534 Text string `json:"text"`
535 ProviderOptions ProviderOptions `json:"provider_options,omitempty"`
536 }{
537 Text: r.Text,
538 ProviderOptions: r.ProviderOptions,
539 })
540 if err != nil {
541 return nil, err
542 }
543
544 return json.Marshal(messagePartJSON{
545 Type: string(ContentTypeReasoning),
546 Data: json.RawMessage(dataBytes),
547 })
548}
549
550func (r *ReasoningPart) UnmarshalJSON(data []byte) error {
551 var mpj messagePartJSON
552 if err := json.Unmarshal(data, &mpj); err != nil {
553 return err
554 }
555
556 var aux struct {
557 Text string `json:"text"`
558 ProviderOptions map[string]json.RawMessage `json:"provider_options,omitempty"`
559 }
560
561 if err := json.Unmarshal(mpj.Data, &aux); err != nil {
562 return err
563 }
564
565 r.Text = aux.Text
566
567 if len(aux.ProviderOptions) > 0 {
568 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
569 if err != nil {
570 return err
571 }
572 r.ProviderOptions = options
573 }
574
575 return nil
576}
577
578func (f FilePart) MarshalJSON() ([]byte, error) {
579 dataBytes, err := json.Marshal(struct {
580 Filename string `json:"filename"`
581 Data []byte `json:"data"`
582 MediaType string `json:"media_type"`
583 ProviderOptions ProviderOptions `json:"provider_options,omitempty"`
584 }{
585 Filename: f.Filename,
586 Data: f.Data,
587 MediaType: f.MediaType,
588 ProviderOptions: f.ProviderOptions,
589 })
590 if err != nil {
591 return nil, err
592 }
593
594 return json.Marshal(messagePartJSON{
595 Type: string(ContentTypeFile),
596 Data: json.RawMessage(dataBytes),
597 })
598}
599
600func (f *FilePart) UnmarshalJSON(data []byte) error {
601 var mpj messagePartJSON
602 if err := json.Unmarshal(data, &mpj); err != nil {
603 return err
604 }
605
606 var aux struct {
607 Filename string `json:"filename"`
608 Data []byte `json:"data"`
609 MediaType string `json:"media_type"`
610 ProviderOptions map[string]json.RawMessage `json:"provider_options,omitempty"`
611 }
612
613 if err := json.Unmarshal(mpj.Data, &aux); err != nil {
614 return err
615 }
616
617 f.Filename = aux.Filename
618 f.Data = aux.Data
619 f.MediaType = aux.MediaType
620
621 if len(aux.ProviderOptions) > 0 {
622 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
623 if err != nil {
624 return err
625 }
626 f.ProviderOptions = options
627 }
628
629 return nil
630}
631
632func (t ToolCallPart) MarshalJSON() ([]byte, error) {
633 dataBytes, err := json.Marshal(struct {
634 ToolCallID string `json:"tool_call_id"`
635 ToolName string `json:"tool_name"`
636 Input string `json:"input"`
637 ProviderExecuted bool `json:"provider_executed"`
638 ProviderOptions ProviderOptions `json:"provider_options,omitempty"`
639 }{
640 ToolCallID: t.ToolCallID,
641 ToolName: t.ToolName,
642 Input: t.Input,
643 ProviderExecuted: t.ProviderExecuted,
644 ProviderOptions: t.ProviderOptions,
645 })
646 if err != nil {
647 return nil, err
648 }
649
650 return json.Marshal(messagePartJSON{
651 Type: string(ContentTypeToolCall),
652 Data: json.RawMessage(dataBytes),
653 })
654}
655
656func (t *ToolCallPart) UnmarshalJSON(data []byte) error {
657 var mpj messagePartJSON
658 if err := json.Unmarshal(data, &mpj); err != nil {
659 return err
660 }
661
662 var aux struct {
663 ToolCallID string `json:"tool_call_id"`
664 ToolName string `json:"tool_name"`
665 Input string `json:"input"`
666 ProviderExecuted bool `json:"provider_executed"`
667 ProviderOptions map[string]json.RawMessage `json:"provider_options,omitempty"`
668 }
669
670 if err := json.Unmarshal(mpj.Data, &aux); err != nil {
671 return err
672 }
673
674 t.ToolCallID = aux.ToolCallID
675 t.ToolName = aux.ToolName
676 t.Input = aux.Input
677 t.ProviderExecuted = aux.ProviderExecuted
678
679 if len(aux.ProviderOptions) > 0 {
680 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
681 if err != nil {
682 return err
683 }
684 t.ProviderOptions = options
685 }
686
687 return nil
688}
689
690func (t ToolResultPart) MarshalJSON() ([]byte, error) {
691 dataBytes, err := json.Marshal(struct {
692 ToolCallID string `json:"tool_call_id"`
693 Output ToolResultOutputContent `json:"output"`
694 ProviderOptions ProviderOptions `json:"provider_options,omitempty"`
695 }{
696 ToolCallID: t.ToolCallID,
697 Output: t.Output,
698 ProviderOptions: t.ProviderOptions,
699 })
700 if err != nil {
701 return nil, err
702 }
703
704 return json.Marshal(messagePartJSON{
705 Type: string(ContentTypeToolResult),
706 Data: json.RawMessage(dataBytes),
707 })
708}
709
710func (t *ToolResultPart) UnmarshalJSON(data []byte) error {
711 var mpj messagePartJSON
712 if err := json.Unmarshal(data, &mpj); err != nil {
713 return err
714 }
715
716 var aux struct {
717 ToolCallID string `json:"tool_call_id"`
718 Output json.RawMessage `json:"output"`
719 ProviderOptions map[string]json.RawMessage `json:"provider_options,omitempty"`
720 }
721
722 if err := json.Unmarshal(mpj.Data, &aux); err != nil {
723 return err
724 }
725
726 t.ToolCallID = aux.ToolCallID
727
728 // Unmarshal the Output field
729 output, err := UnmarshalToolResultOutputContent(aux.Output)
730 if err != nil {
731 return fmt.Errorf("failed to unmarshal tool result output: %w", err)
732 }
733 t.Output = output
734
735 if len(aux.ProviderOptions) > 0 {
736 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
737 if err != nil {
738 return err
739 }
740 t.ProviderOptions = options
741 }
742
743 return nil
744}
745
746func (m *Message) UnmarshalJSON(data []byte) error {
747 var aux struct {
748 Role MessageRole `json:"role"`
749 Content []json.RawMessage `json:"content"`
750 ProviderOptions map[string]json.RawMessage `json:"provider_options"`
751 }
752
753 if err := json.Unmarshal(data, &aux); err != nil {
754 return err
755 }
756
757 m.Role = aux.Role
758
759 m.Content = make([]MessagePart, len(aux.Content))
760 for i, rawPart := range aux.Content {
761 part, err := UnmarshalMessagePart(rawPart)
762 if err != nil {
763 return fmt.Errorf("failed to unmarshal message part at index %d: %w", i, err)
764 }
765 m.Content[i] = part
766 }
767
768 if len(aux.ProviderOptions) > 0 {
769 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
770 if err != nil {
771 return err
772 }
773 m.ProviderOptions = options
774 }
775
776 return nil
777}
778
779func (f FunctionTool) MarshalJSON() ([]byte, error) {
780 dataBytes, err := json.Marshal(struct {
781 Name string `json:"name"`
782 Description string `json:"description"`
783 InputSchema map[string]any `json:"input_schema"`
784 ProviderOptions ProviderOptions `json:"provider_options,omitempty"`
785 }{
786 Name: f.Name,
787 Description: f.Description,
788 InputSchema: f.InputSchema,
789 ProviderOptions: f.ProviderOptions,
790 })
791 if err != nil {
792 return nil, err
793 }
794
795 return json.Marshal(toolJSON{
796 Type: string(ToolTypeFunction),
797 Data: json.RawMessage(dataBytes),
798 })
799}
800
801func (f *FunctionTool) UnmarshalJSON(data []byte) error {
802 var tj toolJSON
803 if err := json.Unmarshal(data, &tj); err != nil {
804 return err
805 }
806
807 var aux struct {
808 Name string `json:"name"`
809 Description string `json:"description"`
810 InputSchema map[string]any `json:"input_schema"`
811 ProviderOptions map[string]json.RawMessage `json:"provider_options,omitempty"`
812 }
813
814 if err := json.Unmarshal(tj.Data, &aux); err != nil {
815 return err
816 }
817
818 f.Name = aux.Name
819 f.Description = aux.Description
820 f.InputSchema = aux.InputSchema
821
822 if len(aux.ProviderOptions) > 0 {
823 options, err := UnmarshalProviderOptions(aux.ProviderOptions)
824 if err != nil {
825 return err
826 }
827 f.ProviderOptions = options
828 }
829
830 return nil
831}
832
833func (p ProviderDefinedTool) MarshalJSON() ([]byte, error) {
834 dataBytes, err := json.Marshal(struct {
835 ID string `json:"id"`
836 Name string `json:"name"`
837 Args map[string]any `json:"args"`
838 }{
839 ID: p.ID,
840 Name: p.Name,
841 Args: p.Args,
842 })
843 if err != nil {
844 return nil, err
845 }
846
847 return json.Marshal(toolJSON{
848 Type: string(ToolTypeProviderDefined),
849 Data: json.RawMessage(dataBytes),
850 })
851}
852
853func (p *ProviderDefinedTool) UnmarshalJSON(data []byte) error {
854 var tj toolJSON
855 if err := json.Unmarshal(data, &tj); err != nil {
856 return err
857 }
858
859 var aux struct {
860 ID string `json:"id"`
861 Name string `json:"name"`
862 Args map[string]any `json:"args"`
863 }
864
865 if err := json.Unmarshal(tj.Data, &aux); err != nil {
866 return err
867 }
868
869 p.ID = aux.ID
870 p.Name = aux.Name
871 p.Args = aux.Args
872
873 return nil
874}
875
876// UnmarshalTool unmarshals JSON into the appropriate Tool type
877func UnmarshalTool(data []byte) (Tool, error) {
878 var tj toolJSON
879 if err := json.Unmarshal(data, &tj); err != nil {
880 return nil, err
881 }
882
883 switch ToolType(tj.Type) {
884 case ToolTypeFunction:
885 var tool FunctionTool
886 if err := tool.UnmarshalJSON(data); err != nil {
887 return nil, err
888 }
889 return tool, nil
890 case ToolTypeProviderDefined:
891 var tool ProviderDefinedTool
892 if err := tool.UnmarshalJSON(data); err != nil {
893 return nil, err
894 }
895 return tool, nil
896 default:
897 return nil, fmt.Errorf("unknown tool type: %s", tj.Type)
898 }
899}
900
901// UnmarshalContent unmarshals JSON into the appropriate Content type
902func UnmarshalContent(data []byte) (Content, error) {
903 var cj contentJSON
904 if err := json.Unmarshal(data, &cj); err != nil {
905 return nil, err
906 }
907
908 switch ContentType(cj.Type) {
909 case ContentTypeText:
910 var content TextContent
911 if err := content.UnmarshalJSON(data); err != nil {
912 return nil, err
913 }
914 return content, nil
915 case ContentTypeReasoning:
916 var content ReasoningContent
917 if err := content.UnmarshalJSON(data); err != nil {
918 return nil, err
919 }
920 return content, nil
921 case ContentTypeFile:
922 var content FileContent
923 if err := content.UnmarshalJSON(data); err != nil {
924 return nil, err
925 }
926 return content, nil
927 case ContentTypeSource:
928 var content SourceContent
929 if err := content.UnmarshalJSON(data); err != nil {
930 return nil, err
931 }
932 return content, nil
933 case ContentTypeToolCall:
934 var content ToolCallContent
935 if err := content.UnmarshalJSON(data); err != nil {
936 return nil, err
937 }
938 return content, nil
939 case ContentTypeToolResult:
940 var content ToolResultContent
941 if err := content.UnmarshalJSON(data); err != nil {
942 return nil, err
943 }
944 return content, nil
945 default:
946 return nil, fmt.Errorf("unknown content type: %s", cj.Type)
947 }
948}
949
950// UnmarshalMessagePart unmarshals JSON into the appropriate MessagePart type
951func UnmarshalMessagePart(data []byte) (MessagePart, error) {
952 var mpj messagePartJSON
953 if err := json.Unmarshal(data, &mpj); err != nil {
954 return nil, err
955 }
956
957 switch ContentType(mpj.Type) {
958 case ContentTypeText:
959 var part TextPart
960 if err := part.UnmarshalJSON(data); err != nil {
961 return nil, err
962 }
963 return part, nil
964 case ContentTypeReasoning:
965 var part ReasoningPart
966 if err := part.UnmarshalJSON(data); err != nil {
967 return nil, err
968 }
969 return part, nil
970 case ContentTypeFile:
971 var part FilePart
972 if err := part.UnmarshalJSON(data); err != nil {
973 return nil, err
974 }
975 return part, nil
976 case ContentTypeToolCall:
977 var part ToolCallPart
978 if err := part.UnmarshalJSON(data); err != nil {
979 return nil, err
980 }
981 return part, nil
982 case ContentTypeToolResult:
983 var part ToolResultPart
984 if err := part.UnmarshalJSON(data); err != nil {
985 return nil, err
986 }
987 return part, nil
988 default:
989 return nil, fmt.Errorf("unknown message part type: %s", mpj.Type)
990 }
991}
992
993// UnmarshalToolResultOutputContent unmarshals JSON into the appropriate ToolResultOutputContent type
994func UnmarshalToolResultOutputContent(data []byte) (ToolResultOutputContent, error) {
995 var troj toolResultOutputJSON
996 if err := json.Unmarshal(data, &troj); err != nil {
997 return nil, err
998 }
999
1000 switch ToolResultContentType(troj.Type) {
1001 case ToolResultContentTypeText:
1002 var content ToolResultOutputContentText
1003 if err := content.UnmarshalJSON(data); err != nil {
1004 return nil, err
1005 }
1006 return content, nil
1007 case ToolResultContentTypeError:
1008 var content ToolResultOutputContentError
1009 if err := content.UnmarshalJSON(data); err != nil {
1010 return nil, err
1011 }
1012 return content, nil
1013 case ToolResultContentTypeMedia:
1014 var content ToolResultOutputContentMedia
1015 if err := content.UnmarshalJSON(data); err != nil {
1016 return nil, err
1017 }
1018 return content, nil
1019 default:
1020 return nil, fmt.Errorf("unknown tool result output content type: %s", troj.Type)
1021 }
1022}