mlld/dist/chunk-YRFPMAAJ.mjs

mlld: llm scripting language

import { __name, __publicField } from './chunk-NJQT543K.mjs';

// interpreter/streaming/jsonpath.ts
function extractPath(obj, path, options) {
  if (obj === null || obj === void 0) {
    return options?.returnUndefined ? void 0 : null;
  }
  const parts = parsePath(path);
  let current = obj;
  for (let i = 0; i < parts.length; i++) {
    const part = parts[i];
    if (current === null || current === void 0) {
      return options?.returnUndefined ? void 0 : null;
    }
    if (part.type === "array-iterate") {
      if (!Array.isArray(current)) {
        return options?.returnUndefined ? void 0 : null;
      }
      const remainingParts = parts.slice(i + 1);
      if (remainingParts.length > 0) {
        const remainingPath = partsToPath(remainingParts);
        return current.map((item) => extractPath(item, remainingPath, options));
      }
      return current;
    }
    if (part.type === "array-index") {
      if (!Array.isArray(current[part.key])) {
        return options?.returnUndefined ? void 0 : null;
      }
      const arr = current[part.key];
      current = arr[part.index];
      continue;
    }
    if (part.type === "key") {
      if (typeof current !== "object") {
        return options?.returnUndefined ? void 0 : null;
      }
      current = current[part.key];
      continue;
    }
  }
  if (current === void 0) {
    return options?.returnUndefined ? void 0 : null;
  }
  return current;
}
__name(extractPath, "extractPath");
function extractWithFallback(obj, pathOrPaths, options) {
  const paths = Array.isArray(pathOrPaths) ? pathOrPaths : [
    pathOrPaths
  ];
  for (const path of paths) {
    const value = extractPath(obj, path, {
      returnUndefined: true
    });
    if (value !== void 0) {
      return value;
    }
  }
  return options?.returnUndefined ? void 0 : null;
}
__name(extractWithFallback, "extractWithFallback");
function parsePath(path) {
  const parts = [];
  const segments = path.split(".");
  for (const segment of segments) {
    if (segment.endsWith("[]")) {
      const key = segment.slice(0, -2);
      if (key) {
        parts.push({
          type: "key",
          key
        });
      }
      parts.push({
        type: "array-iterate",
        key: ""
      });
      continue;
    }
    const arrayMatch = segment.match(/^(.+)\[(\d+)\]$/);
    if (arrayMatch) {
      const [, key, indexStr] = arrayMatch;
      parts.push({
        type: "array-index",
        key,
        index: parseInt(indexStr, 10)
      });
      continue;
    }
    parts.push({
      type: "key",
      key: segment
    });
  }
  return parts;
}
__name(parsePath, "parsePath");
function partsToPath(parts) {
  return parts.map((part) => {
    if (part.type === "array-iterate") {
      return "[]";
    }
    if (part.type === "array-index") {
      return `${part.key}[${part.index}]`;
    }
    return part.key;
  }).join(".");
}
__name(partsToPath, "partsToPath");

// interpreter/streaming/adapters/base.ts
var _BaseStreamAdapter = class _BaseStreamAdapter {
  constructor(config) {
    __publicField(this, "buffer", "");
    __publicField(this, "config");
    this.config = config;
  }
  flush() {
    if (!this.buffer.trim()) {
      return [];
    }
    const remaining = this.processRemainingBuffer();
    this.buffer = "";
    return remaining;
  }
  reset() {
    this.buffer = "";
  }
  processRemainingBuffer() {
    return [];
  }
  matchSchema(obj) {
    if (!obj || typeof obj !== "object") {
      return this.config.defaultSchema;
    }
    for (const schema of this.config.schemas) {
      if (this.schemaMatches(obj, schema)) {
        return schema;
      }
    }
    return this.config.defaultSchema;
  }
  schemaMatches(obj, schema) {
    if (!obj || typeof obj !== "object") return false;
    if (schema.match) {
      for (const [key, expectedValue] of Object.entries(schema.match)) {
        const actualValue = this.getNestedValue(obj, key);
        if (actualValue !== expectedValue) {
          return false;
        }
      }
      return true;
    }
    if (schema.matchPath && schema.matchValue !== void 0) {
      const actualValue = this.getNestedValue(obj, schema.matchPath);
      return actualValue === schema.matchValue;
    }
    return false;
  }
  extractData(obj, config) {
    if (!obj || typeof obj !== "object") {
      return {};
    }
    const result = {};
    for (const [field, pathOrPaths] of Object.entries(config)) {
      const value = extractWithFallback(obj, pathOrPaths, {
        returnUndefined: true
      });
      if (value !== void 0) {
        result[field] = value;
      }
    }
    return result;
  }
  getNestedValue(obj, path) {
    return extractWithFallback(obj, path, {
      returnUndefined: true
    });
  }
};
__name(_BaseStreamAdapter, "BaseStreamAdapter");
var BaseStreamAdapter = _BaseStreamAdapter;

// interpreter/streaming/adapters/ndjson.ts
var _NDJSONAdapter = class _NDJSONAdapter extends BaseStreamAdapter {
  constructor(config) {
    super(config);
    __publicField(this, "name");
    __publicField(this, "format", "ndjson");
    this.name = config.name;
  }
  processChunk(chunk) {
    this.buffer += chunk;
    const events = [];
    const lines = this.buffer.split("\n");
    this.buffer = lines.pop() || "";
    for (const line of lines) {
      const trimmed = line.trim();
      if (!trimmed) continue;
      const event = this.parseLine(trimmed);
      if (event) {
        events.push(event);
      }
    }
    return events;
  }
  processRemainingBuffer() {
    const trimmed = this.buffer.trim();
    if (!trimmed) {
      return [];
    }
    const event = this.parseLine(trimmed);
    return event ? [
      event
    ] : [];
  }
  parseLine(line) {
    let parsed;
    try {
      parsed = JSON.parse(line);
    } catch {
      return {
        kind: "unknown",
        data: {
          raw: line
        },
        raw: line,
        timestamp: Date.now()
      };
    }
    const schema = this.matchSchema(parsed);
    if (!schema) {
      return {
        kind: "unknown",
        data: parsed,
        raw: parsed,
        timestamp: Date.now()
      };
    }
    const data = this.extractData(parsed, schema.extract);
    return {
      kind: schema.kind,
      data,
      raw: parsed,
      timestamp: Date.now(),
      templates: schema.templates
    };
  }
};
__name(_NDJSONAdapter, "NDJSONAdapter");
var NDJSONAdapter = _NDJSONAdapter;
function createNDJSONAdapter(config) {
  return new NDJSONAdapter({
    ...config,
    format: "ndjson"
  });
}
__name(createNDJSONAdapter, "createNDJSONAdapter");
var COMMON_SCHEMAS = {
  // Claude Code SDK format
  claudeCodeThinking: {
    kind: "thinking",
    matchPath: "type",
    matchValue: "thinking",
    extract: {
      text: [
        "thinking",
        "content",
        "message"
      ],
      depth: "depth"
    },
    visibility: "optional"
  },
  claudeCodeMessage: {
    kind: "message",
    matchPath: "type",
    matchValue: "text",
    extract: {
      chunk: [
        "text",
        "content",
        "delta.text"
      ],
      role: "role"
    },
    visibility: "always"
  },
  claudeCodeToolUse: {
    kind: "tool-use",
    matchPath: "type",
    matchValue: "tool_use",
    extract: {
      name: [
        "name",
        "tool_name"
      ],
      input: [
        "input",
        "parameters"
      ],
      id: [
        "id",
        "tool_use_id"
      ]
    },
    visibility: "optional"
  },
  claudeCodeToolResult: {
    kind: "tool-result",
    matchPath: "type",
    matchValue: "tool_result",
    extract: {
      result: [
        "content",
        "result",
        "output"
      ],
      toolUseId: [
        "tool_use_id",
        "id"
      ],
      success: "success",
      isError: "is_error"
      // Claude Code uses is_error (inverted)
    },
    visibility: "optional"
  },
  claudeCodeError: {
    kind: "error",
    matchPath: "type",
    matchValue: "error",
    extract: {
      message: [
        "message",
        "error.message",
        "error"
      ],
      code: [
        "code",
        "error.code"
      ]
    },
    visibility: "always"
  },
  claudeCodeUsage: {
    kind: "metadata",
    matchPath: "type",
    matchValue: "result",
    extract: {
      inputTokens: [
        "usage.input_tokens",
        "input_tokens"
      ],
      outputTokens: [
        "usage.output_tokens",
        "output_tokens"
      ],
      model: "model"
    },
    visibility: "optional"
  },
  // Generic content_block_delta (Anthropic API format)
  contentBlockDelta: {
    kind: "message",
    matchPath: "type",
    matchValue: "content_block_delta",
    extract: {
      chunk: [
        "delta.text",
        "delta.partial_json"
      ],
      index: "index"
    },
    visibility: "always"
  },
  // Generic message_delta (Anthropic API format)
  messageDelta: {
    kind: "metadata",
    matchPath: "type",
    matchValue: "message_delta",
    extract: {
      stopReason: "delta.stop_reason",
      inputTokens: "usage.input_tokens",
      outputTokens: "usage.output_tokens"
    },
    visibility: "optional"
  },
  // Claude CLI with --include-partial-messages wraps Anthropic API events
  streamEventTextDelta: {
    kind: "message",
    matchPath: "event.type",
    matchValue: "content_block_delta",
    extract: {
      chunk: [
        "event.delta.text",
        "event.delta.partial_json"
      ]
    },
    visibility: "always"
  },
  streamEventMessageDelta: {
    kind: "metadata",
    matchPath: "event.type",
    matchValue: "message_delta",
    extract: {
      inputTokens: "event.usage.input_tokens",
      outputTokens: "event.usage.output_tokens"
    },
    visibility: "optional"
  }
};

export { COMMON_SCHEMAS, NDJSONAdapter, createNDJSONAdapter, extractPath };
//# sourceMappingURL=chunk-YRFPMAAJ.mjs.map
//# sourceMappingURL=chunk-YRFPMAAJ.mjs.map