agent-skill-manager 1.20.0 → 1.22.0

package/node_modules/@grpc/grpc-js/src/object-stream.ts

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { Readable, Writable } from 'stream';
+import { EmitterAugmentation1 } from './events';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type WriteCallback = (error: Error | null | undefined) => void;
+
+export interface IntermediateObjectReadable<T> extends Readable {
+  read(size?: number): any & T;
+}
+
+export type ObjectReadable<T> = {
+  read(size?: number): T;
+} & EmitterAugmentation1<'data', T> &
+  IntermediateObjectReadable<T>;
+
+export interface IntermediateObjectWritable<T> extends Writable {
+  _write(chunk: any & T, encoding: string, callback: Function): void;
+  write(chunk: any & T, cb?: WriteCallback): boolean;
+  write(chunk: any & T, encoding?: any, cb?: WriteCallback): boolean;
+  setDefaultEncoding(encoding: string): this;
+  end(): ReturnType<Writable['end']> extends Writable ? this : void;
+  end(
+    chunk: any & T,
+    cb?: Function
+  ): ReturnType<Writable['end']> extends Writable ? this : void;
+  end(
+    chunk: any & T,
+    encoding?: any,
+    cb?: Function
+  ): ReturnType<Writable['end']> extends Writable ? this : void;
+}
+
+export interface ObjectWritable<T> extends IntermediateObjectWritable<T> {
+  _write(chunk: T, encoding: string, callback: Function): void;
+  write(chunk: T, cb?: Function): boolean;
+  write(chunk: T, encoding?: any, cb?: Function): boolean;
+  setDefaultEncoding(encoding: string): this;
+  end(): ReturnType<Writable['end']> extends Writable ? this : void;
+  end(
+    chunk: T,
+    cb?: Function
+  ): ReturnType<Writable['end']> extends Writable ? this : void;
+  end(
+    chunk: T,
+    encoding?: any,
+    cb?: Function
+  ): ReturnType<Writable['end']> extends Writable ? this : void;
+}

package/node_modules/@grpc/grpc-js/src/orca.ts

@@ -0,0 +1,349 @@
+/*
+ * Copyright 2025 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { OrcaLoadReport, OrcaLoadReport__Output } from "./generated/xds/data/orca/v3/OrcaLoadReport";
+
+import type { loadSync } from '@grpc/proto-loader';
+import { ProtoGrpcType as OrcaProtoGrpcType } from "./generated/orca";
+import { loadPackageDefinition } from "./make-client";
+import { OpenRcaServiceClient, OpenRcaServiceHandlers } from "./generated/xds/service/orca/v3/OpenRcaService";
+import { durationMessageToDuration, durationToMs, msToDuration } from "./duration";
+import { Server } from "./server";
+import { ChannelCredentials } from "./channel-credentials";
+import { Channel } from "./channel";
+import { OnCallEnded } from "./picker";
+import { DataProducer, Subchannel } from "./subchannel";
+import { BaseSubchannelWrapper, DataWatcher, SubchannelInterface } from "./subchannel-interface";
+import { ClientReadableStream, ServiceError } from "./call";
+import { Status } from "./constants";
+import { BackoffTimeout } from "./backoff-timeout";
+import { ConnectivityState } from "./connectivity-state";
+
+const loadedOrcaProto: OrcaProtoGrpcType | null = null;
+function loadOrcaProto(): OrcaProtoGrpcType {
+  if (loadedOrcaProto) {
+    return loadedOrcaProto;
+  }
+  /* The purpose of this complexity is to avoid loading @grpc/proto-loader at
+   * runtime for users who will not use/enable ORCA. */
+  const loaderLoadSync = require('@grpc/proto-loader')
+    .loadSync as typeof loadSync;
+  const loadedProto = loaderLoadSync('xds/service/orca/v3/orca.proto', {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true,
+    includeDirs: [
+      `${__dirname}/../../proto/xds`,
+      `${__dirname}/../../proto/protoc-gen-validate`
+    ],
+  });
+  return loadPackageDefinition(loadedProto) as unknown as OrcaProtoGrpcType;
+}
+
+/**
+ * ORCA metrics recorder for a single request
+ */
+export class PerRequestMetricRecorder {
+  private message: OrcaLoadReport = {};
+
+  /**
+   * Records a request cost metric measurement for the call.
+   * @param name
+   * @param value
+   */
+  recordRequestCostMetric(name: string, value: number) {
+    if (!this.message.request_cost) {
+      this.message.request_cost = {};
+    }
+    this.message.request_cost[name] = value;
+  }
+
+  /**
+   * Records a request cost metric measurement for the call.
+   * @param name
+   * @param value
+   */
+  recordUtilizationMetric(name: string, value: number) {
+    if (!this.message.utilization) {
+      this.message.utilization = {};
+    }
+    this.message.utilization[name] = value;
+  }
+
+  /**
+   * Records an opaque named metric measurement for the call.
+   * @param name
+   * @param value
+   */
+  recordNamedMetric(name: string, value: number) {
+    if (!this.message.named_metrics) {
+      this.message.named_metrics = {};
+    }
+    this.message.named_metrics[name] = value;
+  }
+
+  /**
+   * Records the CPU utilization metric measurement for the call.
+   * @param value
+   */
+  recordCPUUtilizationMetric(value: number) {
+    this.message.cpu_utilization = value;
+  }
+
+  /**
+   * Records the memory utilization metric measurement for the call.
+   * @param value
+   */
+  recordMemoryUtilizationMetric(value: number) {
+    this.message.mem_utilization = value;
+  }
+
+  /**
+   * Records the memory utilization metric measurement for the call.
+   * @param value
+   */
+  recordApplicationUtilizationMetric(value: number) {
+    this.message.application_utilization = value;
+  }
+
+  /**
+   * Records the queries per second measurement.
+   * @param value
+   */
+  recordQpsMetric(value: number) {
+    this.message.rps_fractional = value;
+  }
+
+  /**
+   * Records the errors per second measurement.
+   * @param value
+   */
+  recordEpsMetric(value: number) {
+    this.message.eps = value;
+  }
+
+  serialize(): Buffer {
+    const orcaProto = loadOrcaProto();
+    return orcaProto.xds.data.orca.v3.OrcaLoadReport.serialize(this.message);
+  }
+}
+
+const DEFAULT_REPORT_INTERVAL_MS = 30_000;
+
+export class ServerMetricRecorder {
+  private message: OrcaLoadReport = {};
+
+  private serviceImplementation: OpenRcaServiceHandlers = {
+    StreamCoreMetrics: call => {
+      const reportInterval = call.request.report_interval ?
+        durationToMs(durationMessageToDuration(call.request.report_interval)) :
+        DEFAULT_REPORT_INTERVAL_MS;
+      const reportTimer = setInterval(() => {
+        call.write(this.message);
+      }, reportInterval);
+      call.on('cancelled', () => {
+        clearInterval(reportTimer);
+      })
+    }
+  }
+
+  putUtilizationMetric(name: string, value: number) {
+    if (!this.message.utilization) {
+      this.message.utilization = {};
+    }
+    this.message.utilization[name] = value;
+  }
+
+  setAllUtilizationMetrics(metrics: {[name: string]: number}) {
+    this.message.utilization = {...metrics};
+  }
+
+  deleteUtilizationMetric(name: string) {
+    delete this.message.utilization?.[name];
+  }
+
+  setCpuUtilizationMetric(value: number) {
+    this.message.cpu_utilization = value;
+  }
+
+  deleteCpuUtilizationMetric() {
+    delete this.message.cpu_utilization;
+  }
+
+  setApplicationUtilizationMetric(value: number) {
+    this.message.application_utilization = value;
+  }
+
+  deleteApplicationUtilizationMetric() {
+    delete this.message.application_utilization;
+  }
+
+  setQpsMetric(value: number) {
+    this.message.rps_fractional = value;
+  }
+
+  deleteQpsMetric() {
+    delete this.message.rps_fractional;
+  }
+
+  setEpsMetric(value: number) {
+    this.message.eps = value;
+  }
+
+  deleteEpsMetric() {
+    delete this.message.eps;
+  }
+
+  addToServer(server: Server) {
+    const serviceDefinition = loadOrcaProto().xds.service.orca.v3.OpenRcaService.service;
+    server.addService(serviceDefinition, this.serviceImplementation);
+  }
+}
+
+export function createOrcaClient(channel: Channel): OpenRcaServiceClient {
+  const ClientClass = loadOrcaProto().xds.service.orca.v3.OpenRcaService;
+  return new ClientClass('unused', ChannelCredentials.createInsecure(), {channelOverride: channel});
+}
+
+export type MetricsListener = (loadReport: OrcaLoadReport__Output) => void;
+
+export const GRPC_METRICS_HEADER = 'endpoint-load-metrics-bin';
+const PARSED_LOAD_REPORT_KEY = 'grpc_orca_load_report';
+
+/**
+ * Create an onCallEnded callback for use in a picker.
+ * @param listener The listener to handle metrics, whenever they are provided.
+ * @param previousOnCallEnded The previous onCallEnded callback to propagate
+ * to, if applicable.
+ * @returns
+ */
+export function createMetricsReader(listener: MetricsListener, previousOnCallEnded: OnCallEnded | null): OnCallEnded {
+  return (code, details, metadata) => {
+    let parsedLoadReport = metadata.getOpaque(PARSED_LOAD_REPORT_KEY) as (OrcaLoadReport__Output | undefined);
+    if (parsedLoadReport) {
+      listener(parsedLoadReport);
+    } else {
+      const serializedLoadReport = metadata.get(GRPC_METRICS_HEADER);
+      if (serializedLoadReport.length > 0) {
+        const orcaProto = loadOrcaProto();
+        parsedLoadReport = orcaProto.xds.data.orca.v3.OrcaLoadReport.deserialize(serializedLoadReport[0] as Buffer);
+        listener(parsedLoadReport);
+        metadata.setOpaque(PARSED_LOAD_REPORT_KEY, parsedLoadReport);
+      }
+    }
+    if (previousOnCallEnded) {
+      previousOnCallEnded(code, details, metadata);
+    }
+  }
+}
+
+const DATA_PRODUCER_KEY = 'orca_oob_metrics';
+
+class OobMetricsDataWatcher implements DataWatcher {
+  private dataProducer: DataProducer | null = null;
+  constructor(private metricsListener: MetricsListener, private intervalMs: number) {}
+  setSubchannel(subchannel: Subchannel): void {
+    const producer = subchannel.getOrCreateDataProducer(DATA_PRODUCER_KEY, createOobMetricsDataProducer);
+    this.dataProducer = producer;
+    producer.addDataWatcher(this);
+  }
+  destroy(): void {
+    this.dataProducer?.removeDataWatcher(this);
+  }
+  getInterval(): number {
+    return this.intervalMs;
+  }
+  onMetricsUpdate(metrics: OrcaLoadReport__Output) {
+    this.metricsListener(metrics);
+  }
+}
+
+class OobMetricsDataProducer implements DataProducer {
+  private dataWatchers: Set<OobMetricsDataWatcher> = new Set();
+  private orcaSupported = true;
+  private client: OpenRcaServiceClient;
+  private metricsCall: ClientReadableStream<OrcaLoadReport__Output> | null = null;
+  private currentInterval = Infinity;
+  private backoffTimer = new BackoffTimeout(() => this.updateMetricsSubscription());
+  private subchannelStateListener = () => this.updateMetricsSubscription();
+  constructor(private subchannel: Subchannel) {
+    const channel = subchannel.getChannel();
+    this.client = createOrcaClient(channel);
+    subchannel.addConnectivityStateListener(this.subchannelStateListener);
+  }
+  addDataWatcher(dataWatcher: OobMetricsDataWatcher): void {
+    this.dataWatchers.add(dataWatcher);
+    this.updateMetricsSubscription();
+  }
+  removeDataWatcher(dataWatcher: OobMetricsDataWatcher): void {
+    this.dataWatchers.delete(dataWatcher);
+    if (this.dataWatchers.size === 0) {
+      this.subchannel.removeDataProducer(DATA_PRODUCER_KEY);
+      this.metricsCall?.cancel();
+      this.metricsCall = null;
+      this.client.close();
+      this.subchannel.removeConnectivityStateListener(this.subchannelStateListener);
+    } else {
+      this.updateMetricsSubscription();
+    }
+  }
+  private updateMetricsSubscription() {
+    if (this.dataWatchers.size === 0 || !this.orcaSupported || this.subchannel.getConnectivityState() !== ConnectivityState.READY) {
+      return;
+    }
+    const newInterval = Math.min(...Array.from(this.dataWatchers).map(watcher => watcher.getInterval()));
+    if (!this.metricsCall || newInterval !== this.currentInterval) {
+      this.metricsCall?.cancel();
+      this.currentInterval = newInterval;
+      const metricsCall = this.client.streamCoreMetrics({report_interval: msToDuration(newInterval)});
+      this.metricsCall = metricsCall;
+      metricsCall.on('data', (report: OrcaLoadReport__Output) => {
+        this.dataWatchers.forEach(watcher => {
+          watcher.onMetricsUpdate(report);
+        });
+      });
+      metricsCall.on('error', (error: ServiceError) => {
+        this.metricsCall = null;
+        if (error.code === Status.UNIMPLEMENTED) {
+          this.orcaSupported = false;
+          return;
+        }
+        if (error.code === Status.CANCELLED) {
+          return;
+        }
+        this.backoffTimer.runOnce();
+      });
+    }
+  }
+}
+
+export class OrcaOobMetricsSubchannelWrapper extends BaseSubchannelWrapper {
+  constructor(child: SubchannelInterface, metricsListener: MetricsListener, intervalMs: number) {
+    super(child);
+    this.addDataWatcher(new OobMetricsDataWatcher(metricsListener, intervalMs));
+  }
+
+  getWrappedSubchannel(): SubchannelInterface {
+    return this.child;
+  }
+}
+
+function createOobMetricsDataProducer(subchannel: Subchannel) {
+  return new OobMetricsDataProducer(subchannel);
+}

package/node_modules/@grpc/grpc-js/src/picker.ts

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { StatusObject } from './call-interface';
+import { Metadata } from './metadata';
+import { Status } from './constants';
+import { LoadBalancer } from './load-balancer';
+import { SubchannelInterface } from './subchannel-interface';
+
+export enum PickResultType {
+  COMPLETE,
+  QUEUE,
+  TRANSIENT_FAILURE,
+  DROP,
+}
+
+export type OnCallEnded = (statusCode: Status, details: string, metadata: Metadata) => void;
+
+export interface PickResult {
+  pickResultType: PickResultType;
+  /**
+   * The subchannel to use as the transport for the call. Only meaningful if
+   * `pickResultType` is COMPLETE. If null, indicates that the call should be
+   * dropped.
+   */
+  subchannel: SubchannelInterface | null;
+  /**
+   * The status object to end the call with. Populated if and only if
+   * `pickResultType` is TRANSIENT_FAILURE.
+   */
+  status: StatusObject | null;
+  onCallStarted: (() => void) | null;
+  onCallEnded: OnCallEnded | null;
+}
+
+export interface CompletePickResult extends PickResult {
+  pickResultType: PickResultType.COMPLETE;
+  subchannel: SubchannelInterface | null;
+  status: null;
+  onCallStarted: (() => void) | null;
+  onCallEnded: OnCallEnded | null;
+}
+
+export interface QueuePickResult extends PickResult {
+  pickResultType: PickResultType.QUEUE;
+  subchannel: null;
+  status: null;
+  onCallStarted: null;
+  onCallEnded: null;
+}
+
+export interface TransientFailurePickResult extends PickResult {
+  pickResultType: PickResultType.TRANSIENT_FAILURE;
+  subchannel: null;
+  status: StatusObject;
+  onCallStarted: null;
+  onCallEnded: null;
+}
+
+export interface DropCallPickResult extends PickResult {
+  pickResultType: PickResultType.DROP;
+  subchannel: null;
+  status: StatusObject;
+  onCallStarted: null;
+  onCallEnded: null;
+}
+
+export interface PickArgs {
+  metadata: Metadata;
+  extraPickInfo: { [key: string]: string };
+}
+
+/**
+ * A proxy object representing the momentary state of a load balancer. Picks
+ * subchannels or returns other information based on that state. Should be
+ * replaced every time the load balancer changes state.
+ */
+export interface Picker {
+  pick(pickArgs: PickArgs): PickResult;
+}
+
+/**
+ * A standard picker representing a load balancer in the TRANSIENT_FAILURE
+ * state. Always responds to every pick request with an UNAVAILABLE status.
+ */
+export class UnavailablePicker implements Picker {
+  private status: StatusObject;
+  constructor(status?: Partial<StatusObject>) {
+    this.status = {
+      code: Status.UNAVAILABLE,
+      details: 'No connection established',
+      metadata: new Metadata(),
+      ...status,
+    };
+  }
+  pick(pickArgs: PickArgs): TransientFailurePickResult {
+    return {
+      pickResultType: PickResultType.TRANSIENT_FAILURE,
+      subchannel: null,
+      status: this.status,
+      onCallStarted: null,
+      onCallEnded: null,
+    };
+  }
+}
+
+/**
+ * A standard picker representing a load balancer in the IDLE or CONNECTING
+ * state. Always responds to every pick request with a QUEUE pick result
+ * indicating that the pick should be tried again with the next `Picker`. Also
+ * reports back to the load balancer that a connection should be established
+ * once any pick is attempted.
+ * If the childPicker is provided, delegate to it instead of returning the
+ * hardcoded QUEUE pick result, but still calls exitIdle.
+ */
+export class QueuePicker {
+  private calledExitIdle = false;
+  // Constructed with a load balancer. Calls exitIdle on it the first time pick is called
+  constructor(
+    private loadBalancer: LoadBalancer,
+    private childPicker?: Picker
+  ) {}
+
+  pick(pickArgs: PickArgs): PickResult {
+    if (!this.calledExitIdle) {
+      process.nextTick(() => {
+        this.loadBalancer.exitIdle();
+      });
+      this.calledExitIdle = true;
+    }
+    if (this.childPicker) {
+      return this.childPicker.pick(pickArgs);
+    } else {
+      return {
+        pickResultType: PickResultType.QUEUE,
+        subchannel: null,
+        status: null,
+        onCallStarted: null,
+        onCallEnded: null,
+      };
+    }
+  }
+}

package/node_modules/@grpc/grpc-js/src/priority-queue.ts

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2025 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+const top = 0;
+const parent = (i: number) => Math.floor(i / 2);
+const left = (i: number) => i * 2 + 1;
+const right = (i: number) => i * 2 + 2;
+
+/**
+ * A generic priority queue implemented as an array-based binary heap.
+ * Adapted from https://stackoverflow.com/a/42919752/159388
+ */
+export class PriorityQueue<T=number> {
+  private readonly heap: T[] = [];
+  /**
+   *
+   * @param comparator Returns true if the first argument should precede the
+   *   second in the queue. Defaults to `(a, b) => a > b`
+   */
+  constructor(private readonly comparator = (a: T, b: T) => a > b) {}
+
+  /**
+   * @returns The number of items currently in the queue
+   */
+  size(): number {
+    return this.heap.length;
+  }
+  /**
+   * @returns True if there are no items in the queue, false otherwise
+   */
+  isEmpty(): boolean {
+    return this.size() == 0;
+  }
+  /**
+   * Look at the front item that would be popped, without modifying the contents
+   * of the queue
+   * @returns The front item in the queue, or undefined if the queue is empty
+   */
+  peek(): T | undefined {
+    return this.heap[top];
+  }
+  /**
+   * Add the items to the queue
+   * @param values The items to add
+   * @returns The new size of the queue after adding the items
+   */
+  push(...values: T[]): number {
+    values.forEach(value => {
+      this.heap.push(value);
+      this.siftUp();
+    });
+    return this.size();
+  }
+  /**
+   * Remove the front item in the queue and return it
+   * @returns The front item in the queue, or undefined if the queue is empty
+   */
+  pop(): T | undefined {
+    const poppedValue = this.peek();
+    const bottom = this.size() - 1;
+    if (bottom > top) {
+      this.swap(top, bottom);
+    }
+    this.heap.pop();
+    this.siftDown();
+    return poppedValue;
+  }
+  /**
+   * Simultaneously remove the front item in the queue and add the provided
+   * item.
+   * @param value The item to add
+   * @returns The front item in the queue, or undefined if the queue is empty
+   */
+  replace(value: T): T | undefined {
+    const replacedValue = this.peek();
+    this.heap[top] = value;
+    this.siftDown();
+    return replacedValue;
+  }
+  private greater(i: number, j: number): boolean {
+    return this.comparator(this.heap[i], this.heap[j]);
+  }
+  private swap(i: number, j: number): void {
+    [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
+  }
+  private siftUp(): void {
+    let node = this.size() - 1;
+    while (node > top && this.greater(node, parent(node))) {
+      this.swap(node, parent(node));
+      node = parent(node);
+    }
+  }
+  private siftDown(): void {
+    let node = top;
+    while (
+      (left(node) < this.size() && this.greater(left(node), node)) ||
+      (right(node) < this.size() && this.greater(right(node), node))
+    ) {
+      let maxChild = (right(node) < this.size() && this.greater(right(node), left(node))) ? right(node) : left(node);
+      this.swap(node, maxChild);
+      node = maxChild;
+    }
+  }
+}