@qloo/qloo-harness 0.1.18

package/dist/mcp.js

@@ -0,0 +1,909 @@
+import { createRequire as __qlooCreateRequire } from "node:module";
+const require = __qlooCreateRequire(import.meta.url);
+
+// apps/qloo-harness/dist/mcp.js
+import { createInterface } from "node:readline";
+
+// packages/qloo-tool-schema/dist/upstream.lock.json
+var upstream_lock_default = {
+  lockVersion: 1,
+  source: {
+    documentationUrl: "https://docs.qloo.com",
+    registryUrl: "https://dash.readme.com/api/v1/api-registry/4svkj1svmrti5tfx",
+    registryId: "4svkj1svmrti5tfx",
+    retrievedAt: "2026-08-20",
+    apiTitle: "Qloo API",
+    apiVersion: "2.0",
+    openapiVersion: "3.1.0",
+    sha256: "da8d4b830f2a646815d25afcaa653f81f1ad939707e2e2560d2d0b9f103076f1"
+  },
+  expectations: {
+    productionServer: "https://api.qloo.com",
+    authentication: {
+      scheme: "ApiKey",
+      type: "apiKey",
+      location: "header",
+      header: "X-Api-Key"
+    },
+    getPaths: [
+      "/",
+      "/entities",
+      "/search",
+      "/v2/analysis/compare",
+      "/v2/audiences",
+      "/v2/audiences/types",
+      "/v2/insights",
+      "/v2/tags",
+      "/v2/tags/types",
+      "/v2/trending"
+    ]
+  },
+  documentedExceptions: [
+    {
+      value: "urn:demographics",
+      scope: "/v2/insights filter.type",
+      status: "documented-but-not-enumerated",
+      documentationUrl: "https://docs.qloo.com/reference/demographics-use-case",
+      treatment: "Preserve as an explicit documentation exception; do not synthesize an endpoint payload schema from it."
+    },
+    {
+      value: "urn:tag",
+      scope: "/v2/insights filter.type",
+      status: "documented-but-not-enumerated",
+      documentationUrl: "https://docs.qloo.com/reference/taste-analysis",
+      treatment: "The pinned specification mentions this value in diversify.by documentation but omits it from the filter.type enum; preserve the discrepancy for review."
+    }
+  ]
+};
+
+// packages/qloo-tool-schema/dist/src/catalog.js
+var QLOO_TOOL_CATALOG_VERSION = "1.0.0";
+var QLOO_TOOL_RESULT_SCHEMA_VERSION = "1.0-preview.1";
+var QLOO_WORKFLOW_OPERATION_IDS = [
+  "recommend",
+  "rank",
+  "describe",
+  "where_popular",
+  "compare_audiences",
+  "entity_tags",
+  "audience_demographics",
+  "trends",
+  "find_tags"
+];
+var QLOO_CAPABILITIES_TOOL_NAME = "qloo_capabilities";
+var QLOO_INSIGHTS_ENTITY_TYPES = [
+  { id: "artist", urn: "urn:entity:artist" },
+  { id: "book", urn: "urn:entity:book" },
+  { id: "brand", urn: "urn:entity:brand" },
+  { id: "movie", urn: "urn:entity:movie" },
+  { id: "person", urn: "urn:entity:person" },
+  { id: "place", urn: "urn:entity:place" },
+  { id: "podcast", urn: "urn:entity:podcast" },
+  { id: "tv_show", urn: "urn:entity:tv_show" },
+  { id: "videogame", urn: "urn:entity:videogame" }
+];
+var QLOO_SEARCH_ENTITY_TYPES = [
+  ...QLOO_INSIGHTS_ENTITY_TYPES,
+  { id: "locality", urn: "urn:entity:locality" },
+  { id: "actor", urn: "urn:entity:actor" },
+  { id: "album", urn: "urn:entity:album" },
+  { id: "author", urn: "urn:entity:author" },
+  { id: "director", urn: "urn:entity:director" }
+];
+function buildEntityTypeAliases(entityTypes) {
+  const aliases = /* @__PURE__ */ new Map();
+  const urnById = new Map(entityTypes.map(({ id, urn }) => [id, urn]));
+  for (const entityType of entityTypes) {
+    aliases.set(entityType.id, entityType.urn);
+    aliases.set(entityType.urn, entityType.urn);
+    aliases.set(`${entityType.id}s`, entityType.urn);
+  }
+  const addAlias = (alias, id) => {
+    const urn = urnById.get(id);
+    if (urn)
+      aliases.set(alias, urn);
+  };
+  addAlias("people", "person");
+  addAlias("localities", "locality");
+  addAlias("tv", "tv_show");
+  addAlias("show", "tv_show");
+  addAlias("shows", "tv_show");
+  addAlias("tv show", "tv_show");
+  addAlias("tv shows", "tv_show");
+  addAlias("game", "videogame");
+  addAlias("games", "videogame");
+  addAlias("video game", "videogame");
+  addAlias("video games", "videogame");
+  return aliases;
+}
+var insightsEntityTypeByAlias = buildEntityTypeAliases(QLOO_INSIGHTS_ENTITY_TYPES);
+var searchEntityTypeByAlias = buildEntityTypeAliases(QLOO_SEARCH_ENTITY_TYPES);
+var operationSummaries = {
+  recommend: "Find entities for a taste profile, audience, or collection of signals.",
+  rank: "Rank a supplied set of options for signals, location, or audience.",
+  describe: "Resolve and describe one Qloo entity.",
+  where_popular: "Find geographic areas where an entity has comparatively strong affinity.",
+  compare_audiences: "Contrast two signal groups and identify shared or differentiating affinities.",
+  entity_tags: "Retrieve concepts and tags that characterize entities.",
+  audience_demographics: "Retrieve aggregate audience segments associated with an entity.",
+  trends: "Retrieve interest or trend information over a time range.",
+  find_tags: "Search the Qloo tag ontology by natural-language concept."
+};
+var QLOO_WORKFLOW_OPERATIONS = Object.freeze(QLOO_WORKFLOW_OPERATION_IDS.map((id) => Object.freeze({
+  id,
+  toolName: `qloo_${id}`,
+  summary: operationSummaries[id],
+  since: QLOO_TOOL_CATALOG_VERSION
+})));
+var upstreamLock = upstream_lock_default;
+var upstreamGetPaths = Object.freeze([
+  ...upstreamLock.expectations.getPaths
+]);
+var documentedExceptions = Object.freeze(upstreamLock.documentedExceptions.map((exception) => Object.freeze({ ...exception })));
+var QLOO_CAPABILITIES_TOOL = Object.freeze({
+  name: QLOO_CAPABILITIES_TOOL_NAME,
+  description: "Return the versioned Qloo workflow catalog and pinned upstream API contract metadata without making a network request.",
+  inputSchema: Object.freeze({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    additionalProperties: false,
+    properties: Object.freeze({
+      operation_ids: Object.freeze({
+        type: "array",
+        description: "Optional canonical operation IDs to include. Omit for the complete catalog.",
+        uniqueItems: true,
+        items: Object.freeze({
+          type: "string",
+          enum: QLOO_WORKFLOW_OPERATION_IDS
+        })
+      })
+    })
+  })
+});
+var operationIds = new Set(QLOO_WORKFLOW_OPERATION_IDS);
+function getQlooCapabilities(input = {}) {
+  const selected = input.operation_ids ? new Set(input.operation_ids) : void 0;
+  return {
+    contract_version: QLOO_TOOL_CATALOG_VERSION,
+    introspection_tool: QLOO_CAPABILITIES_TOOL_NAME,
+    operations: selected ? QLOO_WORKFLOW_OPERATIONS.filter(({ id }) => selected.has(id)) : QLOO_WORKFLOW_OPERATIONS,
+    upstream: {
+      documentation_url: upstreamLock.source.documentationUrl,
+      api_version: upstreamLock.source.apiVersion,
+      openapi_version: upstreamLock.source.openapiVersion,
+      production_server: upstreamLock.expectations.productionServer,
+      lock_sha256: upstreamLock.source.sha256,
+      get_paths: upstreamGetPaths,
+      documented_exceptions: documentedExceptions
+    }
+  };
+}
+
+// packages/qloo-tool-schema/dist/src/workflow-contracts.js
+import { createHash } from "node:crypto";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var QLOO_TOOL_DEFAULT_LIMIT = 10;
+var QLOO_TOOL_MAX_RESULTS = 20;
+var QLOO_TAG_BOOLEAN_OPERATORS = ["union", "intersection"];
+var insightsEntityTypeIds = QLOO_INSIGHTS_ENTITY_TYPES.map(({ id }) => id);
+var searchEntityTypeIds = QLOO_SEARCH_ENTITY_TYPES.map(({ id }) => id);
+var QLOO_INSIGHTS_ENTITY_TYPE_SCHEMA = Type.String({
+  enum: insightsEntityTypeIds,
+  description: `Qloo Insights entity type: ${insightsEntityTypeIds.join(", ")}.`
+});
+var QLOO_SEARCH_ENTITY_TYPE_SCHEMA = Type.String({
+  enum: searchEntityTypeIds,
+  description: `Qloo search entity type: ${searchEntityTypeIds.join(", ")}.`
+});
+var QLOO_TAG_BOOLEAN_OPERATOR_SCHEMA = Type.String({
+  enum: QLOO_TAG_BOOLEAN_OPERATORS,
+  description: "Combine tag values with union (any) or intersection (all)."
+});
+var QLOO_LIMIT_SCHEMA = Type.Optional(Type.Integer({
+  minimum: 1,
+  maximum: QLOO_TOOL_MAX_RESULTS,
+  default: QLOO_TOOL_DEFAULT_LIMIT,
+  description: `Maximum results to return (1-${QLOO_TOOL_MAX_RESULTS}).`
+}));
+var QLOO_ENTITY_INPUTS_SCHEMA = Type.Array(Type.String({ minLength: 1 }), {
+  minItems: 1,
+  maxItems: 10,
+  description: "Entity names or Qloo entity UUIDs. Keep one combined taste profile in one call."
+});
+var QLOO_TAG_INPUTS_SCHEMA = Type.Array(Type.String({ minLength: 1 }), {
+  minItems: 1,
+  maxItems: 10,
+  description: "Natural-language tag concepts or stable Qloo tag URNs."
+});
+var QLOO_DEMOGRAPHIC_SCHEMA = Type.String({
+  minLength: 1,
+  description: "Audience demographic in natural language, such as 'young women', 'men 25-34', or 'millennials'. It is converted to documented Qloo demographic signals.",
+  examples: ["young women", "men 25-34", "millennials"]
+});
+var QLOO_REQUEST_PREVIEW_SCHEMA = Type.Object({
+  method: Type.Literal("GET"),
+  path: Type.String({ minLength: 1 }),
+  query: Type.Unknown()
+}, { additionalProperties: false });
+var QLOO_RESULT_ENVELOPE_SCHEMA = Type.Object({
+  schema_version: Type.Literal(QLOO_TOOL_RESULT_SCHEMA_VERSION),
+  operation: Type.String(),
+  status: Type.Union([
+    Type.Literal("ok"),
+    Type.Literal("empty"),
+    Type.Literal("needs_input"),
+    Type.Literal("partial"),
+    Type.Literal("degraded"),
+    Type.Literal("error")
+  ]),
+  summary: Type.Optional(Type.String()),
+  interpretation: Type.Optional(Type.Unknown()),
+  results: Type.Optional(Type.Unknown()),
+  result_count: Type.Optional(Type.Integer({ minimum: 0 })),
+  warnings: Type.Optional(Type.Array(Type.String())),
+  query_intent: Type.Optional(Type.Unknown()),
+  error: Type.Optional(Type.Object({
+    code: Type.String(),
+    layer: Type.String(),
+    retryable: Type.Boolean(),
+    recovery: Type.String()
+  }, { additionalProperties: false })),
+  execution: Type.Object({
+    transport: Type.String({ enum: ["direct", "cli", "mcp"] }),
+    transport_name: Type.String(),
+    correlation_id: Type.String(),
+    duration_ms: Type.Number({ minimum: 0 })
+  }, { additionalProperties: false }),
+  provenance: Type.Optional(Type.Object({
+    source: Type.String(),
+    endpoint: Type.String(),
+    documentation: Type.String(),
+    transport: Type.Optional(Type.String()),
+    requests: Type.Optional(Type.Array(QLOO_REQUEST_PREVIEW_SCHEMA, {
+      maxItems: 20
+    }))
+  }, { additionalProperties: false }))
+}, { additionalProperties: true });
+var QLOO_WORKFLOW_INPUT_SCHEMAS = {
+  recommend: Type.Object({
+    target_type: QLOO_INSIGHTS_ENTITY_TYPE_SCHEMA,
+    signals: Type.Optional(QLOO_ENTITY_INPUTS_SCHEMA),
+    signal_tags: Type.Optional(QLOO_TAG_INPUTS_SCHEMA),
+    signal_tags_operator: Type.Optional(QLOO_TAG_BOOLEAN_OPERATOR_SCHEMA),
+    signal_location: Type.Optional(Type.String({ minLength: 1 })),
+    demographic: Type.Optional(QLOO_DEMOGRAPHIC_SCHEMA),
+    filter_location: Type.Optional(Type.String({ minLength: 1 })),
+    include_tags: Type.Optional(QLOO_TAG_INPUTS_SCHEMA),
+    include_tags_operator: Type.Optional(QLOO_TAG_BOOLEAN_OPERATOR_SCHEMA),
+    exclude_tags: Type.Optional(QLOO_TAG_INPUTS_SCHEMA),
+    exclude_tags_operator: Type.Optional(QLOO_TAG_BOOLEAN_OPERATOR_SCHEMA),
+    explain: Type.Optional(Type.Boolean({ default: true })),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false }),
+  rank: Type.Object({
+    options: QLOO_ENTITY_INPUTS_SCHEMA,
+    option_type: QLOO_INSIGHTS_ENTITY_TYPE_SCHEMA,
+    signals: Type.Optional(QLOO_ENTITY_INPUTS_SCHEMA),
+    signal_location: Type.Optional(Type.String({ minLength: 1 })),
+    demographic: Type.Optional(QLOO_DEMOGRAPHIC_SCHEMA),
+    include_tags: Type.Optional(QLOO_TAG_INPUTS_SCHEMA),
+    exclude_tags: Type.Optional(QLOO_TAG_INPUTS_SCHEMA)
+  }, { additionalProperties: false }),
+  describe: Type.Object({
+    entity: Type.String({ minLength: 1 }),
+    type: Type.Optional(QLOO_SEARCH_ENTITY_TYPE_SCHEMA)
+  }, { additionalProperties: false }),
+  where_popular: Type.Object({
+    entity: Type.String({ minLength: 1 }),
+    entity_type: Type.Optional(QLOO_SEARCH_ENTITY_TYPE_SCHEMA),
+    within: Type.String({
+      minLength: 1,
+      description: "Required geographic area that constrains the heatmap."
+    }),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false }),
+  compare_audiences: Type.Object({
+    group_a: QLOO_ENTITY_INPUTS_SCHEMA,
+    group_b: QLOO_ENTITY_INPUTS_SCHEMA,
+    target_type: Type.Optional(QLOO_INSIGHTS_ENTITY_TYPE_SCHEMA),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false }),
+  entity_tags: Type.Object({
+    entities: QLOO_ENTITY_INPUTS_SCHEMA,
+    entity_type: Type.Optional(QLOO_SEARCH_ENTITY_TYPE_SCHEMA),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false }),
+  audience_demographics: Type.Object({
+    entity: Type.String({ minLength: 1 }),
+    entity_type: Type.Optional(QLOO_SEARCH_ENTITY_TYPE_SCHEMA),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false }),
+  trends: Type.Object({
+    entities: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, maxItems: 5 }),
+    entity_type: QLOO_INSIGHTS_ENTITY_TYPE_SCHEMA,
+    start_date: Type.String({
+      pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+      description: "Inclusive start date in YYYY-MM-DD format."
+    }),
+    end_date: Type.String({
+      pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+      description: "Inclusive end date in YYYY-MM-DD format."
+    }),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false }),
+  find_tags: Type.Object({
+    query: Type.String({ minLength: 1 }),
+    semantic: Type.Optional(Type.Boolean({ default: true })),
+    limit: QLOO_LIMIT_SCHEMA
+  }, { additionalProperties: false })
+};
+var sharedWorkflowBehavior = Object.freeze({
+  readOnly: true,
+  idempotent: true,
+  mutating: false,
+  destructive: false,
+  openWorld: true,
+  concurrency: "safe_for_independent_inputs",
+  requiredCredential: "qloo_api",
+  defaultResultBudget: QLOO_TOOL_DEFAULT_LIMIT,
+  maximumResultBudget: QLOO_TOOL_MAX_RESULTS,
+  safeRetryClasses: Object.freeze(["dns", "connect", "timeout", "rate_limit", "upstream_5xx"]),
+  supportedTransports: Object.freeze(["direct", "mcp"])
+});
+var mediumLatencyOperations = /* @__PURE__ */ new Set([
+  "recommend",
+  "rank",
+  "compare_audiences",
+  "entity_tags",
+  "audience_demographics",
+  "trends"
+]);
+var QLOO_WORKFLOW_BEHAVIORS = Object.freeze(Object.fromEntries(Object.keys(QLOO_WORKFLOW_INPUT_SCHEMAS).map((operation) => [
+  operation,
+  Object.freeze({
+    ...sharedWorkflowBehavior,
+    expectedLatency: mediumLatencyOperations.has(operation) ? "medium" : "low"
+  })
+])));
+var QLOO_WORKFLOW_METADATA = {
+  recommend: {
+    toolName: "qloo_recommend",
+    label: "Qloo recommendations",
+    description: "Find Qloo entities related to one combined entity, tag, location, and demographic taste profile. Signals influence affinity; filters constrain output.",
+    promptSnippet: "Recommend entities from a combined Qloo taste profile",
+    promptGuidelines: [
+      "Pass every related taste and audience signal together in one qloo_recommend call.",
+      "Use signal_location for audience location and filter_location to constrain result geography.",
+      "Include demographic and location in the same call when both describe the audience."
+    ],
+    documentation: ["https://docs.qloo.com/reference/insights-api-deep-dive"]
+  },
+  rank: {
+    toolName: "qloo_rank",
+    label: "Qloo rank",
+    description: "Rank one supplied option set against one shared entity, location, demographic, and tag profile. Scores from separate calls are not comparable.",
+    promptSnippet: "Rank a caller-supplied shortlist with Qloo",
+    promptGuidelines: ["Pass every option in one qloo_rank call so scores remain comparable."],
+    documentation: ["https://docs.qloo.com/reference/insights-api-deep-dive"]
+  },
+  describe: {
+    toolName: "qloo_describe",
+    label: "Qloo entity",
+    description: "Resolve one named entity or Qloo UUID and return only metadata present in Qloo.",
+    promptSnippet: "Resolve and describe one Qloo entity",
+    documentation: ["https://docs.qloo.com/reference/get-search", "https://docs.qloo.com/reference/get-entities"]
+  },
+  where_popular: {
+    toolName: "qloo_where_popular",
+    label: "Qloo geographic affinity",
+    description: "Find geographic areas where one entity has strong query-relative affinity. This is distinct from filtering recommendations to a place.",
+    promptSnippet: "Find where an entity is comparatively popular",
+    documentation: ["https://docs.qloo.com/reference/heatmaps-use-case"]
+  },
+  compare_audiences: {
+    toolName: "qloo_compare_audiences",
+    label: "Qloo audience comparison",
+    description: "Compare two complete groups of entity signals in one Qloo analysis request.",
+    promptSnippet: "Compare two Qloo taste-signal groups",
+    documentation: ["https://docs.qloo.com/reference/analysis-compare"]
+  },
+  entity_tags: {
+    toolName: "qloo_entity_tags",
+    label: "Qloo entity tags",
+    description: "Retrieve Qloo concepts that jointly characterize one or more entities using the documented urn:tag Insights workflow.",
+    promptSnippet: "Find concepts that characterize Qloo entities",
+    documentation: ["https://docs.qloo.com/reference/taste-analysis"]
+  },
+  audience_demographics: {
+    toolName: "qloo_audience_demographics",
+    label: "Qloo audience demographics",
+    description: "Retrieve aggregate demographic distributions associated with one entity through the documented urn:demographics Insights workflow.",
+    promptSnippet: "Inspect aggregate demographics associated with a Qloo entity",
+    documentation: ["https://docs.qloo.com/reference/demographics-use-case"]
+  },
+  trends: {
+    toolName: "qloo_trends",
+    label: "Qloo trends",
+    description: "Retrieve Qloo time-series popularity metrics for one to five resolved entities over an ISO date range.",
+    promptSnippet: "Track Qloo entity popularity metrics over time",
+    documentation: ["https://docs.qloo.com/reference/get-trending"]
+  },
+  find_tags: {
+    toolName: "qloo_find_tags",
+    label: "Qloo tag search",
+    description: "Search Qloo's tag ontology by natural-language concept and return stable tag URNs.",
+    promptSnippet: "Search the Qloo tag ontology",
+    documentation: ["https://docs.qloo.com/reference/get-tags-1"]
+  }
+};
+var QLOO_WORKFLOW_CONTRACTS = Object.freeze(Object.fromEntries(Object.entries(QLOO_WORKFLOW_METADATA).map(([id, metadata]) => [
+  id,
+  Object.freeze({
+    id,
+    ...metadata,
+    behavior: QLOO_WORKFLOW_BEHAVIORS[id],
+    inputSchema: QLOO_WORKFLOW_INPUT_SCHEMAS[id],
+    resultSchema: QLOO_RESULT_ENVELOPE_SCHEMA
+  })
+])));
+var QLOO_ADAPTER_CONTRACT_MANIFEST_SCHEMA_VERSION = "1.1";
+function getQlooExecutableCapabilities(input = {}) {
+  const capabilities = getQlooCapabilities(input);
+  return {
+    ...capabilities,
+    result_schema_version: QLOO_TOOL_RESULT_SCHEMA_VERSION,
+    operations: capabilities.operations.map((operation) => {
+      const contract = QLOO_WORKFLOW_CONTRACTS[operation.id];
+      return {
+        ...operation,
+        input_schema: contract.inputSchema,
+        result_schema: contract.resultSchema,
+        documentation: contract.documentation,
+        behavior: contract.behavior
+      };
+    })
+  };
+}
+function getQlooAdapterContractManifest() {
+  const capabilities = getQlooExecutableCapabilities();
+  const contract = {
+    manifest_schema_version: QLOO_ADAPTER_CONTRACT_MANIFEST_SCHEMA_VERSION,
+    contract_version: capabilities.contract_version,
+    capabilities_tool: QLOO_CAPABILITIES_TOOL_NAME,
+    result_schema_version: capabilities.result_schema_version,
+    result_schema: QLOO_RESULT_ENVELOPE_SCHEMA,
+    operations: capabilities.operations.map((operation) => {
+      const contract2 = QLOO_WORKFLOW_CONTRACTS[operation.id];
+      return {
+        id: operation.id,
+        shared_tool_name: operation.toolName,
+        summary: operation.summary,
+        description: contract2.description,
+        input_schema: contract2.inputSchema,
+        behavior: contract2.behavior,
+        documentation: contract2.documentation
+      };
+    }),
+    upstream: capabilities.upstream
+  };
+  return {
+    ...contract,
+    contract_checksum: `sha256:${createHash("sha256").update(JSON.stringify(contract)).digest("hex")}`
+  };
+}
+function validationIssues(schema, value) {
+  return [...Value.Errors(schema, value)].slice(0, 20).map((issue) => ({
+    path: issue.keyword === "additionalProperties" && "additionalProperties" in issue.params && Array.isArray(issue.params.additionalProperties) && typeof issue.params.additionalProperties[0] === "string" ? `${issue.instancePath}/${issue.params.additionalProperties[0]}` : issue.instancePath || "/",
+    message: issue.message
+  }));
+}
+function validateQlooWorkflowResult(value) {
+  if (Value.Check(QLOO_RESULT_ENVELOPE_SCHEMA, value)) {
+    return { ok: true, value };
+  }
+  return { ok: false, issues: validationIssues(QLOO_RESULT_ENVELOPE_SCHEMA, value) };
+}
+
+// packages/qloo-tool-schema/dist/src/resolution-contracts.js
+import { Type as Type2 } from "typebox";
+var QLOO_RESOLUTION_CONTRACT_VERSION = "1.0-preview.1";
+var QLOO_RESOLUTION_PROVIDER_DESCRIPTOR_SCHEMA = Type2.Object({
+  contract_version: Type2.Literal(QLOO_RESOLUTION_CONTRACT_VERSION),
+  provider_id: Type2.String({ minLength: 1 }),
+  name: Type2.String({ minLength: 1 }),
+  entity_strategy: Type2.String({ minLength: 1 }),
+  tag_strategy: Type2.String({ minLength: 1 }),
+  remote: Type2.Boolean(),
+  uses_model: Type2.Boolean(),
+  fallback: Type2.Literal("none")
+}, { additionalProperties: false });
+var QLOO_RESOLUTION_CANDIDATE_SCHEMA = Type2.Object({
+  id: Type2.String({ minLength: 1 }),
+  name: Type2.String({ minLength: 1 }),
+  type: Type2.Optional(Type2.String({ minLength: 1 })),
+  rank: Type2.Optional(Type2.Integer({ minimum: 1 })),
+  score: Type2.Optional(Type2.Number()),
+  popularity: Type2.Optional(Type2.Number()),
+  parent_types: Type2.Optional(Type2.Array(Type2.String({ minLength: 1 }), {
+    maxItems: 20,
+    uniqueItems: true
+  })),
+  description: Type2.Optional(Type2.String({ minLength: 1, maxLength: 500 })),
+  release_year: Type2.Optional(Type2.Integer()),
+  address: Type2.Optional(Type2.Unknown())
+}, { additionalProperties: false });
+var QLOO_RESOLUTION_PROVENANCE_SCHEMA = Type2.Object({
+  contract_version: Type2.Literal(QLOO_RESOLUTION_CONTRACT_VERSION),
+  provider_id: Type2.String({ minLength: 1 }),
+  provider_name: Type2.String({ minLength: 1 }),
+  endpoint: Type2.String({ minLength: 1 }),
+  strategy: Type2.String({ minLength: 1 }),
+  remote: Type2.Boolean(),
+  uses_model: Type2.Boolean(),
+  provider_version: Type2.Optional(Type2.String({ minLength: 1 })),
+  cache_status: Type2.Optional(Type2.String({ minLength: 1 }))
+}, { additionalProperties: false });
+var QLOO_RESOLUTION_OUTCOME_COMMON_SCHEMA = {
+  input: Type2.String({ minLength: 1 }),
+  provenance: QLOO_RESOLUTION_PROVENANCE_SCHEMA,
+  warnings: Type2.Optional(Type2.Array(Type2.String()))
+};
+var QLOO_RESOLUTION_OUTCOME_SCHEMA = Type2.Union([
+  Type2.Object({
+    ...QLOO_RESOLUTION_OUTCOME_COMMON_SCHEMA,
+    status: Type2.Literal("resolved"),
+    match: Type2.Union([
+      Type2.Literal("identifier"),
+      Type2.Literal("exact"),
+      Type2.Literal("semantic")
+    ]),
+    selected: QLOO_RESOLUTION_CANDIDATE_SCHEMA,
+    alternatives: Type2.Optional(Type2.Array(QLOO_RESOLUTION_CANDIDATE_SCHEMA))
+  }, { additionalProperties: false }),
+  Type2.Object({
+    ...QLOO_RESOLUTION_OUTCOME_COMMON_SCHEMA,
+    status: Type2.Literal("ambiguous"),
+    candidates: Type2.Array(QLOO_RESOLUTION_CANDIDATE_SCHEMA)
+  }, { additionalProperties: false }),
+  Type2.Object({
+    ...QLOO_RESOLUTION_OUTCOME_COMMON_SCHEMA,
+    status: Type2.Literal("not_found"),
+    candidates: Type2.Optional(Type2.Array(QLOO_RESOLUTION_CANDIDATE_SCHEMA))
+  }, { additionalProperties: false })
+]);
+
+// apps/qloo-harness/dist/mcp.js
+import { createQlooToolsFromEnvironment } from "./qloo-tools.js";
+var QLOO_MCP_CONTRACT_RESOURCE_URI = "qloo://contracts/workflows";
+var QLOO_MCP_HELP = `Start the canonical Qloo MCP stdio server
+
+Usage:
+  qloo mcp
+
+The server exposes qloo_capabilities and the nine shared Qloo workflow tools.
+Use qloo api mcp only when you explicitly need the legacy endpoint-shaped server.`;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function adapterCapabilities(manifest, executableOperationIds, argumentsValue) {
+  const argumentsRecord = isRecord(argumentsValue) ? argumentsValue : {};
+  const knownIds = new Set(manifest.operations.map(({ id }) => id));
+  const requestedValues = argumentsRecord.operation_ids;
+  const requested = requestedValues === void 0 ? knownIds : new Set(Array.isArray(requestedValues) ? requestedValues.filter((value) => typeof value === "string") : []);
+  if (requestedValues !== void 0 && !Array.isArray(requestedValues)) {
+    throw new Error("operation_ids must be an array of canonical workflow operation IDs.");
+  }
+  const unknown = [...requested].filter((id) => !knownIds.has(id)).sort();
+  if (unknown.length > 0) {
+    throw new Error(`Unknown Qloo workflow operation IDs: ${unknown.join(", ")}`);
+  }
+  const supportedOperationIds = manifest.operations.map(({ id }) => id).filter((id) => executableOperationIds.has(id));
+  return {
+    ...manifest,
+    adapter: {
+      id: "qloo_harness_mcp",
+      compatibility: "canonical",
+      canonical_workflow_execution: supportedOperationIds.length === manifest.operations.length,
+      ready: supportedOperationIds.length === manifest.operations.length,
+      supported_operation_ids: supportedOperationIds,
+      capabilities_tool: QLOO_CAPABILITIES_TOOL_NAME,
+      contract_resource: QLOO_MCP_CONTRACT_RESOURCE_URI,
+      tool_name_mapping: Object.fromEntries(manifest.operations.map(({ id, shared_tool_name }) => [id, shared_tool_name])),
+      fallback: "none"
+    },
+    operations: manifest.operations.filter(({ id }) => requested.has(id))
+  };
+}
+function capabilitiesOutputSchema() {
+  return {
+    type: "object",
+    required: [
+      "manifest_schema_version",
+      "contract_version",
+      "contract_checksum",
+      "result_schema_version",
+      "adapter",
+      "operations"
+    ],
+    properties: {
+      manifest_schema_version: { type: "string" },
+      contract_version: { type: "string" },
+      contract_checksum: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" },
+      result_schema_version: { type: "string" },
+      adapter: { type: "object" },
+      operations: { type: "array" }
+    },
+    additionalProperties: true
+  };
+}
+function mcpToolDefinitions(manifest) {
+  const contractMetadata = {
+    "qloo/contractVersion": manifest.contract_version,
+    "qloo/contractChecksum": manifest.contract_checksum
+  };
+  return [
+    {
+      name: QLOO_CAPABILITIES_TOOL_NAME,
+      title: "Inspect Qloo MCP capabilities",
+      description: "Inspect the canonical Qloo workflow contract, checksum, and this server's exact execution readiness without contacting Qloo.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          operation_ids: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: manifest.operations.map(({ id }) => id)
+            },
+            uniqueItems: true,
+            maxItems: manifest.operations.length
+          }
+        },
+        additionalProperties: false
+      },
+      outputSchema: capabilitiesOutputSchema(),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      _meta: contractMetadata
+    },
+    ...manifest.operations.map((operation) => ({
+      name: operation.shared_tool_name,
+      title: operation.summary,
+      description: operation.description,
+      inputSchema: operation.input_schema,
+      outputSchema: manifest.result_schema,
+      annotations: {
+        readOnlyHint: operation.behavior.readOnly,
+        destructiveHint: operation.behavior.destructive,
+        idempotentHint: operation.behavior.idempotent,
+        openWorldHint: operation.behavior.openWorld
+      },
+      _meta: contractMetadata
+    }))
+  ];
+}
+function respond(writeOut, id, result) {
+  const response = { jsonrpc: "2.0", id, result };
+  writeOut(`${JSON.stringify(response)}
+`);
+}
+function respondError(writeOut, id, code, message, data) {
+  const response = {
+    jsonrpc: "2.0",
+    id,
+    error: { code, message, ...data === void 0 ? {} : { data } }
+  };
+  writeOut(`${JSON.stringify(response)}
+`);
+}
+function toolResult(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    structuredContent: result,
+    ...result.status === "error" ? { isError: true } : {}
+  };
+}
+function canonicalMcpResult(result) {
+  const execution = isRecord(result.execution) ? result.execution : {};
+  const provenance = isRecord(result.provenance) ? result.provenance : void 0;
+  const normalized = {
+    ...result,
+    execution: {
+      ...execution,
+      transport: "mcp",
+      transport_name: "Qloo canonical MCP"
+    },
+    ...provenance ? { provenance: { ...provenance, transport: "mcp" } } : {}
+  };
+  const validation = validateQlooWorkflowResult(normalized);
+  if (!validation.ok) {
+    const issues = validation.issues.map(({ path, message }) => `${path}: ${message}`).join("; ");
+    throw new Error(`Canonical MCP result failed the shared contract: ${issues}`);
+  }
+  return validation.value;
+}
+function unavailableResult(operation, correlationId) {
+  return {
+    schema_version: QLOO_TOOL_RESULT_SCHEMA_VERSION,
+    operation,
+    status: "error",
+    summary: "Qloo workflow execution requires a configured Qloo API credential.",
+    results: [],
+    result_count: 0,
+    error: {
+      code: "QLOO_AUTH",
+      layer: "qloo",
+      retryable: false,
+      recovery: "Run qloo setup or set QLOO_API_KEY, then restart the MCP server."
+    },
+    execution: {
+      transport: "mcp",
+      transport_name: "Qloo canonical MCP",
+      correlation_id: correlationId,
+      duration_ms: 0
+    }
+  };
+}
+function unexpectedFailureResult(operation, correlationId) {
+  return {
+    schema_version: QLOO_TOOL_RESULT_SCHEMA_VERSION,
+    operation,
+    status: "error",
+    summary: "The Qloo MCP adapter failed before returning a workflow result.",
+    results: [],
+    result_count: 0,
+    error: {
+      code: "MCP_ADAPTER_FAILURE",
+      layer: "harness",
+      retryable: false,
+      recovery: "Run qloo doctor --network and inspect the local redacted trace."
+    },
+    execution: {
+      transport: "mcp",
+      transport_name: "Qloo canonical MCP",
+      correlation_id: correlationId,
+      duration_ms: 0
+    }
+  };
+}
+function startCanonicalMcpServer(options = {}) {
+  const manifest = getQlooAdapterContractManifest();
+  const tools = options.tools ?? createQlooToolsFromEnvironment({ env: options.env ?? process.env });
+  const executableTools = new Map(tools.filter((tool) => tool.name !== QLOO_CAPABILITIES_TOOL_NAME).map((tool) => [tool.name, tool]));
+  const operationByToolName = new Map(manifest.operations.map((operation) => [operation.shared_tool_name, operation.id]));
+  const executableOperationIds = new Set(manifest.operations.filter(({ shared_tool_name }) => executableTools.has(shared_tool_name)).map(({ id }) => id));
+  const definitions = mcpToolDefinitions(manifest);
+  const writeOut = options.writeOut ?? ((value) => process.stdout.write(value));
+  const readline = createInterface({ input: options.input ?? process.stdin, terminal: false });
+  readline.on("line", async (line) => {
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      respondError(writeOut, null, -32700, "Parse error");
+      return;
+    }
+    const id = request.id ?? null;
+    try {
+      switch (request.method) {
+        case "initialize":
+          respond(writeOut, id, {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {}, resources: {} },
+            serverInfo: {
+              name: "qloo-harness",
+              version: options.serverVersion ?? "development"
+            }
+          });
+          return;
+        case "notifications/initialized":
+        case "notifications/cancelled":
+          return;
+        case "ping":
+          respond(writeOut, id, {});
+          return;
+        case "tools/list":
+          respond(writeOut, id, { tools: definitions });
+          return;
+        case "resources/list":
+          respond(writeOut, id, {
+            resources: [{
+              uri: QLOO_MCP_CONTRACT_RESOURCE_URI,
+              name: "qloo_workflow_contract",
+              title: "Qloo workflow contract",
+              description: "Canonical Qloo workflow schemas and MCP adapter readiness.",
+              mimeType: "application/json"
+            }]
+          });
+          return;
+        case "resources/read": {
+          const uri = isRecord(request.params) ? request.params.uri : void 0;
+          if (uri !== QLOO_MCP_CONTRACT_RESOURCE_URI) {
+            respondError(writeOut, id, -32602, "Unknown Qloo MCP resource.");
+            return;
+          }
+          const capabilities = adapterCapabilities(manifest, executableOperationIds, {});
+          respond(writeOut, id, {
+            contents: [{
+              uri: QLOO_MCP_CONTRACT_RESOURCE_URI,
+              mimeType: "application/json",
+              text: JSON.stringify(capabilities)
+            }]
+          });
+          return;
+        }
+        case "tools/call": {
+          const toolName = isRecord(request.params) ? request.params.name : void 0;
+          const argumentsValue = isRecord(request.params) ? request.params.arguments : void 0;
+          if (typeof toolName !== "string") {
+            respondError(writeOut, id, -32602, "tools/call requires a tool name.");
+            return;
+          }
+          if (toolName === QLOO_CAPABILITIES_TOOL_NAME) {
+            try {
+              const result = adapterCapabilities(manifest, executableOperationIds, argumentsValue);
+              respond(writeOut, id, toolResult(result));
+            } catch (error) {
+              respond(writeOut, id, {
+                content: [{
+                  type: "text",
+                  text: error instanceof Error ? error.message : String(error)
+                }],
+                isError: true
+              });
+            }
+            return;
+          }
+          const operation = operationByToolName.get(toolName);
+          if (!operation) {
+            respondError(writeOut, id, -32602, `Unknown Qloo MCP tool: ${toolName}`);
+            return;
+          }
+          const correlationId = `mcp-${id === null ? "request" : String(id)}`;
+          const tool = executableTools.get(toolName);
+          if (!tool) {
+            respond(writeOut, id, toolResult(unavailableResult(operation, correlationId)));
+            return;
+          }
+          try {
+            const result = await tool.execute(correlationId, isRecord(argumentsValue) ? argumentsValue : {}, void 0, void 0, {});
+            if (!isRecord(result.details)) {
+              throw new Error(`${toolName} returned no structured workflow result.`);
+            }
+            respond(writeOut, id, toolResult(canonicalMcpResult(result.details)));
+          } catch {
+            respond(writeOut, id, toolResult(unexpectedFailureResult(operation, correlationId)));
+          }
+          return;
+        }
+        default:
+          respondError(writeOut, id, -32601, `Method not found: ${request.method}`);
+      }
+    } catch {
+      respondError(writeOut, id, -32603, "Internal Qloo MCP adapter error.");
+    }
+  });
+  return readline;
+}
+function runQlooMcp(argv, options = {}) {
+  if (argv.length === 1 && (argv[0] === "--help" || argv[0] === "-h")) {
+    (options.writeOut ?? ((value) => process.stdout.write(value)))(`${QLOO_MCP_HELP}
+`);
+    return 0;
+  }
+  if (argv.length > 0)
+    return 2;
+  startCanonicalMcpServer(options);
+  return 0;
+}
+export {
+  QLOO_MCP_CONTRACT_RESOURCE_URI,
+  QLOO_MCP_HELP,
+  runQlooMcp,
+  startCanonicalMcpServer
+};