@kwirthmagnify/kwirth-common-ai 0.5.61 → 0.5.62

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.
package/dist/back.d.ts CHANGED
@@ -1,11 +1,11 @@
1
- import { ILlm, ILlmProvider, IAgent, ECapability, EToolEffect, EToolSensitivity, IAiToolInfo, IAiToolsetInfo, IToolsetConfig } from './index';
1
+ import { ILlm, ILlmProvider, ECapability, EToolEffect, EToolSensitivity, IAiToolInfo, IAiToolsetInfo, IToolsetConfig } from './index';
2
2
  import type { AppsV1Api, CoreV1Api, NetworkingV1Api } from '@kubernetes/client-node';
3
3
  interface ILogChannel {
4
4
  logInfo?: (msg: string) => void;
5
5
  logWarning?: (msg: string) => void;
6
6
  logError?: (msg: string) => void;
7
7
  }
8
- import { LanguageModel, Tool, ToolSet } from 'ai';
8
+ import { LanguageModel, ToolSet } from 'ai';
9
9
  import { z } from 'zod';
10
10
  export declare const buildModel: (llm: ILlm, providers: ILlmProvider[]) => LanguageModel | null;
11
11
  export interface IVisionResult<T> {
@@ -49,26 +49,21 @@ export interface IToolContext {
49
49
  trace: (toolName: string, args: Record<string, unknown>) => void;
50
50
  }
51
51
  export { EToolEffect } from './index';
52
- export interface IToolInfo {
53
- name: string;
54
- description: string;
55
- effect: EToolEffect;
56
- }
57
52
  export declare const runWithToolContext: <T>(context: IToolContext, fn: () => Promise<T>) => Promise<T>;
58
- /** Un nodo del cluster, tal y como lo ve una tool. Compatible con el `INodeInfo` del core. */
53
+ /** A cluster node, as a tool sees it. Compatible with the core's `INodeInfo`. */
59
54
  export interface IK8sNodeInfo {
60
55
  name: string;
61
56
  ip: string;
62
57
  maxPods: number;
63
58
  }
64
- /** Acceso a Kubernetes (`ECapability.K8S`). */
59
+ /** Access to Kubernetes (`ECapability.K8S`). */
65
60
  export interface IK8sCapability {
66
- /** Nombre del cluster tal y como lo conoce Kwirth. */
61
+ /** Cluster name, as Kwirth knows it. */
67
62
  name: string;
68
- /** Sabor detectado: aks, eks, gke, k3s, k3d… */
63
+ /** Detected flavour: aks, eks, gke, k3s, k3d… */
69
64
  flavour: string;
70
65
  vcpus: number;
71
- /** Memoria total del cluster, en bytes. */
66
+ /** Total cluster memory, in bytes. */
72
67
  memory: number;
73
68
  nodes: Map<string, IK8sNodeInfo>;
74
69
  coreApi: CoreV1Api;
@@ -105,12 +100,12 @@ export interface IMetricsNodeSample {
105
100
  };
106
101
  }
107
102
  export interface IMetricsSample {
108
- /** Segundos entre lecturas. Sin esto, una serie de numeros no dice a que ritmo pasa el tiempo. */
103
+ /** Seconds between readings. Without it, a series of numbers says nothing about how fast time passes. */
109
104
  metricsInterval?: number;
110
105
  cluster: {
111
106
  vcpus: number;
112
107
  memory: number;
113
- /** Porcentajes, 0-100. */
108
+ /** Percentages, 0-100. */
114
109
  cpuUsage: number;
115
110
  memoryUsage: number;
116
111
  txmbps: number;
@@ -118,60 +113,61 @@ export interface IMetricsSample {
118
113
  };
119
114
  nodes: IMetricsNodeSample[];
120
115
  }
121
- /** Metricas del cluster (`ECapability.METRICS`). */
116
+ /** Cluster metrics (`ECapability.METRICS`). */
122
117
  export interface IMetricsCapability {
123
- /** Muestras que el core mantiene en memoria. La mas reciente, al final. */
118
+ /** Samples the core keeps in memory. The most recent one last. */
124
119
  samples: IMetricsSample[];
125
120
  }
126
121
  /**
127
- * Un elemento del buffer de eventos del core: el tipo de cambio y el objeto tal y como vino de la API.
128
- * `obj` se deja generico a proposito —ahi caben Events de kube y objetos de cualquier kind— pero tipado
129
- * como objeto, no como `any`: quien lo lea tiene que mirar el `kind` antes de creerse nada.
122
+ * One entry of the core's event buffer: the kind of change and the object exactly as it came from the API.
123
+ * `obj` is left generic on purpose — kube Events and objects of any kind fit in there — but typed as an
124
+ * object rather than as `any`: whoever reads it must check `kind` before believing anything.
130
125
  */
131
126
  export interface IClusterEvent {
132
- /** ADDED | MODIFIED | DELETED para cambios de objeto; los Event de kube tambien viajan aqui. */
127
+ /** ADDED | MODIFIED | DELETED for object changes; kube Events travel through here too. */
133
128
  type?: string;
134
129
  obj?: Record<string, any>;
135
130
  }
136
- /** Eventos recientes del cluster (`ECapability.EVENTS`). */
131
+ /** Recent cluster events (`ECapability.EVENTS`). */
137
132
  export interface IEventsCapability {
138
- /** Buffer que el core va acumulando. El mas reciente, al final. */
133
+ /** Buffer the core keeps accumulating. The most recent one last. */
139
134
  recent: IClusterEvent[];
140
135
  }
141
- /** Credenciales de repositorios fuente (`ECapability.REPOS`). */
136
+ /** Source repository credentials (`ECapability.REPOS`). */
142
137
  export interface IReposCapability {
143
138
  creds: ISourceRepoCred[];
144
139
  }
145
140
  /**
146
- * Lo que recibe una tool al ejecutarse. Solo vienen rellenas las capabilities declaradas por su toolset:
147
- * un `requires: []` recibe unicamente `trace`.
141
+ * What a tool receives when it runs. Only the capabilities its toolset declared come filled in:
142
+ * a `requires: []` receives nothing but `trace`.
148
143
  */
149
144
  export interface IToolHost {
150
- /** Deja constancia de la invocacion. NO es una capability: se presta siempre, y no se declara. */
145
+ /** Records the invocation. NOT a capability: it is always lent, and never declared. */
151
146
  trace: (toolName: string, args: Record<string, unknown>) => void;
152
147
  k8s?: IK8sCapability;
153
148
  metrics?: IMetricsCapability;
154
149
  events?: IEventsCapability;
155
150
  repos?: IReposCapability;
156
151
  }
157
- /** Una tool ejecutable: lo que viaja al front (IAiToolInfo) mas lo que hace falta para invocarla. */
152
+ /** An executable tool: what travels to the front end (IAiToolInfo) plus what it takes to invoke it. */
158
153
  export interface IAiTool extends IAiToolInfo {
159
154
  inputSchema: z.ZodTypeAny;
160
155
  execute: (args: Record<string, unknown>, host: IToolHost) => Promise<unknown>;
161
156
  }
162
- /** Un toolset ejecutable: su ficha (IAiToolsetInfo) con las tools de verdad dentro. */
157
+ /** An executable toolset: its descriptor (IAiToolsetInfo) with the real tools inside. */
163
158
  export interface IAiToolset extends Omit<IAiToolsetInfo, 'tools'> {
164
159
  tools: IAiTool[];
165
160
  }
166
161
  /**
167
- * Declara una tool infiriendo el tipo de sus argumentos DESDE su propio `inputSchema`.
162
+ * Declares a tool, inferring the type of its arguments FROM its own `inputSchema`.
168
163
  *
169
- * Sin esto, `execute` recibe `Record<string, unknown>` y cada tool acaba llena de `String(args.namespace)`
170
- * y castings sueltos: treinta tools asi son treinta sitios donde equivocarse en silencio, y el compilador
171
- * no puede ayudar. Con esto, el esquema es la unica fuente de verdad y `args` viene tipado.
164
+ * Without this, `execute` receives `Record<string, unknown>` and every tool fills up with
165
+ * `String(args.namespace)` and loose casts: thirty tools like that are thirty places to go wrong in
166
+ * silence, with no help from the compiler. With this, the schema is the single source of truth and `args`
167
+ * arrives typed.
172
168
  *
173
- * El registro sigue guardando el tipo suelto (`IAiTool`): quien lo invoca no conoce el esquema, y ahi la
174
- * comprobacion la hace zod en tiempo de ejecucion, como debe ser.
169
+ * The registry still stores the loose type (`IAiTool`): whoever invokes it does not know the schema, and
170
+ * there the check is done by zod at run time, as it should be.
175
171
  */
176
172
  export declare const defineTool: <S extends z.ZodTypeAny>(definition: {
177
173
  name: string;
@@ -182,82 +178,82 @@ export declare const defineTool: <S extends z.ZodTypeAny>(definition: {
182
178
  execute: (args: z.infer<S>, host: IToolHost) => Promise<unknown>;
183
179
  }) => IAiTool;
184
180
  export declare const isBuiltInToolsetId: (id: string) => boolean;
185
- /** Concede un toolset a una lista de plugins. Reemplaza la concesion anterior; `[]` se la quita a todos. */
181
+ /** Grants a toolset to a list of plugins. Replaces the previous grant; `[]` takes it away from everyone. */
186
182
  export declare const setToolsetGrants: (toolsetId: string, pluginIds: string[]) => void;
187
- /** A quien esta concedido un toolset. Vacio = a nadie, que es el estado por defecto. */
183
+ /** Who a toolset is granted to. Empty = nobody, which is the default state. */
188
184
  export declare const getToolsetGrants: (toolsetId: string) => string[];
189
- /** Si ESE plugin puede usar ESE toolset. */
185
+ /** Whether THAT plugin may use THAT toolset. */
190
186
  export declare const isToolsetGrantedTo: (toolsetId: string, pluginId: string) => boolean;
191
187
  /**
192
- * Registra un toolset. `builtIn` solo lo usa el core para los suyos: marca el id como reservado.
193
- * Lanza si el id ya esta ocupado — registrar dos veces el mismo id es un error de empaquetado, no algo
194
- * que deba resolverse en silencio pisando al primero.
188
+ * Registers a toolset. `builtIn` is only used by the core for its own: it marks the id as reserved.
189
+ * Throws if the id is already taken — registering the same id twice is a packaging error, not something
190
+ * to be resolved silently by overwriting the first one.
195
191
  */
196
192
  export declare const registerToolset: (toolset: IAiToolset, builtIn?: boolean) => void;
197
- /** Retira un toolset del registro (desinstalacion). Los built-in no se retiran. */
193
+ /** Removes a toolset from the registry (uninstall). Built-in ones are never removed. */
198
194
  export declare const unregisterToolset: (id: string) => boolean;
199
195
  export declare const getToolset: (id: string) => IAiToolset | undefined;
200
196
  export declare const listToolsets: () => IAiToolset[];
201
- /** Lo que se le manda al front: las fichas, sin inputSchema ni execute. */
197
+ /** What is sent to the front end: the descriptors, without inputSchema or execute. */
202
198
  export declare const listToolsetInfos: () => IAiToolsetInfo[];
203
199
  /**
204
- * Construye el host de un toolset a partir del contexto del core, provisionando SOLO lo declarado.
200
+ * Builds a toolset's host from the core context, provisioning ONLY what was declared.
205
201
  *
206
- * Que el reparto se haga aqui y no en cada llamada es lo que hace cumplible la promesa de `ECapability`:
207
- * si cada sitio armara su propio objeto, bastaria con que uno se pasara de generoso para que la
208
- * declaracion dejara de significar nada.
202
+ * Doing the handing-out here and not at each call site is what makes the `ECapability` promise keepable:
203
+ * if every site assembled its own object, one of them being too generous would be enough for the
204
+ * declaration to stop meaning anything.
209
205
  */
210
206
  export declare const buildToolHost: (requires: ECapability[], context: IToolContext) => IToolHost;
211
207
  /**
212
- * Invoca una tool por su referencia cualificada. Un unico camino de invocacion para built-in e
213
- * instalado, con el host construido segun el `requires` de SU toolset.
208
+ * Invokes a tool by its qualified reference. A single invocation path for built-in and installed alike,
209
+ * with the host built according to the `requires` of ITS toolset.
214
210
  */
215
211
  export declare const invokeToolRef: (ref: string, args: Record<string, unknown>, context: IToolContext) => Promise<unknown>;
216
- /** Resuelve una referencia cualificada '<toolset>/<tool>' contra el registro. */
212
+ /** Resolves a qualified reference '<toolset>/<tool>' against the registry. */
217
213
  export declare const resolveToolRef: (ref: string) => {
218
214
  toolset: IAiToolset;
219
215
  tool: IAiTool;
220
216
  } | undefined;
221
- /** Una tool que SI se le ofrece al modelo. */
217
+ /** A tool that IS offered to the model. */
222
218
  export interface IEffectiveTool {
223
- /** El nombre corto: lo que viaja al LLM. */
219
+ /** The short name: what travels to the LLM. */
224
220
  name: string;
225
- /** La referencia cualificada: lo que se persiste. */
221
+ /** The qualified reference: what gets persisted. */
226
222
  ref: string;
227
223
  toolsetId: string;
228
224
  tool: IAiTool;
229
225
  }
230
- /** Una tool que existe pero NO se ofrece, porque otro toolset de mas precedencia trae ese nombre. */
226
+ /** A tool that exists but is NOT offered, because a toolset with higher precedence carries that name. */
231
227
  export interface IShadowedTool {
232
228
  name: string;
233
229
  ref: string;
234
230
  toolsetId: string;
235
- /** Quien la tapa. El editor tiene que decirlo: si no, apagar esta parece hacer algo y no hace nada. */
231
+ /** Who shadows it. The editor must say so: otherwise turning this one off looks like it does something. */
236
232
  shadowedBy: string;
237
233
  }
238
234
  export interface IToolResolution {
239
235
  effective: IEffectiveTool[];
240
236
  shadowed: IShadowedTool[];
241
- /** Toolsets asignados que no estan registrados (desinstalados, o nunca instalados). */
237
+ /** Assigned toolsets that are not registered (uninstalled, or never installed). */
242
238
  missing: string[];
243
239
  /**
244
- * Toolsets que SI estan instalados pero que a este plugin no se le han concedido.
240
+ * Toolsets that ARE installed but have not been granted to this plugin.
245
241
  *
246
- * Se reporta aparte de `missing` a proposito: "no esta instalado" lo arregla el admin instalandolo, y
247
- * "no te lo han concedido" lo arregla concediendolo. Meterlos en el mismo saco manda al admin a buscar
248
- * en el sitio equivocado.
242
+ * Reported apart from `missing` on purpose: "it is not installed" the admin fixes by installing it, and
243
+ * "it has not been granted to you" the admin fixes by granting it. Lumping them together sends the admin
244
+ * looking in the wrong place.
249
245
  */
250
246
  notGranted: string[];
251
247
  }
252
248
  /**
253
- * Aplica el techo de un cliente sobre el registro. Pura: ni ejecuta ni toca el contexto, asi que el
254
- * editor puede llamarla para PINTAR lo mismo que se va a ejecutar.
249
+ * Applies a client's ceiling over the registry. Pure: it neither executes nor touches the context, so the
250
+ * editor can call it to DRAW exactly what is going to run.
255
251
  *
256
- * Una tool apagada no tapa: se apaga una referencia concreta ('ts1/td'), no un nombre, asi que si `ts1/td`
257
- * esta apagada y `ts2` trae otra `td`, aflora la de `ts2`.
252
+ * A disabled tool does not shadow: what gets disabled is a concrete reference ('ts1/td'), not a name, so if
253
+ * `ts1/td` is off and `ts2` carries another `td`, the one from `ts2` surfaces.
258
254
  */
259
255
  export declare const resolveTools: (config: IToolsetConfig, requesterId?: string) => IToolResolution;
260
- /** Una invocacion concreta, tal y como la ven los dos ganchos. */
256
+ /** One concrete invocation, as the two hooks see it. */
261
257
  export interface IToolInvocation {
262
258
  ref: string;
263
259
  toolsetId: string;
@@ -266,649 +262,34 @@ export interface IToolInvocation {
266
262
  }
267
263
  export interface IToolAuthorization {
268
264
  allowed: boolean;
269
- /** Por que no. Viaja al modelo, asi que se escribe para que pueda decidir otra cosa. */
265
+ /** Why not. It travels to the model, so it is written so the model can decide otherwise. */
270
266
  reason?: string;
271
267
  }
272
- /** Como acabo una invocacion. `ms` incluido: una tool lenta es un problema aunque devuelva bien. */
268
+ /** How an invocation ended. `ms` included: a slow tool is a problem even when it returns correctly. */
273
269
  export interface IToolOutcome {
274
270
  ok: boolean;
275
271
  result?: unknown;
276
272
  error?: string;
277
273
  ms: number;
278
- /** Si no llego a ejecutarse por el gancho de autorizacion. */
274
+ /** Whether it never ran at all, because of the authorisation hook. */
279
275
  denied?: boolean;
280
276
  }
281
277
  export interface IAgentToolHooks {
282
- /** ANTES de ejecutar. Sin gancho, se permite todo: hoy el techo lo pone la seleccion (S4 lo llena). */
278
+ /** BEFORE running. With no hook, everything is allowed: today the ceiling is the selection (S4 fills it). */
283
279
  authorize?: (invocation: IToolInvocation, tool: IAiTool) => IToolAuthorization | Promise<IToolAuthorization>;
284
- /** DESPUES, pase lo que pase. No puede romper la invocacion (S6 lo llena). */
280
+ /** AFTER, whatever happened. It cannot break the invocation (S6 fills it). */
285
281
  observe?: (invocation: IToolInvocation, outcome: IToolOutcome) => void;
286
282
  }
287
283
  /**
288
- * Las tools listas para pasarselas al SDK de IA, ya resueltas por precedencia y con los dos ganchos
289
- * puestos. La clave del objeto es el nombre CORTO, que es lo unico que el proveedor acepta.
284
+ * The tools ready to hand to the AI SDK, already resolved by precedence and with both hooks in place.
285
+ * The object key is the SHORT name, which is the only thing the provider accepts.
290
286
  */
291
287
  export declare const buildAgentTools: (config: IToolsetConfig, context: IToolContext, hooks?: IAgentToolHooks,
292
288
  /**
293
- * Quien pide las tools. Sin esto no se filtra por concesion, asi que un plugin DEBE pasar su id: es lo
294
- * que impide que se sirva a si mismo un toolset que no le han concedido.
289
+ * Who is asking for the tools. Without it nothing is filtered by grant, so a plugin MUST pass its id:
290
+ * that is what stops it from serving itself a toolset it was never granted.
295
291
  */
296
292
  requesterId?: string) => ToolSet;
297
- export declare const tools: {
298
- readonly list_namespaces: Tool<Record<string, never>, {
299
- namespaces: any;
300
- error?: undefined;
301
- } | {
302
- error: any;
303
- namespaces?: undefined;
304
- }>;
305
- readonly get_node_data: Tool<Record<string, never>, any>;
306
- readonly get_cluster_data: Tool<Record<string, never>, {
307
- name: any;
308
- flavour: any;
309
- vcpus: any;
310
- memoryGB: number;
311
- nodeCount: any;
312
- nodes: any;
313
- error?: undefined;
314
- } | {
315
- error: any;
316
- name?: undefined;
317
- flavour?: undefined;
318
- vcpus?: undefined;
319
- memoryGB?: undefined;
320
- nodeCount?: undefined;
321
- nodes?: undefined;
322
- }>;
323
- readonly get_workload_data: Tool<{
324
- namespace?: string | undefined;
325
- }, {
326
- deployments: any;
327
- statefulSets: any;
328
- daemonSets: any;
329
- pods: any;
330
- services: any;
331
- error?: undefined;
332
- } | {
333
- error: any;
334
- deployments?: undefined;
335
- statefulSets?: undefined;
336
- daemonSets?: undefined;
337
- pods?: undefined;
338
- services?: undefined;
339
- }>;
340
- readonly get_space_data: Tool<{
341
- namespace: string;
342
- }, {
343
- namespace: string;
344
- status: any;
345
- labels: any;
346
- resourceQuotas: any;
347
- limitRanges: any;
348
- pods: any;
349
- deployments: any;
350
- services: any;
351
- configMaps: any;
352
- error?: undefined;
353
- } | {
354
- error: any;
355
- namespace?: undefined;
356
- status?: undefined;
357
- labels?: undefined;
358
- resourceQuotas?: undefined;
359
- limitRanges?: undefined;
360
- pods?: undefined;
361
- deployments?: undefined;
362
- services?: undefined;
363
- configMaps?: undefined;
364
- }>;
365
- readonly get_namespace_yaml: Tool<{
366
- name: string;
367
- }, any>;
368
- readonly describe_service: Tool<{
369
- namespace: string;
370
- name: string;
371
- }, {
372
- name: string;
373
- namespace: string;
374
- type: any;
375
- clusterIP: any;
376
- externalIPs: any;
377
- loadBalancer: any;
378
- sessionAffinity: any;
379
- selector: any;
380
- ports: any;
381
- endpoints: any;
382
- endpointCount: any;
383
- error?: undefined;
384
- } | {
385
- error: any;
386
- name?: undefined;
387
- namespace?: undefined;
388
- type?: undefined;
389
- clusterIP?: undefined;
390
- externalIPs?: undefined;
391
- loadBalancer?: undefined;
392
- sessionAffinity?: undefined;
393
- selector?: undefined;
394
- ports?: undefined;
395
- endpoints?: undefined;
396
- endpointCount?: undefined;
397
- }>;
398
- readonly describe_ingress: Tool<{
399
- namespace: string;
400
- name: string;
401
- }, {
402
- name: string;
403
- namespace: string;
404
- ingressClass: any;
405
- defaultBackend: string | undefined;
406
- rules: any;
407
- tls: any;
408
- loadBalancer: any;
409
- error?: undefined;
410
- } | {
411
- error: any;
412
- name?: undefined;
413
- namespace?: undefined;
414
- ingressClass?: undefined;
415
- defaultBackend?: undefined;
416
- rules?: undefined;
417
- tls?: undefined;
418
- loadBalancer?: undefined;
419
- }>;
420
- readonly describe_controller: Tool<{
421
- namespace: string;
422
- kind: "Deployment" | "StatefulSet" | "DaemonSet" | "ReplicaSet";
423
- name: string;
424
- }, {
425
- kind: "Deployment" | "StatefulSet" | "DaemonSet" | "ReplicaSet";
426
- name: string;
427
- namespace: string;
428
- replicas: {
429
- desired: any;
430
- current: any;
431
- ready: any;
432
- available: any;
433
- updated: any;
434
- } | {
435
- desired: any;
436
- ready: any;
437
- available: any;
438
- updated: any;
439
- current?: undefined;
440
- };
441
- strategy: any;
442
- conditions: any;
443
- selector: any;
444
- template: {
445
- containers: any;
446
- initContainers: any;
447
- serviceAccount: any;
448
- };
449
- error?: undefined;
450
- } | {
451
- error: any;
452
- kind?: undefined;
453
- name?: undefined;
454
- namespace?: undefined;
455
- replicas?: undefined;
456
- strategy?: undefined;
457
- conditions?: undefined;
458
- selector?: undefined;
459
- template?: undefined;
460
- }>;
461
- readonly get_service_yaml: Tool<{
462
- namespace: string;
463
- name: string;
464
- }, any>;
465
- readonly list_services: Tool<{
466
- namespace?: string | undefined;
467
- }, {
468
- services: any;
469
- error?: undefined;
470
- } | {
471
- error: any;
472
- services?: undefined;
473
- }>;
474
- readonly list_ingresses: Tool<{
475
- namespace?: string | undefined;
476
- }, {
477
- ingresses: any;
478
- error?: undefined;
479
- } | {
480
- error: any;
481
- ingresses?: undefined;
482
- }>;
483
- readonly get_ingress_yaml: Tool<{
484
- namespace: string;
485
- name: string;
486
- }, any>;
487
- readonly get_cluster_usage: Tool<Record<string, never>, {
488
- error: string;
489
- vcpus?: undefined;
490
- memoryGB?: undefined;
491
- cpuUsagePercent?: undefined;
492
- memoryUsagePercent?: undefined;
493
- networkTxMbps?: undefined;
494
- networkRxMbps?: undefined;
495
- metricsIntervalSeconds?: undefined;
496
- } | {
497
- vcpus: any;
498
- memoryGB: number;
499
- cpuUsagePercent: number;
500
- memoryUsagePercent: number;
501
- networkTxMbps: number;
502
- networkRxMbps: number;
503
- metricsIntervalSeconds: any;
504
- error?: undefined;
505
- }>;
506
- readonly get_node_usage: Tool<{
507
- nodeName?: string | undefined;
508
- }, any>;
509
- readonly get_deployment_usage: Tool<{
510
- namespace: string;
511
- name: string;
512
- }, {
513
- deployment: string;
514
- namespace: string;
515
- podCount: number;
516
- cpuMillicores: number;
517
- memoryMB: number;
518
- timestamp: any;
519
- error?: undefined;
520
- } | {
521
- error: any;
522
- deployment?: undefined;
523
- namespace?: undefined;
524
- podCount?: undefined;
525
- cpuMillicores?: undefined;
526
- memoryMB?: undefined;
527
- timestamp?: undefined;
528
- }>;
529
- readonly get_prev_cluster_usage: Tool<{
530
- count?: number | undefined;
531
- }, {
532
- vcpus: any;
533
- memoryGB: number;
534
- cpuUsagePercent: number;
535
- memoryUsagePercent: number;
536
- networkTxMbps: number;
537
- networkRxMbps: number;
538
- }[] | {
539
- error: string;
540
- }>;
541
- readonly get_prev_node_usage: Tool<{
542
- nodeName?: string | undefined;
543
- count?: number | undefined;
544
- }, {
545
- nodes: any;
546
- }[] | {
547
- error: string;
548
- }>;
549
- readonly get_prev_deployment_usage: Tool<{
550
- namespace: string;
551
- name: string;
552
- count?: number | undefined;
553
- }, {
554
- deployment: string;
555
- namespace: string;
556
- podCount: number;
557
- cpuMillicores: number;
558
- memoryMB: number;
559
- timestamp: any;
560
- }[] | {
561
- error: any;
562
- }>;
563
- readonly get_prev_space_data: Tool<{
564
- namespace: string;
565
- count?: number | undefined;
566
- }, {
567
- namespace: string;
568
- podCount: number;
569
- cpuMillicores: number;
570
- memoryMB: number;
571
- timestamp: any;
572
- }[] | {
573
- error: string;
574
- }>;
575
- readonly add_node: Tool<{
576
- nodeName?: string | undefined;
577
- nodePoolName?: string | undefined;
578
- }, {
579
- success: boolean;
580
- message: string;
581
- stdout: string;
582
- stderr: string;
583
- error?: undefined;
584
- } | {
585
- success: boolean;
586
- error: any;
587
- message?: undefined;
588
- stdout?: undefined;
589
- stderr?: undefined;
590
- } | {
591
- success: boolean;
592
- message: string;
593
- stdout?: undefined;
594
- stderr?: undefined;
595
- error?: undefined;
596
- }>;
597
- readonly remove_node: Tool<{
598
- nodeName: string;
599
- nodePoolName?: string | undefined;
600
- }, {
601
- success: boolean;
602
- message: string;
603
- stdout: string;
604
- stderr: string;
605
- error?: undefined;
606
- } | {
607
- success: boolean;
608
- error: any;
609
- message?: undefined;
610
- stdout?: undefined;
611
- stderr?: undefined;
612
- } | {
613
- success: boolean;
614
- message: string;
615
- stdout?: undefined;
616
- stderr?: undefined;
617
- error?: undefined;
618
- }>;
619
- readonly stop_node: Tool<{
620
- nodeName: string;
621
- }, {
622
- success: boolean;
623
- error: string;
624
- message?: undefined;
625
- stdout?: undefined;
626
- stderr?: undefined;
627
- } | {
628
- success: boolean;
629
- message: string;
630
- error?: undefined;
631
- stdout?: undefined;
632
- stderr?: undefined;
633
- } | {
634
- success: boolean;
635
- message: string;
636
- stdout: string;
637
- stderr: string;
638
- error?: undefined;
639
- }>;
640
- readonly start_node: Tool<{
641
- nodeName: string;
642
- }, {
643
- success: boolean;
644
- message: string;
645
- stdout: string;
646
- stderr: string;
647
- error?: undefined;
648
- } | {
649
- success: boolean;
650
- error: any;
651
- message?: undefined;
652
- stdout?: undefined;
653
- stderr?: undefined;
654
- } | {
655
- success: boolean;
656
- message: string;
657
- stdout?: undefined;
658
- stderr?: undefined;
659
- error?: undefined;
660
- }>;
661
- readonly add_replica: Tool<{
662
- namespace: string;
663
- name: string;
664
- }, {
665
- success: boolean;
666
- message: string;
667
- error?: undefined;
668
- } | {
669
- success: boolean;
670
- error: any;
671
- message?: undefined;
672
- }>;
673
- readonly remove_replica: Tool<{
674
- namespace: string;
675
- name: string;
676
- }, {
677
- success: boolean;
678
- message: string;
679
- error?: undefined;
680
- } | {
681
- success: boolean;
682
- error: any;
683
- message?: undefined;
684
- }>;
685
- readonly restart_deployment: Tool<{
686
- namespace: string;
687
- name: string;
688
- }, {
689
- success: boolean;
690
- message: string;
691
- error?: undefined;
692
- } | {
693
- success: boolean;
694
- error: any;
695
- message?: undefined;
696
- }>;
697
- readonly delete_pod: Tool<{
698
- namespace: string;
699
- name: string;
700
- }, {
701
- success: boolean;
702
- message: string;
703
- error?: undefined;
704
- } | {
705
- success: boolean;
706
- error: any;
707
- message?: undefined;
708
- }>;
709
- readonly times_two: Tool<{
710
- data: number;
711
- }, number>;
712
- readonly father_of: Tool<{
713
- data: string;
714
- }, string>;
715
- readonly get_certificate_info: Tool<{
716
- hostname: string;
717
- port?: number | undefined;
718
- }, unknown>;
719
- readonly get_cluster_events: Tool<{
720
- warningsOnly?: boolean | undefined;
721
- namespace?: string | undefined;
722
- limit?: number | undefined;
723
- }, {
724
- count: number;
725
- events: Record<string, unknown>[];
726
- }>;
727
- readonly get_object_events: Tool<{
728
- namespace: string;
729
- name: string;
730
- }, {
731
- count: number;
732
- events: Record<string, unknown>[];
733
- }>;
734
- readonly get_pod_logs: Tool<{
735
- namespace: string;
736
- name: string;
737
- container?: string | undefined;
738
- previous?: boolean | undefined;
739
- tailLines?: number | undefined;
740
- }, {
741
- namespace: string;
742
- name: string;
743
- container: string | null;
744
- previous: boolean;
745
- truncated: boolean;
746
- logs: string;
747
- error?: undefined;
748
- } | {
749
- error: any;
750
- namespace?: undefined;
751
- name?: undefined;
752
- container?: undefined;
753
- previous?: undefined;
754
- truncated?: undefined;
755
- logs?: undefined;
756
- }>;
757
- readonly describe_pod: Tool<{
758
- namespace: string;
759
- name: string;
760
- }, {
761
- name: string;
762
- namespace: string;
763
- phase: any;
764
- node: any;
765
- startTime: any;
766
- reason: any;
767
- message: any;
768
- controlledBy: any;
769
- source: {
770
- repo: any;
771
- revision: any;
772
- } | undefined;
773
- conditions: any;
774
- containers: any;
775
- initContainers: any;
776
- spec: {
777
- containers: any;
778
- restartPolicy: any;
779
- };
780
- error?: undefined;
781
- } | {
782
- error: any;
783
- name?: undefined;
784
- namespace?: undefined;
785
- phase?: undefined;
786
- node?: undefined;
787
- startTime?: undefined;
788
- reason?: undefined;
789
- message?: undefined;
790
- controlledBy?: undefined;
791
- source?: undefined;
792
- conditions?: undefined;
793
- containers?: undefined;
794
- initContainers?: undefined;
795
- spec?: undefined;
796
- }>;
797
- readonly get_pod_yaml: Tool<{
798
- namespace: string;
799
- name: string;
800
- }, any>;
801
- readonly get_deployment_yaml: Tool<{
802
- namespace: string;
803
- name: string;
804
- }, any>;
805
- readonly get_controller_yaml: Tool<{
806
- namespace: string;
807
- kind: "Deployment" | "StatefulSet" | "DaemonSet" | "ReplicaSet";
808
- name: string;
809
- }, any>;
810
- readonly get_rollout_history: Tool<{
811
- namespace: string;
812
- name: string;
813
- }, {
814
- deployment: string;
815
- namespace: string;
816
- revisionCount: any;
817
- revisions: any;
818
- error?: undefined;
819
- } | {
820
- error: any;
821
- deployment?: undefined;
822
- namespace?: undefined;
823
- revisionCount?: undefined;
824
- revisions?: undefined;
825
- }>;
826
- readonly get_configmap: Tool<{
827
- namespace: string;
828
- name: string;
829
- }, {
830
- name: string;
831
- namespace: string;
832
- resourceVersion: any;
833
- lastModified: string | undefined;
834
- data: any;
835
- binaryDataKeys: string[];
836
- error?: undefined;
837
- } | {
838
- error: any;
839
- name?: undefined;
840
- namespace?: undefined;
841
- resourceVersion?: undefined;
842
- lastModified?: undefined;
843
- data?: undefined;
844
- binaryDataKeys?: undefined;
845
- }>;
846
- readonly get_secret: Tool<{
847
- namespace: string;
848
- name: string;
849
- }, {
850
- name: string;
851
- namespace: string;
852
- type: any;
853
- resourceVersion: any;
854
- lastModified: string | undefined;
855
- keys: string[];
856
- error?: undefined;
857
- } | {
858
- error: any;
859
- name?: undefined;
860
- namespace?: undefined;
861
- type?: undefined;
862
- resourceVersion?: undefined;
863
- lastModified?: undefined;
864
- keys?: undefined;
865
- }>;
866
- readonly get_workload_config_refs: Tool<{
867
- namespace: string;
868
- name: string;
869
- }, {
870
- deployment: string;
871
- namespace: string;
872
- refs: ({
873
- resourceVersion: any;
874
- lastModified: string | undefined;
875
- kind: string;
876
- name: string;
877
- via: string[];
878
- } | {
879
- error: any;
880
- kind: string;
881
- name: string;
882
- via: string[];
883
- })[];
884
- error?: undefined;
885
- } | {
886
- error: any;
887
- deployment?: undefined;
888
- namespace?: undefined;
889
- refs?: undefined;
890
- }>;
891
- readonly get_source_file: Tool<{
892
- repo: string;
893
- ref: string;
894
- path: string;
895
- }, {
896
- repo: string;
897
- ref: string;
898
- path: string;
899
- truncated: boolean;
900
- content: string;
901
- error?: undefined;
902
- } | {
903
- error: any;
904
- repo?: undefined;
905
- ref?: undefined;
906
- path?: undefined;
907
- truncated?: undefined;
908
- content?: undefined;
909
- }>;
910
- };
911
- export declare const toolInfoList: IToolInfo[];
912
293
  export interface IAgentRunResult {
913
294
  text: string;
914
295
  inputTokens: number;
@@ -916,5 +297,3 @@ export interface IAgentRunResult {
916
297
  steps: number;
917
298
  toolCalls: string[];
918
299
  }
919
- export declare const selectAgentToolNames: (agent: IAgent) => string[];
920
- export declare const runAgent: (agent: IAgent, prompt: string, llms: ILlm[], providers: ILlmProvider[], context: IToolContext) => Promise<IAgentRunResult>;