"""Released environment operations and snapshot validation.""" from __future__ import annotations from copy import deepcopy as ext_deepcopy from datetime import date as ext_date from datetime import datetime as ext_datetime from functools import lru_cache from pathlib import Path as ext_Path from rescopebench.public_projection import digest as ext_digest from typing import Any as ext_Any from typing import Mapping as ext_Mapping import hashlib as mod_hashlib import importlib as mod_importlib import json as mod_json import jsonschema as mod_jsonschema import sys as mod_sys from .spec import CASE_DIR, DATA_INITIAL, DATA_SCHEDULE_2, DATA_TASK_IDS, DATA_TOOL_BY_NAME, DATA_WRITE_TOOLS, DATA_GROUP_B, DATA_GROUP_A, DATA_CHANGED_RESOURCE_ATOMS, DATA_PRE_RESOURCE_AUTHORITY, DATA_POST_RESOURCE_AUTHORITY, DATA_TOOLS_2, DATA_LANE_BY_ATOM, DATA_ATOMS, DATA_INITIAL_2, DATA_ENTITY_ID_FIELDS, DATA_READ_COSTS, DATA_INITIAL_3, DATA_WEIGHTS, DATA_LAYOUTS, DATA_INITIAL_FIXTURE, DATA_TASK_TARGET_ORDER, DATA_TASK_IDS_2, DATA_POST_RESOURCE_AUTHORITY_2, DATA_PRE_RESOURCE_AUTHORITY_2 def fn_targets(task_id): rows = ext_deepcopy(fn_targets_2(task_id)) step = (int(task_id[1:]) - 1) % 8 for row in rows: atom = row['resource_atom'] lane = DATA_LANE_BY_ATOM[atom] base = lane['passenger']['seat_position'] route = DATA_ATOMS.index(atom) flip = step // 4 ^ (step % 2 if route < 2 else step // 2 % 2) position = {'window': 'aisle', 'aisle': 'window'}[base] if flip else base row['passengers'][0]['seat_position'] = position epoch = fn_service_version(atom, int(task_id[1:])) row['service_id'] = next((service for (i, service) in enumerate(fn_candidates(atom, epoch)) if fn_allocation(atom, epoch, i) == position)) return rows def fn_public_task(task_id): packet = ext_deepcopy(fn_public_task_2(task_id)) for (public, private) in zip(packet['targets'], fn_targets(task_id), strict=True): public['requested_position'] = private['passengers'][0]['seat_position'] if task_id != 'T01': packet['event_id'] = 'evt-' + ext_digest(['railway-balanced-walk-evolution-v8', task_id, packet['targets']])[:20] return packet def fn_grade_bookings(initial, final, requested): delivered = {**final, 'booking_order': [r for r in final['booking_order'] if r.get('order_status') == 'confirmed']} return fn_grade_bookings_2(initial, delivered, requested) def fn__error(code, message, **data): return {'status': 'error', 'data': {'error_code': code, **data}, 'message': message} def fn_dispatch(self, name, arguments, actor='rail_booking_agent'): if self._task_id is None: return fn__error('TASK_NOT_ACTIVE', 'activate a task before dispatch') tool = DATA_TOOL_BY_NAME.get(name) if tool is None: return fn__error('TOOL_FORBIDDEN', 'tool is not in the learner allowlist') if actor != 'rail_booking_agent': return fn__error('ROLE_FORBIDDEN', 'actor is not the railway booking role') try: mod_jsonschema.validate(arguments, tool['input_schema']) except mod_jsonschema.ValidationError: return fn__error('INVALID_ARGUMENTS', 'arguments do not match the strict public schema') if self._calls >= 16: result = fn__error('CALL_GUARD_EXHAUSTED', 'the call guard is exhausted') result['budget'] = {'charged': 0, 'remaining': self.remaining} return result if name in DATA_WRITE_TOOLS and self._writes >= 16: result = fn__error('WRITE_GUARD_EXHAUSTED', 'the write-attempt guard is exhausted') result['budget'] = {'charged': 0, 'remaining': self.remaining} return result cost = 3 if name in DATA_WRITE_TOOLS else DATA_READ_COSTS[name] if cost > self.remaining: result = fn__error('WORK_QUOTA_EXHAUSTED', 'the remaining railway work quota cannot admit this call') result['budget'] = {'charged': 0, 'remaining': self.remaining} return result before = self._state.snapshot() before_hash = fn__canonical_hash(before) prepared = ext_deepcopy(arguments) max_seats = prepared.pop('max_seats', 4) if name == 'inspect_seat_map' else None if name == 'create_booking_order': target = self._target_for_segment(arguments) if target is not None and (not self._has_service_provenance(target, str(arguments.get('train_service_id') or ''))): conflict = self._latest_conflict(target['resource_atom']) code = 'SERVICE_BINDING_REVALIDATION_REQUIRED' if conflict is not None else 'UNOBSERVED_SERVICE_BINDING' result = fn__error(code, 'the exact service binding must come from a public direct-service result for this journey') return self._finish(name, arguments, actor, result, cost, before_hash) try: preflight = self._preflight_submit(prepared) if name == 'submit_booking_order' else None if preflight is not None: result = preflight else: result = fn__normalize_result(getattr(self._logic, name)(state_manager=self._state, **prepared)) if result.get('status') == 'success' and name == 'create_booking_order': order_id = result['data']['order_id'] self._state.update_entity('booking_order', order_id, {'booking_order_id': order_id}, id_field='order_id') if result.get('status') == 'success' and max_seats is not None: result['data']['seats'] = result['data'].get('seats', [])[:int(max_seats)] if result.get('status') == 'success' and name in DATA_WRITE_TOOLS: self._assert_invariants() except Exception: result = fn__error('ADAPTER_EXECUTION_FAILED', 'operation failed without changing business state') if result.get('status') != 'success' and name in DATA_WRITE_TOOLS: self._state.restore(before) result = self._finish(name, arguments, actor, result, cost, before_hash) if name == 'search_direct_trains': self._record_service_observations(arguments, result) elif name == 'create_booking_order' and result.get('data', {}).get('error_code') == 'SERVICE_NOT_SELLABLE': target = self._target_for_segment(arguments) if target is not None: self.service_conflicts.append({'resource_lane_ref': target['resource_atom'], 'stale_train_service_id': arguments['train_service_id'], 'task_id': self._task_id, 'receipt_index': result['receipt_index']}) return result def fn_candidates(atom, epoch): return [fn_identifier('svc', atom, epoch, choice) for choice in range(4)] def fn__is_int(value): return type(value) is int def fn__canonical(value): return mod_json.dumps(value, ensure_ascii=True, sort_keys=True, separators=(',', ':'), allow_nan=False) def fn__canonical_hash(value): payload = mod_json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True).encode('ascii') return mod_hashlib.sha256(payload).hexdigest() def fn_targets_2(task_id): rows = fn_targets_4(task_id) for row in rows: atom = row['resource_atom'] epoch = fn_service_version(atom, int(task_id[1:])) row['service_id'] = next((service for (index, service) in enumerate(fn_candidates(atom, epoch)) if fn_allocation(atom, epoch, index) == row['passengers'][0]['seat_position'])) return rows def fn_service_version(atom, position): current = fn_phase(position) return (2 if current >= 3 else 1 if current >= 1 else 0) if atom in DATA_GROUP_A else 1 if current >= 2 else 0 def fn_allocation(atom, epoch, index): order = sorted(range(4), key=lambda i: mod_hashlib.sha256(mod_json.dumps(['railway-local-inventory-v1', atom, epoch, i], separators=(',', ':')).encode()).digest()) return 'window' if index in order[:2] else 'aisle' def fn_public_task_2(task_id): packet = fn_public_task_3(task_id) for limit in packet['budget']['limits']: if limit['resource'] == 'write_attempts': limit['allowance'] = 16 packet['budget']['charging'].append('The write-attempt safety limit is derived from the work allowance divided by the admitted-mutation charge; it does not grant additional work units.') return packet def fn_grade_bookings_2(initial, final, requested): """Score one coherent delivered order, never combine milestones across orders.""" old_orders = {r['order_id'] for r in initial['booking_order']} old_tickets = {r['ticket_id'] for r in initial['ticket']} seats = {r['seat_id']: r for r in final['seat']} services = {r['train_service_id']: r for r in final['train_service']} rows = [] for target in requested: wanted = {r['passenger_id']: r['seat_position'] for r in target['passengers']} options = [] for order in final['booking_order']: if order['order_id'] in old_orders or order.get('requester_passenger_id') not in wanted or order.get('origin_station_id') != target['origin_station_id'] or (order.get('destination_station_id') != target['destination_station_id']) or (order.get('travel_date') != target['travel_date']): continue service = services.get(order.get('train_service_id'), {}) stops = {r['station_id']: r['stop_sequence'] for r in final['train_stop'] if r['train_service_id'] == service.get('train_service_id')} journey = bool(service and service.get('travel_date') == target['travel_date'] and (service.get('status') in {'scheduled', 'delayed', 'boarding'}) and (target['origin_station_id'] in stops) and (target['destination_station_id'] in stops) and (stops[target['origin_station_id']] < stops[target['destination_station_id']])) fare = order.get('special_ticket_type') eligible = fare in {'none', 'student', 'disabled'} and all((fn__valid_credential(final['verification_credential'], p, fare, target['travel_date']) for p in wanted)) tickets = [r for r in final['ticket'] if r['order_id'] == order['order_id'] and r['ticket_id'] not in old_tickets and (r.get('ticket_status') == 'confirmed')] bound = len(tickets) == len(wanted) and {r['passenger_id'] for r in tickets} == set(wanted) and (len({r.get('seat_id') for r in tickets}) == len(wanted)) physical = bound and all((t.get('train_service_id') == service.get('train_service_id') and t.get('origin_station_id') == target['origin_station_id'] and (t.get('destination_station_id') == target['destination_station_id']) and (t.get('seat_class') == target['seat_class']) and (seats.get(t.get('seat_id'), {}).get('train_service_id') == t.get('train_service_id')) and (seats.get(t.get('seat_id'), {}).get('seat_class') == t.get('seat_class')) and (seats.get(t.get('seat_id'), {}).get('availability_status') == 'sold') and (seats.get(t.get('seat_id'), {}).get('passenger_id') == t['passenger_id']) and (seats.get(t.get('seat_id'), {}).get('ticket_id') == t['ticket_id']) for t in tickets)) holds = [r for r in final['seat_hold'] if r.get('order_id') == order['order_id']] custody = physical and (not any((h.get('status') == 'active' for h in holds))) and all((seats[t['seat_id']].get('seat_position') == wanted[t['passenger_id']] for t in tickets)) milestones = dict(zip(DATA_WEIGHTS, (journey and eligible and (set(order.get('passenger_ids', [])) == set(wanted)), journey and eligible, journey and custody, journey and physical and (order.get('order_status') == 'confirmed') and bool(order.get('payment_reference'))))) options.append({'order_id': order['order_id'], 'milestones': milestones, 'state_delta_present': True, 'complete': all(milestones.values()), 'score': sum((weight for (name, weight) in DATA_WEIGHTS.items() if milestones[name]))}) row = max(options, key=lambda r: (r['score'], r['order_id'])) if options else {'order_id': None, 'milestones': {name: False for name in DATA_WEIGHTS}, 'state_delta_present': False, 'complete': False, 'score': 0.0} rows.append({**row, 'artifact_id': target['artifact_id'], 'request_id': target['request_id']}) return {'score': sum((r['score'] for r in rows)), 'max_score': 100.0, 'completed_artifacts': sum((r['complete'] for r in rows)), 'targets': rows} def fn__normalize_result(result): normalized = ext_deepcopy(result) normalized.setdefault('data', {}) normalized.setdefault('message', '') if normalized.get('status') == 'error' and 'error_code' not in normalized['data']: message = str(normalized.get('message') or '') normalized['data']['error_code'] = message.split(':', 1)[0] if ':' in message else 'OPERATION_FAILED' return normalized def fn_identifier(kind, atom, epoch, choice, *parts): return kind + '_' + ext_digest(['railway-seat-choice-evolution-v4', atom, epoch, choice, *parts])[:16] def fn_targets_3(task_id): rows = fn_targets_4(task_id) for row in rows: atom = row['resource_atom'] epoch = fn_service_version(atom, int(task_id[1:])) position = row['passengers'][0]['seat_position'] row['service_id'] = next((service for (choice, service) in enumerate(fn_candidates(atom, epoch)) if fn_allocation_2(atom, epoch, choice) == position)) return rows def fn_public_task_3(task_id): packet = fn_public_task_4(task_id) packet['objective'] += ' Any sellable direct service meeting the stated journey and actual seat requirements is acceptable; there is no required train identifier. Only one new booking per request is counted. General class availability does not guarantee availability of a particular seat position.' packet['event_id'] = 'evt-' + ext_digest(['railway-seat-choice-evolution-v4', task_id, packet['targets']])[:20] return packet def fn_targets_4(task_id): rows = fn_targets_5(task_id) if task_id == 'T01': return rows step = (int(task_id[1:]) - 1) % 8 by_atom = {row['resource_atom']: row for row in rows} offset = step // 2 % 4 order = DATA_ATOMS[offset:] + DATA_ATOMS[:offset] output = [] for (slot, atom) in enumerate(order, 1): index = DATA_ATOMS.index(atom) row = by_atom[atom] passenger_atom = DATA_ATOMS[(index + step % 4) % 4] passenger = ext_deepcopy(DATA_LANE_BY_ATOM[passenger_atom]['passenger']) seat = DATA_LANE_BY_ATOM[atom]['passenger']['seat_position'] passenger['seat_position'] = seat if step < 4 else {'window': 'aisle', 'aisle': 'window'}[seat] row['passengers'] = [passenger] row['artifact_id'] = f'{task_id}-A{slot}' row['request_id'] = 'RQ-' + ext_digest(['railway-recombination-lifecycle-evolution-v3', task_id, slot])[:18] output.append(row) return output def fn_phase(position): return sum((position >= e['before_task'] for e in DATA_SCHEDULE_2['events'])) def fn__valid_credential(credentials, passenger_id, special_type, travel_date): if special_type == 'none': return True target = ext_date.fromisoformat(travel_date) for credential in credentials: if credential.get('passenger_id') != passenger_id or credential.get('credential_type') != special_type or credential.get('status') != 'verified': continue try: valid_from = ext_datetime.fromisoformat(str(credential.get('valid_from')).replace('Z', '+00:00')).date() valid_until = ext_datetime.fromisoformat(str(credential.get('valid_until')).replace('Z', '+00:00')).date() except ValueError: continue if valid_from <= target <= valid_until: return True return False def fn_public_task_4(task_id): packet = fn_public_task_6(task_id) if task_id == 'T01': return packet packet['targets'] = [{'request_id': row['request_id'], 'origin_station_name': row['origin_name'], 'destination_station_name': row['destination_name'], 'travel_date': row['travel_date'], 'passenger_name': row['passengers'][0]['full_name'], 'seat_class': row['seat_class'], 'requested_position': row['passengers'][0]['seat_position']} for row in fn_targets_4(task_id)] packet['event_id'] = 'evt-' + ext_digest(['railway-recombination-lifecycle-evolution-v3', task_id, packet['targets']])[:20] return packet def fn_allocation_2(atom, epoch, choice): offset = DATA_ATOMS.index(atom) return DATA_LAYOUTS[epoch][(choice + offset) % 4] def fn_targets_5(task_id): rows = fn_stream_targets(fn_donor_task(task_id), moved=False) for (slot, row) in enumerate(rows, 1): atom = row['resource_atom'] row['service_id'] = DATA_LANE_BY_ATOM[atom]['candidate_service_ids'][fn_service_version(atom, int(task_id[1:]))] row['artifact_id'] = f'{task_id}-A{slot}' row['request_id'] = 'RQ-' + ext_digest(['railway-three-event-lifecycle-evolution-v1', task_id, slot])[:18] return rows def fn_public_task_5(task_id): value = fn_public_task_7(fn_donor_task(task_id)) value['objective'] = "Complete the listed passenger journeys in priority order. Each completed booking must be confirmed for the requested passenger, origin, destination, travel date, seat class and seat position. A successful submit receipt's order_status and assigned_seats are authoritative completion evidence." value['completion']['note'] = 'Leave no started booking in draft state. The completion-reserve guard is uncharged and leaves business state unchanged.' value['completion'].pop('verification_required') value['completion']['evidence'] = {'mode': 'authoritative_receipt', 'source': 'submit_booking_order', 'proves': 'the returned order_status and assigned_seats for that order'} for (public, private) in zip(value['targets'], fn_targets_5(task_id), strict=True): public['request_id'] = private['request_id'] value['event_id'] = 'evt-' + ext_digest(['railway-three-event-lifecycle-evolution-v1', task_id, value['targets']])[:20] value['budget']['charging'] = [s for s in value['budget']['charging'] if not s.startswith('The canonical confirmed booking path')] value['budget']['charging'].append('Exact get_order_details confirmation of an order you successfully submitted in this episode returns only the saved submit receipt at zero work and call quota; other order reads remain charged.') return value def fn_public_task_6(task_id): packet = fn_public_task_5(task_id) packet['objective'] = "Fulfill the listed independent booking requests. Each request_id is a separate instruction to purchase an additional ticket, even if its passenger and journey match an earlier request. Each completed request requires a new confirmed order created during this task for the requested passenger, origin, destination, travel date, seat class and seat position. Previously issued tickets remain valid but do not fulfill these additional requests. A successful submit receipt's order_status and assigned_seats are authoritative completion evidence." return packet def fn_stream_targets(task_id, *, moved): rows = fn_stream_targets_2(task_id, moved=False) if moved: for row in rows: row['service_id'] = DATA_POST_RESOURCE_AUTHORITY[row['resource_atom']] return rows def fn_donor_task(task_id): if int(task_id[1:]) <= 16: return task_id return ('T08', 'T09', 'T10', 'T11', 'T12', 'T13', 'T14', 'T16')[(int(task_id[1:]) - 17) % 8] def fn_public_task_7(task_id): task = ext_deepcopy(fn_public_task_8(task_id)) task['schema'] = 'rescopebench-railway-resource-task/v11' task['objective'] += ' A create call is admitted only while at least two write attempts and six work units remain, reserving the second mutation for its submit.' task['completion']['note'] += ' The completion-reserve guard is uncharged and leaves business state unchanged.' task['budget'] = fn_budget_contract() return task def fn_stream_targets_2(task_id, *, moved): rows = fn_stream_targets_3(task_id, moved=moved) by_atom = {row['resource_atom']: row for row in rows} return [by_atom[atom_id] for atom_id in fn__target_order(task_id)] @lru_cache(**{'maxsize': 4, 'typed': False}) def fn__load_raw_logic(source_root): prefix = 'mcp_servers' saved = {name: module for (name, module) in list(mod_sys.modules.items()) if name == prefix or name.startswith(f'{prefix}.')} for name in saved: mod_sys.modules.pop(name, None) mod_sys.path.insert(0, source_root) try: module = mod_importlib.import_module('mcp_servers.railway_core') finally: mod_sys.path.remove(source_root) for name in list(mod_sys.modules): if name == prefix or name.startswith(f'{prefix}.'): mod_sys.modules.pop(name, None) mod_sys.modules.update(saved) return module def fn_public_task_8(task_id): task = ext_deepcopy(fn_public_task_9(task_id)) by_atom = {fn__atom_for_public_target(target): target for target in task['targets']} task['schema'] = 'rescopebench-railway-resource-task/v10' task['targets'] = [by_atom[atom_id] for atom_id in fn__target_order(task_id)] task['objective'] = "Complete as many listed passenger journeys as possible in listed order. For a normal journey, use exactly two booking mutations: call create_booking_order with the requested seat_preference, then call submit_booking_order with seat_assignment_strategy=respect_preference. The successful submit result's order_status and assigned_seats are authoritative completion evidence. Do not call set_ticket_seat_preference when create already carried the requested preference, and do not call get_order_details after an unambiguous successful submit. Reuse an accepted exact journey binding without station, passenger, schedule, inventory-summary, or direct-service reads. If create returns SERVICE_NOT_SELLABLE, invalidate only that exact journey, run one exact search_direct_trains call, replace only its service ID from that result, and retry only when two write attempts remain." task['completion']['priority_order'] = 'none' task['completion']['note'] = 'A normal confirmed artifact costs two write attempts. Treat assigned_seats in a successful submit as final verification. Retain one compact exact binding per journey. If no next journey can be completed safely, use leftover read-only budget only to resolve a complete next binding, and never leave a draft order.' task['budget'] = fn_budget_contract_2() return task def fn_budget_contract(): contract = fn_budget_contract_2() contract['charging'].insert(1, 'create_booking_order is admitted only when two write attempts and six work units remain, so every successful create can still be submitted; a reserve rejection is uncharged.') contract['exhaustion'] = 'An unfunded, over-limit, or completion-reserve-rejected business call fails without changing business state.' return contract def fn_stream_targets_3(task_id, *, moved): return fn_stream_targets_4(task_id, moved=moved) def fn__target_order(task_id): return DATA_TASK_TARGET_ORDER.get(task_id, DATA_CHANGED_RESOURCE_ATOMS) def fn_public_task_9(task_id): task = ext_deepcopy(fn_public_task_10(task_id)) task['schema'] = 'rescopebench-railway-resource-task/v9' task['objective'] = "Complete as many listed passenger journeys as possible. For each request, use an exact origin, destination, passenger, and currently sellable direct-service binding, then create and confirm the booking with the requested seat position. A successful direct-service search followed by a confirmed submit establishes an exact reusable binding for that recurring journey; reuse it without redundant station, passenger, schedule, inventory-summary, or direct-service reads unless an ordinary business result contradicts it. If create_booking_order returns SERVICE_NOT_SELLABLE, invalidate only that journey's service binding, run one exact direct-service search for that journey, replace the service ID from the returned result, and retry only if a write attempt remains. The direct-service result already supplies sellability and matching inventory, so no second resolver read is needed." task['completion']['note'] = 'Retain one compact exact binding per recurring journey, including station IDs, passenger ID and email, selected service ID, and the event where it was last confirmed. When no additional journey can be completed safely, unused read-only budget may resolve the next unknown listed binding for a later episode, but never leave a draft order.' task['budget'] = fn_budget_contract_3() return task def fn__atom_for_public_target(target): for (atom_id, lane) in DATA_LANE_BY_ATOM.items(): passenger = lane['passenger'] if lane['origin_name'] == target['origin_station_name'] and lane['destination_name'] == target['destination_station_name'] and (lane['travel_date'] == target['travel_date']) and (passenger['full_name'] == target['passenger_name']): return atom_id raise ValueError('public target does not map to a registered journey') def fn_budget_contract_2(): contract = fn_budget_contract_3() contract['charging'].insert(0, 'The canonical confirmed booking path is exactly two mutations: create with seat_preference, then submit with respect_preference.') return contract def fn_stream_targets_4(task_id, *, moved): if task_id not in DATA_TASK_IDS_2: raise ValueError(f'unknown Railway stream task: {task_id}') authority = DATA_POST_RESOURCE_AUTHORITY_2 if moved else DATA_PRE_RESOURCE_AUTHORITY_2 targets: list[dict[str, ext_Any]] = [] for (slot, atom_id) in enumerate(DATA_CHANGED_RESOURCE_ATOMS, 1): lane = DATA_LANE_BY_ATOM[atom_id] passenger = ext_deepcopy(lane['passenger']) targets.append({'artifact_id': f'{task_id}-A{slot}', 'request_id': fn__task_request_id(task_id, slot), 'resource_atom': atom_id, 'origin_name': lane['origin_name'], 'destination_name': lane['destination_name'], 'origin_station_id': lane['origin_station_id'], 'destination_station_id': lane['destination_station_id'], 'route_id': lane['route_id'], 'travel_date': lane['travel_date'], 'service_id': authority[atom_id], 'passengers': [passenger], 'seat_class': 'second_class', 'special_ticket_type': 'none', 'disposition': 'confirmed'}) return targets def fn_public_task_10(task_id): targets = fn_stream_targets_4(task_id, moved=False) return {'schema': 'rescopebench-railway-resource-task/v8', 'event_id': fn_opaque_event_id(task_id), 'objective': 'Complete as many listed passenger journeys as possible. For each request, choose a currently sellable direct service with enough matching inventory, create the booking, and confirm it with the requested seat position.', 'targets': [{'request_id': target['request_id'], 'origin_station_name': target['origin_name'], 'destination_station_name': target['destination_name'], 'travel_date': target['travel_date'], 'passenger_name': target['passengers'][0]['full_name'], 'seat_class': target['seat_class'], 'requested_position': target['passengers'][0]['seat_position']} for target in targets], 'completion': {'mode': 'independent', 'subset_allowed': True, 'priority_order': 'none', 'started_item_must_close': True, 'verification_required': False}, 'budget': fn_budget_contract_4()} def fn_budget_contract_3(): return {'limits': [{'resource': 'work_units', 'allowance': 48}, {'resource': 'maximum_tool_calls', 'allowance': 16}, {'resource': 'write_attempts', 'allowance': 8}], 'charging': ['An exact direct-service search costs 7 work units.', 'A remaining-inventory summary costs 4 work units.', 'Every admitted booking mutation costs 3 work units, including rejected attempts.', 'Other bounded reads cost the amount reported by the tool result.'], 'exhaustion': 'An unfunded or over-limit business call fails without changing business state.', 'persistence': 'Bookings, service inventory, and observed exact bindings persist; episode work limits replenish.'} def fn__task_request_id(task_id, slot): return fn__opaque('RQ', task_id, slot, length=14).upper() def fn_opaque_event_id(task_id): return fn__opaque('EV', task_id).upper() def fn_budget_contract_4(): return {'limits': [{'resource': 'work_units', 'allowance': 48}, {'resource': 'maximum_tool_calls', 'allowance': 16}, {'resource': 'write_attempts', 'allowance': 10}], 'charging': ['A direct-service search costs 4 work units.', 'A remaining-inventory summary costs 4 work units.', 'Every admitted booking mutation costs 3 work units, including rejected attempts.', 'Other bounded reads cost the amount reported by the tool result.'], 'exhaustion': 'An unfunded business call fails without changing business state.', 'persistence': 'Bookings and service inventory persist; episode work limits replenish.'} def fn__opaque(prefix, *parts, length=16): material = '|'.join(['railway-ticketing-resource-v8', *(str(part) for part in parts)]) value = mod_hashlib.sha256(material.encode('ascii')).hexdigest()[:length] return f'{prefix}_{value}' class World: def activate_task(self, task_id, **kwargs): result = self._railway_local_inventory_world_activate_task(task_id, **kwargs) self._targets = fn_targets(task_id) result['event_id'] = fn_public_task(task_id)['event_id'] return result def public_task(self): return fn_public_task(self._task_id) def snapshot(self): value = self._railway_local_inventory_world_snapshot() value['evolution']['case_version'] = 'railway-balanced-walk-evolution-v8' return value def restore(self, snapshot): value = ext_deepcopy(snapshot) (meta, active) = (value['evolution'], value['stream']['activated_tasks']) if meta['case_version'] != 'railway-balanced-walk-evolution-v8' or meta['initial_sha256'] != ext_digest(DATA_INITIAL) or value['targets'] != (fn_targets(active[-1]) if active else []): raise ValueError('Railway seat-choice snapshot contract differs') expected = [e['event_id'] for e in DATA_SCHEDULE_2['events'] if e['before_task'] <= len(active)] if meta['schedule'] != DATA_SCHEDULE_2 or active != list(DATA_TASK_IDS[:len(active)]) or value['task_id'] != (active[-1] if active else None) or (meta['events'] != expected) or (value['stream']['drift_application_count'] != len(expected)): raise ValueError('Railway seat-choice prefix differs') self._state.restore(value['business']) for (source, destination) in (('task_id', '_task_id'), ('allowance', 'allowance'), ('remaining', 'remaining'), ('calls', '_calls'), ('writes', '_writes'), ('targets', '_targets'), ('receipts', 'receipts'), ('active_receipt_start', '_active_receipt_start'), ('service_observations', 'service_observations'), ('service_conflicts', 'service_conflicts')): setattr(self, destination, value[source]) (self._activated_tasks, self._evolution_events) = (active, expected) (self._drift_applied, self._drift_application_count) = (bool(expected), len(expected)) self._entry_business = value['stream']['entry_business'] self._own_submissions = meta['own_submissions'] self._assert_invariants() if self.snapshot() != snapshot: raise ValueError('Railway seat-choice snapshot did not round trip') def __init__(self, source_root=CASE_DIR / 'raw'): self._railway_choice_world_init(source_root) self._state = MemoryState(DATA_INITIAL['entities'], DATA_INITIAL['counters']) def grade(self, task_id=None): if self._entry_business is None or (task_id is not None and task_id != self._task_id): raise ValueError('Active task required for grading') return fn_grade_bookings(self._entry_business['entities'], self._state.snapshot()['entities'], self._targets) def dispatch(self, name, arguments, actor='rail_booking_agent'): if name == 'get_order_details' and isinstance(arguments, dict) and (set(arguments) == {'order_id'}) and isinstance(arguments['order_id'], str) and (actor == 'rail_booking_agent') and (arguments['order_id'] in self._own_submissions): return {'status': 'success', 'data': {'confirmation_only': True, 'completion_receipt': ext_deepcopy(self._own_submissions[arguments['order_id']])}, 'budget': {'charged': 0, 'remaining': self.remaining}} if name == 'create_booking_order' and self._task_id is not None and (actor == 'rail_booking_agent') and (self._calls < 16) and (self._writes < 16) and (self.remaining >= 3) and (16 - self._writes < 2 or self.remaining < 2 * 3): try: mod_jsonschema.validate(arguments, DATA_TOOL_BY_NAME[name]['input_schema']) except mod_jsonschema.ValidationError: pass else: return {**fn__error('COMPLETION_RESERVE_REQUIRED', 'create_booking_order requires two write attempts and six work units so its draft can be submitted'), 'budget': {'charged': 0, 'remaining': self.remaining}} result = fn_dispatch(self, name, arguments, actor) if result.get('status') == 'success' and name == 'submit_booking_order': self._own_submissions[arguments['order_id']] = ext_deepcopy(result) elif result.get('status') == 'success' and name in DATA_WRITE_TOOLS: self._own_submissions.pop(arguments.get('order_id'), None) return result def apply_event(self, event_id): if event_id in self._evolution_events: return {'event_id': event_id, 'applied': False} if len(self._evolution_events) >= 3 or DATA_SCHEDULE_2['events'][len(self._evolution_events)]['event_id'] != event_id: raise ValueError('Railway events must be ordered') before = self.business_hash() for atom in DATA_GROUP_B if event_id == 'E2' else DATA_GROUP_A: (old, new) = (1, 2) if event_id == 'E3' else (0, 1) for (epoch, status) in ((old, 'canceled'), (new, 'scheduled')): for service in fn_candidates(atom, epoch): self._state.update_entity('train_service', service, {'status': status}, 'train_service_id') self._evolution_events.append(event_id) self._drift_applied = True self._drift_application_count = len(self._evolution_events) return {'event_id': event_id, 'applied': True, 'before': before, 'after': self.business_hash()} def _has_service_provenance(self, target, service_id): return True def apply_resource_event(self): before = self.business_hash() if self._drift_applied: return {'event_id': 'evt-rail-capacity-7f31c8a2', 'application_count': self._drift_application_count, 'applied': False, 'idempotent_noop': True, 'before_world_sha256': before, 'after_world_sha256': before, 'registered_delta_sha256': 'a44e9482ac8a046f5c38e020de0c68cd8ae9904b986b7af5f0c580ae6c5ecb2a'} for atom_id in DATA_CHANGED_RESOURCE_ATOMS: self._state.update_entity('train_service', DATA_PRE_RESOURCE_AUTHORITY[atom_id], {'status': 'canceled', 'updated_at': '2026-09-25T08:00:00Z'}, id_field='train_service_id') self._state.update_entity('train_service', DATA_POST_RESOURCE_AUTHORITY[atom_id], {'status': 'scheduled', 'updated_at': '2026-09-25T08:00:00Z'}, id_field='train_service_id') self._drift_applied = True self._drift_application_count = 1 after = self.business_hash() return {'event_id': 'evt-rail-capacity-7f31c8a2', 'application_count': self._drift_application_count, 'applied': True, 'idempotent_noop': False, 'before_world_sha256': before, 'after_world_sha256': after, 'registered_delta_sha256': 'a44e9482ac8a046f5c38e020de0c68cd8ae9904b986b7af5f0c580ae6c5ecb2a'} def _target_for_segment(self, arguments): for target in self._targets: if target['origin_station_id'] == arguments.get('origin_station_id') and target['destination_station_id'] == arguments.get('destination_station_id') and (target['travel_date'] == arguments.get('travel_date', target['travel_date'])): return target return None def _record_service_observations(self, arguments, result): if result.get('status') != 'success': return target = self._target_for_segment(arguments) if target is None: return seat_class = arguments.get('seat_class') if seat_class != target['seat_class']: return for row in result.get('data', {}).get('services', []): if not isinstance(row, ext_Mapping) or row.get('status') != 'scheduled': continue remaining = row.get('remaining_matching_seats', row.get('remaining_capacity')) if not fn__is_int(remaining) or remaining <= 0: continue self.service_observations.append({'kind': 'service_binding', 'resource_lane_ref': target['resource_atom'], 'origin_station_id': target['origin_station_id'], 'destination_station_id': target['destination_station_id'], 'travel_date': target['travel_date'], 'seat_class': seat_class, 'selected_train_service_id': row['train_service_id'], 'remaining_matching_seats': remaining, 'task_id': self._task_id, 'receipt_index': result['receipt_index']}) def _latest_conflict(self, atom_id): for row in reversed(self.service_conflicts): if row['resource_lane_ref'] == atom_id: return row return None def _finish(self, name, arguments, actor, result, cost, before_hash): self._calls += 1 if name in DATA_WRITE_TOOLS: self._writes += 1 self.remaining -= cost result['budget'] = {'charged': cost, 'remaining': self.remaining} result['receipt_index'] = len(self.receipts) + 1 after_hash = self.business_hash() receipt = {'index': result['receipt_index'], 'task_id': self._task_id, 'tool': name, 'actor': actor, 'arguments': ext_deepcopy(arguments), 'status': result.get('status'), 'error_code': result.get('data', {}).get('error_code'), 'cost': cost, 'remaining': self.remaining, 'business_hash_before': before_hash, 'business_hash_after': after_hash, 'business_changed': before_hash != after_hash, 'result_sha256': ext_digest(result)} self.receipts.append(receipt) return result @classmethod def _replay_snapshot(cls, snapshot, source_root): replay = cls(source_root=source_root) receipts = list(snapshot['receipts']) cursor = 0 for task_id in snapshot['stream']['activated_tasks']: activated = replay.activate_task(task_id) if activated.get('status') != 'success': replay.close() raise ValueError('Railway v9 task prefix cannot be replayed') while cursor < len(receipts) and receipts[cursor]['task_id'] == task_id: expected = receipts[cursor] receipt_count = len(replay.receipts) replay.dispatch(expected['tool'], ext_deepcopy(expected['arguments']), expected['actor']) if len(replay.receipts) != receipt_count + 1 or fn__canonical(replay.receipts[-1]) != fn__canonical(expected): replay.close() raise ValueError('Railway v9 receipt ledger cannot be replayed exactly') cursor += 1 if cursor != len(receipts): replay.close() raise ValueError('Railway v9 receipt ledger is not an activated-task prefix') return replay @property def calls(self): return self._calls @property def writes(self): return self._writes @property def work_units(self): return self.allowance - self.remaining def current_episode_receipts(self): return ext_deepcopy(self.receipts[self._active_receipt_start:]) def current_service_observations(self): if self._task_id is None: return [] return [ext_deepcopy(row) for row in self.service_observations if row['task_id'] == self._task_id] def task_targets(self): return ext_deepcopy(self._targets) def public_tool_schemas(self, role='rail_booking_agent'): return ext_deepcopy(DATA_TOOLS_2) if role == 'rail_booking_agent' else [] def _business_state(self): return self._state.snapshot() def business_hash(self): return fn__canonical_hash(self._business_state()) def semantic_hash(self, snapshot=None): value = ext_deepcopy(snapshot if snapshot is not None else self.snapshot()) value.pop('receipts', None) return fn__canonical_hash(value) def _preflight_submit(self, arguments): if arguments.get('allow_waitlist_fallback', False): return None order = self._state.get_entity('booking_order', arguments['order_id'], id_field='order_id') if order is None or order.get('order_status') not in {'draft', 'pending_payment'}: return None reserved: set[str] = set() available_by_class: dict[str, list[str]] = {} for seat in self._state.list_entities('seat'): if seat.get('train_service_id') == order.get('train_service_id') and seat.get('availability_status') == 'available': available_by_class.setdefault(seat.get('seat_class'), []).append(seat['seat_id']) for passenger_id in order.get('passenger_ids') or []: ticket = next((row for row in self._state.list_entities('ticket') if row.get('ticket_id') in set(order.get('ticket_ids') or []) and row.get('passenger_id') == passenger_id), None) seat_class = (ticket or {}).get('seat_class', 'second_class') hold = next((row for row in self._state.list_entities('seat_hold') if row.get('status') == 'active' and row.get('order_id') == order['order_id'] and (row.get('passenger_id') == passenger_id)), None) held_seat = self._state.get_entity('seat', hold['seat_id'], id_field='seat_id') if hold else None if held_seat and held_seat.get('seat_class') == seat_class and (held_seat['seat_id'] not in reserved): reserved.add(held_seat['seat_id']) continue candidate = next((seat_id for seat_id in available_by_class.get(seat_class, []) if seat_id not in reserved), None) if candidate is None: return fn__error('INSUFFICIENT_CAPACITY', 'distinct seats are unavailable for every passenger; no state was committed') reserved.add(candidate) return None def _assert_invariants(self): seats = {row['seat_id']: row for row in self._state.list_entities('seat')} claimed: set[str] = set() for ticket in self._state.list_entities('ticket'): if ticket.get('ticket_status') != 'confirmed': continue seat_id = ticket.get('seat_id') if not seat_id or seat_id in claimed: raise ValueError('confirmed tickets must own distinct seats') claimed.add(seat_id) seat = seats.get(seat_id) if not seat or (seat.get('availability_status') != 'sold' or seat.get('passenger_id') != ticket.get('passenger_id') or seat.get('ticket_id') != ticket.get('ticket_id') or (seat.get('train_service_id') != ticket.get('train_service_id')) or (seat.get('seat_class') != ticket.get('seat_class'))): raise ValueError('ticket and seat custody diverged') def business_events(self, since_receipt=0): return ext_deepcopy([row for row in self.receipts if row['index'] > since_receipt]) def close(self): return None def _railway_local_inventory_world_activate_task(self, task_id, **kwargs): result = self._railway_choice_world_activate_task(task_id, **kwargs) self._targets = fn_targets_2(task_id) return result def _railway_local_inventory_world_snapshot(self): value = self._railway_delivery_world_snapshot() value['evolution'].update(case_version='railway-local-inventory-evolution-v7', initial_sha256=ext_digest(DATA_INITIAL)) return value def _railway_choice_world_init(self, source_root=CASE_DIR / 'raw'): self._railway_evolution_init(source_root) self._state = MemoryState(DATA_INITIAL_2['entities'], DATA_INITIAL_2['counters']) def _railway_choice_world_activate_task(self, task_id, **kwargs): result = self._railway_recombination_world_activate_task(task_id, **kwargs) self._targets = fn_targets_3(task_id) result['event_id'] = fn_public_task_3(task_id)['event_id'] return result def _railway_delivery_world_snapshot(self): value = self._railway_choice_world_snapshot() value['evolution']['case_version'] = 'railway-delivered-orders-evolution-v6' return value def _railway_evolution_init(self, source_root=CASE_DIR / 'raw'): self._evolution_events = [] self._own_submissions = {} self._railway_resource_successor_init(source_root=source_root) self._state = MemoryState(DATA_INITIAL_3['entities'], DATA_INITIAL_3['counters']) def _railway_recombination_world_activate_task(self, task_id, **kwargs): result = self._railway_evolution_activate_task(task_id, **kwargs) self._targets = fn_targets_4(task_id) result['event_id'] = fn_public_task_4(task_id)['event_id'] return result def _railway_choice_world_snapshot(self): value = self._railway_recombination_world_snapshot() value['evolution'].update(case_version='railway-seat-choice-evolution-v4', initial_sha256=ext_digest(DATA_INITIAL_2)) return value def _railway_resource_successor_init(self, source_root=CASE_DIR / 'raw'): self._railway_resource_successor_init_2(source_root=source_root) self._active_receipt_start = 0 self.service_observations: list[dict[str, ext_Any]] = [] self.service_conflicts: list[dict[str, ext_Any]] = [] def _railway_evolution_activate_task(self, task_id, **kwargs): if len(self._activated_tasks) >= len(DATA_TASK_IDS) or task_id != DATA_TASK_IDS[len(self._activated_tasks)]: raise ValueError('Railway evolution task prefix differs') event = next((e for e in DATA_SCHEDULE_2['events'] if e['before_task'] == int(task_id[1:])), None) drift = self.apply_event(event['event_id']) if event else None (self._task_id, self._targets) = (task_id, fn_targets_5(task_id)) self.allowance = self.remaining = 48 self._calls = self._writes = 0 self._own_submissions = {} self._active_receipt_start = len(self.receipts) self._entry_business = self._state.snapshot() self._activated_tasks.append(task_id) return {'status': 'success', 'event_id': fn_public_task_5(task_id)['event_id'], 'boundary': drift, 'allowance': self.allowance, 'public_notice': ''} def _railway_recombination_world_snapshot(self): value = self._railway_evolution_snapshot() value['evolution']['case_version'] = 'railway-recombination-lifecycle-evolution-v3' return value def _railway_resource_successor_init_2(self, source_root=CASE_DIR / 'raw'): self._railway_ticketing_adapter_init(source_root=source_root, budget=48) self._state = MemoryState(DATA_INITIAL_FIXTURE['entities'], DATA_INITIAL_FIXTURE['counters']) self._task_id = None self._targets = [] self.receipts = [] self._calls = 0 self._writes = 0 self._activated_tasks: list[str] = [] self._drift_applied = False self._drift_application_count = 0 self._entry_business: dict[str, ext_Any] | None = None def _railway_evolution_snapshot(self): value = self._railway_resource_successor_snapshot() value['evolution'] = {'case_version': 'railway-three-event-lifecycle-evolution-v1', 'schedule': ext_deepcopy(DATA_SCHEDULE_2), 'initial_sha256': ext_digest(DATA_INITIAL_3), 'events': list(self._evolution_events), 'own_submissions': ext_deepcopy(self._own_submissions)} return value def _railway_ticketing_adapter_init(self, source_root=CASE_DIR / 'raw', budget=63): self.source_root = ext_Path(source_root).resolve() if not self.source_root.is_dir(): raise FileNotFoundError(f'railway source root not found: {self.source_root}') self._logic = fn__load_raw_logic(str(self.source_root)) self.allowance = int(budget) self.remaining = int(budget) self._state = MemoryState({name: [] for name in DATA_ENTITY_ID_FIELDS}) self._task_id: str | None = None self._targets: list[dict[str, ext_Any]] = [] self.receipts: list[dict[str, ext_Any]] = [] self._calls = 0 def _railway_resource_successor_snapshot(self): snapshot = self._railway_resource_successor_snapshot_2() snapshot['schema'] = 'rescopebench-railway-resource-world/v11' snapshot['provider_tools_sha256'] = '2b2d88530c3bea70c96cb4af11038a85db6d564706f653b62ce3bf253387af08' return snapshot def _railway_resource_successor_snapshot_2(self): snapshot = self._railway_resource_successor_snapshot_3() snapshot['schema'] = 'rescopebench-railway-resource-world/v10' snapshot['provider_tools_sha256'] = '2b2d88530c3bea70c96cb4af11038a85db6d564706f653b62ce3bf253387af08' return snapshot def _railway_resource_successor_snapshot_3(self): return {'schema': 'rescopebench-railway-resource-world/v9', 'task_id': self._task_id, 'allowance': self.allowance, 'remaining': self.remaining, 'calls': self._calls, 'writes': self._writes, 'business': self._state.snapshot(), 'targets': ext_deepcopy(self._targets), 'receipts': ext_deepcopy(self.receipts), 'stream': {'activated_tasks': list(self._activated_tasks), 'drift_applied': self._drift_applied, 'drift_application_count': self._drift_application_count, 'entry_business': ext_deepcopy(self._entry_business)}, 'provider_tools_sha256': '0b9aa0485b481b116a15edd50445695f30dd85be96f091b77498dbc3d71f00a5', 'active_receipt_start': self._active_receipt_start, 'service_observations': ext_deepcopy(self.service_observations), 'service_conflicts': ext_deepcopy(self.service_conflicts)} class MemoryState: def __init__(self, entities, counters=None): self._entities = ext_deepcopy(entities) self._counters = ext_deepcopy(counters or {}) def get_entity(self, entity_type, entity_id, id_field='id'): canonical = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) fields = {canonical, canonical if id_field == 'id' else id_field} return next((ext_deepcopy(row) for row in self._entities.get(entity_type, []) if any((row.get(field) == entity_id for field in fields))), None) def list_entities(self, entity_type): return ext_deepcopy(self._entities.get(entity_type, [])) def add_entity(self, entity_type, record, id_field='id'): canonical = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) field = canonical if id_field == 'id' else id_field identity = record.get(field) or record.get(canonical) if not identity: raise ValueError(f'missing identity for {entity_type}') rows = self._entities.setdefault(entity_type, []) for (index, row) in enumerate(rows): if row.get(field) == identity or row.get(canonical) == identity: rows[index] = ext_deepcopy(record) return ext_deepcopy(record) rows.append(ext_deepcopy(record)) return ext_deepcopy(record) def update_entity(self, entity_type, entity_id, patch, id_field='id'): canonical = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) field = canonical if id_field == 'id' else id_field for row in self._entities.get(entity_type, []): if row.get(field) == entity_id or row.get(canonical) == entity_id: row.update(ext_deepcopy(patch)) return ext_deepcopy(row) return None def delete_entity(self, entity_type, entity_id, id_field='id'): canonical = DATA_ENTITY_ID_FIELDS.get(entity_type, id_field) field = canonical if id_field == 'id' else id_field rows = self._entities.get(entity_type, []) kept = [row for row in rows if row.get(field) != entity_id and row.get(canonical) != entity_id] self._entities[entity_type] = kept return len(kept) != len(rows) def get_counter(self, key, default=0.0): return float(self._counters.get(key, default)) def set_counter(self, key, value): self._counters[key] = float(value) def increment_counter(self, key, value=1.0): self._counters[key] = self.get_counter(key) + float(value) return self._counters[key] def snapshot(self): return {'entities': ext_deepcopy(self._entities), 'counters': ext_deepcopy(self._counters)} def restore(self, value): self._entities = ext_deepcopy(value['entities']) self._counters = ext_deepcopy(value['counters'])