| """Exploratory-only cap extension of the baseline raw Inspect adapter.""" |
| from inspect_ai.model import ModelAPI, ModelOutput, ModelUsage, ChatCompletionChoice, ChatMessageAssistant, modelapi |
| from encoding_tax.common import ROOT, GateError, load_config, digest |
| from encoding_tax.tokenization import tokenizer |
| from encoding_tax.transport import RawTransport, usage_record, response_text, upstream_evidence |
|
|
| class E6ExploratoryAPI(ModelAPI): |
| def __init__(self, model_name, base_url=None, api_key=None, config=None, study_config="configs/study.json", audit_dir="artifacts/preflight/inspect-transport", **kwargs): |
| super().__init__(model_name, base_url, api_key, config=config) |
| self.study = load_config(study_config) |
| if model_name not in self.study["models"]: |
| raise GateError(f"Unknown pinned model alias: {model_name}") |
| self.profile = self.study["models"][model_name] |
| self.transport = RawTransport(self.profile, audit_dir, config.max_connections or 16) |
| self.tok = tokenizer(self.profile["tokenizer_repo"], self.profile["tokenizer_revision"]) if self.profile.get("tokenizer_repo") else None |
|
|
| from extensions.e6_exploratory_v2.design import require_extension |
| cfg,base,pin=require_extension() |
| if self.study!=base:raise GateError('Extension requires the pinned baseline profiles') |
| self.extension_ref={'path':'extensions/e6_exploratory_v2/freeze.json','sha256':digest(ROOT/'extensions/e6_exploratory_v2/freeze.json')} |
|
|
| def max_connections(self): |
| return 16 |
|
|
| def connection_key(self): |
| |
| |
| return f"{self.model_name}:{self.profile['provider']}" |
|
|
| def should_retry(self, ex): |
| |
| return False |
|
|
| async def generate(self, input, tools, tool_choice, config): |
| if len(input) != 1 or tools or not isinstance(input[0].content, str): |
| raise GateError("Raw adapter requires a single already serialized prompt and no tools") |
| if config.max_tokens not in (48, 256, 512, 1024, 2048): |
| raise GateError("Unregistered output cap") |
| prompt = input[0].content |
| if self.tok and self.profile.get("context_length") and self.tok.count(prompt) + config.max_tokens > self.profile["context_length"]: |
| raise GateError("Prompt exceeds pinned context; clipping is forbidden") |
| phase = "answer" if config.max_tokens == self.study.get("answer_cap",8) else "source" if config.max_tokens == 4096 else "scratchpad" |
| response, audit = await self.transport.complete(prompt, config.max_tokens, config.stop_seqs or [], phase, metadata={"exploratory_e6": self.extension_ref}) |
| if self.profile.get("review",{}).get("raw_upstream") and not upstream_evidence(response,prompt)["exact_prompt_forwarded"]: |
| raise GateError("Reviewed raw route changed its upstream serialization") |
| choice = response["choices"][0] |
| text = response_text(response, reasoning=self.profile.get('native_reasoning',False) and phase in ('source','scratchpad')) |
| metrics = usage_record(response, self.tok, text) |
| content=choice.get("message",choice) |
| if phase=="answer" and (metrics["reasoning_tokens"] is None or metrics["reasoning_tokens"]!=0 or content.get("reasoning") or content.get("reasoning_details")): |
| raise GateError("Answer-phase reasoning is missing, nonzero, or inconsistent with the visible response; audit retained") |
| if metrics["completion_tokens"] is not None and metrics["completion_tokens"]>config.max_tokens: |
| raise GateError("Provider exceeded the requested completion cap") |
| if self.tok and self.profile.get("review",{}).get("native_tokens"): |
| difference=metrics["prompt_tokens"]-self.tok.count(prompt) if metrics["prompt_tokens"] is not None else None |
| if difference!=self.profile["review"].get("native_prompt_offset"): |
| raise GateError("Native/provider prompt counts differ from the reviewed constant offset") |
| usage = None |
| if metrics["prompt_tokens"] is not None and metrics["completion_tokens"] is not None: |
| usage = ModelUsage(input_tokens=metrics["prompt_tokens"], output_tokens=metrics["completion_tokens"], total_tokens=metrics["prompt_tokens"]+metrics["completion_tokens"], reasoning_tokens=metrics["reasoning_tokens"], input_tokens_cache_read=metrics["cache_tokens"], total_cost=metrics["cost"]) |
| stop = "max_tokens" if choice.get("finish_reason") == "length" else "stop" |
| return ModelOutput(model=self.model_name, choices=[ChatCompletionChoice(message=ChatMessageAssistant(content=text), stop_reason=stop)], usage=usage, metadata={**metrics, "response": response, "audit": audit, "prompt_sha256": digest(prompt), "native_prompt_tokens": self.tok.count(prompt) if self.tok else None, "requested_budget": config.max_tokens}) |
|
|
| registered_api = modelapi(name='encoding_tax_e6x2')(E6ExploratoryAPI) |
|
|
