uPj hUddlZddlZddlZddlZddlZddlZddlZddlmZm Z m Z m Z ddl m Z mZmZddlmZmZddlZddlmZmZddlmZddlmZddlZddlmZdd lmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*m+Z+dd l,m-Z-ddl.m/Z/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>m?Z?m@Z@mAZAmBZBmCZCmDZDddlEmFZFmGZGddlHmIZImJZJmKZKmLZLmMZMddlNmOZOddlPmQZQdZReeSd<dZTeeSd<dZUeeSd<ejd ZWeeSd!<d"ZXeeSd#<ejd$ZYeeSd%<Gd&d'ed()ZZGd*d+ed()Z[Gd,d-ed()Z\Gd.d/ed()Z]Gd0d1eZ^Gd2d3eZ_Gd4d5eZ`d6ead7eafd8Zbd6ead7eceafd9Zdd:ecead7eadzfd;ZedZhd?e eaegfd7eafd@Zid[^#]*)#(?P\d+)/(?P\d+)$_VERTEX_BATCH_FANNED_OUT_KEY_PATTERNceZdZUeeed<y)_GcsObjectMetadataJsonpurposeN)__name__ __module__ __qualname__rr,__annotations__p/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/litellm/llms/vertex_ai/files/transformation.pyrHrHUs ( ))rOrHF)totalc^eZdZUeeed<eeed<eeed<eeed<eeed<y)_GcsObjectJsonidnamesize timeCreatedmetadataN)rJrKrLrstrrMrHrNrOrPrSrSYs6  3- 3-#-..rOrSc(eZdZUeeeefed<y)_VertexBatchRowRequestlabelsN)rJrKrLrrrYobjectrMrNrOrPr[r[as WS&[) **rOr[c>eZdZUeeed<eeed<eeed<y)_VertexBatchRowrequeststatusprocessed_timeN)rJrKrLrr[rMrYrNrOrPr_r_es" , -- SMSM!rOr_c.eZdZUeeed<eeed<y)_OpenAIBatchOutputErrorcodemessageN)rJrKrLrrYrMrNrOrPrdrdks 3- c]rOrdcHeZdZUeeed<eeed<eeeefed<y)_OpenAIBatchOutputResponse status_code request_idbodyN) rJrKrLrintrMrYrr]rNrOrPrhrhps*#  73;' ((rOrhcZeZdZUeeed<eeed<eedzed<eedzed<y)_OpenAIBatchOutputRowrT custom_idNresponseerror)rJrKrLrrYrMrhrdrNrOrPrnrnvs8 }1D899 +d2 33rOrnvaluereturnc^tjdd|j}|dtS)aC Sanitize a string to meet GCP label value constraints. GCP label values must: - Be lowercase - Contain only letters, numbers, underscores, and hyphens - Be max 63 characters Args: value: The string to sanitize Returns: A sanitized string that meets GCP label constraints z [^a-z0-9_-]_N)resublowerr:)rr sanitizeds rP_sanitize_gcp_label_valuerz}s+vvnc5;;=AI .. //rOcNtttz }tj|j dj djdj}tdt||Dcgc]}t||||zc}xstgScc}w)z?Encode arbitrary text across one or more GCP-label-safe values.utf-8ascii=r) r:lenr<base64 b32encodeencodedecoderstriprxrange)rrmax_encoded_lenencodedis rP_encode_gcp_label_value_chunksrs5M";M"JF <]K&6q&9F "#"+,r rY isinstancer(_get_litellm_batch_custom_id_from_labels)rr= request_datar\s rP_get_litellm_batch_custom_idrs`    7 8C s3x  $((3L+5lG+L\  h 'RVF 3F ;;rOc |sy|jd}|rt|g}d}g}|jD]e\}}|j|s|t |dj s5|j t|t |dt|fg|jdt|dDt|}||St|St|jddS) zPPrefer encoded custom_id when present (see _set_litellm_batch_custom_id_labels).unknownrrNc3&K|] \}}| ywNrN).0rurs rP z;_get_litellm_batch_custom_id_from_labels..su.@a/uc |dSNrrN)items rPz:_get_litellm_batch_custom_id_from_labels..s lpqrlsrOr=r) rrYitemsrrisdigitrrlextendsortedr)r\raw raw_chunks chunk_prefixindexed_chunksr=rrdecodeds rPrrs 34C  XJ 6 " ,,. SJC~~l+C 4E4G0H0P0P0R%%s3s_sDtuu7 C  N3x vzz-y9 ::rOcd|vry|jd}t|tr t|jdtry|jd}t|jdxrt|txrd|vS)a" Whether a Vertex batch output row came from an `EmbedContentRequest`. Successful rows hold the vector under `response.embedding.values`; failed rows only carry `status`, so they are recognized from the singular `content` that the embeddings request shape echoes back. r`Frp embeddingTracontent)rrdictbool)rrprs rP&_is_vertex_embeddings_batch_output_rowrs~)) $$Z0H(D!jk1JD&Q$((3L !%%h/ 0 qZ d5S qXaeqXqqrOrk error_code error_messagec|dtj||dnd|jdd|d|ddS||ddS) z One row of an OpenAI batch output file. Per the OpenAI Batch spec, failed rows set `response` to null and populate `error` instead. batch_req_NrTr)rirjrk)rerf)rTrorprq)ruuid4r)rorkrrs rP_openai_batch_output_rowrsf4::<.) <((4, $+  ;EQ^1_  rOc |jt}|t|ddfStj t |}|t t |ddfSt |dt|dt|dfS)ar Resolve `(custom_id, index within that custom_id, group size)` for a Vertex batch output row. A `/v1/embeddings` entry whose `input` is an array fans out into one Vertex row per element, tagged `#/` (see `_vertex_batch_embeddings_key`), so the rows can be reassembled into a single OpenAI response. rrrorrQ)rr>rrF fullmatchrYr rl)rr=matchs rP_split_vertex_batch_keyrs    7 8C {+,=>1DD 0 : :3s8 DE }s3x !Q&& 5% &E'N(;Sw=P PPrOvertex_responsec|jd}t|trt|jdxsdSt|jdxsdS)z Prompt tokens billed for one Vertex Gemini Embedding batch row. Live rows report usage under `usageMetadata`; the documented `tokenCount` is kept as a fallback. usageMetadatapromptTokenCountr tokenCount)rrrrl)rusage_metadatas rP_embedding_prompt_token_countrsU%((9N.'*>%%&89>Q?? ""<05A 66rOvertex_output_rows.element_indices element_countmodelc td|Dd}|rt|d|S|tt|k7rt|ddt |d|dStd|D}t d |D}t |xsdt|D cgc]\}} t| d d |d c} }t|| j} t|| Scc} }w)a Transforms the Vertex Gemini Embedding batch output rows belonging to one OpenAI batch entry into an OpenAI batch output row holding an `/v1/embeddings` response. Example Vertex jsonl {"key": "id_1", "request": {...}, "response": {"embedding": {"values": [-0.015, 0.024]}, "usageMetadata": {"promptTokenCount": 2}}} An entry that asked for several embeddings at once maps to several rows here, which become the indexed elements of a single `data` array. One failed or missing element fails the whole entry, since an OpenAI batch row is either a response or an error and a partial `data` array would silently shift the remaining embeddings onto the wrong input positions. Rows carry no `modelVersion`, so the model comes from the batch they belong to. c3JK|]}|jds|dyw)raN)rrrows rPrzE_vertex_embeddings_rows_to_openai_batch_output_row..;sTS#''(BS3x=Ts# #rvertex_ai_errorrorrz/Vertex returned embeddings for input positions z of the z requestedc3&K|] }|d yw)rpNrNrs rPrzE_vertex_embeddings_rows_to_openai_batch_output_row..MsD#c*oDrc32K|]}t|ywr)r)rrps rPrzE_vertex_embeddings_rows_to_openai_batch_output_row..NsX(3H=Xsrr)rrr]) prompt_tokens total_tokens)rdatausagerork) nextrtuplerlistsumr1rr0r4 model_dump) rorrrrra responses token_countrrprks rP2_vertex_embeddings_rows_to_openai_batch_output_rowr&s*T,>TVX YF '(   %m 455'(A$BWAXY' 4   D1CDDIXiXXK kr$-Y#7   x ";/9"  +KH jl  $id CC sC# ctd|D}tjt|ddDcic]\}}|t|c}}tfdtj d|DDScc}}w)aH Transforms a whole Vertex Gemini Embedding batch output into OpenAI batch output rows, one per OpenAI batch entry, in the order the entries first appear. Rows are grouped rather than mapped one to one because a single entry can fan out into several Vertex rows, and Vertex returns them in arbitrary order. c36K|]}t||fywr)rrs rPrzF_transform_vertex_embeddings_batch_output_to_openai..isYs/4c:Ysc |dSrrNkrs rPrzE_transform_vertex_embeddings_batch_output_to_openai..ls TVWXTYrOrc|ddSrrNrs rPrzE_transform_vertex_embeddings_batch_output_to_openai..lskmnokpqrksrOc 3K|]M}t|td|Dtd|Dtd|DOyw)c3&K|] \}}| ywrrN)rrurs rPrzP_transform_vertex_embeddings_batch_output_to_openai...qs$OVQS$Orc3.K|] \\}}}}|ywrrN)rrurs rPrzP_transform_vertex_embeddings_batch_output_to_openai...rs!X,..ssT(8 AuqeTr)rorrrrN)rrmax)rro grouped_rowsrs rPrzF_transform_vertex_embeddings_batch_output_to_openai..nsd   ;$$O|I7N$OO!!X Y@W!XXTL.vs&X5I5FiAy&Xr)r itertoolsgroupbyrrfromkeys)rr keyed_rowsrogrouprs ` @rP3_transform_vertex_embeddings_batch_output_to_openair^sYFXYYJ!* 1 1&IY2Z`s t Iu 5<L  &XZ&XX    sBurlchtjt|}|r|jdSdS)ae Extracts the model from a LiteLLM-managed Vertex batch GCS url. Batch inputs and their sibling outputs are stored under `.../publishers/google/models//...`, which is the only place the model of an embeddings batch output row can be recovered from; unlike `generateContent` responses, embedding rows carry no `modelVersion`. rN)r?searchr r)rrs rP_model_from_managed_gcs_urlrzs- , 2 273< @E"5;;q>,,rO openai_entryc|jd}t|tsy|jddj d}|dk(xs|j dS)a" Whether an OpenAI batch JSONL line targets the embeddings endpoint. OpenAI puts the target route on each line's `url` (e.g. `/v1/embeddings`); Vertex has no equivalent per-line field, so the route decides which Vertex request shape the line has to be translated into. rF?r/ embeddingsz /embeddings)rrrYsplitrendswith)rrpaths rP_is_embeddings_batch_entryrsW   5 !C c3  99S>!  # #C (D <  ?4==#??rOembedding_inputc>t|tr t|S|fS)a Split an OpenAI `input` into the elements that each get their own embedding. A string is one embedding, a flat array is one embedding per element, and a nested array is one combined embedding per inner array, matching the online `batchEmbedContents` path. )rrr)rs rP _openai_embedding_input_elementsrs"/4(_%%  rOrrQc>t|d}|dkr|S|d|d|S)a The top-level `key` Vertex echoes back on an embeddings row. An entry asking for several embeddings needs several Vertex rows, so its key also carries the element index and the group size; `_split_vertex_batch_key` reads them back out. The `custom_id` is percent-encoded so that a customer one ending in `#/` cannot be mistaken for that tag, which would merge two entries. r)safer5#r )r )rorrQencoded_custom_ids rP_vertex_batch_embeddings_keyrs6ib1 % U2C1DAeWAeW/UUrOembed_content_requestc~d|ditDcic]\}}||vr|||c}}}|d|iSt|d|iScc}}w)z One Vertex Gemini Embedding batch input row. The config fields live inside the `EmbedContentRequest` under their snake_case batch names, and the OpenAI `custom_id` rides along in the top-level `key` that Vertex echoes back. rr`)rEr>)r=r gemini_param request_fieldr`s rP_vertex_embeddings_rowrsr (30T + m44 0> > G {7## #S)W == s9cR|jdtts tdjd}| t dt |}|s t dt fd|D|jdt fdtDS) a Transforms a single OpenAI `/v1/embeddings` batch entry into Vertex Gemini Embedding batch rows, one per requested embedding. Example Vertex jsonl {"key": "id_1", "request": {"content": {"parts": [{"text": "Hello World"}]}, "output_dimensionality": 768, "task_type": "RETRIEVAL_DOCUMENT"}} Note that `content` is singular (an `EmbedContentRequest`, not a `GenerateContentRequest`) and that the `custom_id` round-trips through the top-level `key`. An `EmbedContentRequest` returns exactly one vector, so an entry whose `input` is an array fans out into one row per element and is reassembled on the way back. The docs put the per-row config in an `embed_content_config` sibling of `request`, but the API rejects that key outright and fails the whole batch job, so the config fields go inside the `EmbedContentRequest` itself. API Ref: https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/batch-prediction-genai-embeddings rkz_`body` on /v1/embeddings batch requests must be a JSON object, but was missing or not an objectinputzJ`input` is required on /v1/embeddings batch requests, but was not providedz:`input` on /v1/embeddings batch requests must not be emptyc3ZK|]"}t|jdd$yw)rr)rroptional_paramsN)r$r)relementopenai_request_bodys rPrzF_openai_batch_jsonl_entry_to_vertex_embeddings_rows..s;#  4%))'26/  #s(+roc 3K|]6\}}tdntt|t|8yw)N)rorrQ)r=r)rrrYr)rrrroembed_content_requestss rPrzF_openai_batch_jsonl_entry_to_vertex_embeddings_rows..sU  )E(  -i.01 #8  s} Example Vertex jsonl {"request":{"contents": [{"role": "user", "parts": [{"text": "What is the relation between the following video and image samples?"}, {"fileData": {"fileUri": "gs://cloud-samples-data/generative-ai/video/animals.mp4", "mimeType": "video/mp4"}}, {"fileData": {"fileUri": "gs://cloud-samples-data/generative-ai/image/cricket.jpeg", "mimeType": "image/jpeg"}}]}]}} rkmessagesrr vertex_aiN)r,rr!custom_llm_providerlitellm_paramscached_contentror\r`)rr)rr!r)rr*r#vertex_request_bodyros rP(_openai_batch_jsonl_entry_to_vertex_rowsr2s",/B<PP!-!1!1&!9!?R!8$((R8!%%gr234GH' "$'' 4I . .,.  )+,?,I9U + , ..rO raw_linesc#K|D]B}t|ttfr|jdn|}|j }|s?|Dyw)zLDecode (when needed), strip, and drop blank lines from an iterable of lines.r|N)rbytes bytearrayrstrip)r3rlines rP_iter_stripped_linesr9!sF&0ui6H&Iszz'"szz| J s AA A openai_file_contentc#@K|}t|tr|d}t|ttfrrt d}dt |}}||krT|j ||}|dk(r||d|}}n ||||dz}}|jdj}|r|||krTyt|tr'ttj|Ed{yt|tr2tt|d5}t|Ed{dddyt|dr7t!|d d} | t#d  | dt|Ed{yt#d 77]#1swYyxYw#t$t"f$r} t#d | d} ~ wwxYw7Cw) z Yield non-empty JSONL lines one at a time without materializing the whole payload, so peak memory stays bounded regardless of payload size. Mirrors ``str.splitlines()`` + ``line.strip()`` for ``\n`` / ``\r\n`` delimited JSONL. r rNr|rbreadseekzoBatch upload file handle must be seekable; got a non-seekable stream. Pass bytes, a path, or a seekable handle.zkBatch upload file handle must be seekable so it can be re-read for the GCS object name and the upload body.Unsupported file content type)rrr5r6ordrfindrr7rYr9ioStringIOr-openhasattrgetattrr'OSError) r:rnewlinerlengthidxchunkr8handler@es rP_iter_openai_jsonl_linesrP*s 3G'5!!*'E9-.T3w 4 4$ ?   1srBF!2FE)*F>E- E+E-/FE9 FFF+E--E62F9F FFFc#ZKt|D]}tj|ywr)rPjsonloads)r:r8s rP_iter_openai_jsonl_entriesrTfs,))<=jjs)+r8c0tj|}|SrrRrS)r8rs rP_parse_vertex_batch_output_rowrWms"&**T"2C JrOcheZdZdZdedeeeefgeeeffddfdZ de e fdZ de e fdZ y) _OpenAIToVertexBatchUploadStreama Streams an OpenAI batch JSONL upload as Vertex-wrapped JSONL one row at a time, so the transformed payload is never held in full. The transform runs lazily as the HTTP client pulls each chunk, which keeps peak memory at one row regardless of how large the batch file is. r:r*rsNc ||_||_yr)_openai_file_content_map_openai_to_vertex_params)selfr:r*s rP__init__z)_OpenAIToVertexBatchUploadStream.__init__zs %8!,G)rOc#Kd}t|jD]N}t||jD]3}|rdnd}d}|t j |j dz5Pyw)NTrO Fr|)rTr[r2r\rRdumpsr)r]firstentrywrappedprefixs rP_iter_vertex_jsonl_chunksz:_OpenAIToVertexBatchUploadStream._iter_vertex_jsonl_chunkssr/0I0IJ CECE4KlKlm C %5tzz'299'BBB C CsA*A,c"|jSr)rfr]s rP iter_bytesz+_OpenAIToVertexBatchUploadStream.iter_bytess--//rO)rJrKrL__doc__r(rrrYrr^rr5rfrirNrOrPrYrYrskH&H&.tCH~.>S#X.N%OH  HC8E?C0HUO0rOrYceZdZdZfdZedefdZ d4dede de e d ed ed e dzd e dzdefd Z de ee e fde fdZdede de fdZd ede fdZd e dzd e dzde d ed edede fdZde de efdZded ede dedef dZdee e fdee e ffdZde ded ed edee zezf dZde dzdeded edef d Zd!e d"edee zde!fd#Z"d5d$e d edzde#e e ffd%Z$d$e d ed ede#e effd&Z%deded edefd'Z&d$e d ed ede#e effd(Z'deded ede(fd)Z)de dzd ed ede#e effd*Z*deded ede efd+Z+d ed ede#e effd,Z,deded ede-fd-Z. d4d.ededzde dzdefd/Z/d0e0d1e1de2d2e3j6de4f d3Z5xZ6S)6VertexAIFilesConfigz# Config for VertexAI Files c"t|yr)superr^)r] __class__s rPr^zVertexAIFilesConfig.__init__s rOrsc"tjSr)r2 VERTEX_AIrhs rPr.z'VertexAIFilesConfig.custom_llm_providers%%%rONheadersrr,r!r/api_keyapi_basec|sI|j|jd|jd\}}|s tdd||d<|S)Nvertex_credentialsvertex_project) credentials project_idzapi_key is requiredzBearer Authorization)get_access_tokenrr') r]rrrr,r!r/rsrtrus rPvalidate_environmentz(VertexAIFilesConfig.validate_environmentse..*../CD)--.>?/JGQ !677)0 ':GO $rOopenai_jsonl_contentc|djdijdd}d|vrd|}t|d}t|dtj}|S) z Gets a unique GCS object name for the VertexAI batch prediction job named as: litellm-vertex-{model}-{uuid} rrkrrzpublishers/google/modelszpublishers/google/models/)fallbackr )rrrrr)r]r}_modelsafe_model_path object_names rP%_get_gcs_object_name_from_batch_jsonlz9VertexAIFilesConfig._get_gcs_object_name_from_batch_jsonlsn&a(,,VR8< *O1[M:K%CK%P0 =VWjVkl??34 41XJ''rOcgSrrN)r]rs rPget_supported_openai_paramsz/VertexAIFilesConfig.get_supported_openai_paramss rOnon_default_params drop_paramsc|SrrN)r]rr!rrs rPmap_openai_paramsz%VertexAIFilesConfig.map_openai_paramss rOr#cnddlm}|}|jdd}|j||id}|S)zF wrapper to call VertexGeminiConfig.map_openai_params rr"rrF)rrr!r)@litellm.llms.vertex_ai.gemini.vertex_and_google_ai_studio_geminir#rr)r]r#r#configr vertex_paramss rPr\z0VertexAIFilesConfig._map_openai_to_vertex_paramssL +,+//<%772 8 rOcreate_file_datac<|jd}| tdt|\}}tj||r#dt t ||jdiSt|jd}t|tr|Std) a 2 Cases: 1. Handle basic file upload 2. Handle batch file upload (.jsonl), staged to a temp file and uploaded in a single media request so large uploads stay memory-bounded without the per-chunk round-trips of a resumable session. rr)r content_typestreaming_media_uploadapplication/json) body_streamrrrA) rr'rris_batch_jsonl_requestr%rYr\rrr5) r]rrr!r/rrurextracted_file_data_contents rPtransform_create_file_requestz1VertexAIFilesConfig.transform_create_file_requests,//7  /0 0/ :<  / /-% )*D @!99!"4 + .?y-I-M-Mi-X# 15 9. .899rO raw_response logging_objc |j} tdi|}|j dd}|r#dj|jdddnd}t|j dd d ||j d dt|j d d dt|j dddS#t$r*}t|jd||j d}~wwxYw)zV Transform VertexAI File upload response into OpenAI-style FileObject z#Error reading GCS bucket response: rirfrrNrTrr r=rIrgs://rUrWvertex_datetimeuploadedrVrr)rIrTr created_atrar5r]rN) rRr.rr7rirrrrr r+r rl) r]rrrr/ response_jsonresponse_objectrOgcs_ids rPtransform_create_file_responsez2VertexAIFilesConfig.transform_create_file_responseAs3?2C2C2E  %6%G%GO!$$T2.5;&,,s+CR01#'' 7;vh$((4B / 3 3M2 Fo))&!45   (44=aSA$,,  s B>> C1%C,,C1rrict|||S)Nrr6)r]rrirrs rPget_error_classz#VertexAIFilesConfig.get_error_classfsmU\]]rOfile_idc |j|xsi}t|d|tft|\}}|t |fS)z^ Validate a managed GCS file_id and return (bucket, url-encoded-object-path). r)rschemeconfigured_bucket_nameallowed_object_prefixesallow_legacy_cloud_file_ids)rrrrr)r]rr/rr object_paths rP_parse_gcs_uriz"VertexAIFilesConfig._parse_gcs_uriisT)-(H(HI][](^#A#9%A$C(J>(Z $  [:;GGGrOcD|j||\}}d|d|}|ifSN,https://storage.googleapis.com/storage/v1/b//o/rr]rr!r/bucketencoded_objectrs rPtransform_retrieve_file_requestz3VertexAIFilesConfig.transform_retrieve_file_requestw7 "&!4!4Wn!MCF83~N^_BwrOc |j}|jdd}|r#dj|jdddnd}t d|t |jddt |jdd |jd dd |jd ijd dddS)NrTrr r=rrVrrWrrUrrXrIr processed)rTr5rrr]rIrastatus_details)rRrrr r+rlr )r]rrr/rrs rP transform_retrieve_file_responsez4VertexAIFilesConfig.transform_retrieve_file_responses 0>$0$<$< 3 + , 4 4 ,M 6}MM *<@@    sCB1C C)(C)rc  t|} t|}t|}t |xsXd|vxrRd|vxrLd|vxrFd|j divxs0d|j divxst |j d}|s|St}tdgdd tjdd } i| _ tjd d d itjdd} tj|f|} t |r,t!d| D|} dj#d| DSt%} | D]O} |j't||| | }| r| dz } | t+j,|j/dz } Qt1| S#t$r|cYSwxYw#t($r|cYcSwxYw#t($r|cYSwxYw)aJ Try to transform Vertex AI batch output to OpenAI format. If conversion fails at any point, return the original content as-is. Vertex AI batch output format (predictions.jsonl): { "request": {"contents": [...], "labels": {"litellm_custom_id": "request-1", "litellm_custom_id_raw": "..."}}, "status": "", "response": {"candidates": [...], "modelVersion": "gemini-2.5-flash", ...}, "processed_time": "2026-04-13T10:18:18.102004+00:00" } OpenAI batch output format: { "id": "batch_req_...", "custom_id": "request-1", "response": { "status_code": 200, "request_id": "chatcmpl-...", "body": {} }, "error": null } r`rprb candidatespromptFeedbackrarFbatch_transform)rr,stream call_type start_timelitellm_call_id function_idrz content-typerPOSTzhttps://example.com)methodr)rirrr`c3FK|]}tj|ywrrV)rr8s rPrzSVertexAIFilesConfig._try_transform_vertex_batch_output_to_openai..Ss'OT 4(8'Os!)rrr`c3dK|](}tj|jd*yw)r|N)rRrar)r openai_outputs rPrzSVertexAIFilesConfig._try_transform_vertex_batch_output_to_openai..Vs%!pP]$**]";"B"B7"K!ps.0) vertex_outputvertex_gemini_configrmock_httpx_responser|)rPr StopIterationrWrrrr#rtimer!rr Requestrchainrrr6/_transform_single_vertex_batch_output_to_openairrRrarr5)r]rrrlines first_line first_rowis_vertex_batch_outputrbatch_transform_logging_objr all_linesopenai_outputsoutputr8rs rPrz@VertexAIFilesConfig._try_transform_vertex_batch_output_to_openais&jII,RS\,] -Y&)+$ 1!IMM*b$AA5'9==R+HH5IMM(34 #**<*> 29+99; "2 ';= ' 7).');< V9NO*  " u=I 6i@!T'OY'O"zz!pao!ppp [F! D#$($X$X&DT&J-A$?,? %Y%MeOF$**]3::7CC D= O!  B!#"N# N se G F(A3G B1G ?G F9-:G ( F63G 5F66G 9 G G G  G GGrrrct|}|jdd}t|}|rt|d|S|jdi}|jdd} d| vr| j dd } t } |j || | || } | j} t|| S#t$r} t|d d | cYd} ~ Sd} ~ wwxYw)z Transform a single Vertex AI batch output line to OpenAI format. Uses the existing VertexGeminiConfig transformation for the response. rarrrrp modelVersionzgemini-1.5-flash-001@r)completion_responsemodel_responserrrrtransformation_errorzFailed to transform response: N) rrrrr r3;_transform_google_generate_content_to_openai_model_responserr)r]rrrrrora has_errorrrrtransformed_response response_dictrOs rPrzCVertexAIFilesConfig._transform_single_vertex_batch_output_to_openaips8 F &))(B7< +#,$ "/!2!2:r!B ##N4JK %<KK$Q'E $1ON#7#s#s$3-'0 $t$ $8#B#B#DM,imT T +#1 >qcB  s62    S S *$3(*(t( (  (  ( ( (>>c9d      !#s(^ c3h*$:$:,$: $:  $: t  $:L# Tz# # ' #  #  # J^S^s^TT[^^`p^ Hc H4$; HRWX[]`X`Ra H  sDy    '     ,  sDy  DD'D D  D"WtWW W sDy  WWW'W W   W    sDy  .A.A'.A .A $ .Af15 qq'-qTz q  qf7&717 7 #^^ 7  7rOrl)NNr)rrDrrRrrvrcollections.abcrrrrtypingrrr rr r rr r openai.types.file_deletedrtyping_extensionsrr litellm._uuidrlitellm.files.utilsr1litellm.litellm_core_utils.cloud_storage_securityrrrrrrr*litellm.litellm_core_utils.litellm_loggingr8litellm.litellm_core_utils.prompt_templates.common_utilsrr)litellm.llms.base_llm.chat.transformationr*litellm.llms.base_llm.files.transformationrrr#litellm.llms.vertex_ai.common_utilsr ,litellm.llms.vertex_ai.gemini.transformationr!rr#Klitellm.llms.vertex_ai.gemini_embeddings.batch_embed_content_transformationr$litellm.types.filesr%litellm.types.llms.openair&r'r(r)r*r+r,r-litellm.types.llms.vertex_air.r/litellm.types.utilsr0r1r2r3r4 common_utilsr7vertex_llm_baser8r:rMr<r>compiler?rErFrHrSr[r_rdrhrnrYrzrrrrr]rrrrrrrrlrrrrrrrrrr)r2r5r9rPrTrWrYrlrNrOrPr.s2  AA((' #1&-?G Q;   Q)("$%$%+U+!&&)34W)XX/$e /9bjj9n.o$eo*Ye*/Ye/+Ye+"iu" i )) 4I40S0S0&'#'$s)' 49 t  CS#X C6 CVZ C OrTXr&&*!  #s( d "d    0QwsCx/@QU3PSUX=EYQ& 77383D 7 75D5Dgc3h/455D38_5D 5D : 5D  5Dp c!23 : # %&8 -S -S4Z - @WS#X-> @4 @ )  3c?C    VC V VC VC V>d >73PS8CT>Y`adfiaiYj>*6#s(#6 738 c !"6r/sCx./!)4S>*:DcN*J!K/ 738 c !"/BHS5[$9hsm96)96 96x" d38n 0';08Y*oYrO