windmill-client 1.850.0 → 1.851.0

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.
@@ -29,7 +29,7 @@ const OpenAPI = {
29
29
  PASSWORD: void 0,
30
30
  TOKEN: getEnv("WM_TOKEN"),
31
31
  USERNAME: void 0,
32
- VERSION: "1.850.0",
32
+ VERSION: "1.851.0",
33
33
  WITH_CREDENTIALS: !getEnv("WM_RAW_APP"),
34
34
  interceptors: {
35
35
  request: new Interceptors(),
package/dist/index.js CHANGED
@@ -126,7 +126,7 @@ const OpenAPI = {
126
126
  PASSWORD: void 0,
127
127
  TOKEN: getEnv$1("WM_TOKEN"),
128
128
  USERNAME: void 0,
129
- VERSION: "1.850.0",
129
+ VERSION: "1.851.0",
130
130
  WITH_CREDENTIALS: !getEnv$1("WM_RAW_APP"),
131
131
  interceptors: {
132
132
  request: new Interceptors(),
@@ -12368,6 +12368,279 @@ var SlackAgentsService = class {
12368
12368
  });
12369
12369
  }
12370
12370
  };
12371
+ var AiService = class {
12372
+ /**
12373
+ * one text completion with the workspace's AI config
12374
+ * Sends a system and a user message to the configured provider and returns the text of the answer, with no tools and no streaming. For callers that do not speak a provider's own API through the proxy, such as the CLI and jobs.
12375
+ *
12376
+ * @param data The data for the request.
12377
+ * @param data.workspace
12378
+ * @param data.requestBody
12379
+ * @returns unknown the answer, and the model that wrote it
12380
+ * @throws ApiError
12381
+ */
12382
+ static completeAi(data) {
12383
+ return request(OpenAPI, {
12384
+ method: "POST",
12385
+ url: "/w/{workspace}/ai/complete",
12386
+ path: { workspace: data.workspace },
12387
+ body: data.requestBody,
12388
+ mediaType: "application/json"
12389
+ });
12390
+ }
12391
+ /**
12392
+ * record AI token usage for the calling user
12393
+ * @param data The data for the request.
12394
+ * @param data.workspace
12395
+ * @param data.requestBody
12396
+ * @returns void usage recorded
12397
+ * @throws ApiError
12398
+ */
12399
+ static recordAiUsage(data) {
12400
+ return request(OpenAPI, {
12401
+ method: "POST",
12402
+ url: "/w/{workspace}/ai/usage",
12403
+ path: { workspace: data.workspace },
12404
+ body: data.requestBody,
12405
+ mediaType: "application/json"
12406
+ });
12407
+ }
12408
+ /**
12409
+ * list aggregated AI token usage
12410
+ * @param data The data for the request.
12411
+ * @param data.workspace
12412
+ * @param data.days
12413
+ * @param data.groupBy
12414
+ * @param data.scope workspace-wide usage (admin only) or the calling user's own
12415
+ * @returns unknown usage buckets
12416
+ * @throws ApiError
12417
+ */
12418
+ static listAiUsage(data) {
12419
+ return request(OpenAPI, {
12420
+ method: "GET",
12421
+ url: "/w/{workspace}/ai/usage",
12422
+ path: { workspace: data.workspace },
12423
+ query: {
12424
+ days: data.days,
12425
+ group_by: data.groupBy,
12426
+ scope: data.scope
12427
+ }
12428
+ });
12429
+ }
12430
+ /**
12431
+ * list the calling user's AI session backups in the workspace object storage
12432
+ * @param data The data for the request.
12433
+ * @param data.workspace
12434
+ * @returns unknown backups, newest first; `enabled` is false when the workspace has no storage for them
12435
+ * @throws ApiError
12436
+ */
12437
+ static listAiSessionBackups(data) {
12438
+ return request(OpenAPI, {
12439
+ method: "GET",
12440
+ url: "/w/{workspace}/ai/sessions/list",
12441
+ path: { workspace: data.workspace }
12442
+ });
12443
+ }
12444
+ /**
12445
+ * fetch whole AI session backups
12446
+ * @param data The data for the request.
12447
+ * @param data.workspace
12448
+ * @param data.requestBody
12449
+ * @returns unknown the backups found; `deferred` lists ids that did not fit the response budget
12450
+ * @throws ApiError
12451
+ */
12452
+ static pullAiSessionBackups(data) {
12453
+ return request(OpenAPI, {
12454
+ method: "POST",
12455
+ url: "/w/{workspace}/ai/sessions/pull",
12456
+ path: { workspace: data.workspace },
12457
+ body: data.requestBody,
12458
+ mediaType: "application/json"
12459
+ });
12460
+ }
12461
+ /**
12462
+ * write changed pieces of AI sessions to their backups, and remove deleted ones
12463
+ * @param data The data for the request.
12464
+ * @param data.workspace
12465
+ * @param data.requestBody
12466
+ * @returns unknown one result per session written or removed, in request order
12467
+ * @throws ApiError
12468
+ */
12469
+ static pushAiSessionBackups(data) {
12470
+ return request(OpenAPI, {
12471
+ method: "POST",
12472
+ url: "/w/{workspace}/ai/sessions/push",
12473
+ path: { workspace: data.workspace },
12474
+ body: data.requestBody,
12475
+ mediaType: "application/json"
12476
+ });
12477
+ }
12478
+ /**
12479
+ * share an AI session artifact with the workspace
12480
+ * Stores a read-only copy that any member of the workspace can open by id. Sharing the same artifact again updates that copy, keeps its id, and restarts its retention window.
12481
+ *
12482
+ * @param data The data for the request.
12483
+ * @param data.workspace
12484
+ * @param data.requestBody
12485
+ * @returns SharedAiArtifactInfo the shared copy
12486
+ * @throws ApiError
12487
+ */
12488
+ static shareAiArtifact(data) {
12489
+ return request(OpenAPI, {
12490
+ method: "POST",
12491
+ url: "/w/{workspace}/ai/shared_artifacts/share",
12492
+ path: { workspace: data.workspace },
12493
+ body: data.requestBody,
12494
+ mediaType: "application/json"
12495
+ });
12496
+ }
12497
+ /**
12498
+ * get the calling user's share of one of their AI session artifacts
12499
+ * @param data The data for the request.
12500
+ * @param data.workspace
12501
+ * @param data.artifactId
12502
+ * @returns unknown the live share, if any, and how long shares last
12503
+ * @throws ApiError
12504
+ */
12505
+ static getAiArtifactShareStatus(data) {
12506
+ return request(OpenAPI, {
12507
+ method: "GET",
12508
+ url: "/w/{workspace}/ai/shared_artifacts/status",
12509
+ path: { workspace: data.workspace },
12510
+ query: { artifact_id: data.artifactId }
12511
+ });
12512
+ }
12513
+ /**
12514
+ * get a shared AI session artifact
12515
+ * @param data The data for the request.
12516
+ * @param data.workspace
12517
+ * @param data.id
12518
+ * @returns unknown the shared artifact
12519
+ * @throws ApiError
12520
+ */
12521
+ static getSharedAiArtifact(data) {
12522
+ return request(OpenAPI, {
12523
+ method: "GET",
12524
+ url: "/w/{workspace}/ai/shared_artifacts/get/{id}",
12525
+ path: {
12526
+ workspace: data.workspace,
12527
+ id: data.id
12528
+ }
12529
+ });
12530
+ }
12531
+ /**
12532
+ * stop sharing an AI session artifact
12533
+ * @param data The data for the request.
12534
+ * @param data.workspace
12535
+ * @param data.id
12536
+ * @returns string share deleted
12537
+ * @throws ApiError
12538
+ */
12539
+ static unshareAiArtifact(data) {
12540
+ return request(OpenAPI, {
12541
+ method: "DELETE",
12542
+ url: "/w/{workspace}/ai/shared_artifacts/delete/{id}",
12543
+ path: {
12544
+ workspace: data.workspace,
12545
+ id: data.id
12546
+ }
12547
+ });
12548
+ }
12549
+ /**
12550
+ * share an AI session transcript by link
12551
+ * Stores a read-only snapshot of the session that members of the workspace can open by id, or anyone with the link once it is public. Sharing the same session again updates that snapshot and keeps its id.
12552
+ *
12553
+ * @param data The data for the request.
12554
+ * @param data.workspace
12555
+ * @param data.requestBody
12556
+ * @returns SharedAiSessionInfo the shared snapshot
12557
+ * @throws ApiError
12558
+ */
12559
+ static shareAiSession(data) {
12560
+ return request(OpenAPI, {
12561
+ method: "POST",
12562
+ url: "/w/{workspace}/ai/shared_sessions/share",
12563
+ path: { workspace: data.workspace },
12564
+ body: data.requestBody,
12565
+ mediaType: "application/json"
12566
+ });
12567
+ }
12568
+ /**
12569
+ * get the calling user's share of one of their AI sessions
12570
+ * @param data The data for the request.
12571
+ * @param data.workspace
12572
+ * @param data.sessionId
12573
+ * @returns unknown the share, if any
12574
+ * @throws ApiError
12575
+ */
12576
+ static getAiSessionShareStatus(data) {
12577
+ return request(OpenAPI, {
12578
+ method: "GET",
12579
+ url: "/w/{workspace}/ai/shared_sessions/status",
12580
+ path: { workspace: data.workspace },
12581
+ query: { session_id: data.sessionId }
12582
+ });
12583
+ }
12584
+ /**
12585
+ * make a shared AI session public, or reserve it to workspace members
12586
+ * @param data The data for the request.
12587
+ * @param data.workspace
12588
+ * @param data.id
12589
+ * @param data.requestBody
12590
+ * @returns SharedAiSessionInfo the updated share
12591
+ * @throws ApiError
12592
+ */
12593
+ static setAiSessionSharePublic(data) {
12594
+ return request(OpenAPI, {
12595
+ method: "POST",
12596
+ url: "/w/{workspace}/ai/shared_sessions/set_public/{id}",
12597
+ path: {
12598
+ workspace: data.workspace,
12599
+ id: data.id
12600
+ },
12601
+ body: data.requestBody,
12602
+ mediaType: "application/json"
12603
+ });
12604
+ }
12605
+ /**
12606
+ * get a shared AI session
12607
+ * A public share is served without authentication; any other one only to a member of the workspace.
12608
+ *
12609
+ * @param data The data for the request.
12610
+ * @param data.workspace
12611
+ * @param data.id
12612
+ * @returns unknown the shared session
12613
+ * @throws ApiError
12614
+ */
12615
+ static getSharedAiSession(data) {
12616
+ return request(OpenAPI, {
12617
+ method: "GET",
12618
+ url: "/w/{workspace}/ai_u/shared_sessions/get/{id}",
12619
+ path: {
12620
+ workspace: data.workspace,
12621
+ id: data.id
12622
+ }
12623
+ });
12624
+ }
12625
+ /**
12626
+ * stop sharing an AI session
12627
+ * @param data The data for the request.
12628
+ * @param data.workspace
12629
+ * @param data.id
12630
+ * @returns string share deleted
12631
+ * @throws ApiError
12632
+ */
12633
+ static unshareAiSession(data) {
12634
+ return request(OpenAPI, {
12635
+ method: "DELETE",
12636
+ url: "/w/{workspace}/ai/shared_sessions/delete/{id}",
12637
+ path: {
12638
+ workspace: data.workspace,
12639
+ id: data.id
12640
+ }
12641
+ });
12642
+ }
12643
+ };
12371
12644
  var AiEvalsService = class {
12372
12645
  /**
12373
12646
  * list eval datasets
@@ -12699,260 +12972,6 @@ var RawAppService = class {
12699
12972
  });
12700
12973
  }
12701
12974
  };
12702
- var AiService = class {
12703
- /**
12704
- * record AI token usage for the calling user
12705
- * @param data The data for the request.
12706
- * @param data.workspace
12707
- * @param data.requestBody
12708
- * @returns void usage recorded
12709
- * @throws ApiError
12710
- */
12711
- static recordAiUsage(data) {
12712
- return request(OpenAPI, {
12713
- method: "POST",
12714
- url: "/w/{workspace}/ai/usage",
12715
- path: { workspace: data.workspace },
12716
- body: data.requestBody,
12717
- mediaType: "application/json"
12718
- });
12719
- }
12720
- /**
12721
- * list aggregated AI token usage
12722
- * @param data The data for the request.
12723
- * @param data.workspace
12724
- * @param data.days
12725
- * @param data.groupBy
12726
- * @param data.scope workspace-wide usage (admin only) or the calling user's own
12727
- * @returns unknown usage buckets
12728
- * @throws ApiError
12729
- */
12730
- static listAiUsage(data) {
12731
- return request(OpenAPI, {
12732
- method: "GET",
12733
- url: "/w/{workspace}/ai/usage",
12734
- path: { workspace: data.workspace },
12735
- query: {
12736
- days: data.days,
12737
- group_by: data.groupBy,
12738
- scope: data.scope
12739
- }
12740
- });
12741
- }
12742
- /**
12743
- * list the calling user's AI session backups in the workspace object storage
12744
- * @param data The data for the request.
12745
- * @param data.workspace
12746
- * @returns unknown backups, newest first; `enabled` is false when the workspace has no storage for them
12747
- * @throws ApiError
12748
- */
12749
- static listAiSessionBackups(data) {
12750
- return request(OpenAPI, {
12751
- method: "GET",
12752
- url: "/w/{workspace}/ai/sessions/list",
12753
- path: { workspace: data.workspace }
12754
- });
12755
- }
12756
- /**
12757
- * fetch whole AI session backups
12758
- * @param data The data for the request.
12759
- * @param data.workspace
12760
- * @param data.requestBody
12761
- * @returns unknown the backups found; `deferred` lists ids that did not fit the response budget
12762
- * @throws ApiError
12763
- */
12764
- static pullAiSessionBackups(data) {
12765
- return request(OpenAPI, {
12766
- method: "POST",
12767
- url: "/w/{workspace}/ai/sessions/pull",
12768
- path: { workspace: data.workspace },
12769
- body: data.requestBody,
12770
- mediaType: "application/json"
12771
- });
12772
- }
12773
- /**
12774
- * write changed pieces of AI sessions to their backups, and remove deleted ones
12775
- * @param data The data for the request.
12776
- * @param data.workspace
12777
- * @param data.requestBody
12778
- * @returns unknown one result per session written or removed, in request order
12779
- * @throws ApiError
12780
- */
12781
- static pushAiSessionBackups(data) {
12782
- return request(OpenAPI, {
12783
- method: "POST",
12784
- url: "/w/{workspace}/ai/sessions/push",
12785
- path: { workspace: data.workspace },
12786
- body: data.requestBody,
12787
- mediaType: "application/json"
12788
- });
12789
- }
12790
- /**
12791
- * share an AI session artifact with the workspace
12792
- * Stores a read-only copy that any member of the workspace can open by id. Sharing the same artifact again updates that copy, keeps its id, and restarts its retention window.
12793
- *
12794
- * @param data The data for the request.
12795
- * @param data.workspace
12796
- * @param data.requestBody
12797
- * @returns SharedAiArtifactInfo the shared copy
12798
- * @throws ApiError
12799
- */
12800
- static shareAiArtifact(data) {
12801
- return request(OpenAPI, {
12802
- method: "POST",
12803
- url: "/w/{workspace}/ai/shared_artifacts/share",
12804
- path: { workspace: data.workspace },
12805
- body: data.requestBody,
12806
- mediaType: "application/json"
12807
- });
12808
- }
12809
- /**
12810
- * get the calling user's share of one of their AI session artifacts
12811
- * @param data The data for the request.
12812
- * @param data.workspace
12813
- * @param data.artifactId
12814
- * @returns unknown the live share, if any, and how long shares last
12815
- * @throws ApiError
12816
- */
12817
- static getAiArtifactShareStatus(data) {
12818
- return request(OpenAPI, {
12819
- method: "GET",
12820
- url: "/w/{workspace}/ai/shared_artifacts/status",
12821
- path: { workspace: data.workspace },
12822
- query: { artifact_id: data.artifactId }
12823
- });
12824
- }
12825
- /**
12826
- * get a shared AI session artifact
12827
- * @param data The data for the request.
12828
- * @param data.workspace
12829
- * @param data.id
12830
- * @returns unknown the shared artifact
12831
- * @throws ApiError
12832
- */
12833
- static getSharedAiArtifact(data) {
12834
- return request(OpenAPI, {
12835
- method: "GET",
12836
- url: "/w/{workspace}/ai/shared_artifacts/get/{id}",
12837
- path: {
12838
- workspace: data.workspace,
12839
- id: data.id
12840
- }
12841
- });
12842
- }
12843
- /**
12844
- * stop sharing an AI session artifact
12845
- * @param data The data for the request.
12846
- * @param data.workspace
12847
- * @param data.id
12848
- * @returns string share deleted
12849
- * @throws ApiError
12850
- */
12851
- static unshareAiArtifact(data) {
12852
- return request(OpenAPI, {
12853
- method: "DELETE",
12854
- url: "/w/{workspace}/ai/shared_artifacts/delete/{id}",
12855
- path: {
12856
- workspace: data.workspace,
12857
- id: data.id
12858
- }
12859
- });
12860
- }
12861
- /**
12862
- * share an AI session transcript by link
12863
- * Stores a read-only snapshot of the session that members of the workspace can open by id, or anyone with the link once it is public. Sharing the same session again updates that snapshot and keeps its id.
12864
- *
12865
- * @param data The data for the request.
12866
- * @param data.workspace
12867
- * @param data.requestBody
12868
- * @returns SharedAiSessionInfo the shared snapshot
12869
- * @throws ApiError
12870
- */
12871
- static shareAiSession(data) {
12872
- return request(OpenAPI, {
12873
- method: "POST",
12874
- url: "/w/{workspace}/ai/shared_sessions/share",
12875
- path: { workspace: data.workspace },
12876
- body: data.requestBody,
12877
- mediaType: "application/json"
12878
- });
12879
- }
12880
- /**
12881
- * get the calling user's share of one of their AI sessions
12882
- * @param data The data for the request.
12883
- * @param data.workspace
12884
- * @param data.sessionId
12885
- * @returns unknown the share, if any
12886
- * @throws ApiError
12887
- */
12888
- static getAiSessionShareStatus(data) {
12889
- return request(OpenAPI, {
12890
- method: "GET",
12891
- url: "/w/{workspace}/ai/shared_sessions/status",
12892
- path: { workspace: data.workspace },
12893
- query: { session_id: data.sessionId }
12894
- });
12895
- }
12896
- /**
12897
- * make a shared AI session public, or reserve it to workspace members
12898
- * @param data The data for the request.
12899
- * @param data.workspace
12900
- * @param data.id
12901
- * @param data.requestBody
12902
- * @returns SharedAiSessionInfo the updated share
12903
- * @throws ApiError
12904
- */
12905
- static setAiSessionSharePublic(data) {
12906
- return request(OpenAPI, {
12907
- method: "POST",
12908
- url: "/w/{workspace}/ai/shared_sessions/set_public/{id}",
12909
- path: {
12910
- workspace: data.workspace,
12911
- id: data.id
12912
- },
12913
- body: data.requestBody,
12914
- mediaType: "application/json"
12915
- });
12916
- }
12917
- /**
12918
- * get a shared AI session
12919
- * A public share is served without authentication; any other one only to a member of the workspace.
12920
- *
12921
- * @param data The data for the request.
12922
- * @param data.workspace
12923
- * @param data.id
12924
- * @returns unknown the shared session
12925
- * @throws ApiError
12926
- */
12927
- static getSharedAiSession(data) {
12928
- return request(OpenAPI, {
12929
- method: "GET",
12930
- url: "/w/{workspace}/ai_u/shared_sessions/get/{id}",
12931
- path: {
12932
- workspace: data.workspace,
12933
- id: data.id
12934
- }
12935
- });
12936
- }
12937
- /**
12938
- * stop sharing an AI session
12939
- * @param data The data for the request.
12940
- * @param data.workspace
12941
- * @param data.id
12942
- * @returns string share deleted
12943
- * @throws ApiError
12944
- */
12945
- static unshareAiSession(data) {
12946
- return request(OpenAPI, {
12947
- method: "DELETE",
12948
- url: "/w/{workspace}/ai/shared_sessions/delete/{id}",
12949
- path: {
12950
- workspace: data.workspace,
12951
- id: data.id
12952
- }
12953
- });
12954
- }
12955
- };
12956
12975
  var TriggerService = class {
12957
12976
  /**
12958
12977
  * resume all suspended jobs for a specific trigger